@hcrosse/opencode-pr-tracker 0.3.0 → 0.4.1

package/dist/server.js

@@ -1,2939 +1,1316 @@
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = import.meta.require;
+// src/server.ts
+import { Plugin } from "@opencode/plugin/effect";
+import { Context as Context7, Effect as Effect13, Layer as Layer7, Option as Option17, Schedule, Schema as Schema15, Stream as Stream2 } from "effect";
 
-// node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
-var require_polyfills = __commonJS((exports, module) => {
-  var constants = __require("constants");
-  var origCwd = process.cwd;
-  var cwd = null;
-  var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-  process.cwd = function() {
-    if (!cwd)
-      cwd = origCwd.call(process);
-    return cwd;
-  };
-  try {
-    process.cwd();
-  } catch (er) {}
-  if (typeof process.chdir === "function") {
-    chdir = process.chdir;
-    process.chdir = function(d) {
-      cwd = null;
-      chdir.call(process, d);
-    };
-    if (Object.setPrototypeOf)
-      Object.setPrototypeOf(process.chdir, chdir);
+// src/adapters/github/Client.ts
+import { Array as Arr3, Effect as Effect4, Layer as Layer3, Option as Option6, Redacted as Redacted2, Result as Result4, Schema as Schema7 } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+
+// src/ports/GitHub.ts
+import { Context, Schema as Schema3 } from "effect";
+
+// src/domain/Snapshot.ts
+import { Duration, Match, Schema as Schema2 } from "effect";
+
+// src/domain/PullRequest.ts
+import { Option, Result, Schema } from "effect";
+var canonicalSegment = /^(?!\.{1,2}$)[a-z0-9._-]+$/u;
+var pullRequestUrl = /^(?:https:\/\/)?github\.com\/(?<owner>[\w.-]+)\/(?<repository>[\w.-]+)\/pull\/(?<number>\d+)$/iu;
+var decimal = /^\d+$/u;
+var printableAscii = /^[\u0021-\u007E]*$/u;
+var Segment = Schema.String.check(Schema.isPattern(canonicalSegment));
+var PullRequestNumber = Schema.Int.check(Schema.isBetween({ maximum: Number.MAX_SAFE_INTEGER, minimum: 1 }));
+
+class PullRequestRef extends Schema.Class("PullRequestRef")({
+  number: PullRequestNumber,
+  owner: Segment,
+  repository: Segment
+}) {
+  get url() {
+    return `https://github.com/${this.owner}/${this.repository}/pull/${String(this.number)}`;
   }
-  var chdir;
-  module.exports = patch;
-  function patch(fs) {
-    if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-      patchLchmod(fs);
-    }
-    if (!fs.lutimes) {
-      patchLutimes(fs);
-    }
-    fs.chown = chownFix(fs.chown);
-    fs.fchown = chownFix(fs.fchown);
-    fs.lchown = chownFix(fs.lchown);
-    fs.chmod = chmodFix(fs.chmod);
-    fs.fchmod = chmodFix(fs.fchmod);
-    fs.lchmod = chmodFix(fs.lchmod);
-    fs.chownSync = chownFixSync(fs.chownSync);
-    fs.fchownSync = chownFixSync(fs.fchownSync);
-    fs.lchownSync = chownFixSync(fs.lchownSync);
-    fs.chmodSync = chmodFixSync(fs.chmodSync);
-    fs.fchmodSync = chmodFixSync(fs.fchmodSync);
-    fs.lchmodSync = chmodFixSync(fs.lchmodSync);
-    fs.stat = statFix(fs.stat);
-    fs.fstat = statFix(fs.fstat);
-    fs.lstat = statFix(fs.lstat);
-    fs.statSync = statFixSync(fs.statSync);
-    fs.fstatSync = statFixSync(fs.fstatSync);
-    fs.lstatSync = statFixSync(fs.lstatSync);
-    if (fs.chmod && !fs.lchmod) {
-      fs.lchmod = function(path, mode, cb) {
-        if (cb)
-          process.nextTick(cb);
-      };
-      fs.lchmodSync = function() {};
-    }
-    if (fs.chown && !fs.lchown) {
-      fs.lchown = function(path, uid, gid, cb) {
-        if (cb)
-          process.nextTick(cb);
-      };
-      fs.lchownSync = function() {};
-    }
-    if (platform === "win32") {
-      fs.rename = typeof fs.rename !== "function" ? fs.rename : function(fs$rename) {
-        function rename(from, to, cb) {
-          var start = Date.now();
-          var backoff = 0;
-          fs$rename(from, to, function CB(er) {
-            if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 60000) {
-              setTimeout(function() {
-                fs.stat(to, function(stater, st) {
-                  if (stater && stater.code === "ENOENT")
-                    fs$rename(from, to, CB);
-                  else
-                    cb(er);
-                });
-              }, backoff);
-              if (backoff < 100)
-                backoff += 10;
-              return;
-            }
-            if (cb)
-              cb(er);
-          });
-        }
-        if (Object.setPrototypeOf)
-          Object.setPrototypeOf(rename, fs$rename);
-        return rename;
-      }(fs.rename);
-    }
-    fs.read = typeof fs.read !== "function" ? fs.read : function(fs$read) {
-      function read(fd, buffer, offset, length, position, callback_) {
-        var callback;
-        if (callback_ && typeof callback_ === "function") {
-          var eagCounter = 0;
-          callback = function(er, _, __) {
-            if (er && er.code === "EAGAIN" && eagCounter < 10) {
-              eagCounter++;
-              return fs$read.call(fs, fd, buffer, offset, length, position, callback);
-            }
-            callback_.apply(this, arguments);
-          };
-        }
-        return fs$read.call(fs, fd, buffer, offset, length, position, callback);
-      }
-      if (Object.setPrototypeOf)
-        Object.setPrototypeOf(read, fs$read);
-      return read;
-    }(fs.read);
-    fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : function(fs$readSync) {
-      return function(fd, buffer, offset, length, position) {
-        var eagCounter = 0;
-        while (true) {
-          try {
-            return fs$readSync.call(fs, fd, buffer, offset, length, position);
-          } catch (er) {
-            if (er.code === "EAGAIN" && eagCounter < 10) {
-              eagCounter++;
-              continue;
-            }
-            throw er;
-          }
-        }
-      };
-    }(fs.readSync);
-    function patchLchmod(fs2) {
-      fs2.lchmod = function(path, mode, callback) {
-        fs2.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
-          if (err) {
-            if (callback)
-              callback(err);
-            return;
-          }
-          fs2.fchmod(fd, mode, function(err2) {
-            fs2.close(fd, function(err22) {
-              if (callback)
-                callback(err2 || err22);
-            });
-          });
-        });
-      };
-      fs2.lchmodSync = function(path, mode) {
-        var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
-        var threw = true;
-        var ret;
-        try {
-          ret = fs2.fchmodSync(fd, mode);
-          threw = false;
-        } finally {
-          if (threw) {
-            try {
-              fs2.closeSync(fd);
-            } catch (er) {}
-          } else {
-            fs2.closeSync(fd);
-          }
-        }
-        return ret;
-      };
-    }
-    function patchLutimes(fs2) {
-      if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
-        fs2.lutimes = function(path, at, mt, cb) {
-          fs2.open(path, constants.O_SYMLINK, function(er, fd) {
-            if (er) {
-              if (cb)
-                cb(er);
-              return;
-            }
-            fs2.futimes(fd, at, mt, function(er2) {
-              fs2.close(fd, function(er22) {
-                if (cb)
-                  cb(er2 || er22);
-              });
-            });
-          });
-        };
-        fs2.lutimesSync = function(path, at, mt) {
-          var fd = fs2.openSync(path, constants.O_SYMLINK);
-          var ret;
-          var threw = true;
-          try {
-            ret = fs2.futimesSync(fd, at, mt);
-            threw = false;
-          } finally {
-            if (threw) {
-              try {
-                fs2.closeSync(fd);
-              } catch (er) {}
-            } else {
-              fs2.closeSync(fd);
-            }
-          }
-          return ret;
-        };
-      } else if (fs2.futimes) {
-        fs2.lutimes = function(_a, _b, _c, cb) {
-          if (cb)
-            process.nextTick(cb);
-        };
-        fs2.lutimesSync = function() {};
-      }
-    }
-    function chmodFix(orig) {
-      if (!orig)
-        return orig;
-      return function(target, mode, cb) {
-        return orig.call(fs, target, mode, function(er) {
-          if (chownErOk(er))
-            er = null;
-          if (cb)
-            cb.apply(this, arguments);
-        });
-      };
-    }
-    function chmodFixSync(orig) {
-      if (!orig)
-        return orig;
-      return function(target, mode) {
-        try {
-          return orig.call(fs, target, mode);
-        } catch (er) {
-          if (!chownErOk(er))
-            throw er;
-        }
-      };
-    }
-    function chownFix(orig) {
-      if (!orig)
-        return orig;
-      return function(target, uid, gid, cb) {
-        return orig.call(fs, target, uid, gid, function(er) {
-          if (chownErOk(er))
-            er = null;
-          if (cb)
-            cb.apply(this, arguments);
-        });
-      };
-    }
-    function chownFixSync(orig) {
-      if (!orig)
-        return orig;
-      return function(target, uid, gid) {
-        try {
-          return orig.call(fs, target, uid, gid);
-        } catch (er) {
-          if (!chownErOk(er))
-            throw er;
-        }
-      };
-    }
-    function statFix(orig) {
-      if (!orig)
-        return orig;
-      return function(target, options, cb) {
-        if (typeof options === "function") {
-          cb = options;
-          options = null;
-        }
-        function callback(er, stats) {
-          if (stats) {
-            if (stats.uid < 0)
-              stats.uid += 4294967296;
-            if (stats.gid < 0)
-              stats.gid += 4294967296;
-          }
-          if (cb)
-            cb.apply(this, arguments);
-        }
-        return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
-      };
-    }
-    function statFixSync(orig) {
-      if (!orig)
-        return orig;
-      return function(target, options) {
-        var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
-        if (stats) {
-          if (stats.uid < 0)
-            stats.uid += 4294967296;
-          if (stats.gid < 0)
-            stats.gid += 4294967296;
-        }
-        return stats;
-      };
-    }
-    function chownErOk(er) {
-      if (!er)
-        return true;
-      if (er.code === "ENOSYS")
-        return true;
-      var nonroot = !process.getuid || process.getuid() !== 0;
-      if (nonroot) {
-        if (er.code === "EINVAL" || er.code === "EPERM")
-          return true;
-      }
-      return false;
-    }
+  get label() {
+    return `${this.owner}/${this.repository}#${String(this.number)}`;
   }
-});
+}
 
-// node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
-var require_legacy_streams = __commonJS((exports, module) => {
-  var Stream = __require("stream").Stream;
-  module.exports = legacy;
-  function legacy(fs) {
-    return {
-      ReadStream,
-      WriteStream
-    };
-    function ReadStream(path, options) {
-      if (!(this instanceof ReadStream))
-        return new ReadStream(path, options);
-      Stream.call(this);
-      var self = this;
-      this.path = path;
-      this.fd = null;
-      this.readable = true;
-      this.paused = false;
-      this.flags = "r";
-      this.mode = 438;
-      this.bufferSize = 64 * 1024;
-      options = options || {};
-      var keys = Object.keys(options);
-      for (var index = 0, length = keys.length;index < length; index++) {
-        var key = keys[index];
-        this[key] = options[key];
-      }
-      if (this.encoding)
-        this.setEncoding(this.encoding);
-      if (this.start !== undefined) {
-        if (typeof this.start !== "number") {
-          throw TypeError("start must be a Number");
-        }
-        if (this.end === undefined) {
-          this.end = Infinity;
-        } else if (typeof this.end !== "number") {
-          throw TypeError("end must be a Number");
-        }
-        if (this.start > this.end) {
-          throw new Error("start must be <= end");
-        }
-        this.pos = this.start;
-      }
-      if (this.fd !== null) {
-        process.nextTick(function() {
-          self._read();
-        });
-        return;
-      }
-      fs.open(this.path, this.flags, this.mode, function(err, fd) {
-        if (err) {
-          self.emit("error", err);
-          self.readable = false;
-          return;
-        }
-        self.fd = fd;
-        self.emit("open", fd);
-        self._read();
-      });
-    }
-    function WriteStream(path, options) {
-      if (!(this instanceof WriteStream))
-        return new WriteStream(path, options);
-      Stream.call(this);
-      this.path = path;
-      this.fd = null;
-      this.writable = true;
-      this.flags = "w";
-      this.encoding = "binary";
-      this.mode = 438;
-      this.bytesWritten = 0;
-      options = options || {};
-      var keys = Object.keys(options);
-      for (var index = 0, length = keys.length;index < length; index++) {
-        var key = keys[index];
-        this[key] = options[key];
-      }
-      if (this.start !== undefined) {
-        if (typeof this.start !== "number") {
-          throw TypeError("start must be a Number");
-        }
-        if (this.start < 0) {
-          throw new Error("start must be >= zero");
-        }
-        this.pos = this.start;
-      }
-      this.busy = false;
-      this._queue = [];
-      if (this.fd === null) {
-        this._open = fs.open;
-        this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
-        this.flush();
-      }
-    }
-  }
-});
+class InvalidPullRequestUrl extends Schema.TaggedError()("InvalidPullRequestUrl", { input: Schema.String }) {
+}
 
