@hcrosse/opencode-pr-tracker 0.1.0 → 0.3.0

package/dist/tui.js

@@ -536,8 +536,8 @@ GFS4: `);
     fs2.createReadStream = createReadStream;
     fs2.createWriteStream = createWriteStream;
     var fs$readFile = fs2.readFile;
-    fs2.readFile = readFile;
-    function readFile(path, options, cb) {
+    fs2.readFile = readFile2;
+    function readFile2(path, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
       return go$readFile(path, options, cb);
@@ -1553,46 +1553,53 @@ var require_proper_lockfile = __commonJS((exports, module) => {
 });
 
 // src/tui.tsx
-import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent4 } from "@opentui/solid";
+
+// src/feedback-tui.tsx
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
 import { createTextNode as _$createTextNode } from "@opentui/solid";
 import { insertNode as _$insertNode } from "@opentui/solid";
-import { setProp as _$setProp } from "@opentui/solid";
-import { effect as _$effect } from "@opentui/solid";
 import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
 import { createElement as _$createElement } from "@opentui/solid";
-import { createComponent as _$createComponent } from "@opentui/solid";
-import { TextAttributes } from "@opentui/core";
-import { createSignal, onCleanup } from "solid-js";
-
-// src/github.ts
-import { execFile } from "child_process";
+import { useKeyboard } from "@opentui/solid";
+import { createSignal } from "solid-js";
 
 // src/exhaustive.ts
 function casesHandled(value) {
   throw new Error(`Unhandled case: ${String(value)}`);
 }
 
+// src/github.ts
+import { execFile } from "child_process";
+
 // 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: "Expected https://github.com/<owner>/<repository>/pull/<positive-integer>"
+    message: expectedPullRequestUrl
   }
 };
 var segmentPattern = /^[A-Za-z0-9._-]+$/;
+var schemeLessPrefix = "github.com/";
 function parsePullRequestUrl(input) {
-  if (input.trim() !== input)
+  if (/\s/.test(input))
+    return invalidPullRequestUrl;
+  if (input.includes("\\"))
     return invalidPullRequestUrl;
-  if (!input.startsWith("https://"))
+  const candidate = input.slice(0, schemeLessPrefix.length).toLowerCase() === schemeLessPrefix ? `https://${input}` : input;
+  if (!candidate.startsWith("https://"))
     return invalidPullRequestUrl;
-  const authorityEnd = input.indexOf("/", "https://".length);
+  const authorityEnd = candidate.indexOf("/", "https://".length);
   if (authorityEnd === -1)
     return invalidPullRequestUrl;
-  if (input.slice("https://".length, authorityEnd).toLowerCase() !== "github.com") {
+  if (candidate.slice("https://".length, authorityEnd).toLowerCase() !== "github.com") {
     return invalidPullRequestUrl;
   }
-  const rawPath = input.slice(authorityEnd).split(/[?#]/, 1).join("");
+  const rawPath = candidate.slice(authorityEnd).split(/[?#]/, 1).join("");
   for (const segment of rawPath.split("/")) {
     let decoded;
     try {
@@ -1605,7 +1612,7 @@ function parsePullRequestUrl(input) {
   }
   let parsed;
   try {
-    parsed = new URL(input);
+    parsed = new URL(candidate);
   } catch {
     return invalidPullRequestUrl;
   }
@@ -1616,15 +1623,17 @@ function parsePullRequestUrl(input) {
   if (segments.length !== 5 || segments[0] !== "" || segments[3] !== "pull") {
     return invalidPullRequestUrl;
   }
-  const owner = segments[1];
-  const repository = segments[2];
+  const rawOwner = segments[1];
+  const rawRepository = segments[2];
   const numberText = segments[4];
-  if (owner === undefined || repository === undefined || numberText === undefined || !segmentPattern.test(owner) || !segmentPattern.test(repository) || !/^\d+$/.test(numberText)) {
+  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 };
@@ -1641,6 +1650,13 @@ var 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: {
@@ -1649,15 +1665,13 @@ var githubBatchLimitExceeded = {
     message: "GitHub batch cannot contain more than 20 pull requests"
   }
 };
-var checkRunPending = new Set(["QUEUED", "IN_PROGRESS", "WAITING", "PENDING"]);
-var checkRunPassed = new Set(["SUCCESS"]);
-var checkRunFailed = new Set(["FAILURE", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE", "STALE"]);
-var checkRunIgnored = new Set(["NEUTRAL", "SKIPPED"]);
-var statusContextPending = new Set(["EXPECTED", "PENDING"]);
-var statusContextPassed = new Set(["SUCCESS"]);
-var statusContextFailed = new Set(["ERROR", "FAILURE"]);
 var maximumPullRequestsPerBatch = 20;
-var pullRequestSelection = `__typename ... on PullRequest { title state url mergedAt mergeable statusCheckRollup { contexts(first: 1) { checkRunCount statusContextCount checkRunCountsByState { state count } statusContextCountsByState { state count } } } }`;
+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);
 }
@@ -1673,67 +1687,297 @@ function parseProcessExecutionFailed(value) {
     cause: value.cause
   };
 }
-function classifyCountState(state, states) {
-  if (states.failed.has(state))
-    return "failed";
-  if (states.pending.has(state))
-    return "pending";
-  if (states.passed.has(state))
-    return "passed";
-  if (states.ignored?.has(state))
-    return "ignored";
-  return;
+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;
+  return {
+    epochSeconds,
+    fractionalSeconds: (match[7] ?? "").replace(/0+$/, "")
+  };
+}
+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;
+  }
+}
+function parseCheckRunStatus(input) {
+  switch (input) {
+    case "REQUESTED":
+    case "QUEUED":
+    case "IN_PROGRESS":
+    case "COMPLETED":
+    case "WAITING":
+    case "PENDING":
+      return input;
+    default:
+      return;
+  }
+}
+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:
+      return;
+  }
 }
-function aggregateCounts(input, expectedTotal, states) {
-  if (!Array.isArray(input) || !Number.isInteger(expectedTotal) || Number(expectedTotal) < 0) {
+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;
   }
-  const buckets = new Set;
-  const seenStates = new Set;
-  let total = 0;
-  for (const item of input) {
-    if (!isRecord(item) || typeof item.state !== "string" || !Number.isInteger(item.count) || Number(item.count) < 0 || seenStates.has(item.state)) {
+  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 bucket = classifyCountState(item.state, states);
-    if (bucket === undefined && Number(item.count) > 0)
+    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;
-    seenStates.add(item.state);
-    total += Number(item.count);
-    if (bucket !== undefined && Number(item.count) > 0)
-      buckets.add(bucket);
+    }
+    workflowRun = { event, workflowId, runNumber: Number(runNumber), runAttempt: Number(runAttempt) };
   }
-  return total === expectedTotal ? { ok: true, value: buckets } : invalidGitHubResponse;
+  return {
+    ok: true,
+    value: { tag: "CheckRun", id, name, status, conclusion, suiteId, suiteCreatedAt, sourceIdentity, workflowRun }
+  };
 }
-function parseStatusCheckRollup(input) {
-  if (input === null)
-    return { ok: true, value: "none" };
-  if (!isRecord(input) || !isRecord(input.contexts))
+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 contexts = input.contexts;
-  const checkRuns = aggregateCounts(contexts.checkRunCountsByState, contexts.checkRunCount, {
-    passed: checkRunPassed,
-    pending: checkRunPending,
-    failed: checkRunFailed,
-    ignored: checkRunIgnored
-  });
-  if (!checkRuns.ok)
-    return checkRuns;
-  const statusContexts = aggregateCounts(contexts.statusContextCountsByState, contexts.statusContextCount, {
-    passed: statusContextPassed,
-    pending: statusContextPending,
-    failed: statusContextFailed
-  });
-  if (!statusContexts.ok)
-    return statusContexts;
-  const buckets = new Set([...checkRuns.value, ...statusContexts.value]);
+  }
+  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;
+    }
+    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 }
+    }
+  };
+}
+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 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 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]
+        });
+      } 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 { ok: true, value: "failed" };
+    return "failed";
   if (buckets.has("pending"))
-    return { ok: true, value: "pending" };
+    return "pending";
   if (buckets.has("passed"))
-    return { ok: true, value: "passed" };
-  return { ok: true, value: "none" };
+    return "passed";
+  return "none";
+}
+function parseStatusCheckRollup(input) {
+  if (input === null)
+    return { ok: true, value: null };
+  if (!isRecord(input))
+    return invalidGitHubResponse;
+  return parseCheckContexts(input.contexts);
 }
 function samePullRequest(left, right) {
   return left.number === right.number && left.owner.toLowerCase() === right.owner.toLowerCase() && left.repository.toLowerCase() === right.repository.toLowerCase();
@@ -1750,7 +1994,118 @@ function parseMergeability(input) {
       return invalidGitHubResponse;
   }
 }
-function parseResponse(input, pullRequest) {
+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 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 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;
+    }
+    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
+    }
+  };
+}
+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;
   }
@@ -1771,17 +2126,34 @@ function parseResponse(input, pullRequest) {
   const responseUrl = parsePullRequestUrl(input.url);
   if (!responseUrl.ok || !samePullRequest(responseUrl.value, pullRequest))
     return invalidGitHubResponse;
-  const ci = parseStatusCheckRollup(input.statusCheckRollup);
-  if (!ci.ok)
-    return ci;
   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 finalizeResponse(metadata, pullRequest, ci) {
   let state;
-  switch (input.state) {
-    case "OPEN":
-      state = { tag: "Open", ci: ci.value, mergeability: mergeability.value };
+  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;
@@ -1789,19 +2161,33 @@ function parseResponse(input, pullRequest) {
       state = { tag: "Closed" };
       break;
     default:
-      return casesHandled(input.state);
+      return casesHandled(metadata.state);
   }
   return {
     ok: true,
     value: {
       tag: "Available",
       pullRequest,
-      title: input.title,
+      title: metadata.title,
       state,
       stale: false
     }
   };
 }
+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(" ");
@@ -1836,9 +2222,22 @@ function parseBatchResponse(input, pullRequests) {
     return errorAliases;
   return {
     ok: true,
-    value: pullRequests.map((pullRequest, index) => errorAliases.value.has(index) ? invalidGitHubResponse : parseResponse(data[`pr${index}`], pullRequest))
+    value: pullRequests.map((pullRequest, index) => errorAliases.value.has(index) ? invalidGitHubResponse : parseInitialPullRequest(data[`pr${index}`], pullRequest))
   };
 }
+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;
@@ -1867,6 +2266,94 @@ function processFailureStdout(cause) {
     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",
@@ -1898,40 +2385,26 @@ function createGitHubClient(runner = execFileRunner) {
       for (const [index, pullRequest] of pullRequests.entries()) {
         args.push("-f", `url${index}=${pullRequest.url}`);
       }
-      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) {
-          stdout = partialStdout;
-        } else {
-          return { ok: false, error: processFailure };
-        }
-      }
-      let decoded;
-      try {
-        decoded = JSON.parse(stdout);
-      } catch {
-        return processFailure === undefined ? invalidGitHubResponse : { ok: false, error: processFailure };
+      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);
       }
-      const parsed = parseBatchResponse(decoded, pullRequests);
-      if (processFailure === undefined || parsed.ok)
-        return parsed;
-      return { ok: false, error: processFailure };
+      return cancellation === undefined ? { ok: true, value: batch } : { ok: false, error: cancellation };
     }
   };
 }
