@gtrabanco/pi-web-github-pr-status 0.1.0

package/dist/index.js

@@ -0,0 +1,1427 @@
+// src/checks.ts
+var EMPTY_CI = Object.freeze({ state: "none", total: 0, passed: 0, running: 0, failed: 0, checks: [] });
+var FAILING_CONCLUSIONS = new Set(["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED", "STARTUP_FAILURE"]);
+var NEUTRAL_CONCLUSIONS = new Set(["NEUTRAL", "SKIPPED"]);
+function optionalString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function parseCheckRun(entry) {
+  const name = optionalString(entry.name) ?? "check";
+  const status = optionalString(entry.status);
+  const conclusion = optionalString(entry.conclusion);
+  let state;
+  if (status !== "COMPLETED" || conclusion === undefined) {
+    state = "running";
+  } else if (conclusion === "SUCCESS") {
+    state = "passed";
+  } else if (NEUTRAL_CONCLUSIONS.has(conclusion)) {
+    state = "skipped";
+  } else if (FAILING_CONCLUSIONS.has(conclusion)) {
+    state = "failed";
+  } else {
+    state = "running";
+  }
+  return { name, state, url: optionalString(entry.detailsUrl), workflow: optionalString(entry.workflowName) };
+}
+function parseStatusContext(entry) {
+  const name = optionalString(entry.context) ?? "status";
+  const state = optionalString(entry.state);
+  let checkState;
+  if (state === "SUCCESS") {
+    checkState = "passed";
+  } else if (state === "PENDING" || state === "EXPECTED") {
+    checkState = "running";
+  } else if (state === "FAILURE" || state === "ERROR") {
+    checkState = "failed";
+  } else {
+    return;
+  }
+  return { name, state: checkState, url: optionalString(entry.targetUrl) };
+}
+function summarizeChecks(rollup) {
+  if (!Array.isArray(rollup))
+    return EMPTY_CI;
+  const checks = [];
+  for (const raw of rollup) {
+    if (typeof raw !== "object" || raw === null)
+      continue;
+    const entry = raw;
+    const typename = optionalString(entry.__typename);
+    if (typename === "CheckRun") {
+      const check = parseCheckRun(entry);
+      if (check !== undefined)
+        checks.push(check);
+    } else if (typename === "StatusContext") {
+      const check = parseStatusContext(entry);
+      if (check !== undefined)
+        checks.push(check);
+    }
+  }
+  if (checks.length === 0)
+    return EMPTY_CI;
+  let passed = 0;
+  let running = 0;
+  let failed = 0;
+  for (const check of checks) {
+    if (check.state === "failed")
+      failed += 1;
+    else if (check.state === "running")
+      running += 1;
+    else
+      passed += 1;
+  }
+  const state = failed > 0 ? "failed" : running > 0 ? "running" : "passed";
+  return { state, total: checks.length, passed, running, failed, checks };
+}
+
+// src/types.ts
+var PLUGIN_ID = "github-pr-status";
+var SETTINGS_PATH = ".pi-web/github-pr.json";
+var SCRATCH_DIR = ".pi-web/github-pr";
+var PROBE_SCRIPT_PATH = `${SCRATCH_DIR}/probe.sh`;
+var PROBE_MARKER_PATH = `${SCRATCH_DIR}/probe.json`;
+
+// src/probe.ts
+var PROBE_SCRIPT_PATH2 = `${SCRATCH_DIR}/probe.sh`;
+var PROBE_COMMAND = `sh ${PROBE_SCRIPT_PATH2}`;
+var PROBE_SCRIPT = `#!/bin/sh
+# Generated by @gtrabanco/pi-web-github-pr-status. Do not edit.
+D=${SCRATCH_DIR}
+mkdir -p "$D"
+T=$(date +%s 2>/dev/null)
+if [ -z "$T" ]; then T=0; fi
+G=1
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  git rev-parse --abbrev-ref HEAD >"$D/branch.txt" 2>/dev/null
+  git rev-parse HEAD >"$D/head.txt" 2>/dev/null
+  git rev-parse --abbrev-ref --symbolic-full-name "@{u}" >"$D/upstream.txt" 2>/dev/null
+  git diff --cached --numstat 2>/dev/null | wc -l | tr -d " " >"$D/staged.txt"
+  git diff --numstat 2>/dev/null | wc -l | tr -d " " >"$D/unstaged.txt"
+  git ls-files --others --exclude-standard --exclude=.pi-web/github-pr/ 2>/dev/null | wc -l | tr -d " " >"$D/untracked.txt"
+  git rev-list --left-right --count "@{u}"..."HEAD" >"$D/ab.txt" 2>/dev/null
+  if command -v gh >/dev/null 2>&1; then
+    GH_PAGER=cat gh pr view --json number,url,title,state,isDraft,author,headRefName,baseRefName,mergeable,mergeStateStatus,reviewDecision,statusCheckRollup >"$D/pr.json" 2>"$D/gh.err"
+  else
+    printf "gh: command not found" >"$D/gh.err"
+  fi
+else
+  G=0
+fi
+printf '{"v":1,"ts":%s,"git":%s}
+' "$T" "$G" >"$D/probe.json"
+exit 0
+`;
+function parseCount(raw) {
+  if (raw === undefined)
+    return 0;
+  const match = /^\s*(\d+)\s*$/.exec(raw);
+  return match === null ? 0 : Number(match[1]);
+}
+function parseAheadBehind(raw) {
+  if (raw === undefined)
+    return { ahead: 0, behind: 0 };
+  const parts = raw.trim().split("\t");
+  const behind = parseCount(parts[0]);
+  const ahead = parseCount(parts[1]);
+  return { ahead, behind };
+}
+function parseMarker(raw) {
+  if (raw === undefined || raw.trim() === "")
+    return { git: false, usable: false };
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null)
+      return { git: false, usable: false };
+    const record = parsed;
+    return {
+      git: record.git === 1 || record.git === true,
+      probeAt: typeof record.ts === "number" && Number.isFinite(record.ts) ? record.ts : undefined,
+      usable: true
+    };
+  } catch {
+    return { git: false, usable: false };
+  }
+}
+var GH_MISSING_PATTERN = /command not found|not recognized/iu;
+var GH_AUTH_PATTERN = /gh auth login|GH_TOKEN|authentication/iu;
+var GH_NO_PR_PATTERN = /no pull requests found/iu;
+function classifyGh(ghErr, hasPr) {
+  if (hasPr)
+    return { gh: "ok" };
+  const message = ghErr?.trim();
+  if (message === undefined || message === "")
+    return { gh: "error", ghMessage: "gh output unavailable" };
+  if (GH_MISSING_PATTERN.test(message))
+    return { gh: "missing", ghMessage: message.split(`
+`)[0] };
+  if (GH_AUTH_PATTERN.test(message))
+    return { gh: "unauthenticated", ghMessage: message.split(`
+`)[0] };
+  if (GH_NO_PR_PATTERN.test(message))
+    return { gh: "ok" };
+  return { gh: "error", ghMessage: message.split(`
+`)[0] };
+}
+function optionalString2(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
+}
+function parseBoolean(value) {
+  return value === true || value === "true";
+}
+function parsePrJson(raw) {
+  if (raw === undefined || raw.trim() === "")
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return;
+  const record = parsed;
+  const number = record.number;
+  if (typeof number !== "number" || !Number.isInteger(number) || number < 1 || number > 2147483647)
+    return;
+  const url = record.url;
+  if (typeof url !== "string" || !/^https:\/\/[\w.-]+/u.test(url))
+    return;
+  const state = record.state;
+  if (state !== "OPEN" && state !== "CLOSED" && state !== "MERGED")
+    return;
+  const author = record.author;
+  return {
+    number,
+    url,
+    title: typeof record.title === "string" ? record.title : "",
+    state,
+    isDraft: parseBoolean(record.isDraft),
+    author: typeof author === "object" && author !== null ? optionalString2(author.login) : undefined,
+    headRefName: optionalString2(record.headRefName),
+    baseRefName: optionalString2(record.baseRefName),
+    mergeable: optionalString2(record.mergeable),
+    mergeStateStatus: optionalString2(record.mergeStateStatus),
+    reviewDecision: optionalString2(record.reviewDecision)
+  };
+}
+var EMPTY_STATUS = Object.freeze({
+  git: false,
+  staged: 0,
+  unstaged: 0,
+  untracked: 0,
+  ahead: 0,
+  behind: 0,
+  hasUpstream: false,
+  ci: EMPTY_CI,
+  cold: true
+});
+function parseProbeResult(files) {
+  const marker = parseMarker(files.probe);
+  if (!marker.usable)
+    return { ...EMPTY_STATUS };
+  if (!marker.git) {
+    return {
+      ...EMPTY_STATUS,
+      git: false,
+      cold: false,
+      probeAt: marker.probeAt
+    };
+  }
+  const upstream = optionalString2(files.upstream);
+  const counts = parseAheadBehind(files.aheadBehind);
+  const pr = parsePrJson(files.pr);
+  const gh = classifyGh(files.ghErr, pr !== undefined);
+  const staged = parseCount(files.staged);
+  const unstaged = parseCount(files.unstaged);
+  const untracked = parseCount(files.untracked);
+  const ahead = upstream === undefined ? 0 : counts.ahead;
+  const behind = upstream === undefined ? 0 : counts.behind;
+  const ci = pr !== undefined && pr.state === "OPEN" ? summarizeChecks(extractRollup(files.pr)) : EMPTY_CI;
+  return {
+    git: true,
+    cold: false,
+    probeAt: marker.probeAt,
+    branch: optionalString2(files.branch),
+    head: optionalString2(files.head),
+    upstream,
+    staged,
+    unstaged,
+    untracked,
+    ahead,
+    behind,
+    hasUpstream: upstream !== undefined,
+    pr,
+    ci,
+    gh: gh.gh,
+    ghMessage: gh.ghMessage,
+    isDirty: staged + unstaged + untracked > 0,
+    unpushed: upstream === undefined || ahead > 0
+  };
+}
+function extractRollup(prRaw) {
+  if (prRaw === undefined)
+    return;
+  try {
+    const parsed = JSON.parse(prRaw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed.statusCheckRollup;
+    }
+  } catch {}
+  return;
+}
+async function readProbeFile(readFile, path) {
+  try {
+    const file = await readFile(path);
+    return file.binary ? undefined : file.content;
+  } catch {
+    return;
+  }
+}
+var PROBE_FILE_PATHS = {
+  probe: `${SCRATCH_DIR}/probe.json`,
+  branch: `${SCRATCH_DIR}/branch.txt`,
+  head: `${SCRATCH_DIR}/head.txt`,
+  upstream: `${SCRATCH_DIR}/upstream.txt`,
+  staged: `${SCRATCH_DIR}/staged.txt`,
+  unstaged: `${SCRATCH_DIR}/unstaged.txt`,
+  untracked: `${SCRATCH_DIR}/untracked.txt`,
+  aheadBehind: `${SCRATCH_DIR}/ab.txt`,
+  pr: `${SCRATCH_DIR}/pr.json`,
+  ghErr: `${SCRATCH_DIR}/gh.err`
+};
+async function readAllProbeFiles(readFile) {
+  const paths = Object.values(PROBE_FILE_PATHS);
+  const [probe, branch, head, upstream, staged, unstaged, untracked, aheadBehind, pr, ghErr] = await Promise.all(paths.map(async (path) => readProbeFile(readFile, path)));
+  return { probe, branch, head, upstream, staged, unstaged, untracked, aheadBehind, pr, ghErr };
+}
+
+// src/settings.ts
+var DEFAULT_SETTINGS = Object.freeze({
+  showCI: true,
+  refreshSeconds: 90,
+  merge: Object.freeze({
+    enabled: true,
+    method: "merge",
+    requireCleanWorktree: true,
+    requireCI: true,
+    deleteBranch: false
+  })
+});
+var MERGE_METHODS = ["merge", "squash", "rebase"];
+var MIN_REFRESH_SECONDS = 0;
+var MAX_REFRESH_SECONDS = 3600;
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function coerceBoolean(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === 1)
+    return true;
+  if (value === 0)
+    return false;
+  return;
+}
+function mergeBooleans(raw, defaults, warnings, prefix) {
+  const pick = (key) => {
+    const coerced = coerceBoolean(raw[key]);
+    if (coerced === undefined) {
+      if (raw[key] !== undefined)
+        warnings.push(`${prefix}${key}: ignored invalid value`);
+      return defaults[key];
+    }
+    return coerced;
+  };
+  return {
+    enabled: pick("enabled"),
+    requireCleanWorktree: pick("requireCleanWorktree"),
+    requireCI: pick("requireCI"),
+    deleteBranch: pick("deleteBranch"),
+    method: normalizeMethod(raw.method, defaults.method, warnings)
+  };
+}
+function normalizeMethod(value, fallback, warnings) {
+  if (value === undefined)
+    return fallback;
+  if (typeof value === "string" && MERGE_METHODS.includes(value)) {
+    return value;
+  }
+  warnings.push(`merge.method: ignored invalid value ${JSON.stringify(String(value))}`);
+  return fallback;
+}
+function normalizeRefreshSeconds(value, fallback, warnings) {
+  if (value === undefined)
+    return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    warnings.push("refreshSeconds: ignored invalid value");
+    return fallback;
+  }
+  const seconds = Math.max(MIN_REFRESH_SECONDS, Math.min(MAX_REFRESH_SECONDS, Math.floor(value)));
+  return seconds;
+}
+function normalizeSettings(raw) {
+  const warnings = [];
+  const source = asObject(raw);
+  const showCI = coerceBoolean(source.showCI);
+  if (showCI === undefined && source.showCI !== undefined)
+    warnings.push("showCI: ignored invalid value");
+  const mergeSource = asObject(source.merge);
+  const settings = {
+    showCI: showCI ?? DEFAULT_SETTINGS.showCI,
+    refreshSeconds: normalizeRefreshSeconds(source.refreshSeconds, DEFAULT_SETTINGS.refreshSeconds, warnings),
+    merge: mergeBooleans(mergeSource, DEFAULT_SETTINGS.merge, warnings, "merge.")
+  };
+  return { settings, warnings };
+}
+function serializeSettings(settings) {
+  return `${JSON.stringify(settings, null, 2)}
+`;
+}
+
+// src/cache.ts
+var FILE_TTL_MS = 1e4;
+var PROBE_TIMEOUT_MS = 25000;
+var MAX_ENTRIES = 32;
+function contextKey(context) {
+  return `${context.machine.id}:${context.workspace.projectId}:${context.workspace.id}`;
+}
+function nowMs() {
+  return Date.now();
+}
+async function runWorkspaceCommand(context, input) {
+  if (context.terminal === undefined)
+    throw new Error("Workspace terminal helper is unavailable in this context");
+  const handle = await context.terminal.runCommand({
+    title: input.title,
+    command: input.command,
+    open: false,
+    metadata: { "pi.plugin": PLUGIN_ID, op: input.op }
+  });
+  return await withTimeout(handle.completed, input.timeoutMs ?? PROBE_TIMEOUT_MS);
+}
+async function withTimeout(promise, timeoutMs) {
+  return await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Command timed out after ${String(Math.round(timeoutMs / 1000))}s`)), timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+
+class StatusCache {
+  entries = new Map;
+  get(context) {
+    return this.entries.get(contextKey(context));
+  }
+  entryStatus(context) {
+    return this.entries.get(contextKey(context))?.status;
+  }
+  statusByKey(machineId, projectId, workspaceId) {
+    return this.entries.get(`${machineId}:${projectId}:${workspaceId}`)?.status;
+  }
+  entrySettings(context) {
+    const entry = this.entries.get(contextKey(context));
+    return {
+      settings: entry?.settings ?? DEFAULT_SETTINGS,
+      warnings: entry?.settingsWarnings ?? [],
+      error: entry?.settingsError
+    };
+  }
+  ensureLoaded(context) {
+    const key = contextKey(context);
+    let entry = this.entries.get(key);
+    if (entry === undefined) {
+      if (context.state?.selectedWorkspace?.id !== context.workspace.id) {
+        return { settingsWarnings: [], loadedAt: 0, probedAt: 0 };
+      }
+      entry = this.evictAndCreate(key);
+    }
+    entry.host = context.host;
+    if (nowMs() - entry.loadedAt > FILE_TTL_MS && entry.reading === undefined) {
+      this.startRead(context, entry);
+    }
+    return entry;
+  }
+  async refreshFiles(context) {
+    const key = contextKey(context);
+    const entry = this.entries.get(key) ?? this.evictAndCreate(key);
+    entry.host = context.host;
+    await this.startRead(context, entry);
+  }
+  async probe(context, options = {}) {
+    const key = contextKey(context);
+    const entry = this.entries.get(key) ?? this.evictAndCreate(key);
+    entry.host = context.host;
+    if (entry.probing !== undefined)
+      return await entry.probing;
+    entry.probing = (async () => {
+      try {
+        await context.files.writeFile(PROBE_SCRIPT_PATH2, PROBE_SCRIPT, { overwrite: true });
+        await runWorkspaceCommand(context, { title: "GitHub PR status", command: PROBE_COMMAND, op: "probe" });
+      } finally {
+        entry.probedAt = nowMs();
+        entry.probing = undefined;
+      }
+      await this.startRead(context, entry);
+    })();
+    return await entry.probing;
+  }
+  startRead(context, entry) {
+    if (entry.reading !== undefined)
+      return entry.reading;
+    entry.reading = (async () => {
+      try {
+        const files = await readAllProbeFiles((path) => context.files.readFile(path));
+        const status = parseProbeResult(files);
+        const { settings, warnings, error } = await readSettings(context);
+        this.apply(entry, status, settings, warnings, error);
+      } catch (error) {
+        entry.settingsError = error instanceof Error ? error.message : String(error);
+      } finally {
+        entry.loadedAt = nowMs();
+        entry.reading = undefined;
+      }
+    })();
+    return entry.reading;
+  }
+  apply(entry, status, settings, warnings, settingsError) {
+    entry.status = status;
+    entry.settings = settings;
+    entry.settingsWarnings = warnings;
+    entry.settingsError = settingsError;
+    const serialized = JSON.stringify([status, settings, warnings, settingsError]);
+    const changed = entry.serialized !== serialized;
+    entry.serialized = serialized;
+    if (changed)
+      entry.host?.requestRender();
+  }
+  evictAndCreate(key) {
+    if (this.entries.size >= MAX_ENTRIES) {
+      const oldest = [...this.entries.entries()].sort((left, right) => left[1].loadedAt - right[1].loadedAt)[0];
+      if (oldest !== undefined)
+        this.entries.delete(oldest[0]);
+    }
+    const entry = { settingsWarnings: [], loadedAt: 0, probedAt: 0 };
+    this.entries.set(key, entry);
+    return entry;
+  }
+}
+async function readSettings(context) {
+  try {
+    const file = await context.files.readFile(SETTINGS_PATH);
+    if (file.binary)
+      return { settings: DEFAULT_SETTINGS, warnings: [], error: `${SETTINGS_PATH} is binary` };
+    const parsed = JSON.parse(file.content);
+    const { settings, warnings } = normalizeSettings(parsed);
+    return { settings, warnings };
+  } catch {
+    return { settings: DEFAULT_SETTINGS, warnings: [] };
+  }
+}
+var statusCache = new StatusCache;
+
+// src/guards.ts
+var STATUS_UNAVAILABLE = "PR status is not available yet — refresh";
+function dirtyCount(status) {
+  return status.staged + status.unstaged + status.untracked;
+}
+function evaluateMerge(status, settings) {
+  if (!settings.merge.enabled) {
+    return { canMerge: false, blockers: ["One-click merge is disabled in this workspace's plugin settings"], confirmations: [] };
+  }
+  if (status === undefined) {
+    return { canMerge: false, blockers: [STATUS_UNAVAILABLE], confirmations: [] };
+  }
+  if (!status.git) {
+    return { canMerge: false, blockers: ["Not a git repository workspace"], confirmations: [] };
+  }
+  const blockers = [];
+  const pr = status.pr;
+  if (pr === undefined) {
+    blockers.push(status.branch === "HEAD" ? "HEAD is detached" : `No open pull request for branch ${status.branch ?? ""}`.trimEnd());
+    return { canMerge: false, blockers, confirmations: [] };
+  }
+  if (pr.state === "MERGED") {
+    blockers.push(`Pull request #${String(pr.number)} is already merged`);
+  } else if (pr.state === "CLOSED") {
+    blockers.push(`Pull request #${String(pr.number)} is closed`);
+  }
+  if (pr.isDraft)
+    blockers.push("Pull request is a draft");
+  if (pr.mergeable === "CONFLICTING")
+    blockers.push("Pull request has merge conflicts");
+  const dirty = dirtyCount(status);
+  if (settings.merge.requireCleanWorktree && dirty > 0) {
+    blockers.push(`Worktree has uncommitted changes (${String(status.staged)} staged, ${String(status.unstaged)} unstaged, ${String(status.untracked)} untracked)`);
+  }
+  if (!status.hasUpstream) {
+    blockers.push("Branch has no upstream — publish it first (git push -u)");
+  } else if (status.ahead > 0) {
+    blockers.push(`${String(status.ahead)} local commit(s) not pushed`);
+  }
+  const confirmations = [];
+  if (settings.merge.requireCI) {
+    const ciNote = ciConfirmation(status.ci);
+    if (ciNote !== undefined)
+      confirmations.push(ciNote);
+  }
+  if (status.behind > 0) {
+    confirmations.push(`Local branch is ${String(status.behind)} commit(s) behind its upstream`);
+  }
+  if (pr.mergeStateStatus === "BLOCKED" || pr.mergeStateStatus === "UNSTABLE") {
+    confirmations.push(`GitHub reports merge state: ${pr.mergeStateStatus}`);
+  }
+  return { canMerge: blockers.length === 0, blockers, confirmations };
+}
+function ciConfirmation(ci) {
+  if (ci.state === "running")
+    return `CI is still running (${String(ci.passed)} passed, ${String(ci.running)} running)`;
+  if (ci.state === "failed")
+    return `CI has failures (${String(ci.failed)} failed)`;
+  return;
+}
+function evaluateClose(status, _settings) {
+  if (status === undefined)
+    return { canClose: false, blockers: [STATUS_UNAVAILABLE] };
+  if (!status.git)
+    return { canClose: false, blockers: ["Not a git repository workspace"] };
+  const pr = status.pr;
+  if (pr === undefined) {
+    const reason = status.branch === "HEAD" ? "HEAD is detached" : `No open pull request for branch ${status.branch ?? ""}`.trimEnd();
+    return { canClose: false, blockers: [reason] };
+  }
+  if (pr.state !== "OPEN")
+    return { canClose: false, blockers: [`Pull request #${String(pr.number)} is ${pr.state.toLowerCase()}`] };
+  return { canClose: true, blockers: [] };
+}
+function assertPrNumber(prNumber) {
+  if (!Number.isInteger(prNumber) || prNumber < 1 || prNumber > 2147483647) {
+    throw new Error(`Invalid pull request number: ${String(prNumber)}`);
+  }
+}
+function buildMergeCommand(prNumber, settings) {
+  assertPrNumber(prNumber);
+  const flag = `--${settings.merge.method}`;
+  const deleteFlag = settings.merge.deleteBranch ? " --delete-branch" : "";
+  return `gh pr merge ${String(prNumber)} ${flag}${deleteFlag} < /dev/null`;
+}
+function buildCloseCommand(prNumber) {
+  assertPrNumber(prNumber);
+  return `gh pr close ${String(prNumber)} < /dev/null`;
+}
+function explainCiState(ci) {
+  switch (ci.state) {
+    case "none":
+      return "No CI checks";
+    case "passed":
+      return `CI passing (${String(ci.passed)}/${String(ci.total)})`;
+    case "running":
+      return `CI running (${String(ci.passed)}/${String(ci.total)})`;
+    case "failed":
+      return `CI failing (${String(ci.failed)} failed)`;
+  }
+}
+
+// src/panel.ts
+var PANEL_LOCAL_ID = "workspace.pr";
+var ACTIVITY_ELEMENT_TAG = "pi-web-github-pr-activity";
+var INVALIDATE_MIN_INTERVAL_MS = 3000;
+var MERGE_CLOSE_TIMEOUT_MS = 60000;
+
+class PrUiController {
+  states = new Map;
+  stateFor(context) {
+    const key = `${context.machine.id}:${context.workspace.projectId}:${context.workspace.id}`;
+    const existing = this.states.get(key);
+    if (existing !== undefined) {
+      existing.context = context;
+      return existing;
+    }
+    const created = {
+      context,
+      retained: true,
+      confirm: null,
+      busy: null,
+      outcome: null,
+      settingsOpen: false,
+      draft: null,
+      lastInvalidate: 0
+    };
+    this.states.set(key, created);
+    return created;
+  }
+  connect(context) {
+    const state = this.stateFor(context);
+    statusCache.ensureLoaded(context);
+    const settings = statusCache.entrySettings(context).settings;
+    const entry = statusCache.get(context);
+    const staleMs = settings.refreshSeconds * 1000;
+    const shouldProbe = entry !== undefined && settings.refreshSeconds > 0 && Date.now() - entry.probedAt > staleMs && Date.now() - entry.loadedAt > staleMs;
+    if (shouldProbe)
+      this.probe(context);
+    else
+      this.requestRender(state);
+  }
+  disconnect(context) {
+    const key = `${context.machine.id}:${context.workspace.projectId}:${context.workspace.id}`;
+    this.states.delete(key);
+  }
+  tick(context) {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden")
+      return;
+    const settings = statusCache.entrySettings(context).settings;
+    if (settings.refreshSeconds <= 0)
+      return;
+    const entry = statusCache.get(context);
+    const staleMs = settings.refreshSeconds * 1000;
+    if (entry === undefined) {
+      this.probe(context);
+      return;
+    }
+    if (Date.now() - Math.max(entry.probedAt, entry.loadedAt) >= staleMs)
+      this.probe(context);
+  }
+  invalidate(context) {
+    const state = this.stateFor(context);
+    const now = Date.now();
+    if (now - state.lastInvalidate < INVALIDATE_MIN_INTERVAL_MS) {
+      statusCache.refreshFiles(context).then(() => this.requestRender(state));
+      return;
+    }
+    state.lastInvalidate = now;
+    this.probe(context);
+  }
+  async refresh(context) {
+    await this.probe(context);
+  }
+  async probe(context) {
+    const state = this.stateFor(context);
+    if (state.busy !== null)
+      return;
+    state.busy = "probe";
+    state.outcome = null;
+    this.requestRender(state);
+    try {
+      await statusCache.probe(context, { force: true });
+    } catch (error) {
+      state.outcome = { ok: false, message: errorMessage(error) };
+    } finally {
+      state.busy = null;
+      this.requestRender(state);
+    }
+  }
+  onMergeClick(context) {
+    const state = this.stateFor(context);
+    const status = statusCache.entryStatus(context);
+    const settings = statusCache.entrySettings(context).settings;
+    const evaluation = evaluateMerge(status, settings);
+    if (!evaluation.canMerge) {
+      state.confirm = null;
+      state.outcome = { ok: false, message: evaluation.blockers.join(" · ") };
+      this.requestRender(state);
+      return;
+    }
+    if (evaluation.confirmations.length > 0 && state.confirm?.kind !== "merge") {
+      state.confirm = { kind: "merge", reasons: evaluation.confirmations };
+      state.outcome = null;
+      this.requestRender(state);
+      return;
+    }
+    this.runMerge(context, status, settings);
+  }
+  onCloseClick(context) {
+    const state = this.stateFor(context);
+    const status = statusCache.entryStatus(context);
+    const evaluation = evaluateClose(status);
+    if (!evaluation.canClose) {
+      state.confirm = null;
+      state.outcome = { ok: false, message: evaluation.blockers.join(" · ") };
+      this.requestRender(state);
+      return;
+    }
+    const prNumber = status?.pr?.number;
+    if (state.confirm?.kind !== "close") {
+      state.confirm = { kind: "close", reasons: [`Close PR #${String(prNumber ?? 0)} without merging?`] };
+      state.outcome = null;
+      this.requestRender(state);
+      return;
+    }
+    this.runClose(context, status);
+  }
+  cancelConfirm(context) {
+    const state = this.stateFor(context);
+    state.confirm = null;
+    this.requestRender(state);
+  }
+  async runMerge(context, status, settings) {
+    const state = this.stateFor(context);
+    const pr = status?.pr;
+    if (pr === undefined)
+      return;
+    state.confirm = null;
+    state.busy = "merge";
+    state.outcome = null;
+    this.requestRender(state);
+    try {
+      const run = await runGuardedCommand(context, {
+        title: `Merge PR #${String(pr.number)}`,
+        command: buildMergeCommand(pr.number, settings),
+        op: "merge"
+      });
+      if (run.exitCode === 0) {
+        state.outcome = { ok: true, message: `PR #${String(pr.number)} merged (${settings.merge.method}).` };
+      } else {
+        state.outcome = { ok: false, message: `Merge failed (exit ${String(run.exitCode ?? "?")}). Check the terminal output.`, terminalId: run.terminalId };
+      }
+    } catch (error) {
+      state.outcome = { ok: false, message: errorMessage(error) };
+    } finally {
+      state.busy = null;
+      statusCache.probe(context, { force: true }).catch(() => {
+        return;
+      });
+      this.requestRender(state);
+    }
+  }
+  async runClose(context, status) {
+    const state = this.stateFor(context);
+    const pr = status?.pr;
+    if (pr === undefined)
+      return;
+    state.confirm = null;
+    state.busy = "close";
+    state.outcome = null;
+    this.requestRender(state);
+    try {
+      const run = await runGuardedCommand(context, {
+        title: `Close PR #${String(pr.number)}`,
+        command: buildCloseCommand(pr.number),
+        op: "close"
+      });
+      if (run.exitCode === 0) {
+        state.outcome = { ok: true, message: `PR #${String(pr.number)} closed.` };
+      } else {
+        state.outcome = { ok: false, message: `Close failed (exit ${String(run.exitCode ?? "?")}). Check the terminal output.`, terminalId: run.terminalId };
+      }
+    } catch (error) {
+      state.outcome = { ok: false, message: errorMessage(error) };
+    } finally {
+      state.busy = null;
+      statusCache.probe(context, { force: true }).catch(() => {
+        return;
+      });
+      this.requestRender(state);
+    }
+  }
+  updateDraft(context, mutate) {
+    const state = this.stateFor(context);
+    const current = state.draft ?? statusCache.entrySettings(context).settings;
+    state.draft = mutate({ ...current, merge: { ...current.merge } });
+    this.requestRender(state);
+  }
+  toggleSettings(context) {
+    const state = this.stateFor(context);
+    state.settingsOpen = !state.settingsOpen;
+    state.draft = null;
+    this.requestRender(state);
+  }
+  async saveSettings(context) {
+    const state = this.stateFor(context);
+    const draft = state.draft ?? statusCache.entrySettings(context).settings;
+    state.busy = "settings";
+    state.outcome = null;
+    this.requestRender(state);
+    try {
+      await context.files.writeFile(SETTINGS_PATH, serializeSettings(draft), { overwrite: true });
+      state.outcome = { ok: true, message: `Settings saved to ${SETTINGS_PATH}.` };
+      state.draft = null;
+      state.settingsOpen = false;
+    } catch (error) {
+      state.outcome = { ok: false, message: `Could not save settings: ${errorMessage(error)}` };
+    } finally {
+      state.busy = null;
+      statusCache.refreshFiles(context).catch(() => {
+        return;
+      });
+      this.requestRender(state);
+    }
+  }
+  resetSettings(context) {
+    const state = this.stateFor(context);
+    state.draft = { ...DEFAULT_SETTINGS, merge: { ...DEFAULT_SETTINGS.merge } };
+    this.requestRender(state);
+  }
+  requestRender(state) {
+    if (state.retained)
+      state.context.host.requestRender();
+  }
+}
+async function runGuardedCommand(context, input) {
+  return await runWorkspaceCommand(context, { ...input, timeoutMs: MERGE_CLOSE_TIMEOUT_MS });
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createPanelContribution(html, svg, controller) {
+  defineActivityElement(controller);
+  return {
+    id: PANEL_LOCAL_ID,
+    title: "Pull Request",
+    icon: svg`
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <circle cx="6" cy="6" r="2.5"></circle>
+        <circle cx="6" cy="18" r="2.5"></circle>
+        <circle cx="18" cy="18" r="2.5"></circle>
+        <path d="M6 8.5v7"></path>
+        <path d="M13 6h3a2 2 0 0 1 2 2v7.5"></path>
+        <path d="m13 6 2-2"></path>
+        <path d="m13 6 2 2"></path>
+      </svg>
+    `,
+    order: 30,
+    routeAliases: ["pull-request", "pr"],
+    visible: (context) => {
+      const metadata = context.workspace.provider?.metadata;
+      if (metadata?.isGitRepo === false)
+        return false;
+      const status = statusCache.get(context)?.status;
+      if (status !== undefined && status.git === false && status.cold !== true)
+        return false;
+      return true;
+    },
+    badge: (context) => {
+      const settings = statusCache.entrySettings(context).settings;
+      if (!settings.showCI)
+        return;
+      const ci = statusCache.get(context)?.status?.ci;
+      if (ci === undefined || ci.state === "none" || ci.state === "passed")
+        return;
+      const color = ci.state === "failed" ? CI_DOT_COLORS.failed : CI_DOT_COLORS.running;
+      return html`<span title=${explainCiState(ci)} style="display:inline-block;width:9px;height:9px;border-radius:999px;background:${color}"></span>`;
+    },
+    onInvalidate: (context) => {
+      controller.invalidate(context);
+    },
+    render: (context) => renderPanel(html, controller, context)
+  };
+}
+function defineActivityElement(controller) {
+  if (typeof customElements === "undefined" || typeof HTMLElement === "undefined")
+    return;
+  if (customElements.get(ACTIVITY_ELEMENT_TAG) !== undefined)
+    return;
+
+  class PrPanelActivityElement extends HTMLElement {
+    contextValue;
+    tickTimer;
+    set context(value) {
+      this.contextValue = value;
+    }
+    get context() {
+      return this.contextValue;
+    }
+    connectedCallback() {
+      if (this.contextValue !== undefined)
+        controller.connect(this.contextValue);
+      this.tickTimer = window.setInterval(() => {
+        if (this.contextValue !== undefined)
+          controller.tick(this.contextValue);
+      }, 1000);
+    }
+    disconnectedCallback() {
+      if (this.tickTimer !== undefined)
+        window.clearInterval(this.tickTimer);
+      this.tickTimer = undefined;
+      if (this.contextValue !== undefined)
+        controller.disconnect(this.contextValue);
+    }
+  }
+  customElements.define(ACTIVITY_ELEMENT_TAG, PrPanelActivityElement);
+}
+var CI_DOT_COLORS = { passed: "#3fb950", running: "#d29922", failed: "#f85149" };
+function renderPanel(html, controller, context) {
+  const state = controller.stateFor(context);
+  const entry = statusCache.ensureLoaded(context);
+  const settings = state.draft ?? statusCache.entrySettings(context).settings;
+  const status = entry.status;
+  const busy = state.busy !== null;
+  return html`
+    <section class="ghpr-panel">
+      <style .textContent=${panelStyles}></style>
+      <pi-web-github-pr-activity .context=${context}></pi-web-github-pr-activity>
+      <section class="ghpr-toolbar">
+        <strong>Pull Request</strong>
+        <div class="ghpr-toolbar-actions">
+          <button type="button" ?disabled=${busy} @click=${() => {
+    controller.refresh(context);
+  }}>Refresh</button>
+        </div>
+      </section>
+      ${renderBody(html, controller, context, state, settings, status, busy)}
+    </section>
+  `;
+}
+function renderBody(html, controller, context, state, settings, status, busy) {
+  if (status === undefined || status.cold === true) {
+    return html`<p class="ghpr-muted">${busy ? "Probing workspace…" : "PR status has not been collected yet. Press Refresh."}</p>`;
+  }
+  if (!status.git) {
+    return html`<p class="ghpr-muted">Not a git repository workspace.</p>`;
+  }
+  const mergeEvaluation = evaluateMerge(status, settings);
+  const closeEvaluation = evaluateClose(status);
+  const pr = status.pr;
+  return html`
+    ${status.gh !== undefined && status.gh !== "ok" ? renderGhHint(html, status) : null}
+    ${pr === undefined ? renderNoPr(html, status) : renderPrCard(html, pr)}
+    ${settings.showCI ? renderCiSection(html, status) : html`<p class="ghpr-muted">CI display is disabled in settings.</p>`}
+    ${renderWorktreeSection(html, status)}
+    ${renderOutcome(html, state)}
+    ${pr !== undefined && pr.state === "OPEN" ? renderActions(html, controller, context, state, mergeEvaluation, closeEvaluation, busy) : null}
+    ${renderSettings(html, controller, context, state, settings)}
+  `;
+}
+function renderGhHint(html, status) {
+  const hint = status.gh === "missing" ? "GitHub CLI (gh) was not found on this machine. Install it to see pull request and CI status: https://cli.github.com" : status.gh === "unauthenticated" ? "gh is not authenticated. Run `gh auth login` in a terminal to enable pull request status." : `gh error: ${status.ghMessage ?? "unknown error"}`;
+  return html`<div class="ghpr-warning" role="status">${hint}</div>`;
+}
+function renderNoPr(html, status) {
+  const branch = status.branch === "HEAD" ? "detached HEAD" : status.branch ?? "unknown branch";
+  return html`<p class="ghpr-muted">No open pull request for branch ${branch}.</p>`;
+}
+function renderPrCard(html, pr) {
+  const stateChip = pr.state === "OPEN" ? pr.isDraft ? "DRAFT" : "OPEN" : pr.state === "MERGED" ? "MERGED" : "CLOSED";
+  return html`
+    <section class="ghpr-pr">
+      <div class="ghpr-pr-title">
+        <a href=${pr.url} target="_blank" rel="noopener noreferrer">PR #${String(pr.number)} — ${pr.title}</a>
+        <span class=${`ghpr-chip ghpr-chip-${stateChip.toLowerCase()}`}>${stateChip}</span>
+      </div>
+      <p class="ghpr-meta">
+        ${pr.author === undefined ? null : html`<span>@${pr.author}</span>`}
+        ${pr.headRefName === undefined || pr.baseRefName === undefined ? null : html`<span>${pr.headRefName} → ${pr.baseRefName}</span>`}
+        ${pr.mergeable === "CONFLICTING" ? html`<span class="ghpr-conflict">conflicts</span>` : null}
+        ${pr.reviewDecision === undefined ? null : html`<span>review: ${pr.reviewDecision.toLowerCase()}</span>`}
+      </p>
+    </section>
+  `;
+}
+function renderCiSection(html, status) {
+  const ci = status.ci;
+  if (ci.state === "none") {
+    return html`<p class="ghpr-muted">${status.pr === undefined ? "No CI checks (status unknown without a PR)." : "No CI checks configured for this pull request."}</p>`;
+  }
+  return html`
+    <section class="ghpr-ci">
+      <p class="ghpr-ci-head">
+        <span
+          class="ghpr-ball"
+          title=${explainCiState(ci)}
+          style="background:${CI_DOT_COLORS[ci.state]}"
+        ></span>
+        ${explainCiState(ci)}
+      </p>
+      ${ci.checks.length === 0 ? null : html`
+            <ul class="ghpr-checks">
+              ${ci.checks.map((check) => html`
+                  <li>
+                    <span class=${`ghpr-check-state ghpr-check-${check.state}`}>${checkStateGlyph(check.state)}</span>
+                    ${check.url === undefined ? html`<span>${check.name}</span>` : html`<a href=${check.url} target="_blank" rel="noopener noreferrer">${check.name}</a>`}
+                  </li>
+                `)}
+            </ul>
+          `}
+    </section>
+  `;
+}
+function checkStateGlyph(state) {
+  if (state === "passed")
+    return "✓";
+  if (state === "failed")
+    return "✗";
+  if (state === "running")
+    return "◐";
+  return "○";
+}
+function renderWorktreeSection(html, status) {
+  const dirty = status.staged + status.unstaged + status.untracked;
+  return html`
+    <section class="ghpr-git">
+      <p class="ghpr-meta">
+        <span>${status.branch ?? "unknown branch"}</span>
+        ${status.hasUpstream && (status.ahead > 0 || status.behind > 0) ? html`<span>↑${String(status.ahead)} ↓${String(status.behind)}</span>` : null}
+        ${!status.hasUpstream ? html`<span class="ghpr-conflict">no upstream</span>` : null}
+      </p>
+      <p class="ghpr-meta ${dirty > 0 ? "ghpr-dirty" : ""}">
+        ${dirty > 0 ? html`<span title="Uncommitted changes">✎ ${String(dirty)} changed (${String(status.staged)} staged, ${String(status.unstaged)} unstaged, ${String(status.untracked)} untracked)</span>` : html`<span>worktree clean</span>`}
+      </p>
+    </section>
+  `;
+}
+function renderOutcome(html, state) {
+  if (state.outcome === null)
+    return null;
+  return html`
+    <div class=${state.outcome.ok ? "ghpr-success" : "ghpr-error"} role="status">
+      ${state.outcome.message}
+      ${state.outcome.terminalId === undefined ? null : html`<button type="button" @click=${() => {
+    state.context.terminal.open({ terminalId: state.outcome?.terminalId });
+  }}>Open terminal</button>`}
+    </div>
+  `;
+}
+function renderActions(html, controller, context, state, mergeEvaluation, closeEvaluation, busy) {
+  const mergeTitle = mergeEvaluation.canMerge ? mergeEvaluation.confirmations.length > 0 ? "Merge with confirmation" : "Merge this pull request" : mergeEvaluation.blockers.join(" · ");
+  const confirm = state.confirm;
+  return html`
+    <section class="ghpr-actions">
+      ${confirm === null ? null : html`
+            <div class="ghpr-warning" role="alert">
+              <p>${confirm.reasons.join(" ")}</p>
+              <div class="ghpr-confirm-buttons">
+                <button
+                  type="button"
+                  class="ghpr-primary"
+                  ?disabled=${busy}
+                  @click=${() => {
+    confirm.kind === "merge" ? controller.onMergeClick(context) : controller.onCloseClick(context);
+  }}
+                >
+                  ${confirm.kind === "merge" ? "Merge anyway" : "Close PR"}
+                </button>
+                <button type="button" ?disabled=${busy} @click=${() => {
+    controller.cancelConfirm(context);
+  }}>Cancel</button>
+              </div>
+            </div>
+          `}
+      <div class="ghpr-buttons">
+        <button
+          type="button"
+          class="ghpr-primary"
+          title=${mergeTitle}
+          ?disabled=${busy}
+          @click=${() => {
+    controller.onMergeClick(context);
+  }}
+        >
+          ${state.busy === "merge" ? "Merging…" : "Merge"}
+        </button>
+        <button
+          type="button"
+          title=${closeEvaluation.canClose ? "Close this pull request" : closeEvaluation.blockers.join(" · ")}
+          ?disabled=${busy}
+          @click=${() => {
+    controller.onCloseClick(context);
+  }}
+        >
+          ${state.busy === "close" ? "Closing…" : "Close PR"}
+        </button>
+      </div>
+    </section>
+  `;
+}
+function renderSettings(html, controller, context, state, settings) {
+  if (!state.settingsOpen) {
+    return html`<button type="button" class="ghpr-settings-toggle" @click=${() => {
+      controller.toggleSettings(context);
+    }}>⚙ Settings</button>`;
+  }
+  const draft = state.draft ?? settings;
+  return html`
+    <section class="ghpr-settings">
+      <p class="ghpr-settings-hint">
+        Stored per workspace in <code>${SETTINGS_PATH}</code>. Plugin: ${PLUGIN_ID}.
+      </p>
+      <label><input type="checkbox" ?checked=${draft.showCI} @change=${(event) => {
+    updateCheckbox(context, controller, event, (d, value) => {
+      d.showCI = value;
+    });
+  }} /> Show CI status</label>
+      <label><input type="checkbox" ?checked=${draft.merge.enabled} @change=${(event) => {
+    updateCheckbox(context, controller, event, (d, value) => {
+      d.merge.enabled = value;
+    });
+  }} /> Allow one-click merge</label>
+      <label><input type="checkbox" ?checked=${draft.merge.requireCleanWorktree} @change=${(event) => {
+    updateCheckbox(context, controller, event, (d, value) => {
+      d.merge.requireCleanWorktree = value;
+    });
+  }} /> Require clean worktree to merge</label>
+      <label
+        ><input type="checkbox" ?checked=${draft.merge.requireCI} @change=${(event) => {
+    updateCheckbox(context, controller, event, (d, value) => {
+      d.merge.requireCI = value;
+    });
+  }} /> Require CI
+        confirmation (only when CI exists)</label
+      >
+      <label
+        ><input type="checkbox" ?checked=${draft.merge.deleteBranch} @change=${(event) => {
+    updateCheckbox(context, controller, event, (d, value) => {
+      d.merge.deleteBranch = value;
+    });
+  }} /> Delete
+        branch after merge</label
+      >
+      <label>
+        Merge method
+        <select
+          @change=${(event) => {
+    const value = event.target.value;
+    controller.updateDraft(context, (d) => {
+      d.merge.method = value === "squash" ? "squash" : value === "rebase" ? "rebase" : "merge";
+      return d;
+    });
+  }}
+        >
+          ${MERGE_METHODS.map((method) => html`<option value=${method} ?selected=${draft.merge.method === method}>${method}</option>`)}
+        </select>
+      </label>
+      <label>
+        Refresh every
+        <input
+          type="number"
+          min="0"
+          max="3600"
+          step="5"
+          .value=${String(draft.refreshSeconds)}
+          @change=${(event) => {
+    const raw = event.target.value;
+    const seconds = Math.max(0, Math.min(3600, Math.floor(Number(raw))));
+    controller.updateDraft(context, (d) => {
+      d.refreshSeconds = Number.isFinite(seconds) ? seconds : 0;
+      return d;
+    });
+  }}
+        />
+        seconds (0 = only manual refresh)
+      </label>
+      <div class="ghpr-settings-actions">
+        <button type="button" class="ghpr-primary" ?disabled=${state.busy === "settings"} @click=${() => {
+    controller.saveSettings(context);
+  }}>Save</button>
+        <button type="button" @click=${() => {
+    controller.resetSettings(context);
+  }}>Reset to defaults</button>
+        <button type="button" @click=${() => {
+    controller.toggleSettings(context);
+  }}>Close</button>
+      </div>
+    </section>
+  `;
+}
+function updateCheckbox(context, controller, event, apply) {
+  const value = event.target.checked;
+  controller.updateDraft(context, (draft) => {
+    apply(draft, value);
+    return draft;
+  });
+}
+var panelStyles = `
+  .ghpr-panel { flex: 1 1 auto; min-height: 0; overflow: auto; color: var(--pi-text); background: var(--pi-bg); font: 13px system-ui, sans-serif; display: flex; flex-direction: column; }
+  .ghpr-panel ${ACTIVITY_ELEMENT_TAG} { display: none; }
+  .ghpr-panel button { display: inline-flex; align-items: center; gap: 5px; border: 1px solid var(--pi-border); border-radius: 7px; background: var(--pi-surface); color: var(--pi-text); padding: 5px 8px; cursor: pointer; font-size: 12px; }
+  .ghpr-panel button:disabled { cursor: wait; opacity: .6; }
+  .ghpr-panel button.ghpr-primary { border-color: var(--pi-accent); color: var(--pi-accent); }
+  .ghpr-panel a { color: var(--pi-accent); text-decoration: none; }
+  .ghpr-panel a:hover { text-decoration: underline; }
+  .ghpr-toolbar { flex: 0 0 auto; display: flex; align-items: center; gap: 8px; padding: 8px; border-bottom: 1px solid var(--pi-border-muted); }
+  .ghpr-toolbar-actions { display: flex; gap: 8px; margin-left: auto; }
+  .ghpr-muted { color: var(--pi-muted); margin: 10px 8px; }
+  .ghpr-panel > :not(.ghpr-toolbar) { margin: 8px; }
+  .ghpr-warning, .ghpr-error { border: 1px solid var(--pi-warning, #d29922); border-radius: 7px; padding: 8px; color: var(--pi-warning, #d29922); display: flex; flex-direction: column; gap: 6px; }
+  .ghpr-error { border-color: var(--pi-danger, #f85149); color: var(--pi-danger, #f85149); }
+  .ghpr-success { border: 1px solid var(--pi-success, #3fb950); border-radius: 7px; padding: 8px; color: var(--pi-success, #3fb950); display: flex; align-items: center; gap: 8px; }
+  .ghpr-warning p { margin: 0; }
+  .ghpr-confirm-buttons, .ghpr-buttons, .ghpr-settings-actions { display: flex; gap: 8px; flex-wrap: wrap; }
+  .ghpr-pr-title { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; font-weight: 600; }
+  .ghpr-meta { display: flex; gap: 10px; flex-wrap: wrap; color: var(--pi-muted); margin: 4px 0 0; font-size: 12px; }
+  .ghpr-meta span { white-space: nowrap; }
+  .ghpr-chip { border: 1px solid var(--pi-border); border-radius: 999px; padding: 0 7px; font-size: 11px; font-weight: 500; }
+  .ghpr-chip-open, .ghpr-chip-merged { border-color: var(--pi-success, #3fb950); color: var(--pi-success, #3fb950); }
+  .ghpr-chip-closed, .ghpr-chip-draft { border-color: var(--pi-muted); color: var(--pi-muted); }
+  .ghpr-conflict { color: var(--pi-danger, #f85149); font-weight: 600; }
+  .ghpr-ci-head { display: flex; align-items: center; gap: 8px; margin: 0; }
+  .ghpr-ball { width: 10px; height: 10px; border-radius: 999px; display: inline-block; }
+  .ghpr-checks { list-style: none; margin: 6px 0 0; padding: 0 0 0 18px; font-size: 12px; display: flex; flex-direction: column; gap: 3px; }
+  .ghpr-check-state { display: inline-block; width: 14px; font-weight: 600; }
+  .ghpr-check-passed { color: var(--pi-success, #3fb950); }
+  .ghpr-check-failed { color: var(--pi-danger, #f85149); }
+  .ghpr-check-running { color: #d29922; }
+  .ghpr-check-skipped { color: var(--pi-muted); }
+  .ghpr-git { border-top: 1px dashed var(--pi-border-muted); padding-top: 8px; }
+  .ghpr-dirty span { color: #e3b341; }
+  .ghpr-actions { display: flex; flex-direction: column; gap: 8px; border-top: 1px dashed var(--pi-border-muted); padding-top: 8px; }
+  .ghpr-settings { display: flex; flex-direction: column; gap: 8px; border-top: 1px dashed var(--pi-border-muted); padding-top: 8px; font-size: 12px; }
+  .ghpr-settings label { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
+  .ghpr-settings input[type="number"] { width: 80px; }
+  .ghpr-settings select { background: var(--pi-surface); color: var(--pi-text); border: 1px solid var(--pi-border); border-radius: 6px; padding: 3px 6px; }
+  .ghpr-settings-hint { color: var(--pi-muted); margin: 0; }
+  .ghpr-settings-hint code { font-size: 11px; }
+  .ghpr-settings-toggle { align-self: flex-start; margin-top: auto; }
+`;
+
+// src/actions.ts
+function createActions(runtimePluginId) {
+  const panelId = `${runtimePluginId}:${PANEL_LOCAL_ID}`;
+  return [
+    {
+      id: "workspace.open-pr",
+      title: "Open Pull Request panel",
+      description: "Open the GitHub pull request status panel for this workspace",
+      group: "Workspace",
+      enabled: (context) => context.state.selectedWorkspace !== undefined,
+      run: (context) => {
+        context.selectWorkspaceTool(panelId);
+      }
+    },
+    {
+      id: "workspace.refresh-pr",
+      title: "Refresh GitHub PR status",
+      description: "Re-run the pull request status probe for the selected workspace",
+      group: "Workspace",
+      enabled: (context) => context.state.selectedWorkspace !== undefined,
+      run: (context) => {
+        context.refreshWorkspacePanels(panelId);
+      }
+    },
+    {
+      id: "workspace.open-pr-on-github",
+      title: "Open pull request on GitHub",
+      description: "Open the current pull request in a new tab",
+      group: "Workspace",
+      enabled: (context) => currentPrUrl(context) !== undefined,
+      run: (context) => {
+        const url = currentPrUrl(context);
+        if (url !== undefined)
+          window.open(url, "_blank", "noopener,noreferrer");
+      }
+    }
+  ];
+}
+function currentPrUrl(context) {
+  const workspace = context.state.selectedWorkspace;
+  if (workspace === undefined)
+    return;
+  const machineId = context.state.selectedMachine?.id ?? "local";
+  return statusCache.statusByKey(machineId, workspace.projectId, workspace.id)?.pr?.url;
+}
+
+// src/labels.ts
+function labelDescriptors(status, showCI) {
+  if (status === undefined || !status.git)
+    return [];
+  const pr = status.pr;
+  if (pr === undefined || pr.state !== "OPEN")
+    return [];
+  const items = [
+    {
+      kind: "prLink",
+      number: pr.number,
+      href: pr.url,
+      title: pr.isDraft ? `PR #${String(pr.number)} (draft): ${pr.title}` : `PR #${String(pr.number)}: ${pr.title}`,
+      draft: pr.isDraft
+    }
+  ];
+  if (showCI && status.ci.state !== "none") {
+    items.push({ kind: "ciDot", ciState: status.ci.state, href: pr.url, title: explainCiState(status.ci) });
+  }
+  const dirty = status.staged + status.unstaged + status.untracked;
+  if (dirty > 0) {
+    items.push({
+      kind: "dirtyDot",
+      count: dirty,
+      title: `Uncommitted changes: ${String(status.staged)} staged, ${String(status.unstaged)} unstaged, ${String(status.untracked)} untracked`
+    });
+  }
+  if (status.ahead > 0) {
+    items.push({ kind: "aheadArrow", count: status.ahead, title: `${String(status.ahead)} commit(s) not pushed` });
+  }
+  if (status.behind > 0) {
+    items.push({ kind: "behindArrow", count: status.behind, title: `${String(status.behind)} commit(s) behind upstream` });
+  }
+  return items;
+}
+var CI_DOT_COLORS2 = {
+  none: "transparent",
+  passed: "#3fb950",
+  running: "#d29922",
+  failed: "#f85149"
+};
+function labelItem(html, descriptor) {
+  switch (descriptor.kind) {
+    case "prLink":
+      return { type: "link", text: `#${String(descriptor.number)}`, href: descriptor.href, title: descriptor.title, target: "_blank" };
+    case "ciDot": {
+      const color = CI_DOT_COLORS2[descriptor.ciState];
+      return {
+        type: "render",
+        render: () => html`<a
+            href=${descriptor.href}
+            target="_blank"
+            rel="noopener noreferrer"
+            title=${descriptor.title}
+            style="text-decoration:none;color:${color};font-size:11px;line-height:1"
+            >●</a
+          >`
+      };
+    }
+    case "dirtyDot":
+      return {
+        type: "render",
+        render: () => html`<span title=${descriptor.title} style="color:#e3b341;font-weight:600;font-size:11px;line-height:1"
+            >✎${String(descriptor.count)}</span
+          >`
+      };
+    case "aheadArrow":
+      return {
+        type: "render",
+        render: () => html`<span title=${descriptor.title} style="font-weight:600;font-size:11px;line-height:1">↑${String(descriptor.count)}</span>`
+      };
+    case "behindArrow":
+      return {
+        type: "render",
+        render: () => html`<span title=${descriptor.title} style="color:var(--pi-muted, #8b949e);font-size:11px;line-height:1">↓${String(descriptor.count)}</span>`
+      };
+  }
+}
+function createWorkspaceLabelContribution(html) {
+  return {
+    id: "pr-status",
+    order: 15,
+    items: (context) => {
+      const entry = statusCache.ensureLoaded(context);
+      const showCI = entry.settings?.showCI ?? true;
+      return labelDescriptors(entry.status, showCI).map((descriptor) => labelItem(html, descriptor));
+    }
+  };
+}
+
+// src/index.ts
+var plugin = {
+  apiVersion: 2,
+  name: "GitHub PR Status",
+  activate: ({ runtimePluginId, html, svg }) => {
+    const controller = new PrUiController;
+    return {
+      contributions: {
+        actions: createActions(runtimePluginId),
+        workspacePanels: [createPanelContribution(html, svg, controller)],
+        workspaceLabels: [createWorkspaceLabelContribution(html)]
+      }
+    };
+  }
+};
+var src_default = plugin;
+export {
+  src_default as default
+};