-// node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
-var require_clone = __commonJS((exports, module) => {
-  module.exports = clone;
-  var getPrototypeOf = Object.getPrototypeOf || function(obj) {
-    return obj.__proto__;
+class InvalidPullRequestInput extends Schema.TaggedError()("InvalidPullRequestInput", { input: Schema.String }) {
+}
+var decodeRef = Schema.decodeUnknownOption(PullRequestRef);
+var decodeNumber = Schema.decodeUnknownOption(PullRequestNumber);
+function samePullRequest(left, right) {
+  return left.url === right.url;
+}
+function parsePullRequestUrl(input) {
+  const match = printableAscii.test(input) ? pullRequestUrl.exec(input) : null;
+  const groups = match === null ? {} : match.groups ?? {};
+  const candidate = {
+    number: Number(groups["number"] ?? Number.NaN),
+    owner: (groups["owner"] ?? "").toLowerCase(),
+    repository: (groups["repository"] ?? "").toLowerCase()
   };
-  function clone(obj) {
-    if (obj === null || typeof obj !== "object")
-      return obj;
-    if (obj instanceof Object)
-      var copy = { __proto__: getPrototypeOf(obj) };
-    else
-      var copy = Object.create(null);
-    Object.getOwnPropertyNames(obj).forEach(function(key) {
-      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
-    });
-    return copy;
-  }
+  return Result.fromOption(decodeRef(candidate), () => new InvalidPullRequestUrl({ input }));
+}
+function parsePullRequestInput(input) {
+  const reference = parsePullRequestUrl(input);
+  if (Result.isSuccess(reference))
+    return Result.succeed({ _tag: "Reference", ref: reference.success });
+  const number = decimal.test(input) ? decodeNumber(Number(input)) : Option.none();
+  return Result.fromOption(number, () => new InvalidPullRequestInput({ input })).pipe(Result.map((value) => ({ _tag: "Number", number: value })));
+}
+
+// src/domain/Snapshot.ts
+var Ci = Schema2.Literals(["passed", "pending", "failed", "none"]);
+var Mergeability = Schema2.Literals(["mergeable", "conflicting", "unknown"]);
+var PullRequestState = Schema2.Union([
+  Schema2.TaggedStruct("Open", {
+    behind: Schema2.Boolean,
+    ci: Ci,
+    draft: Schema2.Boolean,
+    mergeability: Mergeability
+  }),
+  Schema2.TaggedStruct("Merged", {}),
+  Schema2.TaggedStruct("Closed", {})
+]);
+var Snapshot = Schema2.Struct({
+  ref: PullRequestRef,
+  state: PullRequestState,
+  title: Schema2.String
 });
+var Diagnostic = Schema2.Literals([
+  "GitHubCliMissing",
+  "AuthenticationRequired",
+  "GitHubUnavailable",
+  "NotFound",
+  "InvalidResponse"
+]);
+var Status = Schema2.Union([
+  Schema2.TaggedStruct("Pending", {}),
+  Schema2.TaggedStruct("Fresh", { snapshot: Snapshot }),
+  Schema2.TaggedStruct("Stale", {
+    diagnostic: Diagnostic,
+    failingSince: Schema2.Int,
+    snapshot: Snapshot
+  }),
+  Schema2.TaggedStruct("Unavailable", { diagnostic: Diagnostic })
+]);
+var staleLimit = Duration.minutes(5);
+var pending = { _tag: "Pending" };
+function succeeded(snapshot) {
+  return { _tag: "Fresh", snapshot };
+}
+function failed(status, diagnostic, now) {
+  return Match.valueTags(status, {
+    Fresh: ({ snapshot }) => ({ _tag: "Stale", diagnostic, failingSince: now, snapshot }),
+    Pending: () => ({ _tag: "Unavailable", diagnostic }),
+    Stale: ({ failingSince, snapshot }) => now - failingSince >= Duration.toMillis(staleLimit) ? { _tag: "Unavailable", diagnostic } : { _tag: "Stale", diagnostic, failingSince, snapshot },
+    Unavailable: () => ({ _tag: "Unavailable", diagnostic })
+  });
+}
 
-// node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
-var require_graceful_fs = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var polyfills = require_polyfills();
-  var legacy = require_legacy_streams();
-  var clone = require_clone();
-  var util = __require("util");
-  var gracefulQueue;
-  var previousSymbol;
-  if (typeof Symbol === "function" && typeof Symbol.for === "function") {
-    gracefulQueue = Symbol.for("graceful-fs.queue");
-    previousSymbol = Symbol.for("graceful-fs.previous");
-  } else {
-    gracefulQueue = "___graceful-fs.queue";
-    previousSymbol = "___graceful-fs.previous";
-  }
-  function noop() {}
-  function publishQueue(context, queue2) {
-    Object.defineProperty(context, gracefulQueue, {
-      get: function() {
-        return queue2;
-      }
-    });
-  }
-  var debug = noop;
-  if (util.debuglog)
-    debug = util.debuglog("gfs4");
-  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-    debug = function() {
-      var m = util.format.apply(util, arguments);
-      m = "GFS4: " + m.split(/\n/).join(`
-GFS4: `);
-      console.error(m);
-    };
-  if (!fs[gracefulQueue]) {
-    queue = global[gracefulQueue] || [];
-    publishQueue(fs, queue);
-    fs.close = function(fs$close) {
-      function close(fd, cb) {
-        return fs$close.call(fs, fd, function(err) {
-          if (!err) {
-            resetQueue();
-          }
-          if (typeof cb === "function")
-            cb.apply(this, arguments);
-        });
-      }
-      Object.defineProperty(close, previousSymbol, {
-        value: fs$close
-      });
-      return close;
-    }(fs.close);
-    fs.closeSync = function(fs$closeSync) {
-      function closeSync(fd) {
-        fs$closeSync.apply(fs, arguments);
-        resetQueue();
-      }
-      Object.defineProperty(closeSync, previousSymbol, {
-        value: fs$closeSync
-      });
-      return closeSync;
-    }(fs.closeSync);
-    if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
-      process.on("exit", function() {
-        debug(fs[gracefulQueue]);
-        __require("assert").equal(fs[gracefulQueue].length, 0);
-      });
-    }
-  }
-  var queue;
-  if (!global[gracefulQueue]) {
-    publishQueue(global, fs[gracefulQueue]);
-  }
-  module.exports = patch(clone(fs));
-  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-    module.exports = patch(fs);
-    fs.__patched = true;
-  }
-  function patch(fs2) {
-    polyfills(fs2);
-    fs2.gracefulify = patch;
-    fs2.createReadStream = createReadStream;
-    fs2.createWriteStream = createWriteStream;
-    var fs$readFile = fs2.readFile;
-    fs2.readFile = readFile;
-    function readFile(path, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      return go$readFile(path, options, cb);
-      function go$readFile(path2, options2, cb2, startTime) {
-        return fs$readFile(path2, options2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$writeFile = fs2.writeFile;
-    fs2.writeFile = writeFile;
-    function writeFile(path, data, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      return go$writeFile(path, data, options, cb);
-      function go$writeFile(path2, data2, options2, cb2, startTime) {
-        return fs$writeFile(path2, data2, options2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$appendFile = fs2.appendFile;
-    if (fs$appendFile)
-      fs2.appendFile = appendFile;
-    function appendFile(path, data, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      return go$appendFile(path, data, options, cb);
-      function go$appendFile(path2, data2, options2, cb2, startTime) {
-        return fs$appendFile(path2, data2, options2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$copyFile = fs2.copyFile;
-    if (fs$copyFile)
-      fs2.copyFile = copyFile;
-    function copyFile(src, dest, flags, cb) {
-      if (typeof flags === "function") {
-        cb = flags;
-        flags = 0;
-      }
-      return go$copyFile(src, dest, flags, cb);
-      function go$copyFile(src2, dest2, flags2, cb2, startTime) {
-        return fs$copyFile(src2, dest2, flags2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$readdir = fs2.readdir;
-    fs2.readdir = readdir;
-    var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir(path, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path2, options2, cb2, startTime) {
-        return fs$readdir(path2, fs$readdirCallback(path2, options2, cb2, startTime));
-      } : function go$readdir2(path2, options2, cb2, startTime) {
-        return fs$readdir(path2, options2, fs$readdirCallback(path2, options2, cb2, startTime));
-      };
-      return go$readdir(path, options, cb);
-      function fs$readdirCallback(path2, options2, cb2, startTime) {
-        return function(err, files) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([
-              go$readdir,
-              [path2, options2, cb2],
-              err,
-              startTime || Date.now(),
-              Date.now()
-            ]);
-          else {
-            if (files && files.sort)
-              files.sort();
-            if (typeof cb2 === "function")
-              cb2.call(this, err, files);
-          }
-        };
-      }
-    }
-    if (process.version.substr(0, 4) === "v0.8") {
-      var legStreams = legacy(fs2);
-      ReadStream = legStreams.ReadStream;
-      WriteStream = legStreams.WriteStream;
-    }
-    var fs$ReadStream = fs2.ReadStream;
-    if (fs$ReadStream) {
-      ReadStream.prototype = Object.create(fs$ReadStream.prototype);
-      ReadStream.prototype.open = ReadStream$open;
-    }
-    var fs$WriteStream = fs2.WriteStream;
-    if (fs$WriteStream) {
-      WriteStream.prototype = Object.create(fs$WriteStream.prototype);
-      WriteStream.prototype.open = WriteStream$open;
-    }
-    Object.defineProperty(fs2, "ReadStream", {
-      get: function() {
-        return ReadStream;
-      },
-      set: function(val) {
-        ReadStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    Object.defineProperty(fs2, "WriteStream", {
-      get: function() {
-        return WriteStream;
-      },
-      set: function(val) {
-        WriteStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    var FileReadStream = ReadStream;
-    Object.defineProperty(fs2, "FileReadStream", {
-      get: function() {
-        return FileReadStream;
-      },
-      set: function(val) {
-        FileReadStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    var FileWriteStream = WriteStream;
-    Object.defineProperty(fs2, "FileWriteStream", {
-      get: function() {
-        return FileWriteStream;
-      },
-      set: function(val) {
-        FileWriteStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    function ReadStream(path, options) {
-      if (this instanceof ReadStream)
-        return fs$ReadStream.apply(this, arguments), this;
-      else
-        return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
-    }
-    function ReadStream$open() {
-      var that = this;
-      open(that.path, that.flags, that.mode, function(err, fd) {
-        if (err) {
-          if (that.autoClose)
-            that.destroy();
-          that.emit("error", err);
-        } else {
-          that.fd = fd;
-          that.emit("open", fd);
-          that.read();
-        }
-      });
-    }
-    function WriteStream(path, options) {
-      if (this instanceof WriteStream)
-        return fs$WriteStream.apply(this, arguments), this;
-      else
-        return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
-    }
-    function WriteStream$open() {
-      var that = this;
-      open(that.path, that.flags, that.mode, function(err, fd) {
-        if (err) {
-          that.destroy();
-          that.emit("error", err);
-        } else {
-          that.fd = fd;
-          that.emit("open", fd);
+// src/ports/GitHub.ts
+class GitHubFailure extends Schema3.TaggedError()("GitHubFailure", {
+  diagnostic: Diagnostic
+}) {
+}
+
+class RepositoryUnavailable extends Schema3.TaggedError()("RepositoryUnavailable", { directory: Schema3.String }) {
+}
+var maximumBatch = 20;
+
+class GitHub extends Context.Service()("opencode-pr-tracker/GitHub") {
+}
+
+// src/adapters/Command.ts
+import { Context as Context2, Effect, Layer, Schema as Schema4 } from "effect";
+
+class CommandMissing extends Schema4.TaggedError()("CommandMissing", {
+  command: Schema4.String
+}) {
+}
+
+class CommandFailed extends Schema4.TaggedError()("CommandFailed", {
+  command: Schema4.String,
+  exitCode: Schema4.Int,
+  stderr: Schema4.String
+}) {
+}
+
+class CommandRunner extends Context2.Service()("opencode-pr-tracker/CommandRunner") {
+}
+var isMissingExecutable = Schema4.is(Schema4.Struct({ code: Schema4.Literal("ENOENT") }));
+function spawn(command, args, cwd) {
+  const process2 = Bun.spawn([command, ...args], {
+    cwd,
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  return {
+    completed: async () => {
+      const result = await Promise.all([
+        new Response(process2.stdout).text(),
+        new Response(process2.stderr).text(),
+        process2.exited
+      ]);
+      return result;
+    },
+    kill: () => {
+      process2.kill();
+    },
+    running: () => process2.exitCode === null
+  };
+}
+function start(command, args, cwd) {
+  const started = Effect.try({
+    catch: (cause) => isMissingExecutable(cause) ? new CommandMissing({ command }) : new CommandFailed({ command, exitCode: -1, stderr: String(cause) }),
+    try: () => spawn(command, args, cwd)
+  });
+  return Effect.acquireRelease(started, (child) => Effect.sync(() => {
+    if (child.running())
+      child.kill();
+  }));
+}
+function output(command, child) {
+  return Effect.gen(function* () {
+    const [stdout, stderr, exitCode] = yield* Effect.promise(child.completed);
+    if (exitCode === 0)
+      return stdout;
+    return yield* new CommandFailed({ command, exitCode, stderr });
+  });
+}
+var layer = Layer.succeed(CommandRunner, CommandRunner.of({
+  run: (command, args, cwd) => Effect.scoped(Effect.flatMap(start(command, args, cwd), (child) => output(command, child)))
+}));
+
+// src/adapters/github/Query.ts
+var defaultPageSize = 100;
+var contexts = (pageSize, after) => `
+  contexts(first: ${String(pageSize)}${after}) {
+    pageInfo { hasNextPage endCursor }
+    nodes {
+      __typename
+      ... on StatusContext { context state createdAt }
+      ... on CheckRun {
+        name status conclusion
+        checkSuite {
+          id
+          createdAt
+          app { id }
+          workflowRun { event runNumber runAttempt workflow { id } }
         }
-      });
-    }
-    function createReadStream(path, options) {
-      return new fs2.ReadStream(path, options);
-    }
-    function createWriteStream(path, options) {
-      return new fs2.WriteStream(path, options);
-    }
-    var fs$open = fs2.open;
-    fs2.open = open;
-    function open(path, flags, mode, cb) {
-      if (typeof mode === "function")
-        cb = mode, mode = null;
-      return go$open(path, flags, mode, cb);
-      function go$open(path2, flags2, mode2, cb2, startTime) {
-        return fs$open(path2, flags2, mode2, function(err, fd) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    return fs2;
-  }
-  function enqueue(elem) {
-    debug("ENQUEUE", elem[0].name, elem[1]);
-    fs[gracefulQueue].push(elem);
-    retry();
-  }
-  var retryTimer;
-  function resetQueue() {
-    var now = Date.now();
-    for (var i = 0;i < fs[gracefulQueue].length; ++i) {
-      if (fs[gracefulQueue][i].length > 2) {
-        fs[gracefulQueue][i][3] = now;
-        fs[gracefulQueue][i][4] = now;
       }
     }
-    retry();
-  }
-  function retry() {
-    clearTimeout(retryTimer);
-    retryTimer = undefined;
-    if (fs[gracefulQueue].length === 0)
-      return;
-    var elem = fs[gracefulQueue].shift();
-    var fn = elem[0];
-    var args = elem[1];
-    var err = elem[2];
-    var startTime = elem[3];
-    var lastTime = elem[4];
-    if (startTime === undefined) {
-      debug("RETRY", fn.name, args);
-      fn.apply(null, args);
-    } else if (Date.now() - startTime >= 60000) {
-      debug("TIMEOUT", fn.name, args);
-      var cb = args.pop();
-      if (typeof cb === "function")
-        cb.call(null, err);
-    } else {
-      var sinceAttempt = Date.now() - lastTime;
-      var sinceStart = Math.max(lastTime - startTime, 1);
-      var desiredDelay = Math.min(sinceStart * 1.2, 100);
-      if (sinceAttempt >= desiredDelay) {
-        debug("RETRY", fn.name, args);
-        fn.apply(null, args.concat([startTime]));
-      } else {
-        fs[gracefulQueue].push(elem);
+  }`;
+var pullRequest = (pageSize) => `
+  __typename
+  ... on PullRequest {
+    url title state isDraft mergeable mergeStateStatus
+    stack {
+      id size
+      entries(first: 100) {
+        pageInfo { hasNextPage }
+        nodes { position pullRequest { url } }
       }
     }
-    if (retryTimer === undefined) {
-      retryTimer = setTimeout(retry, 0);
-    }
+    statusCheckRollup { ${contexts(pageSize, "")} }
+  }`;
+var alias = (index) => `pr${String(index)}`;
+function batch(count, pageSize = defaultPageSize) {
+  const indexes = Array.from({ length: count }, (_, index) => index);
+  const variables = indexes.map((index) => `$${alias(index)}: URI!`).join(", ");
+  const fields = indexes.map((index) => `${alias(index)}: resource(url: $${alias(index)}) { ${pullRequest(pageSize)} }`).join(`
+`);
+  return `query PullRequests(${variables}) {
+${fields}
+}`;
+}
+function continuation(pageSize = defaultPageSize) {
+  return `query CheckContexts($url: URI!, $cursor: String!) {
+  resource(url: $url) {
+    __typename
+    ... on PullRequest { statusCheckRollup { ${contexts(pageSize, ", after: $cursor")} } }
   }
+}`;
+}
+
+// src/adapters/github/Repository.ts
+import { Effect as Effect2, Result as Result2, Schema as Schema5 } from "effect";
+var RepositoryView = Schema5.fromJsonString(Schema5.Struct({ url: Schema5.String }));
+var resolveInRepository = Effect2.fn("resolveInRepository")(function* (directory, number) {
+  const runner = yield* CommandRunner;
+  const unavailable = new RepositoryUnavailable({ directory });
+  const output = yield* runner.run("gh", ["repo", "view", "--json", "url"], directory).pipe(Effect2.catchTags({
+    CommandFailed: () => Effect2.fail(unavailable),
+    CommandMissing: () => Effect2.fail(new GitHubFailure({ diagnostic: "GitHubCliMissing" }))
+  }));
+  const view = yield* Schema5.decodeUnknownEffect(RepositoryView)(output).pipe(Effect2.mapError(() => unavailable));
+  return yield* Result2.match(parsePullRequestUrl(`${view.url}/pull/${String(number)}`), {
+    onFailure: () => Effect2.fail(unavailable),
+    onSuccess: Effect2.succeed
+  });
 });
 
-// node_modules/.bun/retry@0.12.0/node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS((exports, module) => {
-  function RetryOperation(timeouts, options) {
-    if (typeof options === "boolean") {
-      options = { forever: options };
-    }
-    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-    this._timeouts = timeouts;
-    this._options = options || {};
-    this._maxRetryTime = options && options.maxRetryTime || Infinity;
-    this._fn = null;
-    this._errors = [];
-    this._attempts = 1;
-    this._operationTimeout = null;
-    this._operationTimeoutCb = null;
-    this._timeout = null;
-    this._operationStart = null;
-    if (this._options.forever) {
-      this._cachedTimeouts = this._timeouts.slice(0);
+// src/adapters/github/Response.ts
+import { Array as Arr2, Option as Option4, Result as Result3, Schema as Schema6 } from "effect";
+
+// src/domain/Checks.ts
+import { Array as Arr, Option as Option3, Order } from "effect";
+var generationOrder = Arr.makeOrder(Order.Number);
+function withRun(current, check) {
+  const replacement = { generation: check.generation, outcomes: [check.outcome] };
+  return Option3.match(current, {
+    onNone: () => replacement,
+    onSome: (existing) => {
+      const comparison = generationOrder(check.generation, existing.generation);
+      if (comparison > 0)
+        return replacement;
+      if (comparison < 0)
+        return existing;
+      return { generation: existing.generation, outcomes: [...existing.outcomes, check.outcome] };
     }
+  });
+}
+function latestOutcomes(checks) {
+  const latest = new Map;
+  for (const check of checks) {
+    latest.set(check.identity, withRun(Option3.fromNullishOr(latest.get(check.identity)), check));
   }
-  module.exports = RetryOperation;
-  RetryOperation.prototype.reset = function() {
-    this._attempts = 1;
-    this._timeouts = this._originalTimeouts;
-  };
-  RetryOperation.prototype.stop = function() {
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-    }
-    this._timeouts = [];
-    this._cachedTimeouts = null;
-  };
-  RetryOperation.prototype.retry = function(err) {
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-    }
-    if (!err) {
-      return false;
-    }
-    var currentTime = new Date().getTime();
-    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-      this._errors.unshift(new Error("RetryOperation timeout occurred"));
-      return false;
-    }
-    this._errors.push(err);
-    var timeout = this._timeouts.shift();
-    if (timeout === undefined) {
-      if (this._cachedTimeouts) {
-        this._errors.splice(this._errors.length - 1, this._errors.length);
-        this._timeouts = this._cachedTimeouts.slice(0);
-        timeout = this._timeouts.shift();
-      } else {
-        return false;
-      }
-    }
-    var self = this;
-    var timer = setTimeout(function() {
-      self._attempts++;
-      if (self._operationTimeoutCb) {
-        self._timeout = setTimeout(function() {
-          self._operationTimeoutCb(self._attempts);
-        }, self._operationTimeout);
-        if (self._options.unref) {
-          self._timeout.unref();
-        }
-      }
-      self._fn(self._attempts);
-    }, timeout);
-    if (this._options.unref) {
-      timer.unref();
-    }
-    return true;
-  };
-  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-    this._fn = fn;
-    if (timeoutOps) {
-      if (timeoutOps.timeout) {
-        this._operationTimeout = timeoutOps.timeout;
-      }
-      if (timeoutOps.cb) {
-        this._operationTimeoutCb = timeoutOps.cb;
-      }
-    }
-    var self = this;
-    if (this._operationTimeoutCb) {
-      this._timeout = setTimeout(function() {
-        self._operationTimeoutCb();
-      }, self._operationTimeout);
-    }
-    this._operationStart = new Date().getTime();
-    this._fn(this._attempts);
-  };
-  RetryOperation.prototype.try = function(fn) {
-    console.log("Using RetryOperation.try() is deprecated");
-    this.attempt(fn);
-  };
-  RetryOperation.prototype.start = function(fn) {
-    console.log("Using RetryOperation.start() is deprecated");
-    this.attempt(fn);
-  };
-  RetryOperation.prototype.start = RetryOperation.prototype.try;
-  RetryOperation.prototype.errors = function() {
-    return this._errors;
-  };
-  RetryOperation.prototype.attempts = function() {
-    return this._attempts;
-  };
-  RetryOperation.prototype.mainError = function() {
-    if (this._errors.length === 0) {
-      return null;
-    }
-    var counts = {};
-    var mainError = null;
-    var mainErrorCount = 0;
-    for (var i = 0;i < this._errors.length; i++) {
-      var error = this._errors[i];
-      var message = error.message;
-      var count = (counts[message] || 0) + 1;
-      counts[message] = count;
-      if (count >= mainErrorCount) {
-        mainError = error;
-        mainErrorCount = count;
-      }
-    }
-    return mainError;
-  };
-});
+  return new Set([...latest.values()].flatMap((entry) => entry.outcomes));
+}
+function classifyCi(checks) {
+  const outcomes = latestOutcomes(checks);
+  if (outcomes.has("failed"))
+    return "failed";
+  if (outcomes.has("pending"))
+    return "pending";
+  if (outcomes.has("passed"))
+    return "passed";
+  return "none";
+}
 
-// node_modules/.bun/retry@0.12.0/node_modules/retry/lib/retry.js
-var require_retry = __commonJS((exports) => {
-  var RetryOperation = require_retry_operation();
-  exports.operation = function(options) {
-    var timeouts = exports.timeouts(options);
-    return new RetryOperation(timeouts, {
-      forever: options && options.forever,
-      unref: options && options.unref,
-      maxRetryTime: options && options.maxRetryTime
-    });
-  };
-  exports.timeouts = function(options) {
-    if (options instanceof Array) {
-      return [].concat(options);
-    }
-    var opts = {
-      retries: 10,
-      factor: 2,
-      minTimeout: 1 * 1000,
-      maxTimeout: Infinity,
-      randomize: false
+// src/adapters/github/Response.ts
+var PageInfo = Schema6.Struct({
+  endCursor: Schema6.NullOr(Schema6.String),
+  hasNextPage: Schema6.Boolean
+});
+var StatusState = Schema6.Literals(["EXPECTED", "PENDING", "SUCCESS", "ERROR", "FAILURE"]);
+var MergeableState = Schema6.Literals(["MERGEABLE", "CONFLICTING", "UNKNOWN"]);
+var StatusContextNode = Schema6.Struct({
+  __typename: Schema6.Literal("StatusContext"),
+  context: Schema6.String,
+  createdAt: Schema6.String,
+  state: StatusState
+});
+var CheckRunNode = Schema6.Struct({
+  __typename: Schema6.Literal("CheckRun"),
+  checkSuite: Schema6.Struct({
+    app: Schema6.NullOr(Schema6.Struct({ id: Schema6.String })),
+    createdAt: Schema6.String,
+    id: Schema6.String,
+    workflowRun: Schema6.NullOr(Schema6.Struct({
+      event: Schema6.String,
+      runAttempt: Schema6.Int,
+      runNumber: Schema6.Int,
+      workflow: Schema6.Struct({ id: Schema6.String })
+    }))
+  }),
+  conclusion: Schema6.NullOr(Schema6.String),
+  name: Schema6.String,
+  status: Schema6.String
+});
+var ContextNode = Schema6.Union([StatusContextNode, CheckRunNode]);
+var Contexts = Schema6.Struct({
+  nodes: Schema6.Array(ContextNode),
+  pageInfo: PageInfo
+});
+var StackNode = Schema6.Struct({
+  entries: Schema6.Struct({
+    nodes: Schema6.Array(Schema6.Struct({ position: Schema6.Int, pullRequest: Schema6.Struct({ url: Schema6.String }) })),
+    pageInfo: Schema6.Struct({ hasNextPage: Schema6.Boolean })
+  }),
+  id: Schema6.String,
+  size: Schema6.Int
+});
+var PullRequestNode = Schema6.Struct({
+  __typename: Schema6.Literal("PullRequest"),
+  isDraft: Schema6.Boolean,
+  mergeStateStatus: Schema6.String,
+  mergeable: MergeableState,
+  stack: Schema6.NullOr(StackNode),
+  state: Schema6.Literals(["OPEN", "CLOSED", "MERGED"]),
+  statusCheckRollup: Schema6.NullOr(Schema6.Struct({ contexts: Contexts })),
+  title: Schema6.String,
+  url: Schema6.String
+});
+var failedConclusions = new Set([
+  "FAILURE",
+  "CANCELLED",
+  "TIMED_OUT",
+  "ACTION_REQUIRED",
+  "STARTUP_FAILURE",
+  "STALE"
+]);
+var timestamp = /^(?<seconds>[^.]+?)(?:\.(?<fraction>\d+))?Z$/u;
+function generationOf(createdAt) {
+  const match = timestamp.exec(createdAt);
+  const groups = match === null ? {} : match.groups ?? {};
+  const seconds = Date.parse(`${groups["seconds"] ?? ""}Z`) / 1000;
+  const nanoseconds = Number((groups["fraction"] ?? "").padEnd(9, "0").slice(0, 9));
+  return [Number.isFinite(seconds) ? seconds : 0, nanoseconds];
+}
+function checkRunOutcome(status, conclusion) {
+  if (status !== "COMPLETED")
+    return "pending";
+  if (conclusion === "SUCCESS")
+    return "passed";
+  return failedConclusions.has(conclusion ?? "") ? "failed" : "ignored";
+}
+var mergeabilities = {
+  CONFLICTING: "conflicting",
+  MERGEABLE: "mergeable",
+  UNKNOWN: "unknown"
+};
+var statusOutcomes = {
+  ERROR: "failed",
+  EXPECTED: "pending",
+  FAILURE: "failed",
+  PENDING: "pending",
+  SUCCESS: "passed"
+};
+function toCheck(node) {
+  if (node.__typename === "StatusContext") {
+    const identity = `status ${node.context.toLowerCase()}`;
+    return {
+      generation: generationOf(node.createdAt),
+      identity,
+      outcome: statusOutcomes[node.state]
     };
-    for (var key in options) {
-      opts[key] = options[key];
-    }
-    if (opts.minTimeout > opts.maxTimeout) {
-      throw new Error("minTimeout is greater than maxTimeout");
-    }
-    var timeouts = [];
-    for (var i = 0;i < opts.retries; i++) {
-      timeouts.push(this.createTimeout(i, opts));
-    }
-    if (options && options.forever && !timeouts.length) {
-      timeouts.push(this.createTimeout(i, opts));
-    }
-    timeouts.sort(function(a, b) {
-      return a - b;
-    });
-    return timeouts;
-  };
-  exports.createTimeout = function(attempt, opts) {
-    var random = opts.randomize ? Math.random() + 1 : 1;
-    var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
-    timeout = Math.min(timeout, opts.maxTimeout);
-    return timeout;
+  }
+  const outcome = checkRunOutcome(node.status, node.conclusion);
+  const source = node.checkSuite.app === null ? `suite ${node.checkSuite.id}` : `app ${node.checkSuite.app.id}`;
+  return Option4.match(Option4.fromNullishOr(node.checkSuite.workflowRun), {
+    onNone: () => ({
+      generation: generationOf(node.checkSuite.createdAt),
+      identity: `check ${source} ${node.name}`,
+      outcome
+    }),
+    onSome: (run) => ({
+      generation: [run.runNumber, run.runAttempt],
+      identity: `workflow ${source} ${run.workflow.id} ${run.event} ${node.name}`,
+      outcome
+    })
+  });
+}
+function toState(node, contexts) {
+  if (node.state === "MERGED")
+    return { _tag: "Merged" };
+  if (node.state === "CLOSED")
+    return { _tag: "Closed" };
+  return {
+    _tag: "Open",
+    behind: node.mergeStateStatus === "BEHIND",
+    ci: classifyCi(contexts.map((context) => toCheck(context))),
+    draft: node.isDraft,
+    mergeability: mergeabilities[node.mergeable]
   };
-  exports.wrap = function(obj, options, methods) {
-    if (options instanceof Array) {
-      methods = options;
-      options = null;
-    }
-    if (!methods) {
-      methods = [];
-      for (var key in obj) {
-        if (typeof obj[key] === "function") {
-          methods.push(key);
-        }
-      }
-    }
-    for (var i = 0;i < methods.length; i++) {
-      var method = methods[i];
-      var original = obj[method];
-      obj[method] = function retryWrapper(original2) {
-        var op = exports.operation(options);
-        var args = Array.prototype.slice.call(arguments, 1);
-        var callback = args.pop();
-        args.push(function(err) {
-          if (op.retry(err)) {
-            return;
-          }
-          if (err) {
-            arguments[0] = op.mainError();
-          }
-          callback.apply(this, arguments);
-        });
-        op.attempt(function() {
-          original2.apply(obj, args);
-        });
-      }.bind(obj, original);
-      obj[method].options = options;
-    }
+}
+function toMembership(node) {
+  if (node.stack === null)
+    return Option4.some({ _tag: "Standalone" });
+  const { entries, id, size } = node.stack;
+  const ordered = entries.nodes.toSorted((left, right) => left.position - right.position);
+  const members = ordered.flatMap((entry) => Option4.toArray(Result3.getSuccess(parsePullRequestUrl(entry.pullRequest.url))));
+  const complete = !entries.pageInfo.hasNextPage && members.length === size;
+  return complete && Arr2.isArrayNonEmpty(members) ? Option4.some({ _tag: "Stack", id, members }) : Option4.none();
+}
+function toReport(ref, node, contexts) {
+  return {
+    membership: toMembership(node),
+    snapshot: { ref, state: toState(node, contexts), title: node.title }
   };
-});
+}
+function combined(outcomes) {
+  const failures = outcomes.flatMap((outcome) => Option4.toArray(outcome.failure));
+  const everyBatchFailed = failures.length === outcomes.length;
+  return Option4.match(Option4.filter(Arr2.head(failures), () => everyBatchFailed), {
+    onNone: () => Result3.succeed(new Map(outcomes.flatMap((outcome) => outcome.entries))),
+    onSome: (diagnostic) => Result3.fail(diagnostic)
+  });
+}
 
-// node_modules/.bun/signal-exit@3.0.7/node_modules/signal-exit/signals.js
-var require_signals = __commonJS((exports, module) => {
-  module.exports = [
-    "SIGABRT",
-    "SIGALRM",
-    "SIGHUP",
-    "SIGINT",
-    "SIGTERM"
-  ];
-  if (process.platform !== "win32") {
-    module.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
-  }
-  if (process.platform === "linux") {
-    module.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
-  }
+// src/adapters/github/Token.ts
+import { Config, Context as Context3, Effect as Effect3, Layer as Layer2, Option as Option5, Redacted, Ref } from "effect";
+class Token extends Context3.Service()("opencode-pr-tracker/Token") {
+}
+var variable = (name) => Config.option(Config.redacted(name)).pipe(Config.map(Option5.filter((token) => Redacted.value(token).trim() !== "")));
+var environmentToken = Config.all([variable("GH_TOKEN"), variable("GITHUB_TOKEN")]).pipe(Config.map(([ghToken, githubToken]) => Option5.orElse(ghToken, () => githubToken)));
+var layer2 = Layer2.effect(Token, Effect3.gen(function* () {
+  const runner = yield* CommandRunner;
+  const cached = yield* Ref.make(Option5.none());
+  const fromGh = runner.run("gh", ["auth", "token"], process.cwd()).pipe(Effect3.map((output) => output.trim()), Effect3.filterOrFail((token) => token !== "", () => new GitHubFailure({ diagnostic: "AuthenticationRequired" })), Effect3.catchTags({
+    CommandFailed: () => Effect3.fail(new GitHubFailure({ diagnostic: "AuthenticationRequired" })),
+    CommandMissing: () => Effect3.fail(new GitHubFailure({ diagnostic: "GitHubCliMissing" }))
+  }));
+  const fromEnvironment = yield* environmentToken.pipe(Effect3.orElseSucceed(() => Option5.none()));
+  const load = Option5.match(fromEnvironment, {
+    onNone: () => Effect3.map(fromGh, Redacted.make),
+    onSome: Effect3.succeed
+  }).pipe(Effect3.tap((token) => Ref.set(cached, Option5.some(token))));
+  return Token.of({
+    get: Ref.get(cached).pipe(Effect3.flatMap(Option5.match({ onNone: () => load, onSome: Effect3.succeed }))),
+    invalidate: Ref.set(cached, Option5.none())
+  });
+}));
+
+// src/adapters/github/Client.ts
+var endpoint = "https://api.github.com/graphql";
+var GraphQlError = Schema7.Struct({
+  path: Schema7.optional(Schema7.Array(Schema7.Union([Schema7.String, Schema7.Number]))),
+  type: Schema7.optional(Schema7.String)
+});
+var Envelope = Schema7.Struct({
+  data: Schema7.optional(Schema7.NullOr(Schema7.Record(Schema7.String, Schema7.Unknown))),
+  errors: Schema7.optional(Schema7.Array(GraphQlError))
+});
+var ContinuationData = Schema7.Struct({
+  resource: Schema7.Struct({ statusCheckRollup: Schema7.Struct({ contexts: Contexts }) })
 });
+var failure = (diagnostic) => new GitHubFailure({ diagnostic });
 
-// node_modules/.bun/signal-exit@3.0.7/node_modules/signal-exit/index.js
-var require_signal_exit = __commonJS((exports, module) => {
-  var process2 = global.process;
-  var processOk = function(process3) {
-    return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+class Unauthorized extends Schema7.TaggedError()("Unauthorized", {}) {
+}
+var failed2 = (diagnostic) => ({ _tag: "Failed", diagnostic });
+var decodeEnvelope = Schema7.decodeUnknownEffect(Envelope);
+var makePost = Effect4.fn("makePost")(function* () {
+  const http = yield* HttpClient.HttpClient;
+  const token = yield* Token;
+  const attempt = Effect4.fn("attempt")(function* (query, variables) {
+    const bearer = yield* token.get;
+    const request = HttpClientRequest.post(endpoint).pipe(HttpClientRequest.bearerToken(Redacted2.value(bearer)), HttpClientRequest.bodyJsonUnsafe({ query, variables }));
+    const response = yield* http.execute(request).pipe(Effect4.mapError(() => failure("GitHubUnavailable")));
+    if (response.status === 401)
+      return yield* new Unauthorized;
+    if (response.status < 200 || response.status >= 300)
+      return yield* failure("GitHubUnavailable");
+    const body = yield* response.json.pipe(Effect4.mapError(() => failure("InvalidResponse")));
+    return yield* decodeEnvelope(body).pipe(Effect4.mapError(() => failure("InvalidResponse")));
+  });
+  return (query, variables) => attempt(query, variables).pipe(Effect4.catchTag("Unauthorized", () => Effect4.andThen(token.invalidate, attempt(query, variables))), Effect4.catchTag("Unauthorized", () => Effect4.fail(failure("AuthenticationRequired"))));
+});
+var allContexts = Effect4.fn("allContexts")(function* (post, node) {
+  const collected = [];
+  const followed = new Set;
+  let page = Option6.map(Option6.fromNullishOr(node.statusCheckRollup), (rollup) => rollup.contexts);
+  while (Option6.isSome(page)) {
+    collected.push(...page.value.nodes);
+    if (!page.value.pageInfo.hasNextPage)
+      break;
+    const after = page.value.pageInfo.endCursor ?? "";
+    if (after === "" || followed.has(after))
+      return yield* failure("InvalidResponse");
+    followed.add(after);
+    const envelope = yield* post(continuation(), { cursor: after, url: node.url });
+    if ((envelope.errors ?? []).length > 0)
+      return yield* failure("InvalidResponse");
+    const data = yield* Schema7.decodeUnknownEffect(ContinuationData)(envelope.data).pipe(Effect4.mapError(() => failure("InvalidResponse")));
+    page = Option6.some(data.resource.statusCheckRollup.contexts);
+  }
+  return collected;
+});
+var inaccessible = new Set(["NOT_FOUND", "FORBIDDEN"]);
+function aliasFailure(request, key) {
+  const diagnostics = (request.envelope.errors ?? []).flatMap((error) => {
+    const root = String((error.path ?? [])[0] ?? "");
+    if (root === key)
+      return [inaccessible.has(error.type ?? "") ? "NotFound" : "InvalidResponse"];
+    return request.aliases.has(root) ? [] : ["InvalidResponse"];
+  });
+  if (diagnostics.length === 0)
+    return Option6.none();
+  return Option6.some(diagnostics.includes("InvalidResponse") ? "InvalidResponse" : "NotFound");
+}
+var itemResult = Effect4.fn("itemResult")(function* (request, ref, key) {
+  const { envelope, post } = request;
+  const reported = aliasFailure(request, key);
+  const raw = Option6.fromNullishOr((envelope.data ?? {})[key]);
+  if (Option6.isSome(reported))
+    return failed2(reported.value);
+  if (Option6.isNone(raw))
+    return failed2("NotFound");
+  const node = Schema7.decodeUnknownOption(PullRequestNode)(raw.value);
+  if (Option6.isNone(node))
+    return failed2("InvalidResponse");
+  const contexts = yield* Effect4.result(allContexts(post, node.value));
+  if (Result4.isFailure(contexts))
+    return failed2(contexts.failure.diagnostic);
+  return {
+    _tag: "Reported",
+    report: toReport(ref, node.value, contexts.success)
   };
-  if (!processOk(process2)) {
-    module.exports = function() {
-      return function() {};
-    };
-  } else {
-    assert = __require("assert");
-    signals = require_signals();
-    isWin = /^win/i.test(process2.platform);
-    EE = __require("events");
-    if (typeof EE !== "function") {
-      EE = EE.EventEmitter;
-    }
-    if (process2.__signal_exit_emitter__) {
-      emitter = process2.__signal_exit_emitter__;
-    } else {
-      emitter = process2.__signal_exit_emitter__ = new EE;
-      emitter.count = 0;
-      emitter.emitted = {};
-    }
-    if (!emitter.infinite) {
-      emitter.setMaxListeners(Infinity);
-      emitter.infinite = true;
-    }
-    module.exports = function(cb, opts) {
-      if (!processOk(global.process)) {
-        return function() {};
-      }
-      assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
-      if (loaded === false) {
-        load();
-      }
-      var ev = "exit";
-      if (opts && opts.alwaysLast) {
-        ev = "afterexit";
-      }
-      var remove = function() {
-        emitter.removeListener(ev, cb);
-        if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
-          unload();
-        }
-      };
-      emitter.on(ev, cb);
-      return remove;
-    };
-    unload = function unload2() {
-      if (!loaded || !processOk(global.process)) {
-        return;
-      }
-      loaded = false;
-      signals.forEach(function(sig) {
-        try {
-          process2.removeListener(sig, sigListeners[sig]);
-        } catch (er) {}
-      });
-      process2.emit = originalProcessEmit;
-      process2.reallyExit = originalProcessReallyExit;
-      emitter.count -= 1;
-    };
-    module.exports.unload = unload;
-    emit = function emit2(event, code, signal) {
-      if (emitter.emitted[event]) {
-        return;
-      }
-      emitter.emitted[event] = true;
-      emitter.emit(event, code, signal);
-    };
-    sigListeners = {};
-    signals.forEach(function(sig) {
-      sigListeners[sig] = function listener() {
-        if (!processOk(global.process)) {
-          return;
-        }
-        var listeners = process2.listeners(sig);
-        if (listeners.length === emitter.count) {
-          unload();
-          emit("exit", null, sig);
-          emit("afterexit", null, sig);
-          if (isWin && sig === "SIGHUP") {
-            sig = "SIGINT";
-          }
-          process2.kill(process2.pid, sig);
-        }
-      };
-    });
-    module.exports.signals = function() {
-      return signals;
-    };
-    loaded = false;
-    load = function load2() {
-      if (loaded || !processOk(global.process)) {
-        return;
-      }
-      loaded = true;
-      emitter.count += 1;
-      signals = signals.filter(function(sig) {
-        try {
-          process2.on(sig, sigListeners[sig]);
-          return true;
-        } catch (er) {
-          return false;
-        }
-      });
-      process2.emit = processEmit;
-      process2.reallyExit = processReallyExit;
-    };
-    module.exports.load = load;
-    originalProcessReallyExit = process2.reallyExit;
-    processReallyExit = function processReallyExit2(code) {
-      if (!processOk(global.process)) {
-        return;
-      }
-      process2.exitCode = code || 0;
-      emit("exit", process2.exitCode, null);
-      emit("afterexit", process2.exitCode, null);
-      originalProcessReallyExit.call(process2, process2.exitCode);
-    };
-    originalProcessEmit = process2.emit;
-    processEmit = function processEmit2(ev, arg) {
-      if (ev === "exit" && processOk(global.process)) {
-        if (arg !== undefined) {
-          process2.exitCode = arg;
-        }
-        var ret = originalProcessEmit.apply(this, arguments);
-        emit("exit", process2.exitCode, null);
-        emit("afterexit", process2.exitCode, null);
-        return ret;
-      } else {
-        return originalProcessEmit.apply(this, arguments);
-      }
-    };
-  }
-  var assert;
-  var signals;
-  var isWin;
-  var EE;
-  var emitter;
-  var unload;
-  var emit;
-  var sigListeners;
-  var loaded;
-  var load;
-  var originalProcessReallyExit;
-  var processReallyExit;
-  var originalProcessEmit;
-  var processEmit;
 });
-
-// node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js
-var require_mtime_precision = __commonJS((exports, module) => {
-  var cacheSymbol = Symbol();
-  function probe(file, fs, callback) {
-    const cachedPrecision = fs[cacheSymbol];
-    if (cachedPrecision) {
-      return fs.stat(file, (err, stat) => {
-        if (err) {
-          return callback(err);
-        }
-        callback(null, stat.mtime, cachedPrecision);
-      });
-    }
-    const mtime = new Date(Math.ceil(Date.now() / 1000) * 1000 + 5);
-    fs.utimes(file, mtime, mtime, (err) => {
-      if (err) {
-        return callback(err);
-      }
-      fs.stat(file, (err2, stat) => {
-        if (err2) {
-          return callback(err2);
-        }
-        const precision = stat.mtime.getTime() % 1000 === 0 ? "s" : "ms";
-        Object.defineProperty(fs, cacheSymbol, { value: precision });
-        callback(null, stat.mtime, precision);
-      });
-    });
-  }
-  function getMtime(precision) {
-    let now = Date.now();
-    if (precision === "s") {
-      now = Math.ceil(now / 1000) * 1000;
-    }
-    return new Date(now);
-  }
-  exports.probe = probe;
-  exports.getMtime = getMtime;
+var fetchBatch = Effect4.fn("fetchBatch")(function* (post, refs) {
+  const variables = Object.fromEntries(refs.map((ref, index) => [alias(index), ref.url]));
+  const envelope = yield* post(batch(refs.length), variables);
+  if (Option6.isNone(Option6.fromNullishOr(envelope.data)))
+    return yield* failure("GitHubUnavailable");
+  const results = yield* Effect4.forEach(refs, (ref, index) => itemResult({ aliases: new Set(Object.keys(variables)), envelope, post }, ref, alias(index)), {
+    concurrency: 4
+  });
+  return Arr3.zip(refs.map((ref) => ref.url), results);
 });
-
-// node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js
-var require_lockfile = __commonJS((exports, module) => {
-  var path = __require("path");
-  var fs = require_graceful_fs();
-  var retry = require_retry();
-  var onExit = require_signal_exit();
-  var mtimePrecision = require_mtime_precision();
-  var locks = {};
-  function getLockFile(file, options) {
-    return options.lockfilePath || `${file}.lock`;
-  }
-  function resolveCanonicalPath(file, options, callback) {
-    if (!options.realpath) {
-      return callback(null, path.resolve(file));
-    }
-    options.fs.realpath(file, callback);
-  }
-  function acquireLock(file, options, callback) {
-    const lockfilePath = getLockFile(file, options);
-    options.fs.mkdir(lockfilePath, (err) => {
-      if (!err) {
-        return mtimePrecision.probe(lockfilePath, options.fs, (err2, mtime, mtimePrecision2) => {
-          if (err2) {
-            options.fs.rmdir(lockfilePath, () => {});
-            return callback(err2);
-          }
-          callback(null, mtime, mtimePrecision2);
-        });
-      }
-      if (err.code !== "EEXIST") {
-        return callback(err);
-      }
-      if (options.stale <= 0) {
-        return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
-      }
-      options.fs.stat(lockfilePath, (err2, stat) => {
-        if (err2) {
-          if (err2.code === "ENOENT") {
-            return acquireLock(file, { ...options, stale: 0 }, callback);
-          }
-          return callback(err2);
-        }
-        if (!isLockStale(stat, options)) {
-          return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
-        }
-        removeLock(file, options, (err3) => {
-          if (err3) {
-            return callback(err3);
-          }
-          acquireLock(file, { ...options, stale: 0 }, callback);
-        });
-      });
-    });
-  }
-  function isLockStale(stat, options) {
-    return stat.mtime.getTime() < Date.now() - options.stale;
-  }
-  function removeLock(file, options, callback) {
-    options.fs.rmdir(getLockFile(file, options), (err) => {
-      if (err && err.code !== "ENOENT") {
-        return callback(err);
-      }
-      callback();
-    });
-  }
-  function updateLock(file, options) {
-    const lock2 = locks[file];
-    if (lock2.updateTimeout) {
-      return;
-    }
-    lock2.updateDelay = lock2.updateDelay || options.update;
-    lock2.updateTimeout = setTimeout(() => {
-      lock2.updateTimeout = null;
-      options.fs.stat(lock2.lockfilePath, (err, stat) => {
-        const isOverThreshold = lock2.lastUpdate + options.stale < Date.now();
-        if (err) {
-          if (err.code === "ENOENT" || isOverThreshold) {
-            return setLockAsCompromised(file, lock2, Object.assign(err, { code: "ECOMPROMISED" }));
-          }
-          lock2.updateDelay = 1000;
-          return updateLock(file, options);
-        }
-        const isMtimeOurs = lock2.mtime.getTime() === stat.mtime.getTime();
-        if (!isMtimeOurs) {
-          return setLockAsCompromised(file, lock2, Object.assign(new Error("Unable to update lock within the stale threshold"), { code: "ECOMPROMISED" }));
-        }
-        const mtime = mtimePrecision.getMtime(lock2.mtimePrecision);
-        options.fs.utimes(lock2.lockfilePath, mtime, mtime, (err2) => {
-          const isOverThreshold2 = lock2.lastUpdate + options.stale < Date.now();
-          if (lock2.released) {
-            return;
-          }
-          if (err2) {
-            if (err2.code === "ENOENT" || isOverThreshold2) {
-              return setLockAsCompromised(file, lock2, Object.assign(err2, { code: "ECOMPROMISED" }));
-            }
-            lock2.updateDelay = 1000;
-            return updateLock(file, options);
-          }
-          lock2.mtime = mtime;
-          lock2.lastUpdate = Date.now();
-          lock2.updateDelay = null;
-          updateLock(file, options);
-        });
-      });
-    }, lock2.updateDelay);
-    if (lock2.updateTimeout.unref) {
-      lock2.updateTimeout.unref();
-    }
-  }
-  function setLockAsCompromised(file, lock2, err) {
-    lock2.released = true;
-    if (lock2.updateTimeout) {
-      clearTimeout(lock2.updateTimeout);
-    }
-    if (locks[file] === lock2) {
-      delete locks[file];
-    }
-    lock2.options.onCompromised(err);
-  }
-  function lock(file, options, callback) {
-    options = {
-      stale: 1e4,
-      update: null,
-      realpath: true,
-      retries: 0,
-      fs,
-      onCompromised: (err) => {
-        throw err;
-      },
-      ...options
-    };
-    options.retries = options.retries || 0;
-    options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
-    options.stale = Math.max(options.stale || 0, 2000);
-    options.update = options.update == null ? options.stale / 2 : options.update || 0;
-    options.update = Math.max(Math.min(options.update, options.stale / 2), 1000);
-    resolveCanonicalPath(file, options, (err, file2) => {
-      if (err) {
-        return callback(err);
-      }
-      const operation = retry.operation(options.retries);
-      operation.attempt(() => {
-        acquireLock(file2, options, (err2, mtime, mtimePrecision2) => {
-          if (operation.retry(err2)) {
-            return;
-          }
-          if (err2) {
-            return callback(operation.mainError());
-          }
-          const lock2 = locks[file2] = {
-            lockfilePath: getLockFile(file2, options),
-            mtime,
-            mtimePrecision: mtimePrecision2,
-            options,
-            lastUpdate: Date.now()
-          };
-          updateLock(file2, options);
-          callback(null, (releasedCallback) => {
-            if (lock2.released) {
-              return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
-            }
-            unlock(file2, { ...options, realpath: false }, releasedCallback);
-          });
-        });
-      });
-    });
-  }
-  function unlock(file, options, callback) {
-    options = {
-      fs,
-      realpath: true,
-      ...options
-    };
-    resolveCanonicalPath(file, options, (err, file2) => {
-      if (err) {
-        return callback(err);
-      }
-      const lock2 = locks[file2];
-      if (!lock2) {
-        return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
-      }
-      lock2.updateTimeout && clearTimeout(lock2.updateTimeout);
-      lock2.released = true;
-      delete locks[file2];
-      removeLock(file2, options, callback);
-    });
-  }
-  function check(file, options, callback) {
-    options = {
-      stale: 1e4,
-      realpath: true,
-      fs,
-      ...options
-    };
-    options.stale = Math.max(options.stale || 0, 2000);
-    resolveCanonicalPath(file, options, (err, file2) => {
-      if (err) {
-        return callback(err);
-      }
-      options.fs.stat(getLockFile(file2, options), (err2, stat) => {
-        if (err2) {
-          return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
-        }
-        return callback(null, !isLockStale(stat, options));
-      });
-    });
-  }
-  function getLocks() {
-    return locks;
-  }
-  onExit(() => {
-    for (const file in locks) {
-      const options = locks[file].options;
-      try {
-        options.fs.rmdirSync(getLockFile(file, options));
-      } catch (e) {}
-    }
+var outcomeOf = (post, refs) => Effect4.gen(function* () {
+  const result = yield* Effect4.result(fetchBatch(post, refs));
+  if (Result4.isSuccess(result))
+    return { entries: result.success, failure: Option6.none() };
+  const { diagnostic } = result.failure;
+  return {
+    entries: refs.map((ref) => [ref.url, { _tag: "Failed", diagnostic }]),
+    failure: Option6.some(diagnostic)
+  };
+});
+var layer3 = Layer3.effect(GitHub, Effect4.gen(function* () {
+  const post = yield* makePost();
+  const runner = yield* CommandRunner;
+  return GitHub.of({
+    fetch: (refs) => {
+      const batches = Arr3.chunksOf(Arr3.dedupeWith(refs, (left, right) => left.url === right.url), maximumBatch);
+      return Effect4.forEach(batches, (refsInBatch) => outcomeOf(post, refsInBatch)).pipe(Effect4.flatMap((outcomes) => Effect4.fromResult(combined(outcomes))), Effect4.mapError(failure));
+    },
+    pullRequestInRepository: (directory, number) => resolveInRepository(directory, number).pipe(Effect4.provideService(CommandRunner, runner))
   });
-  exports.lock = lock;
-  exports.unlock = unlock;
-  exports.check = check;
-  exports.getLocks = getLocks;
+}));
+var live = layer3.pipe(Layer3.provide(layer2), Layer3.provide([layer, FetchHttpClient.layer]));
+
+// src/adapters/Storage.ts
+import { Array as Arr5, Effect as Effect5, Layer as Layer4, Option as Option8, Result as Result6, Schema as Schema10 } from "effect";
+
+// src/domain/Tracking.ts
+import { Array as Arr4, Option as Option7, Result as Result5, Schema as Schema8 } from "effect";
+var maximumAttachments = 20;
+
+class Attachment extends Schema8.Class("Attachment")({
+  attachedAt: Schema8.Int,
+  ref: PullRequestRef
+}) {
+}
+
+class AttachmentLimitReached extends Schema8.TaggedError()("AttachmentLimitReached", { limit: Schema8.Int, requested: Schema8.Int }) {
+}
+
+class AmbiguousPullRequestNumber extends Schema8.TaggedError()("AmbiguousPullRequestNumber", { matches: Schema8.Array(PullRequestRef), number: Schema8.Int }) {
+}
+function isMember(stack, attachment) {
+  return stack.some((ref) => samePullRequest(ref, attachment.ref));
+}
+function attach(tracking, stack, now) {
+  const members = Arr4.dedupeWith(stack, samePullRequest);
+  const others = tracking.filter((attachment) => !isMember(members, attachment));
+  const requested = others.length + members.length;
+  if (requested > maximumAttachments) {
+    return Result5.fail(new AttachmentLimitReached({ limit: maximumAttachments, requested }));
+  }
+  const position = tracking.findIndex((attachment) => isMember(members, attachment));
+  const insertAt = position === -1 ? others.length : position;
+  const placed = members.map((ref) => Option7.getOrElse(Arr4.findFirst(tracking, (attachment) => samePullRequest(attachment.ref, ref)), () => new Attachment({ attachedAt: now, ref })));
+  const next = [...others.slice(0, insertAt), ...placed, ...others.slice(insertAt)];
+  const changed = next.length !== tracking.length || next.some((attachment, index) => attachment !== tracking[index]);
+  return Result5.succeed({ changed, tracking: next });
+}
+function detach(tracking, ref) {
+  const next = tracking.filter((attachment) => !samePullRequest(attachment.ref, ref));
+  const removed = next.length === tracking.length ? Option7.none() : Option7.some(ref);
+  return { removed, tracking: next };
+}
+function detachNumber(tracking, number) {
+  const matches = tracking.filter((attachment) => attachment.ref.number === number);
+  if (matches.length > 1) {
+    const refs = matches.map((attachment) => attachment.ref);
+    return Result5.fail(new AmbiguousPullRequestNumber({ matches: refs, number }));
+  }
+  return Result5.succeed(Option7.match(Arr4.head(matches), {
+    onNone: () => ({ removed: Option7.none(), tracking }),
+    onSome: (attachment) => detach(tracking, attachment.ref)
+  }));
+}
+
+// src/ports/TrackingRepository.ts
+import { Context as Context4, Schema as Schema9 } from "effect";
+
+class StoredStateInvalid extends Schema9.TaggedError()("StoredStateInvalid", {
+  sessionID: Schema9.String
+}) {
+}
+
+class TrackingRepository extends Context4.Service()("opencode-pr-tracker/TrackingRepository") {
+}
+
+// src/adapters/Storage.ts
+var Stored = Schema10.Struct({
+  pullRequests: Schema10.Array(Schema10.Struct({ attachedAt: Schema10.Int, url: Schema10.String })).check(Schema10.isMaxLength(maximumAttachments)),
+  version: Schema10.Literal(1)
 });
+var keyOf = (sessionID) => `session/${sessionID}`;
+function toTracking(stored) {
+  const attachments = stored.pullRequests.map((entry) => Result6.map(parsePullRequestUrl(entry.url), (ref) => new Attachment({ attachedAt: entry.attachedAt, ref })));
+  const valid = attachments.flatMap((attachment) => Option8.toArray(Result6.getSuccess(attachment)));
+  const unique = Arr5.dedupeWith(valid, (left, right) => left.ref.url === right.ref.url);
+  return unique.length === stored.pullRequests.length ? Option8.some(unique) : Option8.none();
+}
+function toStored(tracking) {
+  return {
+    pullRequests: tracking.map((attachment) => ({
+      attachedAt: attachment.attachedAt,
+      url: attachment.ref.url
+    })),
+    version: 1
+  };
+}
+function layer4(storage) {
+  return Layer4.succeed(TrackingRepository, TrackingRepository.of({
+    load: (sessionID) => storage.get(keyOf(sessionID)).pipe(Effect5.flatMap((value) => Option8.match(Option8.fromNullishOr(value), {
+      onNone: () => Effect5.succeed([]),
+      onSome: (json) => Schema10.decodeUnknownOption(Stored)(json).pipe(Option8.flatMap(toTracking), Option8.match({
+        onNone: () => Effect5.fail(new StoredStateInvalid({ sessionID })),
+        onSome: (tracking) => Effect5.succeed(tracking)
+      }))
+    }))),
+    remove: (sessionID) => storage.remove(keyOf(sessionID)),
+    save: (sessionID, tracking) => storage.set(keyOf(sessionID), toStored(tracking))
+  }));
+}
 
-// node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js
-var require_adapter = __commonJS((exports, module) => {
-  var fs = require_graceful_fs();
-  function createSyncFs(fs2) {
-    const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-    const newFs = { ...fs2 };
-    methods.forEach((method) => {
-      newFs[method] = (...args) => {
-        const callback = args.pop();
-        let ret;
-        try {
-          ret = fs2[`${method}Sync`](...args);
-        } catch (err) {
-          return callback(err);
-        }
-        callback(null, ret);
-      };
-    });
-    return newFs;
-  }
-  function toPromise(method) {
-    return (...args) => new Promise((resolve, reject) => {
-      args.push((err, result) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(result);
-        }
-      });
-      method(...args);
+// src/application/Monitor.ts
+import { Context as Context6, Effect as Effect9, Layer as Layer6, Option as Option13, PubSub, Ref as Ref2, Result as Result7, Stream } from "effect";
+
+// src/application/FetchQueue.ts
+import { Deferred, Effect as Effect6, Exit, Option as Option9 } from "effect";
+
+class FetchQueue {
+  running = false;
+  queued = Option9.none();
+  fetchNow;
+  scope;
+  constructor(fetchNow, scope) {
+    this.fetchNow = fetchNow;
+    this.scope = scope;
+  }
+  fetch(refs) {
+    return Effect6.suspend(() => {
+      if (refs.length === 0)
+        return Effect6.void;
+      if (this.running)
+        return Effect6.asVoid(Deferred.await(this.join(refs)));
+      this.running = true;
+      const done = Deferred.makeUnsafe();
+      return Effect6.andThen(Effect6.forkIn(this.drain(refs, done), this.scope), Deferred.await(done));
     });
   }
-  function toSync(method) {
-    return (...args) => {
-      let err;
-      let result;
-      args.push((_err, _result) => {
-        err = _err;
-        result = _result;
-      });
-      method(...args);
-      if (err) {
-        throw err;
+  join(refs) {
+    const next = Option9.getOrElse(this.queued, () => ({
+      done: Deferred.makeUnsafe(),
+      refs: new Map
+    }));
+    for (const ref of refs)
+      next.refs.set(ref.url, ref);
+    this.queued = Option9.some(next);
+    return next.done;
+  }
+  drain(refs, done) {
+    return this.fetchNow(refs).pipe(Effect6.andThen(Deferred.succeed(done, true)), Effect6.andThen(Effect6.suspend(() => this.next())), Effect6.onExit((exit) => Exit.isSuccess(exit) ? Effect6.void : Effect6.suspend(() => this.reset(done, exit.cause))));
+  }
+  next() {
+    return Option9.match(this.queued, {
+      onNone: () => Effect6.sync(() => {
+        this.running = false;
+      }),
+      onSome: (queued) => {
+        this.queued = Option9.none();
+        return this.drain([...queued.refs.values()], queued.done);
       }
-      return result;
-    };
+    });
   }
-  function toSyncOptions(options) {
-    options = { ...options };
-    options.fs = createSyncFs(options.fs || fs);
-    if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
-      throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
-    }
-    return options;
+  reset(done, cause) {
+    const waiting = [done, ...Option9.toArray(Option9.map(this.queued, (queued) => queued.done))];
+    this.running = false;
+    this.queued = Option9.none();
+    return Effect6.forEach(waiting, (deferred) => Deferred.failCause(deferred, cause), {
+      discard: true
+    });
   }
-  module.exports = {
-    toPromise,
-    toSync,
-    toSyncOptions
-  };
-});
+}
 
-// node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js
-var require_proper_lockfile = __commonJS((exports, module) => {
-  var lockfile = require_lockfile();
-  var { toPromise, toSync, toSyncOptions } = require_adapter();
-  async function lock(file, options) {
-    const release = await toPromise(lockfile.lock)(file, options);
-    return toPromise(release);
-  }
-  function lockSync(file, options) {
-    const release = toSync(lockfile.lock)(file, toSyncOptions(options));
-    return toSync(release);
-  }
-  function unlock(file, options) {
-    return toPromise(lockfile.unlock)(file, options);
-  }
-  function unlockSync(file, options) {
-    return toSync(lockfile.unlock)(file, toSyncOptions(options));
-  }
-  function check(file, options) {
-    return toPromise(lockfile.check)(file, options);
-  }
-  function checkSync(file, options) {
-    return toSync(lockfile.check)(file, toSyncOptions(options));
-  }
-  module.exports = lock;
-  module.exports.lock = lock;
-  module.exports.unlock = unlock;
-  module.exports.lockSync = lockSync;
-  module.exports.unlockSync = unlockSync;
-  module.exports.check = check;
-  module.exports.checkSync = checkSync;
-});
+// src/application/Known.ts
+import { Duration as Duration3, Option as Option11 } from "effect";
 
-// src/server.ts
-import { tool } from "@opencode-ai/plugin";
+// src/domain/RefreshPolicy.ts
+import { Duration as Duration2, Option as Option10 } from "effect";
+var refreshInterval = Duration2.seconds(15);
+function nextRefresh(status) {
+  const merged = (status._tag === "Fresh" || status._tag === "Stale") && status.snapshot.state._tag === "Merged";
+  return merged ? Option10.none() : Option10.some(refreshInterval);
+}
 
-// src/github.ts
-import { execFile } from "child_process";
+// src/application/Known.ts
+var unknown = { dueAt: Option11.some(0), membership: Option11.none(), status: pending };
+function afterRefresh(previous, result, now) {
+  const status = result._tag === "Reported" ? succeeded(result.report.snapshot) : failed(previous.status, result.diagnostic, now);
+  const membership = result._tag === "Reported" ? result.report.membership : previous.membership;
+  return {
+    dueAt: Option11.map(nextRefresh(status), (delay) => now + Duration3.toMillis(delay)),
+    membership,
+    status
+  };
+}
+var isDue = (known, now, ref) => Option11.match((known.get(ref.url) ?? unknown).dueAt, {
+  onNone: () => false,
+  onSome: (at) => at <= now
+});
+function withoutUnattached(entries, before, attached) {
+  return new Map([...entries].filter(([url, entry]) => attached.has(url) || entry !== before.get(url)));
+}
+
+// src/application/Time.ts
+import { Clock, Effect as Effect7 } from "effect";
+var currentMillis = Effect7.map(Clock.currentTimeMillis, Math.floor);
 
-// src/exhaustive.ts
-function casesHandled(value) {
-  throw new Error(`Unhandled case: ${String(value)}`);
+// src/application/Tracker.ts
+import { Array as Arr6, Context as Context5, Effect as Effect8, Layer as Layer5, Option as Option12, Schema as Schema11, Semaphore } from "effect";
+class PullRequestUnavailable extends Schema11.TaggedError()("PullRequestUnavailable", { diagnostic: Diagnostic, url: Schema11.String }) {
 }
 
-// src/url.ts
-var expectedPullRequestUrl = "Expected https://github.com/<owner>/<repository>/pull/<positive-integer> or github.com/<owner>/<repository>/pull/<positive-integer>";
-var invalidPullRequestUrl = {
-  ok: false,
-  error: {
-    tag: "InvalidPullRequestUrl",
-    message: expectedPullRequestUrl
-  }
-};
-var segmentPattern = /^[A-Za-z0-9._-]+$/;
-var schemeLessPrefix = "github.com/";
-function parsePullRequestUrl(input) {
-  if (/\s/.test(input))
-    return invalidPullRequestUrl;
-  if (input.includes("\\"))
-    return invalidPullRequestUrl;
-  const candidate = input.slice(0, schemeLessPrefix.length).toLowerCase() === schemeLessPrefix ? `https://${input}` : input;
-  if (!candidate.startsWith("https://"))
-    return invalidPullRequestUrl;
-  const authorityEnd = candidate.indexOf("/", "https://".length);
-  if (authorityEnd === -1)
-    return invalidPullRequestUrl;
-  if (candidate.slice("https://".length, authorityEnd).toLowerCase() !== "github.com") {
-    return invalidPullRequestUrl;
-  }
-  const rawPath = candidate.slice(authorityEnd).split(/[?#]/, 1).join("");
-  for (const segment of rawPath.split("/")) {
-    let decoded;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-      return invalidPullRequestUrl;
-    }
-    if (decoded === "." || decoded === "..")
-      return invalidPullRequestUrl;
-  }
-  let parsed;
-  try {
-    parsed = new URL(candidate);
-  } catch {
-    return invalidPullRequestUrl;
-  }
-  if (parsed.protocol !== "https:" || parsed.hostname !== "github.com" || parsed.username !== "" || parsed.password !== "" || parsed.port !== "" || parsed.search !== "" || parsed.hash !== "") {
-    return invalidPullRequestUrl;
-  }
-  const segments = parsed.pathname.split("/");
-  if (segments.length !== 5 || segments[0] !== "" || segments[3] !== "pull") {
-    return invalidPullRequestUrl;
-  }
-  const rawOwner = segments[1];
-  const rawRepository = segments[2];
-  const numberText = segments[4];
-  if (rawOwner === undefined || rawRepository === undefined || numberText === undefined || !segmentPattern.test(rawOwner) || !segmentPattern.test(rawRepository) || !/^\d+$/.test(numberText)) {
-    return invalidPullRequestUrl;
-  }
-  const number = Number(numberText);
-  if (!Number.isSafeInteger(number) || number <= 0)
-    return invalidPullRequestUrl;
-  const owner = rawOwner.toLowerCase();
-  const repository = rawRepository.toLowerCase();
-  const url = `https://github.com/${owner}/${repository}/pull/${number}`;
-  const value = { url, owner, repository, number };
-  return { ok: true, value };
-}
-function formatPullRequestRef(pullRequest) {
-  return `${pullRequest.owner}/${pullRequest.repository}#${pullRequest.number}`;
+class StackIncomplete extends Schema11.TaggedError()("StackIncomplete", {
+  url: Schema11.String
+}) {
 }
 
-// src/github.ts
-var invalidGitHubResponse = {
-  ok: false,
-  error: {
-    tag: "InvalidGitHubResponse",
-    message: "GitHub returned an invalid pull request response"
-  }
-};
-var pullRequestNotFound = {
-  ok: false,
-  error: {
-    tag: "PullRequestNotFound",
-    message: "Pull request does not exist or is not accessible"
-  }
-};
-var githubBatchLimitExceeded = {
-  ok: false,
-  error: {
-    tag: "GitHubBatchLimitExceeded",
-    limit: 20,
-    message: "GitHub batch cannot contain more than 20 pull requests"
-  }
-};
-var maximumPullRequestsPerBatch = 20;
-var maximumCheckContextsPerPage = 100;
-var statusContextOnlyFields = ["context", "state", "createdAt"];
-var checkRunOnlyFields = ["name", "status", "conclusion", "checkSuite"];
-var checkContextSelection = `nodes { __typename ... on StatusContext { id context state createdAt } ... on CheckRun { id name status conclusion checkSuite { id createdAt app { id } workflowRun { event runNumber runAttempt workflow { id } } } } } totalCount pageInfo { hasNextPage endCursor }`;
-var pullRequestSelection = `__typename ... on PullRequest { title state url mergedAt mergeable mergeStateStatus baseRef { branchProtectionRule { requiresStatusChecks requiresStrictStatusChecks } refUpdateRule { requiredStatusCheckContexts } rules(first: 100) { nodes { parameters { __typename ... on RequiredStatusChecksParameters { strictRequiredStatusChecksPolicy requiredStatusChecks { context } } } } totalCount pageInfo { hasNextPage } } } statusCheckRollup { contexts(first: ${maximumCheckContextsPerPage}) { ${checkContextSelection} } } }`;
-var continuationQuery = `query PullRequestContexts($url: URI!, $cursor: String!) { resource(url: $url) { __typename ... on PullRequest { url statusCheckRollup { contexts(first: ${maximumCheckContextsPerPage}, after: $cursor) { ${checkContextSelection} } } } } }`;
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function parseProcessExecutionFailed(value) {
-  if (!isRecord(value) || value.tag !== "ProcessExecutionFailed" || value.code !== null && typeof value.code !== "string" && typeof value.code !== "number" || typeof value.stderr !== "string" || typeof value.stdout !== "string" || !("cause" in value)) {
-    return;
-  }
+class Tracker extends Context5.Service()("opencode-pr-tracker/Tracker") {
+}
+function discovered(ref, result) {
+  if (result._tag === "Failed")
+    return Effect8.fail(new PullRequestUnavailable({ diagnostic: result.diagnostic, url: ref.url }));
+  const { report } = result;
+  return Option12.match(report.membership, {
+    onNone: () => Effect8.fail(new StackIncomplete({ url: ref.url })),
+    onSome: (membership) => Effect8.succeed({
+      report,
+      stack: membership._tag === "Stack" ? membership.members : Arr6.of(ref)
+    })
+  });
+}
+function sessionLocks() {
+  const locks = new Map;
+  return (sessionID) => (effect) => Effect8.suspend(() => {
+    const lock = locks.get(sessionID) ?? Semaphore.makeUnsafe(1);
+    locks.set(sessionID, lock);
+    return lock.withPermit(effect);
+  });
+}
+function resolve({ github }, input, directory) {
+  return input._tag === "Reference" ? Effect8.succeed(input.ref) : github.pullRequestInRepository(directory, input.number);
+}
+var attachTo = Effect8.fn("Tracker.attach")(function* (services, sessionID, target) {
+  const ref = yield* resolve(services, target.input, target.directory);
+  const reports = yield* services.github.fetch([ref]);
+  const missing = { _tag: "Failed", diagnostic: "NotFound" };
+  const { report, stack } = yield* discovered(ref, reports.get(ref.url) ?? missing);
+  const current = yield* services.repository.load(sessionID);
+  const change = yield* Effect8.fromResult(attach(current, stack, yield* currentMillis));
+  if (change.changed)
+    yield* services.repository.save(sessionID, change.tracking);
   return {
-    tag: "ProcessExecutionFailed",
-    code: value.code,
-    stderr: value.stderr,
-    stdout: value.stdout,
-    cause: value.cause
+    changed: change.changed,
+    ref,
+    report,
+    stackSize: stack.length,
+    tracking: change.tracking
   };
+});
+var detachFrom = Effect8.fn("Tracker.detach")(function* ({ repository }, sessionID, input) {
+  const current = yield* repository.load(sessionID);
+  const removal = input._tag === "Reference" ? detach(current, input.ref) : yield* Effect8.fromResult(detachNumber(current, input.number));
+  if (Option12.isSome(removal.removed))
+    yield* repository.save(sessionID, removal.tracking);
+  return removal;
+});
+var layer5 = Layer5.effect(Tracker, Effect8.gen(function* () {
+  const services = { github: yield* GitHub, repository: yield* TrackingRepository };
+  const locked = sessionLocks();
+  return Tracker.of({
+    attach: (sessionID, input, directory) => locked(sessionID)(attachTo(services, sessionID, { directory, input })),
+    detach: (sessionID, input) => locked(sessionID)(detachFrom(services, sessionID, input)),
+    forget: (sessionID) => locked(sessionID)(services.repository.remove(sessionID)),
+    list: (sessionID) => services.repository.load(sessionID)
+  });
+}));
+
+// src/application/Monitor.ts
+class Monitor extends Context6.Service()("opencode-pr-tracker/Monitor") {
 }
-function parseNonBlankString(input) {
-  return typeof input === "string" && input.trim() !== "" ? input : undefined;
-}
-function parseDate(input) {
-  if (typeof input !== "string")
-    return;
-  const match = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(?:[Zz]|[+-](\d{2}):(\d{2}))$/.exec(input);
-  if (match === null)
-    return;
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  const day = Number(match[3]);
-  const hour = Number(match[4]);
-  const minute = Number(match[5]);
-  const second = Number(match[6]);
-  const offsetHour = Number(match[8] ?? 0);
-  const offsetMinute = Number(match[9] ?? 0);
-  const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-  const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
-  if (daysInMonth === undefined || day < 1 || day > daysInMonth || hour > 23 || minute > 59 || second > 59 || offsetHour > 23 || offsetMinute > 59) {
-    return;
-  }
-  if (Number.isNaN(new Date(input).valueOf()))
-    return;
-  const epochSeconds = new Date(input.replace(/\.\d+/, "")).valueOf() / 1000;
-  if (!Number.isInteger(epochSeconds))
-    return;
+function entryOf(known, attachment) {
+  const current = known.get(attachment.ref.url) ?? unknown;
   return {
-    epochSeconds,
-    fractionalSeconds: (match[7] ?? "").replace(/0+$/, "")
+    attachedAt: attachment.attachedAt,
+    membership: current.membership,
+    ref: attachment.ref,
+    status: current.status
   };
 }
-function compareTimestamps(left, right) {
-  if (left.epochSeconds < right.epochSeconds)
-    return -1;
-  if (left.epochSeconds > right.epochSeconds)
-    return 1;
-  const width = Math.max(left.fractionalSeconds.length, right.fractionalSeconds.length);
-  const leftFraction = left.fractionalSeconds.padEnd(width, "0");
-  const rightFraction = right.fractionalSeconds.padEnd(width, "0");
-  if (leftFraction < rightFraction)
-    return -1;
-  if (leftFraction > rightFraction)
-    return 1;
-  return 0;
-}
-function parseStatusContextState(input) {
-  switch (input) {
-    case "EXPECTED":
-    case "PENDING":
-    case "SUCCESS":
-    case "ERROR":
-    case "FAILURE":
-      return input;
-    default:
-      return;
-  }
+var urlsOf = (tracking) => tracking.map((attachment) => attachment.ref.url);
+function remember(cache, results) {
+  return Effect9.gen(function* () {
+    const now = yield* currentMillis;
+    yield* Ref2.update(cache.known, (current) => {
+      const next = new Map(current);
+      for (const [url, result] of results)
+        next.set(url, afterRefresh(current.get(url) ?? unknown, result, now));
+      return next;
+    });
+  });
 }
-function parseCheckRunStatus(input) {
-  switch (input) {
-    case "REQUESTED":
-    case "QUEUED":
-    case "IN_PROGRESS":
-    case "COMPLETED":
-    case "WAITING":
-    case "PENDING":
-      return input;
-    default:
-      return;
-  }
+function update(cache, refs) {
+  return Effect9.gen(function* () {
+    const outcome = yield* Effect9.result(cache.github.fetch(refs));
+    const results = Result7.isSuccess(outcome) ? outcome.success : new Map(refs.map((ref) => [ref.url, { _tag: "Failed", diagnostic: outcome.failure.diagnostic }]));
+    yield* remember(cache, results);
+  });
+}
+function viewOf(state, sessionID) {
+  return Effect9.gen(function* () {
+    const tracking = yield* state.tracker.list(sessionID);
+    const current = yield* Ref2.get(state.known);
+    return { entries: tracking.map((attachment) => entryOf(current, attachment)), sessionID };
+  });
+}
+function publish(state, sessionID) {
+  return viewOf(state, sessionID).pipe(Effect9.flatMap((view) => PubSub.publish(state.published, view)), Effect9.ignore);
 }
-function parseCheckRunConclusion(input) {
-  switch (input) {
-    case null:
-    case "SUCCESS":
-    case "FAILURE":
-    case "CANCELLED":
-    case "TIMED_OUT":
-    case "ACTION_REQUIRED":
-    case "STARTUP_FAILURE":
-    case "STALE":
-    case "NEUTRAL":
-    case "SKIPPED":
-      return input;
-    default:
+var use = (state, sessionID) => Ref2.update(state.working, (sessions) => new Set(sessions).add(sessionID));
+function poll(state) {
+  return Effect9.gen(function* () {
+    const sessions = [...yield* Ref2.get(state.working)];
+    const known = yield* Ref2.get(state.known);
+    const trackings = yield* Effect9.forEach(sessions, (sessionID) => state.tracker.list(sessionID).pipe(Effect9.orElseSucceed(() => [])));
+    const attached = new Map(trackings.flat().map((attachment) => [attachment.ref.url, attachment.ref]));
+    const now = yield* currentMillis;
+    const current = yield* Ref2.get(state.known);
+    const due = [...attached.values()].filter((ref) => isDue(current, now, ref));
+    yield* Ref2.update(state.known, (entries) => withoutUnattached(entries, known, attached));
+    if (due.length === 0)
       return;
-  }
+    yield* state.fetch(due);
+    const dueUrls = new Set(due.map((ref) => ref.url));
+    const affected = sessions.filter((_, index) => urlsOf(trackings[index] ?? []).some((url) => dueUrls.has(url)));
+    yield* Effect9.forEach(affected, (sessionID) => publish(state, sessionID), {
+      discard: true
+    });
+  });
 }
-function parseStatusContext(input) {
-  const id = parseNonBlankString(input.id);
-  const context = parseNonBlankString(input.context);
-  const state = parseStatusContextState(input.state);
-  const createdAt = parseDate(input.createdAt);
-  if (id === undefined || context === undefined || state === undefined || createdAt === undefined) {
-    return invalidGitHubResponse;
-  }
-  return { ok: true, value: { tag: "StatusContext", id, context, state, createdAt } };
-}
-function parseCheckRun(input) {
-  const id = parseNonBlankString(input.id);
-  const name = parseNonBlankString(input.name);
-  const status = parseCheckRunStatus(input.status);
-  const conclusion = parseCheckRunConclusion(input.conclusion);
-  if (id === undefined || name === undefined || status === undefined || conclusion === undefined || status !== "COMPLETED" && conclusion !== null || !isRecord(input.checkSuite)) {
-    return invalidGitHubResponse;
-  }
-  const suiteId = parseNonBlankString(input.checkSuite.id);
-  const suiteCreatedAt = parseDate(input.checkSuite.createdAt);
-  if (suiteId === undefined || suiteCreatedAt === undefined)
-    return invalidGitHubResponse;
-  let sourceIdentity;
-  if (input.checkSuite.app === null) {
-    sourceIdentity = ["suite", suiteId];
-  } else {
-    if (!isRecord(input.checkSuite.app))
-      return invalidGitHubResponse;
-    const appId = parseNonBlankString(input.checkSuite.app.id);
-    if (appId === undefined)
-      return invalidGitHubResponse;
-    sourceIdentity = ["app", appId];
-  }
-  let workflowRun;
-  if (input.checkSuite.workflowRun === null) {
-    workflowRun = undefined;
-  } else {
-    if (!isRecord(input.checkSuite.workflowRun) || !isRecord(input.checkSuite.workflowRun.workflow)) {
-      return invalidGitHubResponse;
-    }
-    const event = parseNonBlankString(input.checkSuite.workflowRun.event);
-    const workflowId = parseNonBlankString(input.checkSuite.workflowRun.workflow.id);
-    const runNumber = input.checkSuite.workflowRun.runNumber;
-    const runAttempt = input.checkSuite.workflowRun.runAttempt;
-    if (event === undefined || workflowId === undefined || !Number.isInteger(runNumber) || Number(runNumber) <= 0 || !Number.isInteger(runAttempt) || Number(runAttempt) <= 0) {
-      return invalidGitHubResponse;
-    }
-    workflowRun = { event, workflowId, runNumber: Number(runNumber), runAttempt: Number(runAttempt) };
-  }
-  return {
-    ok: true,
-    value: { tag: "CheckRun", id, name, status, conclusion, suiteId, suiteCreatedAt, sourceIdentity, workflowRun }
+function fetchAndShow(state, sessionID, select) {
+  return Effect9.gen(function* () {
+    yield* use(state, sessionID);
+    const tracking = yield* state.tracker.list(sessionID);
+    const known = yield* Ref2.get(state.known);
+    yield* state.fetch(tracking.map((attachment) => attachment.ref).filter((ref) => select(Option13.fromNullishOr(known.get(ref.url)))));
+    const view = yield* viewOf(state, sessionID);
+    yield* PubSub.publish(state.published, view);
+    return view;
+  });
+}
+var refreshable = (known) => Option13.isSome(Option13.getOrElse(known, () => unknown).dueAt);
+var notYetKnown = (known) => Option13.isNone(known);
+var layer6 = Layer6.effect(Monitor, Effect9.gen(function* () {
+  const cache = {
+    github: yield* GitHub,
+    known: yield* Ref2.make(new Map)
   };
+  const queue = new FetchQueue((refs) => update(cache, refs), yield* Effect9.scope);
+  const state = {
+    fetch: (refs) => queue.fetch(refs),
+    github: cache.github,
+    known: cache.known,
+    published: yield* PubSub.unbounded(),
+    tracker: yield* Tracker,
+    working: yield* Ref2.make(new Set)
+  };
+  return Monitor.of({
+    changes: Stream.fromPubSub(state.published),
+    forget: (sessionID) => Ref2.update(state.working, (sessions) => new Set([...sessions].filter((id) => id !== sessionID))),
+    poll: poll(state),
+    attached: (sessionID, ref, report) => Effect9.andThen(remember(cache, new Map([[ref.url, { _tag: "Reported", report }]])), fetchAndShow(state, sessionID, notYetKnown)),
+    refresh: (sessionID) => fetchAndShow(state, sessionID, refreshable),
+    show: (sessionID) => fetchAndShow(state, sessionID, notYetKnown),
+    view: (sessionID) => Effect9.andThen(use(state, sessionID), viewOf(state, sessionID))
+  });
+}));
+
+// src/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
+import { Schema as Schema13 } from "effect";
+
+// src/domain/StackLayout.ts
+import { Array as Arr7, Option as Option14, Schema as Schema12 } from "effect";
+var Membership = Schema12.Union([
+  Schema12.TaggedStruct("Standalone", {}),
+  Schema12.TaggedStruct("Stack", {
+    id: Schema12.String,
+    members: Schema12.NonEmptyArray(PullRequestRef)
+  })
+]);
+var stackOf = (entry) => Option14.filter(entry.membership, (membership) => membership._tag === "Stack");
+var urlsOf2 = (stack) => stack.members.map((member) => member.url);
+function reportsById(entries) {
+  const byId = new Map;
+  for (const [index, entry] of entries.entries()) {
+    for (const stack of Option14.toArray(stackOf(entry))) {
+      byId.set(stack.id, [...byId.get(stack.id) ?? [], { index, stack, url: entry.ref.url }]);
+    }
+  }
+  return byId;
 }
-function parseCheckContexts(input) {
-  if (!isRecord(input) || !Number.isInteger(input.totalCount) || Number(input.totalCount) < 0 || !isRecord(input.pageInfo) || typeof input.pageInfo.hasNextPage !== "boolean" || input.pageInfo.endCursor !== null && typeof input.pageInfo.endCursor !== "string") {
-    return invalidGitHubResponse;
-  }
-  const nodes = input.nodes === null && input.totalCount === 0 ? [] : input.nodes;
-  if (!Array.isArray(nodes) || nodes.length > maximumCheckContextsPerPage || nodes.length > Number(input.totalCount)) {
-    return invalidGitHubResponse;
-  }
-  const contexts = [];
-  const ids = new Set;
-  for (const node of nodes) {
-    if (!isRecord(node))
-      return invalidGitHubResponse;
-    let parsed;
-    switch (node.__typename) {
-      case "StatusContext":
-        if (checkRunOnlyFields.some((field) => (field in node)))
-          return invalidGitHubResponse;
-        parsed = parseStatusContext(node);
-        break;
-      case "CheckRun":
-        if (statusContextOnlyFields.some((field) => (field in node)))
-          return invalidGitHubResponse;
-        parsed = parseCheckRun(node);
-        break;
-      default:
-        return invalidGitHubResponse;
+function claims(byId) {
+  const claimed = new Map;
+  for (const [id, reports] of byId) {
+    for (const url of reports.flatMap((report) => urlsOf2(report.stack))) {
+      claimed.set(url, new Set([...claimed.get(url) ?? [], id]));
     }
-    if (!parsed.ok || ids.has(parsed.value.id))
-      return invalidGitHubResponse;
-    ids.add(parsed.value.id);
-    contexts.push(parsed.value);
   }
-  const nextCursor = input.pageInfo.hasNextPage ? parseNonBlankString(input.pageInfo.endCursor) : undefined;
-  if (input.pageInfo.hasNextPage && nextCursor === undefined)
-    return invalidGitHubResponse;
-  if (nextCursor !== undefined && contexts.length === 0)
-    return invalidGitHubResponse;
-  return {
-    ok: true,
-    value: {
-      contexts,
-      totalCount: Number(input.totalCount),
-      ...nextCursor === undefined ? {} : { nextCursor }
-    }
-  };
+  return claimed;
 }
-function classifyStatusContext(state) {
-  switch (state) {
-    case "ERROR":
-    case "FAILURE":
-      return "failed";
-    case "EXPECTED":
-    case "PENDING":
-      return "pending";
-    case "SUCCESS":
-      return "passed";
-    default:
-      return casesHandled(state);
-  }
+function agrees(reports, entries, claimed) {
+  const members = Option14.match(Arr7.head(reports), {
+    onNone: () => [],
+    onSome: (report) => urlsOf2(report.stack)
+  });
+  const listed = new Set(members);
+  const attachedMembers = entries.filter((entry) => listed.has(entry.ref.url));
+  return listed.size === members.length && reports.every((report) => urlsOf2(report.stack).join(`
+`) === members.join(`
+`)) && members.every((url) => (claimed.get(url) ?? new Set).size === 1) && attachedMembers.length === reports.length;
 }
-function classifyCheckRun(checkRun) {
-  if (checkRun.status !== "COMPLETED")
-    return "pending";
-  switch (checkRun.conclusion) {
-    case "FAILURE":
-    case "CANCELLED":
-    case "TIMED_OUT":
-    case "ACTION_REQUIRED":
-    case "STARTUP_FAILURE":
-    case "STALE":
-      return "failed";
-    case "SUCCESS":
-      return "passed";
-    case "NEUTRAL":
-    case "SKIPPED":
-    case null:
-      return "ignored";
-    default:
-      return casesHandled(checkRun.conclusion);
-  }
+function placements(reports) {
+  const placed = reports.map((report) => ({
+    index: report.index,
+    position: urlsOf2(report.stack).indexOf(report.url),
+    size: report.stack.members.length
+  }));
+  const adjacent = Arr7.zipWith(placed, placed.slice(1), (before, after) => after.index === before.index + 1 && after.position > before.position);
+  const ordered = placed.every((member) => member.position >= 0) && adjacent.every(Boolean);
+  return ordered ? Option14.some(placed) : Option14.none();
 }
-function classifyContexts(contexts) {
-  const statusContexts = new Map;
-  const workflowChecks = new Map;
-  const nonWorkflowChecks = new Map;
-  for (const context of contexts) {
-    if (context.tag === "StatusContext") {
-      const identity2 = context.context.toLowerCase();
-      const existing2 = statusContexts.get(identity2);
-      const bucket2 = classifyStatusContext(context.state);
-      const ordering2 = existing2 === undefined ? 1 : compareTimestamps(context.createdAt, existing2.createdAt);
-      if (ordering2 > 0) {
-        statusContexts.set(identity2, { createdAt: context.createdAt, buckets: [bucket2] });
-      } else if (ordering2 === 0 && existing2 !== undefined) {
-        existing2.buckets.push(bucket2);
-      }
-      continue;
-    }
-    const bucket = classifyCheckRun(context);
-    if (context.workflowRun !== undefined) {
-      const identity2 = JSON.stringify([
-        "workflow",
-        context.sourceIdentity,
-        context.workflowRun.workflowId,
-        context.workflowRun.event,
-        context.name
-      ]);
-      const existing2 = workflowChecks.get(identity2);
-      const isNewer = existing2 === undefined || context.workflowRun.runNumber > existing2.runNumber || context.workflowRun.runNumber === existing2.runNumber && context.workflowRun.runAttempt > existing2.runAttempt;
-      if (isNewer) {
-        workflowChecks.set(identity2, {
-          runNumber: context.workflowRun.runNumber,
-          runAttempt: context.workflowRun.runAttempt,
-          buckets: [bucket]
+function consistentStacks(entries) {
+  const byId = reportsById(entries);
+  const claimed = claims(byId);
+  const places = new Map;
+  for (const reports of byId.values()) {
+    const placed = agrees(reports, entries, claimed) ? placements(reports) : Option14.none();
+    for (const group of Option14.toArray(placed)) {
+      for (const [step, current] of group.entries()) {
+        places.set(current.index, {
+          attached: group.length,
+          current,
+          first: step === 0,
+          last: step === group.length - 1,
+          previous: Arr7.get(group, step - 1)
         });
-      } else if (context.workflowRun.runNumber === existing2.runNumber && context.workflowRun.runAttempt === existing2.runAttempt) {
-        existing2.buckets.push(bucket);
       }
-      continue;
     }
-    const identity = JSON.stringify(["check", context.sourceIdentity, context.name]);
-    const existing = nonWorkflowChecks.get(identity);
-    const ordering = existing === undefined ? 1 : compareTimestamps(context.suiteCreatedAt, existing.suiteCreatedAt);
-    if (ordering > 0) {
-      nonWorkflowChecks.set(identity, { suiteCreatedAt: context.suiteCreatedAt, buckets: [bucket] });
-    } else if (ordering === 0 && existing !== undefined) {
-      existing.buckets.push(bucket);
-    }
-  }
-  const buckets = new Set;
-  for (const selection of [...statusContexts.values(), ...workflowChecks.values(), ...nonWorkflowChecks.values()]) {
-    for (const bucket of selection.buckets)
-      buckets.add(bucket);
   }
-  if (buckets.has("failed"))
-    return "failed";
-  if (buckets.has("pending"))
-    return "pending";
-  if (buckets.has("passed"))
-    return "passed";
-  return "none";
+  return places;
 }
-function parseStatusCheckRollup(input) {
-  if (input === null)
-    return { ok: true, value: null };
-  if (!isRecord(input))
-    return invalidGitHubResponse;
-  return parseCheckContexts(input.contexts);
+function marker(place) {
+  const { current } = place;
+  if (place.attached === 1 && current.size > 1)
+    return "middle";
+  if (place.first && current.position === 0)
+    return "first";
+  if (place.last && current.position === current.size - 1)
+    return "last";
+  return "middle";
 }
-function samePullRequest(left, right) {
-  return left.number === right.number && left.owner.toLowerCase() === right.owner.toLowerCase() && left.repository.toLowerCase() === right.repository.toLowerCase();
-}
-function parseMergeability(input) {
-  switch (input) {
-    case "MERGEABLE":
-      return { ok: true, value: "mergeable" };
-    case "CONFLICTING":
-      return { ok: true, value: "conflicting" };
-    case "UNKNOWN":
-      return { ok: true, value: "unknown" };
-    default:
-      return invalidGitHubResponse;
-  }
+function connector(place) {
+  if (!place.last)
+    return "continues";
+  return place.current.position < place.current.size - 1 ? "open" : "none";
 }
-function parseMergeStateStatus(input) {
-  switch (input) {
-    case "BEHIND":
-      return { ok: true, value: "behind" };
-    case "BLOCKED":
-    case "CLEAN":
-    case "DIRTY":
-    case "DRAFT":
-    case "HAS_HOOKS":
-    case "UNKNOWN":
-    case "UNSTABLE":
-      return { ok: true, value: "other" };
-    default:
-      return invalidGitHubResponse;
-  }
+function stackRows(entry, place) {
+  const skipped = Option14.match(place.previous, {
+    onNone: () => 0,
+    onSome: (before) => place.current.position - before.position - 1
+  });
+  const row = {
+    _tag: "PullRequest",
+    connector: connector(place),
+    entry,
+    marker: marker(place)
+  };
+  return skipped > 0 ? [{ _tag: "Gap", count: skipped }, row] : [row];
 }
-function parseRequiredStatusChecks(input) {
-  if (!Array.isArray(input))
-    return invalidGitHubResponse;
-  for (const check of input) {
-    if (!isRecord(check) || typeof check.context !== "string" || check.context.trim() === "") {
-      return invalidGitHubResponse;
-    }
-  }
-  return { ok: true, value: input.length > 0 };
+function layout(entries) {
+  const places = consistentStacks(entries);
+  return entries.flatMap((entry, index) => Option14.match(Option14.fromNullishOr(places.get(index)), {
+    onNone: () => [{ _tag: "PullRequest", connector: "none", entry, marker: "bullet" }],
+    onSome: (place) => stackRows(entry, place)
+  }));
 }
-function parseRules(input) {
-  if (!isRecord(input) || !Number.isInteger(input.totalCount) || Number(input.totalCount) < 0 || !isRecord(input.pageInfo) || typeof input.pageInfo.hasNextPage !== "boolean") {
-    return invalidGitHubResponse;
-  }
-  const nodes = input.nodes === null && input.totalCount === 0 ? [] : input.nodes;
-  if (!Array.isArray(nodes) || nodes.length > Number(input.totalCount))
-    return invalidGitHubResponse;
-  if (input.pageInfo.hasNextPage ? nodes.length >= Number(input.totalCount) : nodes.length !== input.totalCount) {
-    return invalidGitHubResponse;
-  }
-  let strict = false;
-  for (const node of nodes) {
-    if (!isRecord(node) || !(node.parameters === null || isRecord(node.parameters))) {
-      return invalidGitHubResponse;
-    }
-    if (node.parameters === null)
-      continue;
-    if (typeof node.parameters.__typename !== "string")
-      return invalidGitHubResponse;
-    if (node.parameters.__typename !== "RequiredStatusChecksParameters")
-      continue;
-    if (typeof node.parameters.strictRequiredStatusChecksPolicy !== "boolean")
-      return invalidGitHubResponse;
-    const requiredChecks = parseRequiredStatusChecks(node.parameters.requiredStatusChecks);
-    if (!requiredChecks.ok)
-      return requiredChecks;
-    if (node.parameters.strictRequiredStatusChecksPolicy && requiredChecks.value)
-      strict = true;
-  }
-  return { ok: true, value: { strict, incomplete: input.pageInfo.hasNextPage } };
-}
-function parseRefUpdateRule(input) {
-  if (input === null)
-    return { ok: true, value: false };
-  if (!isRecord(input))
-    return invalidGitHubResponse;
-  if (input.requiredStatusCheckContexts === null)
-    return { ok: true, value: false };
-  if (!Array.isArray(input.requiredStatusCheckContexts))
-    return invalidGitHubResponse;
-  for (const context of input.requiredStatusCheckContexts) {
-    if (typeof context !== "string" || context.trim() === "")
-      return invalidGitHubResponse;
-  }
-  return { ok: true, value: input.requiredStatusCheckContexts.length > 0 };
-}
-function parseUpdatePolicy(input) {
-  if (input === null)
-    return { ok: true, value: { strict: false, incomplete: false } };
-  if (!isRecord(input))
-    return invalidGitHubResponse;
-  const refUpdateHasRequiredChecks = parseRefUpdateRule(input.refUpdateRule);
-  if (!refUpdateHasRequiredChecks.ok)
-    return refUpdateHasRequiredChecks;
-  let branchProtectionIsStrict = false;
-  if (input.branchProtectionRule !== null) {
-    if (!isRecord(input.branchProtectionRule) || typeof input.branchProtectionRule.requiresStatusChecks !== "boolean" || typeof input.branchProtectionRule.requiresStrictStatusChecks !== "boolean") {
-      return invalidGitHubResponse;
+
+// src/rpc.ts
+var Layout = Schema13.Literals(["default", "compact"]);
+var EntryView = Schema13.Struct({
+  attachedAt: Schema13.Int,
+  membership: Schema13.NullOr(Membership),
+  ref: PullRequestRef,
+  status: Status
+});
+var View = Schema13.Struct({
+  entries: Schema13.Array(EntryView),
+  layout: Layout,
+  sessionID: Schema13.String
+});
+var Session = Schema13.Struct({ sessionID: Schema13.String });
+var Target = Schema13.Struct({ sessionID: Schema13.String, target: Schema13.String });
+var Changed = Schema13.Struct({ message: Schema13.String, view: View });
+var Rejected = Schema13.Struct({ message: Schema13.String });
+function portable(schema) {
+  return { "~standard": Schema13.toStandardSchemaV1(Schema13.toEncoded(schema))["~standard"] };
+}
+var PullRequestTracker = Rpc.define({
+  events: {
+    updated: { schema: portable(View) }
+  },
+  id: "opencode-pr-tracker",
+  methods: {
+    attach: {
+      errors: { rejected: portable(Rejected) },
+      input: portable(Target),
+      output: portable(Changed)
+    },
+    detach: {
+      errors: { rejected: portable(Rejected) },
+      input: portable(Target),
+      output: portable(Changed)
+    },
+    list: {
+      errors: { rejected: portable(Rejected) },
+      input: portable(Session),
+      output: portable(View)
+    },
+    refresh: {
+      errors: { rejected: portable(Rejected) },
+      input: portable(Session),
+      output: portable(View)
     }
-    branchProtectionIsStrict = input.branchProtectionRule.requiresStatusChecks && input.branchProtectionRule.requiresStrictStatusChecks;
   }
-  const rules = parseRules(input.rules);
-  if (!rules.ok)
-    return rules;
-  return {
-    ok: true,
-    value: {
-      strict: branchProtectionIsStrict || rules.value.strict,
-      incomplete: rules.value.incomplete || input.branchProtectionRule === null && refUpdateHasRequiredChecks.value
-    }
-  };
+});
+
+// src/server/Requests.ts
+import { Effect as Effect10, Option as Option16 } from "effect";
+
+// src/messages.ts
+import { Match as Match2, Option as Option15 } from "effect";
+var diagnosticMessages = {
+  AuthenticationRequired: "GitHub needs you to sign in: run `gh auth login`, or set GH_TOKEN.",
+  GitHubCliMissing: "Install the GitHub CLI (`gh`), or set GH_TOKEN.",
+  GitHubUnavailable: "GitHub is not responding right now. Try again shortly.",
+  InvalidResponse: "GitHub returned a response the tracker could not read.",
+  NotFound: "The pull request does not exist, or your GitHub account cannot see it."
+};
+var list = (refs) => {
+  const labels = refs.map((ref) => ref.label);
+  return labels.length <= 2 ? labels.join(" and ") : `${labels.slice(0, -1).join(", ")}, and ${labels.at(-1) ?? ""}`;
+};
+function failureMessage(failure) {
+  return Match2.valueTags(failure, {
+    AmbiguousPullRequestNumber: ({ matches, number }) => `#${String(number)} matches ${list(matches)}. Use the pull request URL instead.`,
+    AttachmentLimitReached: ({ limit, requested }) => `A session can track at most ${String(limit)} pull requests; this would make ${String(requested)}.`,
+    GitHubFailure: ({ diagnostic }) => diagnosticMessages[diagnostic],
+    InvalidPullRequestInput: () => "Expected a pull request URL, such as github.com/owner/repository/pull/123, or a pull request number.",
+    PullRequestUnavailable: ({ diagnostic, url }) => `${url}: ${diagnosticMessages[diagnostic]}`,
+    RepositoryUnavailable: () => "This session's directory is not a GitHub repository that `gh` can see. Use the pull request URL instead.",
+    StackIncomplete: ({ url }) => `GitHub returned only part of the Stack of ${url}, so nothing was attached. Try again later.`,
+    StoredStateInvalid: () => "The tracker's saved state for this session cannot be read. It has been left unchanged."
+  });
 }
-function parseBlocker(mergeStateStatusInput, baseRefInput) {
-  const mergeStateStatus = parseMergeStateStatus(mergeStateStatusInput);
-  if (!mergeStateStatus.ok)
-    return mergeStateStatus;
-  if (mergeStateStatus.value !== "behind")
-    return { ok: true, value: "none" };
-  const updatePolicy = parseUpdatePolicy(baseRefInput);
-  if (!updatePolicy.ok)
-    return updatePolicy;
-  if (updatePolicy.value.strict)
-    return { ok: true, value: "behind" };
-  return updatePolicy.value.incomplete ? invalidGitHubResponse : { ok: true, value: "none" };
-}
-function parsePullRequestMetadata(input, pullRequest) {
-  if (!isRecord(input) || input.__typename !== "PullRequest" || typeof input.title !== "string" || input.title.trim() === "") {
-    return invalidGitHubResponse;
-  }
-  if (input.state !== "OPEN" && input.state !== "CLOSED" && input.state !== "MERGED") {
-    return invalidGitHubResponse;
-  }
-  if (input.mergedAt !== null && typeof input.mergedAt !== "string")
-    return invalidGitHubResponse;
-  if (typeof input.mergedAt === "string" && Number.isNaN(new Date(input.mergedAt).valueOf())) {
-    return invalidGitHubResponse;
-  }
-  if (input.state === "MERGED" && typeof input.mergedAt !== "string")
-    return invalidGitHubResponse;
-  if (input.state !== "MERGED" && input.mergedAt !== null)
-    return invalidGitHubResponse;
-  if (typeof input.url !== "string")
-    return invalidGitHubResponse;
-  const responseUrl = parsePullRequestUrl(input.url);
-  if (!responseUrl.ok || !samePullRequest(responseUrl.value, pullRequest))
-    return invalidGitHubResponse;
-  const mergeability = parseMergeability(input.mergeable);
-  if (!mergeability.ok)
-    return mergeability;
-  return {
-    ok: true,
-    value: {
-      title: input.title,
-      state: input.state,
-      mergeability: mergeability.value,
-      mergeStateStatus: input.mergeStateStatus,
-      baseRef: input.baseRef
-    }
-  };
+function attachedMessage(attached) {
+  const label = attached.ref.label;
+  if (!attached.changed)
+    return `${label} is already attached.`;
+  return attached.stackSize > 1 ? `Attached ${label} with the rest of its Stack (${String(attached.stackSize)} pull requests).` : `Attached ${label}.`;
 }
-function finalizeResponse(metadata, pullRequest, ci) {
-  let state;
-  switch (metadata.state) {
-    case "OPEN": {
-      let blocker = "none";
-      if (metadata.mergeability !== "conflicting" && (ci === "none" || ci === "passed")) {
-        const parsedBlocker = parseBlocker(metadata.mergeStateStatus, metadata.baseRef);
-        if (!parsedBlocker.ok)
-          return parsedBlocker;
-        blocker = parsedBlocker.value;
-      }
-      state = { tag: "Open", ci, mergeability: metadata.mergeability, blocker };
-      break;
-    }
-    case "MERGED":
-      state = { tag: "Merged" };
-      break;
-    case "CLOSED":
-      state = { tag: "Closed" };
-      break;
-    default:
-      return casesHandled(metadata.state);
-  }
+function detachedMessage(removal, target) {
+  return Option15.match(removal.removed, {
+    onNone: () => `${target} is not attached.`,
+    onSome: (ref) => `Detached ${ref.label}.`
+  });
+}
+
+// src/server/Requests.ts
+function toView(view, layout) {
   return {
-    ok: true,
-    value: {
-      tag: "Available",
-      pullRequest,
-      title: metadata.title,
-      state,
-      stale: false
-    }
+    entries: view.entries.map((entry) => ({
+      attachedAt: entry.attachedAt,
+      membership: Option16.getOrNull(entry.membership),
+      ref: entry.ref,
+      status: entry.status
+    })),
+    layout,
+    sessionID: view.sessionID
   };
 }
-function parseInitialPullRequest(input, pullRequest) {
-  if (input === null)
-    return pullRequestNotFound;
-  if (!isRecord(input))
-    return invalidGitHubResponse;
-  const contextPage = parseStatusCheckRollup(input.statusCheckRollup);
-  if (!contextPage.ok)
-    return contextPage;
-  if (contextPage.value !== null && contextPage.value.nextCursor === undefined && contextPage.value.contexts.length !== contextPage.value.totalCount) {
-    return invalidGitHubResponse;
-  }
-  const metadata = parsePullRequestMetadata(input, pullRequest);
-  return metadata.ok ? { ok: true, value: { pullRequest, metadata: metadata.value, contextPage: contextPage.value } } : metadata;
-}
-function createBatchQuery(size) {
-  const variables = Array.from({ length: size }, (_, index) => `$url${index}: URI!`).join(", ");
-  const fields = Array.from({ length: size }, (_, index) => `pr${index}: resource(url: $url${index}) { ${pullRequestSelection} }`).join(" ");
-  return `query BatchPullRequests(${variables}) { ${fields} }`;
-}
-function parseGraphqlErrorAliases(input, size) {
-  if (input === undefined)
-    return { ok: true, value: new Set };
-  if (!Array.isArray(input))
-    return invalidGitHubResponse;
-  const aliases = new Set;
-  for (const error of input) {
-    if (!isRecord(error) || typeof error.message !== "string" || !Array.isArray(error.path) || typeof error.path[0] !== "string") {
-      return invalidGitHubResponse;
-    }
-    const match = /^pr([0-9]+)$/.exec(error.path[0]);
-    if (match === null)
-      return invalidGitHubResponse;
-    const index = Number(match[1]);
-    if (!Number.isInteger(index) || index < 0 || index >= size)
-      return invalidGitHubResponse;
-    aliases.add(index);
-  }
-  return { ok: true, value: aliases };
-}
-function parseBatchResponse(input, pullRequests) {
-  if (!isRecord(input) || !isRecord(input.data))
-    return invalidGitHubResponse;
-  const data = input.data;
-  const errorAliases = parseGraphqlErrorAliases(input.errors, pullRequests.length);
-  if (!errorAliases.ok)
-    return errorAliases;
+var parseTarget = (target) => Effect10.fromResult(parsePullRequestInput(target));
+function requests({ monitor, tracker }, settings) {
   return {
-    ok: true,
-    value: pullRequests.map((pullRequest, index) => errorAliases.value.has(index) ? invalidGitHubResponse : parseInitialPullRequest(data[`pr${index}`], pullRequest))
+    attach: (sessionID, target) => Effect10.gen(function* () {
+      const attached = yield* tracker.attach(sessionID, yield* parseTarget(target), settings.directory);
+      const view = yield* monitor.attached(sessionID, attached.ref, attached.report);
+      return { message: attachedMessage(attached), view: toView(view, settings.layout) };
+    }),
+    detach: (sessionID, target) => Effect10.gen(function* () {
+      const removal = yield* tracker.detach(sessionID, yield* parseTarget(target));
+      const view = yield* monitor.show(sessionID);
+      return { message: detachedMessage(removal, target), view: toView(view, settings.layout) };
+    })
   };
 }
-function parseContinuationResponse(input, pullRequest) {
-  if (!isRecord(input) || input.errors !== undefined && (!Array.isArray(input.errors) || input.errors.length > 0) || !isRecord(input.data) || !isRecord(input.data.resource)) {
-    return invalidGitHubResponse;
-  }
-  const resource = input.data.resource;
-  if (resource.__typename !== "PullRequest" || typeof resource.url !== "string")
-    return invalidGitHubResponse;
-  const responseUrl = parsePullRequestUrl(resource.url);
-  if (!responseUrl.ok || !samePullRequest(responseUrl.value, pullRequest) || !isRecord(resource.statusCheckRollup)) {
-    return invalidGitHubResponse;
-  }
-  return parseCheckContexts(resource.statusCheckRollup.contexts);
-}
-function isCancellation(cause, signal) {
-  if (signal?.aborted)
-    return true;
-  const originalCause = parseProcessExecutionFailed(cause)?.cause ?? cause;
-  return originalCause instanceof Error && originalCause.name === "AbortError";
-}
-var authenticationFailureMarkers = ["http 401", "bad credentials", "not logged into", "gh auth login"];
-function isAuthenticationFailure(failure) {
-  if (failure.code === 4)
-    return true;
-  const stderr = failure.stderr.toLowerCase();
-  return authenticationFailureMarkers.some((marker) => stderr.includes(marker));
-}
-function classifyProcessFailure(cause) {
-  const failure = parseProcessExecutionFailed(cause);
-  if (failure?.code === "ENOENT") {
-    return { tag: "GitHubCliMissing", message: "GitHub CLI is not installed", cause };
-  }
-  if (failure && isAuthenticationFailure(failure)) {
-    return { tag: "GitHubAuthenticationRequired", message: "GitHub CLI authentication required", cause };
-  }
-  return { tag: "GitHubUnavailable", message: "GitHub status unavailable", cause };
-}
-function processFailureStdout(cause) {
-  if (!isRecord(cause) || typeof cause.stdout !== "string" || cause.stdout.trim() === "")
-    return;
-  return cause.stdout;
-}
-async function runAndDecode(runner, args, options) {
-  let stdout;
-  let processFailure;
-  try {
-    const output = await runner("gh", args, options);
-    stdout = output.stdout;
-  } catch (cause) {
-    if (isCancellation(cause, options.signal)) {
-      return {
-        ok: false,
-        error: {
-          tag: "GitHubCancelled",
-          message: "GitHub status request cancelled",
-          cause
-        }
-      };
-    }
-    processFailure = classifyProcessFailure(cause);
-    const partialStdout = processFailureStdout(cause);
-    if (partialStdout === undefined)
-      return { ok: false, error: processFailure };
-    stdout = partialStdout;
-  }
-  let decoded;
-  try {
-    decoded = JSON.parse(stdout);
-  } catch {
-    return processFailure === undefined ? invalidGitHubResponse : { ok: false, error: processFailure };
-  }
-  return { ok: true, value: { decoded, ...processFailure === undefined ? {} : { processFailure } } };
-}
-async function continuePullRequest(runner, initial, options) {
-  if (initial.contextPage?.nextCursor === undefined) {
-    const ci = initial.contextPage === null ? "none" : classifyContexts(initial.contextPage.contexts);
-    return { tag: "Item", result: finalizeResponse(initial.metadata, initial.pullRequest, ci) };
-  }
-  const contexts = [...initial.contextPage.contexts];
-  const totalCount = initial.contextPage.totalCount;
-  const contextIds = new Set(contexts.map((context) => context.id));
-  const cursors = new Set([initial.contextPage.nextCursor]);
-  let cursor = initial.contextPage.nextCursor;
-  while (cursor !== undefined) {
-    const args = [
-      "api",
-      "graphql",
-      "--method",
-      "POST",
-      "-f",
-      `query=${continuationQuery}`,
-      "-f",
-      `url=${initial.pullRequest.url}`,
-      "-f",
-      `cursor=${cursor}`
-    ];
-    const output = await runAndDecode(runner, args, options);
-    if (!output.ok) {
-      return output.error.tag === "GitHubCancelled" ? { tag: "Cancelled", error: output.error } : { tag: "Item", result: { ok: false, error: output.error } };
-    }
-    const page = parseContinuationResponse(output.value.decoded, initial.pullRequest);
-    if (!page.ok) {
-      return {
-        tag: "Item",
-        result: { ok: false, error: output.value.processFailure ?? page.error }
-      };
-    }
-    if (page.value.totalCount !== totalCount)
-      return { tag: "Item", result: invalidGitHubResponse };
-    for (const context of page.value.contexts) {
-      if (contextIds.has(context.id))
-        return { tag: "Item", result: invalidGitHubResponse };
-      contextIds.add(context.id);
-    }
-    if (contexts.length + page.value.contexts.length > totalCount) {
-      return { tag: "Item", result: invalidGitHubResponse };
-    }
-    if (page.value.nextCursor !== undefined) {
-      if (cursors.has(page.value.nextCursor))
-        return { tag: "Item", result: invalidGitHubResponse };
-      cursors.add(page.value.nextCursor);
-    }
-    contexts.push(...page.value.contexts);
-    cursor = page.value.nextCursor;
-  }
-  if (contexts.length !== totalCount)
-    return { tag: "Item", result: invalidGitHubResponse };
-  const status = finalizeResponse(initial.metadata, initial.pullRequest, classifyContexts(contexts));
-  return { tag: "Item", result: status };
-}
-var execFileRunner = (file, args, options) => new Promise((resolve, reject) => {
-  execFile(file, [...args], {
-    encoding: "utf8",
-    ...options.signal ? { signal: options.signal } : {},
-    ...options.cwd ? { cwd: options.cwd } : {}
-  }, (error, stdout, stderr) => {
-    if (error) {
-      reject({
-        tag: "ProcessExecutionFailed",
-        code: error.code ?? null,
-        stderr,
-        stdout,
-        cause: error
-      });
-      return;
-    }
-    resolve({ stdout });
-  });
-});
-function createGitHubClient(runner = execFileRunner) {
+
+// src/server/Rpc.ts
+import { Effect as Effect11 } from "effect";
+function handlers(services, settings) {
+  const viewOf = (view) => toView(view, settings.layout);
+  const { attach, detach } = requests(services, settings);
   return {
-    async get(pullRequests, options = {}) {
-      if (pullRequests.length === 0)
-        return { ok: true, value: [] };
-      if (pullRequests.length > maximumPullRequestsPerBatch)
-        return githubBatchLimitExceeded;
-      const query = createBatchQuery(pullRequests.length);
-      const args = ["api", "graphql", "--method", "POST", "-f", `query=${query}`];
-      for (const [index, pullRequest] of pullRequests.entries()) {
-        args.push("-f", `url${index}=${pullRequest.url}`);
-      }
-      const output = await runAndDecode(runner, args, options);
-      if (!output.ok)
-        return output;
-      const parsed = parseBatchResponse(output.value.decoded, pullRequests);
-      if (!parsed.ok)
-        return { ok: false, error: output.value.processFailure ?? parsed.error };
-      const outcomes = await Promise.all(parsed.value.map((item) => {
-        if (!item.ok)
-          return Promise.resolve({ tag: "Item", result: item });
-        return continuePullRequest(runner, item.value, options);
-      }));
-      const batch = [];
-      let cancellation;
-      for (const outcome of outcomes) {
-        if (outcome.tag === "Cancelled")
-          cancellation ??= outcome.error;
-        else
-          batch.push(outcome.result);
-      }
-      return cancellation === undefined ? { ok: true, value: batch } : { ok: false, error: cancellation };
-    }
+    attach: ({ sessionID, target }, context) => attach(sessionID, target).pipe(Effect11.mapError(failureMessage), Effect11.mapError((message) => context.error("rejected", message, { message }))),
+    detach: ({ sessionID, target }, context) => detach(sessionID, target).pipe(Effect11.mapError(failureMessage), Effect11.mapError((message) => context.error("rejected", message, { message }))),
+    list: ({ sessionID }, context) => services.monitor.view(sessionID).pipe(Effect11.map(viewOf), Effect11.mapError(failureMessage), Effect11.mapError((message) => context.error("rejected", message, { message }))),
+    refresh: ({ sessionID }, context) => services.monitor.refresh(sessionID).pipe(Effect11.map(viewOf), Effect11.mapError(failureMessage), Effect11.mapError((message) => context.error("rejected", message, { message })))
   };
 }
-var openAppearances = {
-  passed: { tone: "green", label: "checks passed", strikethrough: false },
-  pending: { tone: "yellow", label: "checks pending", strikethrough: false },
-  failed: { tone: "red", label: "checks failed", strikethrough: false },
-  none: { tone: "gray", label: "no checks", strikethrough: false }
-};
+
+// src/server/Tools.ts
+import { Tool } from "@opencode/schema/tool";
+import { Effect as Effect12, Schema as Schema14 } from "effect";
+
+// src/domain/Appearance.ts
+import { Match as Match3 } from "effect";
 var diagnosticLabels = {
+  AuthenticationRequired: "authenticate",
   GitHubCliMissing: "install gh",
-  GitHubAuthenticationRequired: "run gh auth login",
   GitHubUnavailable: "GitHub unavailable",
-  PullRequestNotFound: "not found or inaccessible",
-  InvalidGitHubResponse: "invalid GitHub response"
+  InvalidResponse: "invalid response",
+  NotFound: "inaccessible"
 };
+var shown = (tone, label, strikethrough = false) => ({
+  label,
+  stale: false,
+  strikethrough,
+  tone
+});
+function openAppearance(open) {
+  if (open.mergeability === "conflicting")
+    return shown("red", "conflict");
+  if (open.ci === "failed")
+    return shown("red", "failed");
+  if (open.draft)
+    return shown("gray", "draft");
+  if (open.ci === "pending")
+    return shown("yellow", "pending");
+  if (open.behind)
+    return shown("yellow", "behind");
+  return open.ci === "passed" ? shown("green", "passed") : shown("gray", "no checks");
+}
 function stateAppearance(state) {
-  switch (state.tag) {
-    case "Open": {
-      switch (state.mergeability) {
-        case "conflicting":
-          return { tone: "red", label: "merge conflict", strikethrough: false };
-        case "mergeable":
-        case "unknown":
-          switch (state.ci) {
-            case "failed":
-            case "pending":
-              return openAppearances[state.ci];
-            case "none":
-            case "passed":
-              switch (state.blocker) {
-                case "behind":
-                  return { tone: "yellow", label: "branch behind", strikethrough: false };
-                case "none":
-                  return openAppearances[state.ci];
-                default:
-                  return casesHandled(state.blocker);
-              }
-            default:
-              return casesHandled(state.ci);
-          }
-        default:
-          return casesHandled(state.mergeability);
-      }
-    }
-    case "Merged":
-      return { tone: "purple", label: "merged", strikethrough: true };
-    case "Closed":
-      return { tone: "red", label: "closed", strikethrough: true };
-    default:
-      return casesHandled(state);
-  }
+  return Match3.valueTags(state, {
+    Closed: () => shown("red", "closed", true),
+    Merged: () => shown("purple", "merged", true),
+    Open: openAppearance
+  });
 }
-function statusAppearance(status) {
-  if (status.tag === "Unavailable") {
-    return {
-      tone: "gray",
-      label: status.diagnostic === undefined ? "status unavailable" : diagnosticLabels[status.diagnostic],
-      strikethrough: false
-    };
-  }
-  const appearance = stateAppearance(status.state);
-  return status.stale ? { ...appearance, label: `${appearance.label} (stale; ${diagnosticLabels[status.diagnostic]})` } : appearance;
+function markStale(fresh) {
+  return { label: fresh.label, stale: true, strikethrough: fresh.strikethrough, tone: fresh.tone };
 }
-
-// src/attach.ts
-async function attachPullRequest(dependencies, sessionID, pullRequest, options = {}) {
-  return dependencies.store.attach(sessionID, pullRequest, {
-    async validate() {
-      const batch = await dependencies.github.get([pullRequest], options);
-      if (!batch.ok)
-        return batch;
-      const item = batch.value[0];
-      if (item === undefined)
-        throw new Error("GitHub client omitted the requested pull request");
-      if (!item.ok)
-        return item;
-      return { ok: true, value: undefined };
-    }
+function appearance(status) {
+  return Match3.valueTags(status, {
+    Fresh: ({ snapshot }) => stateAppearance(snapshot.state),
+    Pending: () => shown("gray", "unavailable"),
+    Stale: ({ snapshot }) => markStale(stateAppearance(snapshot.state)),
+    Unavailable: ({ diagnostic }) => shown("gray", diagnosticLabels[diagnostic])
   });
 }
-var invalidPullRequestInput = {
-  ok: false,
-  error: {
-    tag: "InvalidPullRequestInput",
-    message: "Expected https://github.com/<owner>/<repository>/pull/<positive-integer>, github.com/<owner>/<repository>/pull/<positive-integer>, or a positive pull request number"
-  }
-};
-var repositoryResolutionFailed = {
-  tag: "RepositoryResolutionFailed",
-  message: "Unable to resolve the current GitHub repository with gh; attach with a full URL instead"
-};
-var repositoryResolutionCancelled = {
-  ok: false,
-  error: { tag: "RepositoryResolutionCancelled" }
-};
-function isCancellation2(cause, signal) {
-  if (signal?.aborted)
-    return true;
-  return cause instanceof Error && cause.name === "AbortError";
-}
-function parseRepositoryPullRequest(stdout, number) {
-  let decoded;
-  try {
-    decoded = JSON.parse(stdout);
-  } catch {
-    return { ok: false, error: repositoryResolutionFailed };
-  }
-  if (decoded === null || typeof decoded !== "object" || !("url" in decoded) || typeof decoded.url !== "string" || decoded.url === "") {
-    return { ok: false, error: repositoryResolutionFailed };
-  }
-  const repositoryUrl = decoded.url.endsWith("/") ? decoded.url.slice(0, -1) : decoded.url;
-  const pullRequest = parsePullRequestUrl(`${repositoryUrl}/pull/${number}`);
-  return pullRequest.ok ? pullRequest : { ok: false, error: repositoryResolutionFailed };
-}
-async function resolvePullRequestInput(input, options) {
-  const direct = parsePullRequestUrl(input);
-  if (direct.ok)
-    return direct;
-  if (input.trim() !== input || !/^\d+$/.test(input))
-    return invalidPullRequestInput;
-  const number = Number(input);
-  if (!Number.isSafeInteger(number) || number <= 0)
-    return invalidPullRequestInput;
-  let stdout;
-  try {
-    const result = await (options.runner ?? execFileRunner)("gh", ["repo", "view", "--json", "url"], {
-      cwd: options.directory,
-      ...options.signal ? { signal: options.signal } : {}
-    });
-    stdout = result.stdout;
-  } catch (cause) {
-    if (isCancellation2(cause, options.signal))
-      return repositoryResolutionCancelled;
-    return { ok: false, error: { ...repositoryResolutionFailed, cause } };
-  }
-  return parseRepositoryPullRequest(stdout, number);
-}
 
-// src/state.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { createHash, randomUUID } from "crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
-var maximumPullRequestsPerSession = 20;
-var invalidStateFile = {
-  ok: false,
-  error: {
-    tag: "InvalidStateFile",
-    message: "The session pull request state file is invalid"
-  }
-};
-var lockStaleMilliseconds = 1e4;
-var lockUpdateMilliseconds = 2000;
-function stateUnavailable(operation, message, cause) {
-  return { tag: "StateUnavailable", operation, message, cause };
-}
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function hasExactKeys(value, keys) {
-  const actual = Object.keys(value);
-  return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
-}
-function parseState(input) {
-  if (!isRecord2(input) || !hasExactKeys(input, ["version", "pullRequests"]))
-    return invalidStateFile;
-  if (input.version !== 1 || !Array.isArray(input.pullRequests))
-    return invalidStateFile;
-  if (input.pullRequests.length > maximumPullRequestsPerSession)
-    return invalidStateFile;
-  const attachments = [];
-  const seen = new Set;
-  for (const item of input.pullRequests) {
-    if (!isRecord2(item) || !hasExactKeys(item, ["url", "attachedAt"]))
-      return invalidStateFile;
-    if (typeof item.url !== "string" || typeof item.attachedAt !== "string")
-      return invalidStateFile;
-    const parsed = parsePullRequestUrl(item.url);
-    if (!parsed.ok || parsed.value.url !== item.url || seen.has(item.url))
-      return invalidStateFile;
-    const attachedAt = new Date(item.attachedAt);
-    if (Number.isNaN(attachedAt.valueOf()) || attachedAt.toISOString() !== item.attachedAt)
-      return invalidStateFile;
-    seen.add(item.url);
-    attachments.push({ pullRequest: parsed.value, attachedAt: item.attachedAt });
-  }
-  return { ok: true, value: attachments };
-}
-function isMissingFile(cause) {
-  return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
-}
-function fileName(sessionID) {
-  return `${createHash("sha256").update(sessionID).digest("hex")}.json`;
-}
-function defaultStateDirectory(environment = process.env, home = homedir()) {
-  const dataHome = environment.XDG_DATA_HOME || join(home, ".local", "share");
-  return join(dataHome, "opencode", "opencode-pr-tracker");
-}
-function createStateStore(options = {}) {
-  const directory = options.directory ?? defaultStateDirectory();
-  const now = options.now ?? (() => new Date);
-  const lockStateFile = options.lock ?? import_proper_lockfile.lock;
-  const attachTails = new Map;
-  async function enqueueAttach(sessionID, operation) {
-    const previous = attachTails.get(sessionID) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve) => {
-      release = resolve;
-    });
-    attachTails.set(sessionID, current);
-    await previous;
-    try {
-      return await operation();
-    } finally {
-      release();
-      if (attachTails.get(sessionID) === current)
-        attachTails.delete(sessionID);
-    }
-  }
-  async function acquireLock(sessionID) {
-    const stateFile = join(directory, fileName(sessionID));
-    let compromised;
-    try {
-      await mkdir(directory, { recursive: true });
-      const release = await lockStateFile(stateFile, {
-        realpath: false,
-        stale: lockStaleMilliseconds,
-        update: lockUpdateMilliseconds,
-        retries: { retries: 50, factor: 1, minTimeout: 10, maxTimeout: 100 },
-        onCompromised: (error) => {
-          compromised = error;
-        }
-      });
-      return { ok: true, value: { release, compromised: () => compromised } };
-    } catch (cause) {
-      return {
-        ok: false,
-        error: stateUnavailable("write", "Unable to lock the session pull request state", cause)
-      };
-    }
-  }
-  async function withLock(sessionID, operation) {
-    const lock = await acquireLock(sessionID);
-    if (!lock.ok)
-      return lock;
-    let result;
-    try {
-      result = await operation();
-    } catch (cause) {
-      await lock.value.release().catch(() => {
-        return;
-      });
-      throw cause;
-    }
-    try {
-      await lock.value.release();
-    } catch (cause) {
-      return {
-        ok: false,
-        error: stateUnavailable("write", "Unable to unlock the session pull request state", cause)
-      };
-    }
-    const compromise = lock.value.compromised();
-    if (compromise !== undefined) {
-      return {
-        ok: false,
-        error: stateUnavailable("write", "The session pull request state lock was compromised", compromise)
-      };
-    }
-    return result;
-  }
-  async function readExisting(sessionID) {
-    const path = join(directory, fileName(sessionID));
-    let content;
-    try {
-      content = await readFile(path, "utf8");
-    } catch (cause) {
-      if (isMissingFile(cause))
-        return { ok: true, value: undefined };
-      return {
-        ok: false,
-        error: stateUnavailable("read", "Unable to read the session pull request state", cause)
-      };
-    }
-    let decoded;
-    try {
-      decoded = JSON.parse(content);
-    } catch {
-      return invalidStateFile;
-    }
-    return parseState(decoded);
-  }
-  async function read(sessionID) {
-    const result = await readExisting(sessionID);
-    if (!result.ok)
-      return result;
-    return { ok: true, value: result.value ?? [] };
-  }
-  async function write(sessionID, attachments) {
-    const destination = join(directory, fileName(sessionID));
-    const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
-    const state = {
-      version: 1,
-      pullRequests: attachments.map((attachment) => ({
-        url: attachment.pullRequest.url,
-        attachedAt: attachment.attachedAt
-      }))
-    };
-    try {
-      await mkdir(directory, { recursive: true });
-      await writeFile(temporary, `${JSON.stringify(state, null, 2)}
-`, { mode: 384 });
-      await rename(temporary, destination);
-      return { ok: true, value: undefined };
-    } catch (cause) {
-      await rm(temporary, { force: true }).catch(() => {
-        return;
-      });
-      return {
-        ok: false,
-        error: stateUnavailable("write", "Unable to write the session pull request state", cause)
-      };
-    }
-  }
-  async function attach(sessionID, pullRequest, attachOptions = {}) {
-    return enqueueAttach(sessionID, async () => {
-      if (attachOptions.validate !== undefined) {
-        const current = await read(sessionID);
-        if (!current.ok)
-          return current;
-        if (current.value.some((attachment) => attachment.pullRequest.url === pullRequest.url)) {
-          return { ok: true, value: "already_attached" };
-        }
-        if (current.value.length >= maximumPullRequestsPerSession) {
-          return {
-            ok: false,
-            error: {
-              tag: "AttachmentLimitReached",
-              limit: maximumPullRequestsPerSession,
-              message: "A session can track at most 20 pull requests"
-            }
-          };
-        }
-        const validation = await attachOptions.validate();
-        if (!validation.ok)
-          return validation;
-      }
-      return withLock(sessionID, async () => {
-        const current = await read(sessionID);
-        if (!current.ok)
-          return current;
-        if (current.value.some((attachment) => attachment.pullRequest.url === pullRequest.url)) {
-          return { ok: true, value: "already_attached" };
-        }
-        if (current.value.length >= maximumPullRequestsPerSession) {
-          return {
-            ok: false,
-            error: {
-              tag: "AttachmentLimitReached",
-              limit: maximumPullRequestsPerSession,
-              message: "A session can track at most 20 pull requests"
-            }
-          };
-        }
-        const written = await write(sessionID, [...current.value, { pullRequest, attachedAt: now().toISOString() }]);
-        if (!written.ok)
-          return written;
-        return { ok: true, value: "added" };
-      });
+// src/server/Tools.ts
+var options = { codemode: true, namespace: "pr", pinned: true };
+var PullRequestArgument = Schema14.Struct({
+  pull_request: Schema14.Union([Schema14.String, Schema14.Int]).annotate({
+    description: "A pull request URL, such as github.com/owner/repository/pull/123, or a number in this repository"
+  })
+});
+var targetOf = ({ pull_request }) => String(pull_request);
+var NoArguments = Schema14.Struct({});
+var asToolError = (failure) => new Tool.Error({ message: failureMessage(failure) });
+var listTool = ({ monitor }) => ({
+  description: "List the pull requests attached to this session, with their status.",
+  execute: (_input, context) => monitor.view(context.sessionID).pipe(Effect12.map((view) => ({
+    content: view.entries.length === 0 ? "No pull requests are attached to this session." : view.entries.map((entry) => `- ${entry.ref.url} (${appearance(entry.status).label})`).join(`
+`)
+  })), Effect12.mapError(asToolError)),
+  input: NoArguments,
+  name: "list",
+  options
+});
+var changeTool = (name, description, change) => ({
+  description,
+  execute: (argument, context) => change(context.sessionID, targetOf(argument)).pipe(Effect12.map((changed) => ({ content: changed.message })), Effect12.mapError(asToolError)),
+  input: PullRequestArgument,
+  name,
+  options
+});
+function registerTools(tools, services, settings) {
+  return tools.transform((editor) => {
+    editor.namespace({
+      description: "Pull requests attached to this session and shown in its sidebar",
+      name: "pr"
     });
-  }
-  return {
-    list: read,
-    attach,
-    async detach(sessionID, pullRequest) {
-      return withLock(sessionID, async () => {
-        const current = await read(sessionID);
-        if (!current.ok)
-          return current;
-        const next = current.value.filter((attachment) => attachment.pullRequest.url !== pullRequest.url);
-        if (next.length === current.value.length)
-          return { ok: true, value: "absent" };
-        const written = await write(sessionID, next);
-        if (!written.ok)
-          return written;
-        return { ok: true, value: "removed" };
-      });
-    },
-    async detachByNumber(sessionID, number) {
-      return withLock(sessionID, async () => {
-        const current = await read(sessionID);
-        if (!current.ok)
-          return current;
-        const matches = current.value.filter((attachment) => attachment.pullRequest.number === number);
-        if (matches.length === 0)
-          return { ok: true, value: { tag: "absent" } };
-        if (matches.length > 1) {
-          return {
-            ok: true,
-            value: { tag: "ambiguous", pullRequests: matches.map((attachment) => attachment.pullRequest) }
-          };
-        }
-        const match = matches[0];
-        if (match === undefined)
-          return { ok: true, value: { tag: "absent" } };
-        const next = current.value.filter((attachment) => attachment.pullRequest.url !== match.pullRequest.url);
-        const written = await write(sessionID, next);
-        if (!written.ok)
-          return written;
-        return { ok: true, value: { tag: "removed", pullRequest: match.pullRequest } };
-      });
-    },
-    async removeSession(sessionID) {
-      return withLock(sessionID, async () => {
-        const current = await readExisting(sessionID);
-        if (!current.ok)
-          return current;
-        if (current.value === undefined)
-          return { ok: true, value: "absent" };
-        try {
-          await rm(join(directory, fileName(sessionID)), { force: true });
-          return { ok: true, value: "removed" };
-        } catch (cause) {
-          return {
-            ok: false,
-            error: stateUnavailable("write", "Unable to remove the session pull request state", cause)
-          };
-        }
-      });
-    }
-  };
+    const changes = requests(services, settings);
+    editor.add(listTool(services));
+    editor.add(changeTool("attach", "Attach a pull request to this session. Attaching a GitHub Stack member attaches the whole Stack.", changes.attach));
+    editor.add(changeTool("detach", "Detach a pull request from this session. Other members of its Stack stay attached.", changes.detach));
+  });
 }
 
 // src/server.ts
-class PrToolError extends Error {
-  code;
-  name = "PrToolError";
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-}
-function toToolError(failure) {
-  return new PrToolError(failure.tag, failure.message);
-}
-function formatReferenceList(references) {
-  if (references.length < 2)
-    return references.join("");
-  if (references.length === 2)
-    return references.join(" and ");
-  return `${references.slice(0, -1).join(", ")}, and ${references.at(-1)}`;
-}
-function createServerHooks(store, github = createGitHubClient()) {
-  return {
-    async event({ event }) {
-      if (event.type !== "session.deleted")
-        return;
-      const result = await store.removeSession(event.properties.info.id);
-      if (!result.ok)
-        throw toToolError(result.error);
-    },
-    tool: {
-      pr_list: tool({
-        description: "List pull requests attached to the current OpenCode session.",
-        args: {},
-        async execute(_args, context) {
-          const result = await store.list(context.sessionID);
-          if (!result.ok)
-            throw toToolError(result.error);
-          if (result.value.length === 0)
-            return "No pull requests are attached to this session.";
-          return `Attached pull requests:
-${result.value.map((attachment) => `- ${attachment.pullRequest.url}`).join(`
-`)}`;
-        }
-      }),
-      pr_attach: tool({
-        description: "Attach a GitHub pull request URL to the current OpenCode session.",
-        args: {
-          url: tool.schema.string().describe("A https://github.com/<owner>/<repository>/pull/<number> or github.com/<owner>/<repository>/pull/<number> URL")
-        },
-        async execute(args, context) {
-          const pullRequest = parsePullRequestUrl(args.url);
-          if (!pullRequest.ok)
-            throw new PrToolError(pullRequest.error.tag, pullRequest.error.message);
-          const result = await attachPullRequest({ store, github }, context.sessionID, pullRequest.value, {
-            signal: context.abort
-          });
-          if (!result.ok)
-            throw toToolError(result.error);
-          const reference = formatPullRequestRef(pullRequest.value);
-          return result.value === "added" ? `Attached ${reference} to this session.` : `${reference} is already attached to this session.`;
-        }
-      }),
-      pr_detach: tool({
-        description: "Detach a pull request from the current OpenCode session by positive number or GitHub URL.",
-        args: {
-          pull_request: tool.schema.union([tool.schema.number().int().positive().max(Number.MAX_SAFE_INTEGER), tool.schema.string()]).describe("https://github.com/owner/repository/pull/123, github.com/owner/repository/pull/123, or 123")
-        },
-        async execute(args, context) {
-          if (typeof args.pull_request === "number") {
-            if (!Number.isSafeInteger(args.pull_request) || args.pull_request <= 0) {
-              throw new PrToolError("InvalidPullRequestNumber", "Expected 123, https://github.com/owner/repository/pull/123, or github.com/owner/repository/pull/123");
-            }
-            const result2 = await store.detachByNumber(context.sessionID, args.pull_request);
-            if (!result2.ok)
-              throw toToolError(result2.error);
-            if (result2.value.tag === "absent") {
-              return `Pull request #${args.pull_request} is not attached to this session.`;
-            }
-            if (result2.value.tag === "ambiguous") {
-              const references = result2.value.pullRequests.map(formatPullRequestRef);
-              throw new PrToolError("AmbiguousPullRequestNumber", `Pull request #${args.pull_request} matches ${formatReferenceList(references)}. Use a canonical GitHub pull request URL.`);
-            }
-            return `Detached ${formatPullRequestRef(result2.value.pullRequest)} from this session.`;
-          }
-          const pullRequest = parsePullRequestUrl(args.pull_request);
-          if (!pullRequest.ok)
-            throw new PrToolError(pullRequest.error.tag, pullRequest.error.message);
-          const result = await store.detach(context.sessionID, pullRequest.value);
-          if (!result.ok)
-            throw toToolError(result.error);
-          const reference = formatPullRequestRef(pullRequest.value);
-          return result.value === "removed" ? `Detached ${reference} from this session.` : `${reference} is not attached to this session.`;
-        }
-      })
-    }
-  };
-}
-var plugin = {
-  id: "opencode-pr-tracker",
-  server: async () => createServerHooks(createStateStore(), createGitHubClient())
-};
-var server_default = plugin;
+var pollInterval = "1 second";
+var Options = Schema15.Struct({ layout: Layout });
+var layoutOf = (options) => Option17.match(Schema15.decodeUnknownOption(Options)(options), {
+  onNone: () => "default",
+  onSome: ({ layout }) => layout
+});
+var forgetDeletedSessions = (ctx, services) => ctx.event.subscribe().pipe(Stream2.runForEach((event) => event.type === "session.deleted" ? Effect13.andThen(services.tracker.forget(event.data.sessionID), services.monitor.forget(event.data.sessionID)) : Effect13.void), Effect13.ignore);
+var server_default = Plugin.define({
+  effect: (ctx) => Effect13.gen(function* () {
+    const application = layer6.pipe(Layer7.provideMerge(layer5), Layer7.provide([live, layer4(ctx.storage)]));
+    const context = yield* Layer7.build(application);
+    const services = {
+      monitor: Context7.get(context, Monitor),
+      tracker: Context7.get(context, Tracker)
+    };
+    const settings = {
+      directory: ctx.location.directory,
+      layout: layoutOf(ctx.options)
+    };
+    const registration = yield* ctx.rpc.register(PullRequestTracker, handlers(services, settings)).pipe(Effect13.orDie);
+    yield* registerTools(ctx.tool, services, settings);
+    yield* Effect13.forkScoped(forgetDeletedSessions(ctx, services));
+    yield* Effect13.forkScoped(Effect13.repeat(services.monitor.poll, Schedule.spaced(pollInterval)));
+    yield* services.monitor.changes.pipe(Stream2.runForEach((view) => registration.events.emit("updated", toView(view, settings.layout)).pipe(Effect13.ignore)), Effect13.forkScoped);
+  }),
+  id: "opencode-pr-tracker"
+});
 export {
-  server_default as default,
-  createServerHooks,
-  PrToolError
+  server_default as default
 };
 
-//# debugId=A879251DAA53DE8064756E2164756E21
+//# debugId=2C26781E1C009A7864756E2164756E21