@@ -1945,6 +2418,7 @@ var diagnosticLabels = {
   GitHubCliMissing: "install gh",
   GitHubAuthenticationRequired: "run gh auth login",
   GitHubUnavailable: "GitHub unavailable",
+  PullRequestNotFound: "not found or inaccessible",
   InvalidGitHubResponse: "invalid GitHub response"
 };
 function stateAppearance(state) {
@@ -1955,7 +2429,23 @@ function stateAppearance(state) {
           return { tone: "red", label: "merge conflict", strikethrough: false };
         case "mergeable":
         case "unknown":
-          return openAppearances[state.ci];
+          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);
       }
@@ -1980,866 +2470,2005 @@ function statusAppearance(status) {
   return status.stale ? { ...appearance, label: `${appearance.label} (stale; ${diagnosticLabels[status.diagnostic]})` } : appearance;
 }
 
-// src/attach.ts
-var invalidPullRequestInput = {
-  ok: false,
-  error: {
-    tag: "InvalidPullRequestInput",
-    message: "Expected https://github.com/<owner>/<repository>/pull/<positive-integer> or a positive pull request number"
+// src/external-url.ts
+async function openExternalUrl(url, subject, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const executable = platform === "darwin" ? "open" : platform === "linux" ? "xdg-open" : undefined;
+  if (executable === undefined) {
+    return {
+      ok: false,
+      error: {
+        tag: "UnsupportedPlatform",
+        message: `Opening ${subject} is unsupported on ${platform}`,
+        platform
+      }
+    };
   }
-};
-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 };
+    await (options.runner ?? execFileRunner)(executable, [url], options.signal ? { signal: options.signal } : {});
+    return { ok: true, value: undefined };
+  } catch (cause) {
+    return {
+      ok: false,
+      error: { tag: "OpenExternalUrlFailed", message: `Unable to open ${subject}`, cause }
+    };
   }
-  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 } };
+async function openPullRequest(pullRequest, options = {}) {
+  const result = await openExternalUrl(pullRequest.url, "pull requests", options);
+  if (result.ok)
+    return result;
+  if (result.error.tag === "UnsupportedPlatform") {
+    return {
+      ok: false,
+      error: result.error
+    };
   }
-  return parseRepositoryPullRequest(stdout, number);
+  return {
+    ok: false,
+    error: {
+      tag: "OpenPullRequestFailed",
+      message: "Unable to open the pull request",
+      cause: result.error.cause
+    }
+  };
 }
 
-// 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"
+// src/feedback.ts
+function parseProcessExecutionFailed2(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || !("tag" in value) || value.tag !== "ProcessExecutionFailed" || !("code" in value) || value.code !== null && typeof value.code !== "string" && typeof value.code !== "number" || !("stderr" in value) || typeof value.stderr !== "string" || !("stdout" in value) || typeof value.stdout !== "string" || !("cause" in value)) {
+    return;
   }
-};
-var lockStaleMilliseconds = 1e4;
-var lockUpdateMilliseconds = 2000;
-function stateUnavailable(operation, message, cause) {
-  return { tag: "StateUnavailable", operation, message, cause };
+  return {
+    tag: "ProcessExecutionFailed",
+    code: value.code,
+    stderr: value.stderr,
+    stdout: value.stdout,
+    cause: value.cause
+  };
 }
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function isProcessCancellation(cause, signal) {
+  if (signal?.aborted)
+    return true;
+  const originalCause = parseProcessExecutionFailed2(cause)?.cause ?? cause;
+  return originalCause instanceof Error && originalCause.name === "AbortError";
 }
-function hasExactKeys(value, keys) {
-  const actual = Object.keys(value);
-  return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+var authenticationFailureMarkers2 = ["http 401", "bad credentials", "not logged into", "gh auth login"];
+function isAuthenticationFailure2(failure) {
+  if (failure.code === 4)
+    return true;
+  const stderr = failure.stderr.toLowerCase();
+  return authenticationFailureMarkers2.some((marker) => stderr.includes(marker));
 }
-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 });
+function trimRequired(value, field) {
+  const trimmed = value.trim();
+  if (trimmed !== "")
+    return { ok: true, value: trimmed };
+  return {
+    ok: false,
+    error: { tag: "InvalidFeedback", message: `${field} must not be empty` }
+  };
+}
+function appendDiagnostics(draft, diagnostics) {
+  if (diagnostics === undefined)
+    return { ok: true, value: draft };
+  const entries = [
+    ["pluginVersion", "Plugin version", diagnostics.pluginVersion],
+    ["opencodeVersion", "OpenCode version", diagnostics.opencodeVersion],
+    ["operatingSystem", "Operating system", diagnostics.operatingSystem],
+    ["installationSource", "Installation source", diagnostics.installationSource]
+  ];
+  const lines = [];
+  for (const [field, label, value] of entries) {
+    const trimmed = trimRequired(value, field);
+    if (!trimmed.ok)
+      return trimmed;
+    lines.push(`- ${label}: ${trimmed.value}`);
   }
-  return { ok: true, value: attachments };
+  return {
+    ok: true,
+    value: {
+      ...draft,
+      body: [draft.body, "", "## Diagnostics", "", ...lines].join(`
+`)
+    }
+  };
 }
-function isMissingFile(cause) {
-  return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+function createFeedbackDraft(input, diagnostics) {
+  const title = trimRequired(input.title, "title");
+  if (!title.ok)
+    return title;
+  switch (input.kind) {
+    case "bug": {
+      const problem = trimRequired(input.problem, "problem");
+      if (!problem.ok)
+        return problem;
+      const reproduction = trimRequired(input.reproduction, "reproduction");
+      if (!reproduction.ok)
+        return reproduction;
+      const expectedBehavior = trimRequired(input.expectedBehavior, "expectedBehavior");
+      if (!expectedBehavior.ok)
+        return expectedBehavior;
+      return appendDiagnostics({
+        title: title.value,
+        body: [
+          "## Problem",
+          "",
+          problem.value,
+          "",
+          "## Reproduction",
+          "",
+          reproduction.value,
+          "",
+          "## Expected Behavior",
+          "",
+          expectedBehavior.value
+        ].join(`
+`),
+        label: "bug",
+        template: "bug_report.md"
+      }, diagnostics);
+    }
+    case "feature": {
+      const problem = trimRequired(input.problem, "problem");
+      if (!problem.ok)
+        return problem;
+      const desiredOutcome = trimRequired(input.desiredOutcome, "desiredOutcome");
+      if (!desiredOutcome.ok)
+        return desiredOutcome;
+      const body = ["## Problem", "", problem.value, "", "## Desired Outcome", "", desiredOutcome.value];
+      const constraints = input.constraints?.trim();
+      if (constraints !== undefined && constraints !== "") {
+        body.push("", "## Constraints", "", constraints);
+      }
+      return appendDiagnostics({
+        title: title.value,
+        body: body.join(`
+`),
+        label: "enhancement",
+        template: "feature_request.md"
+      }, diagnostics);
+    }
+    case "other": {
+      const details = trimRequired(input.details, "details");
+      if (!details.ok)
+        return details;
+      return appendDiagnostics({
+        title: title.value,
+        body: ["## Details", "", details.value].join(`
+`)
+      }, diagnostics);
+    }
+    default:
+      return casesHandled(input);
+  }
 }
-function fileName(sessionID) {
-  return `${createHash("sha256").update(sessionID).digest("hex")}.json`;
+function createFeedbackIssueUrl(draft) {
+  const url = new URL("https://github.com/hcrosse/opencode-pr-tracker/issues/new");
+  url.searchParams.set("title", draft.title);
+  url.searchParams.set("body", draft.body);
+  if (draft.template !== undefined)
+    url.searchParams.set("template", draft.template);
+  return url.toString();
 }
-function defaultStateDirectory(environment = process.env, home = homedir()) {
-  const dataHome = environment.XDG_DATA_HOME || join(home, ".local", "share");
-  return join(dataHome, "opencode", "opencode-pr-tracker");
+async function openFeedbackDraft(draft, options = {}) {
+  const url = createFeedbackIssueUrl(draft);
+  if (url.length > 8000) {
+    return {
+      ok: false,
+      error: {
+        tag: "FeedbackUrlTooLong",
+        message: "Feedback is too long for browser delivery; choose GitHub CLI delivery"
+      }
+    };
+  }
+  const result = await openExternalUrl(url, "feedback", options);
+  if (result.ok)
+    return result;
+  if (result.error.tag === "UnsupportedPlatform") {
+    return {
+      ok: false,
+      error: result.error
+    };
+  }
+  return {
+    ok: false,
+    error: {
+      tag: "OpenFeedbackFailed",
+      message: "Unable to open feedback; choose GitHub CLI delivery or retry",
+      cause: result.error.cause
+    }
+  };
 }
-function createStateStore(options = {}) {
-  const directory = options.directory ?? defaultStateDirectory();
-  const now = options.now ?? (() => new Date);
-  async function acquireLock(sessionID) {
-    const stateFile = join(directory, fileName(sessionID));
-    let compromised;
-    try {
-      await mkdir(directory, { recursive: true });
-      const release = await import_proper_lockfile.lock(stateFile, {
-        realpath: false,
-        stale: lockStaleMilliseconds,
-        update: lockUpdateMilliseconds,
-        retries: { retries: 50, factor: 1, minTimeout: 10, maxTimeout: 100 },
-        onCompromised: (error) => {
-          compromised = error;
+async function submitFeedbackDraft(draft, options = {}) {
+  const args = [
+    "issue",
+    "create",
+    "--repo",
+    "hcrosse/opencode-pr-tracker",
+    "--title",
+    draft.title,
+    "--body",
+    draft.body
+  ];
+  let stdout;
+  try {
+    const result = await (options.runner ?? execFileRunner)("gh", args, options.signal ? { signal: options.signal } : {});
+    stdout = result.stdout;
+  } catch (cause) {
+    if (isProcessCancellation(cause, options.signal)) {
+      return { ok: false, error: { tag: "SubmitFeedbackCancelled" } };
+    }
+    const failure = parseProcessExecutionFailed2(cause);
+    if (failure?.code === "ENOENT") {
+      return {
+        ok: false,
+        error: {
+          tag: "GitHubCliMissing",
+          message: "GitHub CLI is not installed; install gh and retry",
+          cause
         }
-      });
-      return { ok: true, value: { release, compromised: () => compromised } };
-    } catch (cause) {
+      };
+    }
+    if (failure !== undefined && isAuthenticationFailure2(failure)) {
       return {
         ok: false,
-        error: stateUnavailable("write", "Unable to lock the session pull request state", cause)
+        error: {
+          tag: "GitHubAuthenticationRequired",
+          message: "GitHub CLI authentication required; run gh auth login",
+          cause
+        }
       };
     }
+    return {
+      ok: false,
+      error: {
+        tag: "SubmitFeedbackFailed",
+        message: "Unable to submit feedback with GitHub CLI; choose browser delivery or retry",
+        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(() => {
+  const issueUrl = stdout.trim();
+  if (issueUrl === "") {
+    return {
+      ok: false,
+      error: {
+        tag: "InvalidGitHubResponse",
+        message: "GitHub CLI did not return the created issue URL"
+      }
+    };
+  }
+  return { ok: true, value: issueUrl };
+}
+
+// src/feedback-tui.tsx
+function FeedbackConfirmation(props) {
+  useKeyboard((key) => {
+    if (key.name === "return") {
+      key.preventDefault();
+      key.stopPropagation();
+      props.onConfirm();
+      return;
+    }
+    if (key.name === "escape" || key.ctrl && key.name === "c") {
+      key.preventDefault();
+      key.stopPropagation();
+      props.onCancel();
+    }
+  });
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$3 = _$createElement("b"), _el$4 = _$createElement("scrollbox"), _el$5 = _$createElement("text"), _el$6 = _$createElement("box"), _el$7 = _$createElement("text"), _el$9 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$insertNode(_el$, _el$4);
+    _$insertNode(_el$, _el$6);
+    _$setProp(_el$, "flexDirection", "column");
+    _$setProp(_el$, "gap", 1);
+    _$insertNode(_el$2, _el$3);
+    _$insert(_el$3, () => props.title);
+    _$insertNode(_el$4, _el$5);
+    _$setProp(_el$4, "focused", true);
+    _$setProp(_el$4, "scrollY", true);
+    _$setProp(_el$4, "height", 10);
+    _$insert(_el$5, () => props.preview);
+    _$insertNode(_el$6, _el$7);
+    _$insertNode(_el$6, _el$9);
+    _$setProp(_el$6, "flexDirection", "row");
+    _$setProp(_el$6, "gap", 2);
+    _$insertNode(_el$7, _$createTextNode(`[Esc] Cancel`));
+    _$insert(_el$9, () => props.confirmLabel);
+    _$effect((_p$) => {
+      var { onCancel: _v$, onConfirm: _v$2 } = props;
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$7, "onMouseUp", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$9, "onMouseUp", _v$2, _p$.t));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined
+    });
+    return _el$;
+  })();
+}
+function showDialog(api, signal, render) {
+  return new Promise((resolve) => {
+    let finished = false;
+    const onAbort = () => finish(undefined);
+    const finish = (value, clearDialog = true) => {
+      if (finished)
         return;
-      });
-      throw cause;
+      finished = true;
+      signal.removeEventListener("abort", onAbort);
+      if (clearDialog)
+        api.ui.dialog.clear();
+      resolve(value);
+    };
+    if (signal.aborted) {
+      finish(undefined, false);
+      return;
     }
-    try {
-      await lock.value.release();
-    } catch (cause) {
+    signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+    api.ui.dialog.setSize("medium");
+    api.ui.dialog.replace(() => render((value) => finish(value)), () => finish(undefined, false));
+  });
+}
+function selectFeedbackKind(api, signal) {
+  return showDialog(api, signal, (finish) => {
+    const DialogSelect = api.ui.DialogSelect;
+    return _$createComponent(DialogSelect, {
+      title: "Feedback type",
+      options: [{
+        title: "Bug report",
+        value: "bug"
+      }, {
+        title: "Feature request",
+        value: "feature"
+      }, {
+        title: "Other feedback",
+        value: "other"
+      }],
+      current: "bug",
+      onSelect: (option) => finish(option.value)
+    });
+  });
+}
+function promptForValue(api, signal, title, required) {
+  return showDialog(api, signal, (finish) => {
+    const [error, setError] = createSignal();
+    const DialogPrompt = api.ui.DialogPrompt;
+    return _$createComponent(DialogPrompt, {
+      title,
+      description: () => error() ? (() => {
+        var _el$0 = _$createElement("text");
+        _$insert(_el$0, error);
+        _$effect((_$p) => _$setProp(_el$0, "fg", api.theme.current.error, _$p));
+        return _el$0;
+      })() : null,
+      onConfirm: (value) => {
+        if (required && value.trim() === "") {
+          setError(`${title} is required`);
+          return;
+        }
+        finish(value);
+      },
+      onCancel: () => finish(undefined)
+    });
+  });
+}
+function confirmDiagnostics(api, signal, diagnostics) {
+  const message = [`Plugin version: ${diagnostics.pluginVersion}`, `OpenCode version: ${diagnostics.opencodeVersion}`, `Operating system: ${diagnostics.operatingSystem}`, `Installation source: ${diagnostics.installationSource}`].join(`
+`);
+  return showDialog(api, signal, (finish) => _$createComponent(api.ui.DialogConfirm, {
+    title: "Include diagnostics?",
+    message,
+    onConfirm: () => finish(true),
+    onCancel: () => finish(false)
+  }));
+}
+function selectDelivery(api, signal) {
+  return showDialog(api, signal, (finish) => {
+    const DialogSelect = api.ui.DialogSelect;
+    return _$createComponent(DialogSelect, {
+      title: "Send feedback",
+      options: [{
+        title: "Open in browser",
+        value: "browser"
+      }, {
+        title: "Submit with GitHub CLI",
+        value: "gh"
+      }],
+      current: "browser",
+      onSelect: (option) => finish(option.value)
+    });
+  });
+}
+function deliveryAction(delivery) {
+  return delivery === "browser" ? "Open a prefilled issue in your browser" : "Create the issue with GitHub CLI";
+}
+function feedbackPreview(draft, delivery) {
+  const label = delivery === "gh" ? "none" : draft.template === "bug_report.md" ? "bug" : draft.template === "feature_request.md" ? "enhancement" : "none";
+  return ["Repository: hcrosse/opencode-pr-tracker", `Action: ${deliveryAction(delivery)}`, `Title: ${draft.title}`, `Label: ${label}`, "", "Body:", draft.body].join(`
+`);
+}
+function confirmFeedback(api, signal, draft, delivery, confirmationRenderer) {
+  const title = delivery === "browser" ? "Open PR tracker feedback?" : "Send PR tracker feedback?";
+  const confirmLabel = delivery === "browser" ? "[Enter] Open issue" : "[Enter] Send";
+  return showDialog(api, signal, (finish) => {
+    const Confirmation = confirmationRenderer;
+    return _$createComponent(Confirmation, {
+      title,
+      confirmLabel,
+      get preview() {
+        return feedbackPreview(draft, delivery);
+      },
+      onConfirm: () => finish(true),
+      onCancel: () => finish(false)
+    });
+  });
+}
+async function collectFeedbackInput(api, signal, kind) {
+  const title = await promptForValue(api, signal, "Feedback title", true);
+  if (title === undefined)
+    return;
+  switch (kind) {
+    case "bug": {
+      const problem = await promptForValue(api, signal, "Problem", true);
+      if (problem === undefined)
+        return;
+      const reproduction = await promptForValue(api, signal, "Reproduction steps", true);
+      if (reproduction === undefined)
+        return;
+      const expectedBehavior = await promptForValue(api, signal, "Expected behavior", true);
+      if (expectedBehavior === undefined)
+        return;
       return {
-        ok: false,
-        error: stateUnavailable("write", "Unable to unlock the session pull request state", cause)
+        kind,
+        title,
+        problem,
+        reproduction,
+        expectedBehavior
       };
     }
-    const compromise = lock.value.compromised();
-    if (compromise !== undefined) {
+    case "feature": {
+      const problem = await promptForValue(api, signal, "Problem", true);
+      if (problem === undefined)
+        return;
+      const desiredOutcome = await promptForValue(api, signal, "Desired outcome", true);
+      if (desiredOutcome === undefined)
+        return;
+      const constraints = await promptForValue(api, signal, "Constraints (optional)", false);
+      if (constraints === undefined)
+        return;
       return {
-        ok: false,
-        error: stateUnavailable("write", "The session pull request state lock was compromised", compromise)
+        kind,
+        title,
+        problem,
+        desiredOutcome,
+        constraints
       };
     }
-    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 };
+    case "other": {
+      const details = await promptForValue(api, signal, "Details", true);
+      if (details === undefined)
+        return;
       return {
-        ok: false,
-        error: stateUnavailable("read", "Unable to read the session pull request state", cause)
+        kind,
+        title,
+        details
       };
     }
-    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 ?? [] };
+    default:
+      return casesHandled(kind);
   }
-  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(() => {
+}
+function createFeedbackCommand(api, dependencies, release) {
+  return {
+    name: "pr.tracker.feedback",
+    title: "Send PR tracker feedback",
+    category: "Plugin",
+    namespace: "palette",
+    slashName: "pr-tracker-feedback",
+    async run() {
+      const signal = api.lifecycle.signal;
+      const kind = await selectFeedbackKind(api, signal);
+      if (kind === undefined)
         return;
-      });
-      return {
-        ok: false,
-        error: stateUnavailable("write", "Unable to write the session pull request state", cause)
+      const input = await collectFeedbackInput(api, signal, kind);
+      if (input === undefined)
+        return;
+      const diagnostics = {
+        pluginVersion: release?.version ?? "unavailable",
+        opencodeVersion: api.app.version,
+        operatingSystem: `${process.platform}/${process.arch}`,
+        installationSource: release?.source ?? "unavailable"
       };
-    }
-  }
-  return {
-    list: read,
-    async attach(sessionID, pullRequest) {
-      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" };
-      });
-    },
-    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 includeDiagnostics = await confirmDiagnostics(api, signal, diagnostics);
+      if (includeDiagnostics === undefined)
+        return;
+      const draft = createFeedbackDraft(input, includeDiagnostics ? diagnostics : undefined);
+      if (!draft.ok) {
+        api.ui.toast({
+          variant: "error",
+          title: "Pull request tracker",
+          message: draft.error.message
+        });
+        return;
+      }
+      const delivery = await selectDelivery(api, signal);
+      if (delivery === undefined)
+        return;
+      const confirmed = await confirmFeedback(api, signal, draft.value, delivery, dependencies.confirmationRenderer ?? FeedbackConfirmation);
+      if (!confirmed || signal.aborted)
+        return;
+      if (delivery === "browser") {
+        const result2 = await openFeedbackDraft(draft.value, {
+          ...dependencies.platform === undefined ? {} : {
+            platform: dependencies.platform
+          },
+          ...dependencies.runner === undefined ? {} : {
+            runner: dependencies.runner
+          },
+          signal
+        });
+        if (!result2.ok && !signal.aborted) {
+          api.ui.toast({
+            variant: "error",
+            title: "Pull request tracker",
+            message: result2.error.message
+          });
         }
-        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 } };
+        return;
+      }
+      const result = await submitFeedbackDraft(draft.value, {
+        ...dependencies.runner === undefined ? {} : {
+          runner: dependencies.runner
+        },
+        signal
       });
-    },
-    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)
-          };
+      if (result.ok) {
+        if (!signal.aborted) {
+          api.ui.toast({
+            variant: "success",
+            title: "Pull request tracker",
+            message: result.value
+          });
         }
-      });
+      } else if (result.error.tag !== "SubmitFeedbackCancelled" && !signal.aborted) {
+        api.ui.toast({
+          variant: "error",
+          title: "Pull request tracker",
+          message: result.error.message
+        });
+      }
     }
   };
 }
 
-// src/tui.tsx
-var pollIntervalMilliseconds = 60000;
-var defaultScheduler = {
-  setInterval: (task, delay) => globalThis.setInterval(task, delay),
-  clearInterval: (handle) => globalThis.clearInterval(handle)
-};
-function attachPullRequest(store, sessionID, input) {
-  const pullRequest = parsePullRequestUrl(input);
-  if (!pullRequest.ok)
-    return Promise.resolve(pullRequest);
-  return store.attach(sessionID, pullRequest.value);
+// src/plugin-update-tui.tsx
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+import { join as join2 } from "path";
+
+// src/update.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var updateCacheKey = "plugin-update-check-v1";
+var packageName = "@hcrosse/opencode-pr-tracker";
+var registryUrl = `https://registry.npmjs.org/${encodeURIComponent(packageName)}`;
+var updateCacheMilliseconds = 24 * 60 * 60 * 1000;
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function startSessionPolling(input) {
-  const scheduler = input.scheduler ?? defaultScheduler;
-  const statuses = new Map;
-  const controller = new AbortController;
-  let timer;
-  let timerRegistered = false;
-  let stopped = false;
-  let inFlight;
-  let refreshQueued = false;
-  function project(attachments) {
-    return attachments.map((attachment) => ({
-      attachment,
-      status: statuses.get(attachment.pullRequest.url) ?? {
-        tag: "Unavailable"
-      }
-    }));
+function parseRegistryReleases(input) {
+  if (!isRecord2(input) || !isRecord2(input.versions))
+    return;
+  const releases = [];
+  for (const [version, metadata] of Object.entries(input.versions)) {
+    if (!isRecord2(metadata) || !isRecord2(metadata.engines) || typeof metadata.engines.opencode !== "string")
+      continue;
+    releases.push({ version, opencodeRange: metadata.engines.opencode });
   }
-  async function poll() {
-    const attachments = await input.store.list(input.sessionID);
-    if (stopped)
-      return;
-    if (!attachments.ok) {
-      input.publish([]);
-      input.onStateFailure(attachments.error);
-      return;
-    }
-    const attachedUrls = new Set(attachments.value.map((attachment) => attachment.pullRequest.url));
-    for (const url of statuses.keys()) {
-      if (!attachedUrls.has(url))
-        statuses.delete(url);
-    }
-    input.publish(project(attachments.value));
-    const refreshable = attachments.value.filter((attachment) => {
-      const previous = statuses.get(attachment.pullRequest.url);
-      return previous?.tag !== "Available" || previous.state.tag !== "Merged";
-    });
-    const batch = await input.github.get(refreshable.map((attachment) => attachment.pullRequest), {
-      signal: controller.signal
-    });
-    if (stopped)
-      return;
-    let batchDiagnostic;
-    if (!batch.ok) {
-      if (batch.error.tag === "GitHubCancelled")
-        return;
-      batchDiagnostic = batch.error.tag === "GitHubBatchLimitExceeded" ? "GitHubUnavailable" : batch.error.tag;
-    }
-    for (const [index, attachment] of refreshable.entries()) {
-      const previous = statuses.get(attachment.pullRequest.url);
-      const result = batch.ok ? batch.value[index] : undefined;
-      if (result?.ok) {
-        statuses.set(attachment.pullRequest.url, result.value);
+  return releases;
+}
+function isStableVersion(version) {
+  return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version);
+}
+function isNewerStableVersion(version, currentVersion) {
+  if (!isStableVersion(version))
+    return false;
+  try {
+    return Bun.semver.order(version, currentVersion) > 0;
+  } catch {
+    return false;
+  }
+}
+function newestCompatibleUpdate(releases, versions) {
+  let latest;
+  for (const release of releases) {
+    if (!isNewerStableVersion(release.version, versions.currentVersion))
+      continue;
+    try {
+      if (!Bun.semver.satisfies(versions.opencodeVersion, release.opencodeRange))
         continue;
-      }
-      const diagnostic = result === undefined ? batchDiagnostic ?? "GitHubUnavailable" : result.error.tag;
-      statuses.set(attachment.pullRequest.url, previous?.tag === "Available" ? {
-        ...previous,
-        stale: true,
-        diagnostic
-      } : {
-        tag: "Unavailable",
-        diagnostic
-      });
+      if (latest === undefined || Bun.semver.order(release.version, latest) > 0)
+        latest = release.version;
+    } catch {
+      continue;
     }
-    if (!stopped)
-      input.publish(project(attachments.value));
   }
-  function refresh() {
-    if (stopped)
-      return Promise.resolve();
-    if (inFlight) {
-      refreshQueued = true;
-      return inFlight;
+  return latest === undefined ? undefined : { currentVersion: versions.currentVersion, version: latest };
+}
+function isCancellation2(cause, signal) {
+  return signal?.aborted === true || cause instanceof DOMException && cause.name === "AbortError";
+}
+async function checkForUpdate(versions, options = {}) {
+  const fetcher = options.fetch ?? ((url, input) => globalThis.fetch(url, input));
+  let response;
+  try {
+    response = await fetcher(registryUrl, options.signal ? { signal: options.signal } : {});
+  } catch (cause) {
+    if (isCancellation2(cause, options.signal)) {
+      return { ok: false, error: { tag: "UpdateCheckCancelled", message: "Plugin update check cancelled" } };
     }
-    const wrapped = poll().finally(() => {
-      inFlight = undefined;
-      if (refreshQueued && !stopped) {
-        refreshQueued = false;
-        return refresh();
-      }
-      return;
-    });
-    inFlight = wrapped;
-    return wrapped;
+    return {
+      ok: false,
+      error: { tag: "UpdateCheckUnavailable", message: "Unable to check for plugin updates", cause }
+    };
   }
-  return {
-    start() {
-      if (stopped)
-        return Promise.resolve();
-      if (!timerRegistered) {
-        timer = scheduler.setInterval(() => {
-          refresh().catch(input.onError);
-        }, pollIntervalMilliseconds);
-        timerRegistered = true;
-      }
-      return refresh();
-    },
-    refresh,
-    stop() {
-      if (stopped)
-        return;
-      stopped = true;
-      controller.abort();
-      if (timerRegistered)
-        scheduler.clearInterval(timer);
-    }
-  };
-}
-async function openPullRequest(pullRequest, options = {}) {
-  const platform = options.platform ?? process.platform;
-  const executable = platform === "darwin" ? "open" : platform === "linux" ? "xdg-open" : undefined;
-  if (executable === undefined) {
+  if (!response.ok) {
     return {
       ok: false,
       error: {
-        tag: "UnsupportedPlatform",
-        message: `Opening pull requests is unsupported on ${platform}`,
-        platform
+        tag: "UpdateCheckUnavailable",
+        message: "Unable to check for plugin updates",
+        cause: new Error(`npm registry returned HTTP ${response.status}`)
       }
     };
   }
+  let decoded;
   try {
-    await (options.runner ?? execFileRunner)(executable, [pullRequest.url], options.signal ? {
-      signal: options.signal
-    } : {});
+    decoded = await response.json();
+  } catch {
     return {
-      ok: true,
-      value: undefined
+      ok: false,
+      error: {
+        tag: "InvalidUpdateResponse",
+        message: "The npm registry returned invalid plugin release metadata"
+      }
     };
-  } catch (cause) {
+  }
+  const releases = parseRegistryReleases(decoded);
+  if (releases === undefined) {
     return {
       ok: false,
       error: {
-        tag: "OpenPullRequestFailed",
-        message: "Unable to open the pull request",
-        cause
+        tag: "InvalidUpdateResponse",
+        message: "The npm registry returned invalid plugin release metadata"
       }
     };
   }
+  return { ok: true, value: newestCompatibleUpdate(releases, versions) };
 }
-function createRefreshBus() {
-  const listeners = new Map;
-  return {
-    emit(sessionID) {
-      for (const listener of listeners.get(sessionID) ?? [])
-        listener();
-    },
-    subscribe(sessionID, listener) {
-      const sessionListeners = listeners.get(sessionID) ?? new Set;
-      sessionListeners.add(listener);
-      listeners.set(sessionID, sessionListeners);
-      return () => {
-        sessionListeners.delete(listener);
-        if (sessionListeners.size === 0)
-          listeners.delete(sessionID);
-      };
+function parseFreshUpdateCache(input, versions, now = Date.now()) {
+  if (!isRecord2(input))
+    return;
+  if (typeof input.checkedAt !== "number" || !Number.isFinite(input.checkedAt) || input.checkedAt > now || now - input.checkedAt >= updateCacheMilliseconds || input.currentVersion !== versions.currentVersion || input.opencodeVersion !== versions.opencodeVersion || input.availableVersion !== null && (typeof input.availableVersion !== "string" || !isNewerStableVersion(input.availableVersion, versions.currentVersion))) {
+    return;
+  }
+  return input.availableVersion;
+}
+function isMissingFile(cause) {
+  return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+}
+async function readConfig(path) {
+  try {
+    return Bun.JSONC.parse(await readFile(path, "utf8"));
+  } catch (cause) {
+    if (isMissingFile(cause))
+      return;
+    return;
+  }
+}
+function configuredPluginSpecifier(input) {
+  if (typeof input === "string")
+    return input;
+  if (Array.isArray(input) && input.length === 2 && typeof input[0] === "string" && isRecord2(input[1])) {
+    return input[0];
+  }
+  return;
+}
+function containsPlugin(input) {
+  if (!isRecord2(input) || !Array.isArray(input.plugin))
+    return false;
+  return input.plugin.some((entry) => {
+    const spec = configuredPluginSpecifier(entry);
+    return spec !== undefined && (spec === packageName || spec.startsWith(`${packageName}/`) || spec.startsWith(`${packageName}@`));
+  });
+}
+async function containsConfiguredPlugin(directory) {
+  const configs = await Promise.all(["opencode.json", "opencode.jsonc", "tui.json", "tui.jsonc"].map((name) => readConfig(join(directory, name))));
+  return configs.some(containsPlugin);
+}
+async function detectInstallationScopes(input) {
+  const [project, global2] = await Promise.all([
+    containsConfiguredPlugin(input.projectConfigDirectory),
+    containsConfiguredPlugin(input.globalConfigDirectory)
+  ]);
+  return [...project ? ["project"] : [], ...global2 ? ["global"] : []];
+}
+function updateCommand(version, scope) {
+  const globalFlag = scope === "global" ? " --global" : "";
+  return `opencode plugin ${packageName}@${version}${globalFlag} --force`;
+}
+function formatUpdateInstructions(version, scopes) {
+  const commands = scopes.length === 0 ? ["project", "global"] : scopes;
+  const body = commands.length === 1 ? updateCommand(version, commands[0]) : commands.map((scope) => `${scope === "project" ? "Project" : "Global"} installation:
+${updateCommand(version, scope)}`).join(`
+
+`);
+  return `${body}
+
+Restart OpenCode after updating.`;
+}
+
+// src/plugin-update-tui.tsx
+function createUpdateBus() {
+  const listeners = new Set;
+  let version;
+  return {
+    current: () => version,
+    publish(value) {
+      version = value;
+      for (const listener of listeners)
+        listener(value);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
     }
   };
 }
-function currentSessionID(api) {
-  const route = api.route.current;
-  if (route.name !== "session" || !("params" in route))
-    return;
-  return typeof route.params?.sessionID === "string" ? route.params.sessionID : undefined;
+function writeUpdateCache(api, versions, availableVersion, now) {
+  const cache = {
+    checkedAt: now(),
+    ...versions,
+    availableVersion
+  };
+  api.kv.set(updateCacheKey, cache);
 }
-function promptForPullRequest(api, options) {
+function waitForKvReady(api) {
   return new Promise((resolve) => {
-    const controller = new AbortController;
-    const signal = AbortSignal.any([options.signal, controller.signal]);
-    let finished = false;
-    const finish = (value) => {
-      if (finished)
-        return;
-      finished = true;
-      controller.abort();
-      api.ui.dialog.clear();
-      resolve(value);
+    let timer;
+    const finish = (ready) => {
+      if (timer !== undefined)
+        clearTimeout(timer);
+      api.lifecycle.signal.removeEventListener("abort", onAbort);
+      resolve(ready);
     };
-    api.ui.dialog.setSize("medium");
-    api.ui.dialog.replace(() => {
-      const [error, setError] = createSignal();
-      const [busy, setBusy] = createSignal(false);
-      const DialogPrompt = api.ui.DialogPrompt;
-      return _$createComponent(DialogPrompt, {
-        title: "Attach pull request",
-        placeholder: "https://github.com/owner/repository/pull/123 or 123",
-        description: () => error() ? (() => {
-          var _el$ = _$createElement("text");
-          _$insert(_el$, error);
-          _$effect((_$p) => _$setProp(_el$, "fg", api.theme.current.error, _$p));
-          return _el$;
-        })() : null,
-        get busy() {
-          return busy();
-        },
-        busyText: "Resolving repository",
-        onConfirm: (value) => {
-          if (busy())
-            return;
-          setBusy(true);
-          resolvePullRequestInput(value, {
-            directory: options.directory,
-            ...options.runner ? {
-              runner: options.runner
-            } : {},
-            signal
-          }).then((result) => {
-            if (finished)
-              return;
-            setBusy(false);
-            if (result.ok) {
-              finish(result.value);
-              return;
-            }
-            if (result.error.tag === "RepositoryResolutionCancelled") {
-              finish(undefined);
-              return;
-            }
-            setError(result.error.message);
-          });
-        },
-        onCancel: () => finish(undefined)
-      });
-    }, () => {
-      if (finished)
-        return;
-      finished = true;
-      controller.abort();
-      resolve(undefined);
+    const onAbort = () => finish(false);
+    const check = () => {
+      if (api.lifecycle.signal.aborted) {
+        finish(false);
+      } else if (api.kv.ready) {
+        finish(true);
+      } else {
+        timer = setTimeout(check, 10);
+      }
+    };
+    api.lifecycle.signal.addEventListener("abort", onAbort, {
+      once: true
     });
+    check();
   });
 }
-function selectPullRequest(api, title, attachments) {
-  return new Promise((resolve) => {
-    let finished = false;
-    const finish = (value) => {
-      if (finished)
+function updateStatusLabel(version) {
+  return `${version} available`;
+}
+function createPluginUpdateController(api, dependencies, release) {
+  const updateBus = createUpdateBus();
+  const updateChecker = dependencies.updateChecker ?? checkForUpdate;
+  const installationScopes = dependencies.installationScopes ?? detectInstallationScopes;
+  const now = dependencies.now ?? Date.now;
+  const versions = release?.source === "npm" && release.version !== undefined ? {
+    currentVersion: release.version,
+    opencodeVersion: api.app.version
+  } : undefined;
+  let updateOperations = Promise.resolve();
+  function serializeUpdateOperation(operation) {
+    const result = updateOperations.then(operation);
+    updateOperations = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  }
+  let startup;
+  if (versions !== undefined) {
+    startup = serializeUpdateOperation(async () => {
+      try {
+        if (!await waitForKvReady(api))
+          return;
+        const cached = parseFreshUpdateCache(api.kv.get(updateCacheKey), versions, now());
+        if (cached !== undefined) {
+          updateBus.publish(cached ?? undefined);
+          return;
+        }
+        const result = await updateChecker(versions, {
+          signal: api.lifecycle.signal
+        });
+        if (api.lifecycle.signal.aborted)
+          return;
+        const availableVersion = result.ok ? result.value?.version ?? null : null;
+        writeUpdateCache(api, versions, availableVersion, now);
+        if (result.ok)
+          updateBus.publish(result.value?.version);
+      } catch {
+        if (!api.lifecycle.signal.aborted && api.kv.ready)
+          writeUpdateCache(api, versions, null, now);
+      }
+    });
+  }
+  const command = {
+    name: "pr.tracker.plugin.update",
+    title: "Update PR tracker plugin",
+    category: "Plugin",
+    namespace: "palette",
+    slashName: "pr-tracker-plugin-update",
+    async run() {
+      if (versions === undefined) {
+        api.ui.toast({
+          variant: "info",
+          title: "Pull request tracker",
+          message: "Update checks are unavailable for this plugin installation"
+        });
         return;
-      finished = true;
-      api.ui.dialog.clear();
-      resolve(value);
+      }
+      const result = await serializeUpdateOperation(async () => {
+        if (!await waitForKvReady(api))
+          return;
+        const checked = await updateChecker(versions, {
+          signal: api.lifecycle.signal
+        });
+        if (api.lifecycle.signal.aborted || !checked.ok && checked.error.tag === "UpdateCheckCancelled") {
+          return;
+        }
+        if (checked.ok) {
+          writeUpdateCache(api, versions, checked.value?.version ?? null, now);
+          updateBus.publish(checked.value?.version);
+        }
+        return checked;
+      });
+      if (result === undefined)
+        return;
+      if (!result.ok) {
+        api.ui.toast({
+          variant: "error",
+          title: "Pull request tracker",
+          message: result.error.message
+        });
+        return;
+      }
+      if (result.value === undefined) {
+        api.ui.toast({
+          variant: "info",
+          title: "Pull request tracker",
+          message: "PR tracker is up to date"
+        });
+        return;
+      }
+      const update = result.value;
+      let scopes;
+      try {
+        const projectRoot = api.state.path.worktree === "/" ? api.state.path.directory : api.state.path.worktree;
+        scopes = await installationScopes({
+          projectConfigDirectory: join2(projectRoot, ".opencode"),
+          globalConfigDirectory: api.state.path.config
+        });
+      } catch {
+        scopes = [];
+      }
+      if (api.lifecycle.signal.aborted)
+        return;
+      api.ui.dialog.setSize("medium");
+      api.ui.dialog.replace(() => _$createComponent2(api.ui.DialogAlert, {
+        get title() {
+          return `Update PR tracker to ${update.version}`;
+        },
+        get message() {
+          return formatUpdateInstructions(update.version, scopes);
+        }
+      }));
+    }
+  };
+  return {
+    command,
+    current: updateBus.current,
+    subscribe: updateBus.subscribe,
+    startup
+  };
+}
+
+// src/pull-request-tui.tsx
+import { createTextNode as _$createTextNode2 } from "@opentui/solid";
+import { insertNode as _$insertNode2 } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { effect as _$effect2 } from "@opentui/solid";
+import { insert as _$insert2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+import { createComponent as _$createComponent3 } from "@opentui/solid";
+import { TextAttributes } from "@opentui/core";
+import { createSignal as createSignal2, onCleanup } from "solid-js";
+
+// 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 };
+    }
+  });
+}
+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 isCancellation3(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 (isCancellation3(cause, options.signal))
+      return repositoryResolutionCancelled;
+    return { ok: false, error: { ...repositoryResolutionFailed, cause } };
+  }
+  return parseRepositoryPullRequest(stdout, number);
+}
+
+// src/polling.ts
+var pollIntervalMilliseconds = 60000;
+var defaultScheduler = {
+  setInterval: (task, delay) => globalThis.setInterval(task, delay),
+  clearInterval: (handle) => globalThis.clearInterval(handle)
+};
+function startSessionPolling(input) {
+  const scheduler = input.scheduler ?? defaultScheduler;
+  const statuses = new Map;
+  const controller = new AbortController;
+  let timer;
+  let timerRegistered = false;
+  let stopped = false;
+  let inFlight;
+  let queued;
+  function project(attachments) {
+    return attachments.map((attachment) => ({
+      attachment,
+      status: statuses.get(attachment.pullRequest.url) ?? { tag: "Unavailable" }
+    }));
+  }
+  async function poll() {
+    const attachments = await input.store.list(input.sessionID);
+    if (stopped)
+      return { ok: true, value: "stopped" };
+    if (!attachments.ok) {
+      input.publish([]);
+      input.onStateFailure(attachments.error);
+      return attachments;
+    }
+    const attachedUrls = new Set(attachments.value.map((attachment) => attachment.pullRequest.url));
+    for (const url of statuses.keys()) {
+      if (!attachedUrls.has(url))
+        statuses.delete(url);
+    }
+    input.publish(project(attachments.value));
+    if (attachments.value.length === 0)
+      return { ok: true, value: "no_attachments" };
+    const refreshable = attachments.value.filter((attachment) => {
+      const previous = statuses.get(attachment.pullRequest.url);
+      return previous?.tag !== "Available" || previous.state.tag !== "Merged";
+    });
+    const batch = await input.github.get(refreshable.map((attachment) => attachment.pullRequest), { signal: controller.signal });
+    if (stopped)
+      return { ok: true, value: "stopped" };
+    let batchDiagnostic;
+    let failure;
+    if (!batch.ok) {
+      if (batch.error.tag === "GitHubCancelled")
+        return batch;
+      batchDiagnostic = batch.error.tag === "GitHubBatchLimitExceeded" ? "GitHubUnavailable" : batch.error.tag;
+      failure = batch.error;
+    }
+    for (const [index, attachment] of refreshable.entries()) {
+      const previous = statuses.get(attachment.pullRequest.url);
+      const result = batch.ok ? batch.value[index] : undefined;
+      if (result?.ok) {
+        statuses.set(attachment.pullRequest.url, result.value);
+        continue;
+      }
+      const diagnostic = result === undefined ? batchDiagnostic ?? "GitHubUnavailable" : result.error.tag;
+      if (result !== undefined && !result.ok)
+        failure ??= result.error;
+      statuses.set(attachment.pullRequest.url, previous?.tag === "Available" ? { ...previous, stale: true, diagnostic } : { tag: "Unavailable", diagnostic });
+    }
+    if (!stopped)
+      input.publish(project(attachments.value));
+    return failure === undefined ? { ok: true, value: "refreshed" } : { ok: false, error: failure };
+  }
+  function startQueuedRefresh() {
+    inFlight = undefined;
+    const next = queued;
+    queued = undefined;
+    if (next === undefined)
+      return;
+    if (stopped) {
+      next.resolve({ ok: true, value: "stopped" });
+      return;
+    }
+    requestRefresh().then((result) => next.resolve(result), (error) => next.reject(error));
+  }
+  function requestRefresh() {
+    if (stopped)
+      return Promise.resolve({ ok: true, value: "stopped" });
+    if (inFlight) {
+      if (queued !== undefined)
+        return queued.promise;
+      let resolve;
+      let reject;
+      const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+      });
+      queued = { promise, resolve, reject };
+      return promise;
+    }
+    const current = poll();
+    inFlight = current;
+    current.then(startQueuedRefresh, startQueuedRefresh);
+    return current;
+  }
+  function scheduledRefresh() {
+    return requestRefresh().then(() => {
+      return;
+    });
+  }
+  return {
+    start() {
+      if (stopped)
+        return Promise.resolve();
+      if (!timerRegistered) {
+        timer = scheduler.setInterval(() => {
+          scheduledRefresh().catch(input.onError);
+        }, pollIntervalMilliseconds);
+        timerRegistered = true;
+      }
+      return scheduledRefresh();
+    },
+    refresh: scheduledRefresh,
+    forceRefresh: requestRefresh,
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      controller.abort();
+      if (timerRegistered)
+        scheduler.clearInterval(timer);
+    }
+  };
+}
+
+// src/pull-request-tui.tsx
+function attachPullRequest2(store, sessionID, input, options = {}) {
+  const pullRequest = parsePullRequestUrl(input);
+  if (!pullRequest.ok)
+    return Promise.resolve(pullRequest);
+  return attachPullRequest({
+    store,
+    github: options.github ?? createGitHubClient()
+  }, sessionID, pullRequest.value, options.signal ? {
+    signal: options.signal
+  } : {});
+}
+function createRefreshBus() {
+  const listeners = new Map;
+  return {
+    emit(sessionID) {
+      for (const listener of listeners.get(sessionID) ?? [])
+        listener.refresh();
+    },
+    async forceRefresh(sessionID) {
+      const sessionListeners = listeners.get(sessionID);
+      if (sessionListeners === undefined || sessionListeners.size === 0)
+        return;
+      const settled = await Promise.allSettled([...sessionListeners].map((listener) => listener.forceRefresh()));
+      const rejected = settled.find((result) => result.status === "rejected");
+      if (rejected !== undefined)
+        throw rejected.reason;
+      const results = settled.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+      return results.find((result) => !result.ok) ?? results.find((result) => result.ok && result.value === "refreshed") ?? results[0];
+    },
+    subscribe(sessionID, listener) {
+      const sessionListeners = listeners.get(sessionID) ?? new Set;
+      sessionListeners.add(listener);
+      listeners.set(sessionID, sessionListeners);
+      return () => {
+        sessionListeners.delete(listener);
+        if (sessionListeners.size === 0)
+          listeners.delete(sessionID);
+      };
+    }
+  };
+}
+function currentSessionID(api) {
+  const route = api.route.current;
+  if (route.name !== "session" || !("params" in route))
+    return;
+  return typeof route.params?.sessionID === "string" ? route.params.sessionID : undefined;
+}
+function promptForPullRequest(api, options) {
+  return new Promise((resolve) => {
+    const controller = new AbortController;
+    const signal = AbortSignal.any([options.signal, controller.signal]);
+    let finished = false;
+    const onAbort = () => finish(undefined);
+    const finish = (value, clearDialog = true) => {
+      if (finished)
+        return;
+      finished = true;
+      options.signal.removeEventListener("abort", onAbort);
+      controller.abort();
+      if (clearDialog)
+        api.ui.dialog.clear();
+      resolve(value);
+    };
+    if (options.signal.aborted) {
+      finish(undefined, false);
+      return;
+    }
+    options.signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+    api.ui.dialog.setSize("medium");
+    api.ui.dialog.replace(() => {
+      const [error, setError] = createSignal2();
+      const [busy, setBusy] = createSignal2(false);
+      const DialogPrompt = api.ui.DialogPrompt;
+      return _$createComponent3(DialogPrompt, {
+        title: "Attach pull request",
+        placeholder: "https://github.com/owner/repository/pull/123, github.com/owner/repository/pull/123, or 123",
+        description: () => error() ? (() => {
+          var _el$ = _$createElement2("text");
+          _$insert2(_el$, error);
+          _$effect2((_$p) => _$setProp2(_el$, "fg", api.theme.current.error, _$p));
+          return _el$;
+        })() : null,
+        get busy() {
+          return busy();
+        },
+        busyText: "Resolving repository",
+        onConfirm: (value) => {
+          if (finished || busy())
+            return;
+          setBusy(true);
+          resolvePullRequestInput(value, {
+            directory: options.directory,
+            ...options.runner ? {
+              runner: options.runner
+            } : {},
+            signal
+          }).then((result) => {
+            if (finished)
+              return;
+            setBusy(false);
+            if (result.ok) {
+              finish(result.value);
+              return;
+            }
+            if (result.error.tag === "RepositoryResolutionCancelled") {
+              finish(undefined);
+              return;
+            }
+            setError(result.error.message);
+          });
+        },
+        onCancel: () => finish(undefined)
+      });
+    }, () => finish(undefined, false));
+  });
+}
+function selectPullRequest(api, title, attachments, signal) {
+  return new Promise((resolve) => {
+    let finished = false;
+    const onAbort = () => finish(undefined);
+    const finish = (value, clearDialog = true) => {
+      if (finished)
+        return;
+      finished = true;
+      signal.removeEventListener("abort", onAbort);
+      if (clearDialog)
+        api.ui.dialog.clear();
+      resolve(value);
+    };
+    if (signal.aborted) {
+      finish(undefined, false);
+      return;
+    }
+    signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+    api.ui.dialog.setSize("medium");
+    api.ui.dialog.replace(() => {
+      const DialogSelect = api.ui.DialogSelect;
+      return _$createComponent3(DialogSelect, {
+        title,
+        get options() {
+          return attachments.map((attachment) => ({
+            title: formatPullRequestRef(attachment.pullRequest),
+            value: attachment.pullRequest,
+            description: attachment.pullRequest.url
+          }));
+        },
+        onSelect: (option) => finish(option.value)
+      });
+    }, () => finish(undefined, false));
+  });
+}
+function showStateFailure(api, failure) {
+  api.ui.toast({
+    variant: "error",
+    title: "Pull request tracker",
+    message: failure.message
+  });
+}
+function createPullRequestCommands(api, dependencies, refreshBus) {
+  return [{
+    name: "pr.attach",
+    title: "Attach pull request",
+    category: "Plugin",
+    namespace: "palette",
+    slashName: "pr-attach",
+    async run() {
+      const sessionID = currentSessionID(api);
+      if (sessionID === undefined) {
+        api.ui.toast({
+          variant: "warning",
+          title: "Pull request tracker",
+          message: "Open a session first"
+        });
+        return;
+      }
+      const pullRequest = await promptForPullRequest(api, {
+        directory: api.state.path.directory,
+        ...dependencies.runner ? {
+          runner: dependencies.runner
+        } : {},
+        signal: api.lifecycle.signal
+      });
+      if (pullRequest === undefined)
+        return;
+      const result = await attachPullRequest(dependencies, sessionID, pullRequest, {
+        signal: api.lifecycle.signal
+      });
+      if (!result.ok) {
+        showStateFailure(api, result.error);
+        return;
+      }
+      const message = result.value === "added" ? `Attached ${formatPullRequestRef(pullRequest)}` : `${formatPullRequestRef(pullRequest)} is already attached`;
+      api.ui.toast({
+        variant: "success",
+        title: "Pull request tracker",
+        message
+      });
+      refreshBus.emit(sessionID);
+    }
+  }, {
+    name: "pr.open",
+    title: "Open pull request",
+    category: "Plugin",
+    namespace: "palette",
+    slashName: "pr-open",
+    async run() {
+      const sessionID = currentSessionID(api);
+      if (sessionID === undefined) {
+        api.ui.toast({
+          variant: "warning",
+          title: "Pull request tracker",
+          message: "Open a session first"
+        });
+        return;
+      }
+      const attachments = await dependencies.store.list(sessionID);
+      if (!attachments.ok) {
+        showStateFailure(api, attachments.error);
+        return;
+      }
+      if (attachments.value.length === 0) {
+        api.ui.toast({
+          variant: "info",
+          title: "Pull request tracker",
+          message: "No pull requests are attached"
+        });
+        return;
+      }
+      const pullRequest = await selectPullRequest(api, "Open pull request", attachments.value, api.lifecycle.signal);
+      if (pullRequest === undefined)
+        return;
+      const result = await openPullRequest(pullRequest, {
+        ...dependencies.runner ? {
+          runner: dependencies.runner
+        } : {},
+        signal: api.lifecycle.signal
+      });
+      if (!result.ok) {
+        api.ui.toast({
+          variant: "error",
+          title: "Pull request tracker",
+          message: result.error.message
+        });
+      }
+    }
+  }, {
+    name: "pr.detach",
+    title: "Detach pull request",
+    category: "Plugin",
+    namespace: "palette",
+    slashName: "pr-detach",
+    async run() {
+      const sessionID = currentSessionID(api);
+      if (sessionID === undefined) {
+        api.ui.toast({
+          variant: "warning",
+          title: "Pull request tracker",
+          message: "Open a session first"
+        });
+        return;
+      }
+      const attachments = await dependencies.store.list(sessionID);
+      if (!attachments.ok) {
+        showStateFailure(api, attachments.error);
+        return;
+      }
+      if (attachments.value.length === 0) {
+        api.ui.toast({
+          variant: "info",
+          title: "Pull request tracker",
+          message: "No pull requests are attached"
+        });
+        return;
+      }
+      const pullRequest = await selectPullRequest(api, "Detach pull request", attachments.value, api.lifecycle.signal);
+      if (pullRequest === undefined)
+        return;
+      const result = await dependencies.store.detach(sessionID, pullRequest);
+      if (!result.ok) {
+        showStateFailure(api, result.error);
+        return;
+      }
+      const message = result.value === "removed" ? `Detached ${formatPullRequestRef(pullRequest)}` : `${formatPullRequestRef(pullRequest)} was not attached`;
+      api.ui.toast({
+        variant: "success",
+        title: "Pull request tracker",
+        message
+      });
+      refreshBus.emit(sessionID);
+    }
+  }, {
+    name: "pr.sync",
+    title: "Sync pull request status",
+    category: "Plugin",
+    namespace: "palette",
+    slashName: "pr-sync",
+    async run() {
+      const sessionID = currentSessionID(api);
+      if (sessionID === undefined) {
+        api.ui.toast({
+          variant: "warning",
+          title: "Pull request tracker",
+          message: "Open a session first"
+        });
+        return;
+      }
+      try {
+        const result = await refreshBus.forceRefresh(sessionID);
+        if (result === undefined) {
+          api.ui.toast({
+            variant: "warning",
+            title: "Pull request tracker",
+            message: "Pull request sidebar is not available"
+          });
+          return;
+        }
+        if (!result.ok) {
+          api.ui.toast({
+            variant: "error",
+            title: "Pull request tracker",
+            message: result.error.message
+          });
+          return;
+        }
+        switch (result.value) {
+          case "refreshed":
+            api.ui.toast({
+              variant: "success",
+              title: "Pull request tracker",
+              message: "Pull request status synced"
+            });
+            return;
+          case "no_attachments":
+            api.ui.toast({
+              variant: "info",
+              title: "Pull request tracker",
+              message: "No pull requests are attached"
+            });
+            return;
+          case "stopped":
+            api.ui.toast({
+              variant: "error",
+              title: "Pull request tracker",
+              message: "Unable to refresh pull request status"
+            });
+            return;
+        }
+      } catch {
+        api.ui.toast({
+          variant: "error",
+          title: "Pull request tracker",
+          message: "Unable to refresh pull request status"
+        });
+      }
+    }
+  }];
+}
+function toneColor(theme, tone) {
+  const colors = {
+    green: theme.success,
+    yellow: theme.warning,
+    red: theme.error,
+    purple: theme.secondary,
+    gray: theme.textMuted
+  };
+  return colors[tone];
+}
+function PullRequestSidebar(props) {
+  const [items, setItems] = createSignal2([]);
+  const [failure, setFailure] = createSignal2();
+  const [update, setUpdate] = createSignal2(props.updates.current());
+  const [open, setOpen] = createSignal2(true);
+  const collapsible = () => items().length > 2;
+  const polling = startSessionPolling({
+    sessionID: props.sessionID,
+    store: props.dependencies.store,
+    github: props.dependencies.github,
+    publish: (value) => {
+      setFailure(undefined);
+      setItems(value);
+    },
+    onStateFailure: (error) => setFailure(error.message),
+    onError: () => setFailure("Unable to refresh pull request status")
+  });
+  polling.start().catch(() => setFailure("Unable to refresh pull request status"));
+  const unsubscribe = props.refreshBus.subscribe(props.sessionID, {
+    refresh() {
+      polling.refresh().catch(() => setFailure("Unable to refresh pull request status"));
+    },
+    async forceRefresh() {
+      try {
+        return await polling.forceRefresh();
+      } catch (error) {
+        setFailure("Unable to refresh pull request status");
+        throw error;
+      }
+    }
+  });
+  const unsubscribeUpdate = props.updates.subscribe(setUpdate);
+  const onAbort = () => polling.stop();
+  props.api.lifecycle.signal.addEventListener("abort", onAbort, {
+    once: true
+  });
+  onCleanup(() => {
+    unsubscribe();
+    unsubscribeUpdate();
+    polling.stop();
+    props.api.lifecycle.signal.removeEventListener("abort", onAbort);
+  });
+  return (() => {
+    var _el$2 = _$createElement2("box"), _el$3 = _$createElement2("box"), _el$4 = _$createElement2("text"), _el$5 = _$createElement2("b");
+    _$insertNode2(_el$2, _el$3);
+    _$setProp2(_el$2, "flexDirection", "column");
+    _$setProp2(_el$2, "gap", 1);
+    _$insertNode2(_el$3, _el$4);
+    _$setProp2(_el$3, "flexDirection", "row");
+    _$setProp2(_el$3, "gap", 1);
+    _$setProp2(_el$3, "onMouseDown", () => collapsible() && setOpen((value) => !value));
+    _$insert2(_el$3, (() => {
+      var _c$ = _$memo(() => !!collapsible());
+      return () => _c$() ? (() => {
+        var _el$7 = _$createElement2("text");
+        _$insert2(_el$7, () => open() ? "\u25BC" : "\u25B6");
+        _$effect2((_$p) => _$setProp2(_el$7, "fg", props.api.theme.current.text, _$p));
+        return _el$7;
+      })() : null;
+    })(), _el$4);
+    _$insertNode2(_el$4, _el$5);
+    _$insertNode2(_el$5, _$createTextNode2(`Pull requests`));
+    _$insert2(_el$2, (() => {
+      var _c$2 = _$memo(() => !!(!collapsible() || open()));
+      return () => _c$2() ? (() => {
+        var _el$8 = _$createElement2("box");
+        _$setProp2(_el$8, "flexDirection", "column");
+        _$setProp2(_el$8, "gap", 1);
+        _$insert2(_el$8, (() => {
+          var _c$3 = _$memo(() => !!update());
+          return () => _c$3() ? (() => {
+            var _el$9 = _$createElement2("box"), _el$0 = _$createElement2("text"), _el$10 = _$createElement2("text");
+            _$insertNode2(_el$9, _el$0);
+            _$insertNode2(_el$9, _el$10);
+            _$setProp2(_el$9, "flexDirection", "row");
+            _$setProp2(_el$9, "onMouseUp", () => props.api.keymap.dispatchCommand("pr.tracker.plugin.update"));
+            _$insertNode2(_el$0, _$createTextNode2(`\u2022 `));
+            _$insert2(_el$10, () => updateStatusLabel(update()));
+            _$effect2((_p$) => {
+              var _v$ = props.api.theme.current.warning, _v$2 = props.api.theme.current.textMuted, _v$3 = TextAttributes.ITALIC;
+              _v$ !== _p$.e && (_p$.e = _$setProp2(_el$0, "fg", _v$, _p$.e));
+              _v$2 !== _p$.t && (_p$.t = _$setProp2(_el$10, "fg", _v$2, _p$.t));
+              _v$3 !== _p$.a && (_p$.a = _$setProp2(_el$10, "attributes", _v$3, _p$.a));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined
+            });
+            return _el$9;
+          })() : null;
+        })(), null);
+        _$insert2(_el$8, (() => {
+          var _c$4 = _$memo(() => !!failure());
+          return () => _c$4() ? (() => {
+            var _el$11 = _$createElement2("text");
+            _$insert2(_el$11, failure);
+            _$effect2((_$p) => _$setProp2(_el$11, "fg", props.api.theme.current.error, _$p));
+            return _el$11;
+          })() : null;
+        })(), null);
+        _$insert2(_el$8, (() => {
+          var _c$5 = _$memo(() => !!(!failure() && items().length === 0));
+          return () => _c$5() ? (() => {
+            var _el$12 = _$createElement2("text");
+            _$insertNode2(_el$12, _$createTextNode2(`No pull requests attached`));
+            _$effect2((_$p) => _$setProp2(_el$12, "fg", props.api.theme.current.textMuted, _$p));
+            return _el$12;
+          })() : null;
+        })(), null);
+        _$insert2(_el$8, () => items().map((item) => {
+          const appearance = statusAppearance(item.status);
+          const attributes = appearance.strikethrough ? TextAttributes.STRIKETHROUGH : TextAttributes.NONE;
+          const title = item.status.tag === "Available" ? item.status.title : "Title unavailable";
+          return (() => {
+            var _el$14 = _$createElement2("box"), _el$15 = _$createElement2("text"), _el$16 = _$createElement2("b"), _el$17 = _$createTextNode2(` `), _el$18 = _$createElement2("text");
+            _$insertNode2(_el$14, _el$15);
+            _$insertNode2(_el$14, _el$18);
+            _$setProp2(_el$14, "flexDirection", "column");
+            _$setProp2(_el$14, "onMouseUp", () => {
+              openPullRequest(item.attachment.pullRequest, {
+                ...props.dependencies.runner ? {
+                  runner: props.dependencies.runner
+                } : {},
+                signal: props.api.lifecycle.signal
+              }).then((result) => {
+                if (!result.ok) {
+                  props.api.ui.toast({
+                    variant: "error",
+                    title: "Pull request tracker",
+                    message: result.error.message
+                  });
+                }
+              }).catch(() => {
+                props.api.ui.toast({
+                  variant: "error",
+                  title: "Pull request tracker",
+                  message: "Unable to open the pull request"
+                });
+              });
+            });
+            _$insertNode2(_el$15, _el$16);
+            _$insertNode2(_el$15, _el$17);
+            _$setProp2(_el$15, "attributes", attributes);
+            _$insert2(_el$16, () => formatPullRequestRef(item.attachment.pullRequest));
+            _$insert2(_el$15, () => appearance.label, null);
+            _$setProp2(_el$18, "attributes", attributes);
+            _$insert2(_el$18, title);
+            _$effect2((_p$) => {
+              var _v$4 = toneColor(props.api.theme.current, appearance.tone), _v$5 = props.api.theme.current.textMuted;
+              _v$4 !== _p$.e && (_p$.e = _$setProp2(_el$15, "fg", _v$4, _p$.e));
+              _v$5 !== _p$.t && (_p$.t = _$setProp2(_el$18, "fg", _v$5, _p$.t));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined
+            });
+            return _el$14;
+          })();
+        }), null);
+        return _el$8;
+      })() : null;
+    })(), null);
+    _$effect2((_$p) => _$setProp2(_el$4, "fg", props.api.theme.current.text, _$p));
+    return _el$2;
+  })();
+}
+
+// src/state.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join3 } 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 isRecord3(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 (!isRecord3(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 (!isRecord3(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 isMissingFile2(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 || join3(home, ".local", "share");
+  return join3(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 = join3(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 = join3(directory, fileName(sessionID));
+    let content;
+    try {
+      content = await readFile2(path, "utf8");
+    } catch (cause) {
+      if (isMissingFile2(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 = join3(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
+      }))
     };
-    api.ui.dialog.setSize("medium");
-    api.ui.dialog.replace(() => {
-      const DialogSelect = api.ui.DialogSelect;
-      return _$createComponent(DialogSelect, {
-        title,
-        get options() {
-          return attachments.map((attachment) => ({
-            title: formatPullRequestRef(attachment.pullRequest),
-            value: attachment.pullRequest,
-            description: attachment.pullRequest.url
-          }));
-        },
-        onSelect: (option) => finish(option.value)
+    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;
       });
-    }, () => {
-      if (!finished)
-        resolve(undefined);
-    });
-  });
-}
-function showStateFailure(api, failure) {
-  api.ui.toast({
-    variant: "error",
-    title: "Pull request tracker",
-    message: failure.message
-  });
-}
-function toneColor(theme, tone) {
-  const colors = {
-    green: theme.success,
-    yellow: theme.warning,
-    red: theme.error,
-    purple: theme.secondary,
-    gray: theme.textMuted
-  };
-  return colors[tone];
-}
-function PullRequestSidebar(props) {
-  const [items, setItems] = createSignal([]);
-  const [failure, setFailure] = createSignal();
-  const polling = startSessionPolling({
-    sessionID: props.sessionID,
-    store: props.dependencies.store,
-    github: props.dependencies.github,
-    publish: (value) => {
-      setFailure(undefined);
-      setItems(value);
-    },
-    onStateFailure: (error) => setFailure(error.message),
-    onError: () => setFailure("Unable to refresh pull request status")
-  });
-  polling.start().catch(() => setFailure("Unable to refresh pull request status"));
-  const unsubscribe = props.refreshBus.subscribe(props.sessionID, () => {
-    polling.refresh().catch(() => setFailure("Unable to refresh pull request status"));
-  });
-  const onAbort = () => polling.stop();
-  props.api.lifecycle.signal.addEventListener("abort", onAbort, {
-    once: true
-  });
-  onCleanup(() => {
-    unsubscribe();
-    polling.stop();
-    props.api.lifecycle.signal.removeEventListener("abort", onAbort);
-  });
-  return (() => {
-    var _el$2 = _$createElement("box"), _el$3 = _$createElement("text"), _el$4 = _$createElement("b");
-    _$insertNode(_el$2, _el$3);
-    _$setProp(_el$2, "flexDirection", "column");
-    _$setProp(_el$2, "gap", 1);
-    _$insertNode(_el$3, _el$4);
-    _$insertNode(_el$4, _$createTextNode(`Pull requests`));
-    _$insert(_el$2, (() => {
-      var _c$ = _$memo(() => !!failure());
-      return () => _c$() ? (() => {
-        var _el$6 = _$createElement("text");
-        _$insert(_el$6, failure);
-        _$effect((_$p) => _$setProp(_el$6, "fg", props.api.theme.current.error, _$p));
-        return _el$6;
-      })() : null;
-    })(), null);
-    _$insert(_el$2, (() => {
-      var _c$2 = _$memo(() => !!(!failure() && items().length === 0));
-      return () => _c$2() ? (() => {
-        var _el$7 = _$createElement("text");
-        _$insertNode(_el$7, _$createTextNode(`No pull requests attached`));
-        _$effect((_$p) => _$setProp(_el$7, "fg", props.api.theme.current.textMuted, _$p));
-        return _el$7;
-      })() : null;
-    })(), null);
-    _$insert(_el$2, () => items().map((item) => {
-      const appearance = statusAppearance(item.status);
-      const attributes = appearance.strikethrough ? TextAttributes.STRIKETHROUGH : TextAttributes.NONE;
-      const title = item.status.tag === "Available" ? item.status.title : "Title unavailable";
-      return (() => {
-        var _el$9 = _$createElement("box"), _el$0 = _$createElement("text"), _el$1 = _$createElement("b"), _el$10 = _$createTextNode(` `), _el$11 = _$createElement("text");
-        _$insertNode(_el$9, _el$0);
-        _$insertNode(_el$9, _el$11);
-        _$setProp(_el$9, "flexDirection", "column");
-        _$setProp(_el$9, "onMouseUp", () => {
-          openPullRequest(item.attachment.pullRequest, {
-            ...props.dependencies.runner ? {
-              runner: props.dependencies.runner
-            } : {},
-            signal: props.api.lifecycle.signal
-          }).then((result) => {
-            if (!result.ok) {
-              props.api.ui.toast({
-                variant: "error",
-                title: "Pull request tracker",
-                message: result.error.message
-              });
-            }
-          }).catch(() => {
-            props.api.ui.toast({
-              variant: "error",
-              title: "Pull request tracker",
-              message: "Unable to open the pull request"
-            });
-          });
-        });
-        _$insertNode(_el$0, _el$1);
-        _$insertNode(_el$0, _el$10);
-        _$setProp(_el$0, "attributes", attributes);
-        _$insert(_el$1, () => formatPullRequestRef(item.attachment.pullRequest));
-        _$insert(_el$0, () => appearance.label, null);
-        _$setProp(_el$11, "attributes", attributes);
-        _$insert(_el$11, title);
-        _$effect((_p$) => {
-          var _v$ = toneColor(props.api.theme.current, appearance.tone), _v$2 = props.api.theme.current.textMuted;
-          _v$ !== _p$.e && (_p$.e = _$setProp(_el$0, "fg", _v$, _p$.e));
-          _v$2 !== _p$.t && (_p$.t = _$setProp(_el$11, "fg", _v$2, _p$.t));
-          return _p$;
-        }, {
-          e: undefined,
-          t: undefined
-        });
-        return _el$9;
-      })();
-    }), null);
-    _$effect((_$p) => _$setProp(_el$3, "fg", props.api.theme.current.text, _$p));
-    return _el$2;
-  })();
-}
-function registerTui(api, dependencies) {
-  const refreshBus = createRefreshBus();
-  api.event.on("session.updated", (event) => refreshBus.emit(event.properties.sessionID));
-  api.event.on("message.updated", (event) => refreshBus.emit(event.properties.sessionID));
-  api.event.on("message.part.updated", (event) => refreshBus.emit(event.properties.sessionID));
-  const disposeCommands = api.keymap.registerLayer({
-    commands: [{
-      name: "pr.attach",
-      title: "Attach pull request",
-      category: "Plugin",
-      namespace: "palette",
-      slashName: "pr-attach",
-      async run() {
-        const sessionID = currentSessionID(api);
-        if (sessionID === undefined) {
-          api.ui.toast({
-            variant: "warning",
-            title: "Pull request tracker",
-            message: "Open a session first"
-          });
-          return;
-        }
-        const pullRequest = await promptForPullRequest(api, {
-          directory: api.state.path.directory,
-          ...dependencies.runner ? {
-            runner: dependencies.runner
-          } : {},
-          signal: api.lifecycle.signal
-        });
-        if (pullRequest === undefined)
-          return;
-        const result = await dependencies.store.attach(sessionID, pullRequest);
-        if (!result.ok) {
-          showStateFailure(api, result.error);
-          return;
-        }
-        const message = result.value === "added" ? `Attached ${formatPullRequestRef(pullRequest)}` : `${formatPullRequestRef(pullRequest)} is already attached`;
-        api.ui.toast({
-          variant: "success",
-          title: "Pull request tracker",
-          message
-        });
-        refreshBus.emit(sessionID);
-      }
-    }, {
-      name: "pr.open",
-      title: "Open pull request",
-      category: "Plugin",
-      namespace: "palette",
-      slashName: "pr-open",
-      async run() {
-        const sessionID = currentSessionID(api);
-        if (sessionID === undefined) {
-          api.ui.toast({
-            variant: "warning",
-            title: "Pull request tracker",
-            message: "Open a session first"
-          });
-          return;
-        }
-        const attachments = await dependencies.store.list(sessionID);
-        if (!attachments.ok) {
-          showStateFailure(api, attachments.error);
-          return;
-        }
-        if (attachments.value.length === 0) {
-          api.ui.toast({
-            variant: "info",
-            title: "Pull request tracker",
-            message: "No pull requests are attached"
-          });
-          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" };
         }
-        const pullRequest = await selectPullRequest(api, "Open pull request", attachments.value);
-        if (pullRequest === undefined)
-          return;
-        const result = await openPullRequest(pullRequest, {
-          ...dependencies.runner ? {
-            runner: dependencies.runner
-          } : {},
-          signal: api.lifecycle.signal
-        });
-        if (!result.ok) {
-          api.ui.toast({
-            variant: "error",
-            title: "Pull request tracker",
-            message: result.error.message
-          });
+        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;
       }
-    }, {
-      name: "pr.detach",
-      title: "Detach pull request",
-      category: "Plugin",
-      namespace: "palette",
-      slashName: "pr-detach",
-      async run() {
-        const sessionID = currentSessionID(api);
-        if (sessionID === undefined) {
-          api.ui.toast({
-            variant: "warning",
-            title: "Pull request tracker",
-            message: "Open a session first"
-          });
-          return;
+      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" };
         }
-        const attachments = await dependencies.store.list(sessionID);
-        if (!attachments.ok) {
-          showStateFailure(api, attachments.error);
-          return;
+        if (current.value.length >= maximumPullRequestsPerSession) {
+          return {
+            ok: false,
+            error: {
+              tag: "AttachmentLimitReached",
+              limit: maximumPullRequestsPerSession,
+              message: "A session can track at most 20 pull requests"
+            }
+          };
         }
-        if (attachments.value.length === 0) {
-          api.ui.toast({
-            variant: "info",
-            title: "Pull request tracker",
-            message: "No pull requests are attached"
-          });
-          return;
+        const written = await write(sessionID, [...current.value, { pullRequest, attachedAt: now().toISOString() }]);
+        if (!written.ok)
+          return written;
+        return { ok: true, value: "added" };
+      });
+    });
+  }
+  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 pullRequest = await selectPullRequest(api, "Detach pull request", attachments.value);
-        if (pullRequest === undefined)
-          return;
-        const result = await dependencies.store.detach(sessionID, pullRequest);
-        if (!result.ok) {
-          showStateFailure(api, result.error);
-          return;
+        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(join3(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 message = result.value === "removed" ? `Detached ${formatPullRequestRef(pullRequest)}` : `${formatPullRequestRef(pullRequest)} was not attached`;
-        api.ui.toast({
-          variant: "success",
-          title: "Pull request tracker",
-          message
-        });
-        refreshBus.emit(sessionID);
-      }
-    }],
+      });
+    }
+  };
+}
+
+// src/tui.tsx
+function registerTui(api, dependencies, release) {
+  const refreshBus = dependencies.refreshBus ?? createRefreshBus();
+  const updates = createPluginUpdateController(api, dependencies, release);
+  const disposeEvents = [api.event.on("session.updated", (event) => refreshBus.emit(event.properties.sessionID)), api.event.on("message.updated", (event) => refreshBus.emit(event.properties.sessionID)), api.event.on("message.part.updated", (event) => refreshBus.emit(event.properties.sessionID))];
+  const disposeCommands = api.keymap.registerLayer({
+    commands: [...createPullRequestCommands(api, dependencies, refreshBus), updates.command, createFeedbackCommand(api, dependencies, release)],
     bindings: []
   });
-  api.lifecycle.onDispose(disposeCommands);
+  api.lifecycle.onDispose(async () => {
+    disposeCommands();
+    for (const disposeEvent of disposeEvents)
+      disposeEvent();
+    await updates.startup;
+  });
   api.slots.register({
     order: 250,
     slots: {
       sidebar_content(_context, value) {
-        return _$createComponent(PullRequestSidebar, {
+        return _$createComponent4(PullRequestSidebar, {
           api,
           get sessionID() {
             return value.session_id;
           },
           dependencies,
-          refreshBus
+          refreshBus,
+          updates
         });
       }
     }
@@ -2847,22 +4476,23 @@ function registerTui(api, dependencies) {
 }
 var plugin = {
   id: "opencode-pr-tracker",
-  async tui(api, options) {
+  async tui(api, options, meta) {
     if (options?.enabled === false)
       return;
     registerTui(api, {
       store: createStateStore(),
       github: createGitHubClient()
-    });
+    }, meta);
   }
 };
 var tui_default = plugin;
 export {
+  updateStatusLabel,
   startSessionPolling,
   registerTui,
   openPullRequest,
   tui_default as default,
-  attachPullRequest
+  attachPullRequest2 as attachPullRequest
 };
 
-//# debugId=73D7339550CD79BA64756E2164756E21
+//# debugId=9AE11FCB9BB4D09764756E2164756E21