dsh-super-code 0.3.10 → 0.4.0

package/builtin/skills/pstack/dsh/skills/poteto-mode/scripts/watch-pr/render.ts

@@ -0,0 +1,169 @@
+import type * as T from "./types.ts";
+export const renderJson = (verdict: T.WatcherVerdict): string =>
+  `${JSON.stringify(verdict)}\n`;
+function ciCell(row: T.PrSnapshot): string {
+  if (row.kind !== "open") return "\u2014";
+  const was = row.ci.hadPreviousPassingCi ? ", was ✅" : "";
+  switch (row.ci.kind) {
+    case "ci-clean":
+      return "✅";
+    case "ci-pending":
+      return `⏳ ${row.ci.pending.length} pending${was}`;
+    case "ci-failing":
+      return `❌ ${row.ci.failed.length} failed${row.ci.pending.length ? `, ${row.ci.pending.length} pending` : ""}${was}`;
+    case "ci-github-rejected":
+      return `❌ GitHub reports failing checks${was}`;
+    default: {
+      const exhaustive: never = row.ci;
+      return exhaustive;
+    }
+  }
+}
+function reviewCell(row: T.PrSnapshot): string {
+  if (row.kind !== "open") return "\u2014";
+  const open = row.threads.length;
+  return row.reviewAutomationRunning
+    ? open
+      ? `🤖 running, ${open} open`
+      : "🤖 running"
+    : open
+      ? `📝 ${open} open`
+      : "✅";
+}
+function mergeCell(row: T.PrSnapshot): string {
+  if (row.kind === "merged") return "✅ merged";
+  if (row.kind === "closed") return "❌ closed";
+  if (row.facts.isDraft) return "⏸ draft";
+  if (row.facts.reviewDecision === "CHANGES_REQUESTED")
+    return "⚠️ changes requested";
+  return row.facts.mergeable === "CONFLICTING" ||
+    row.facts.mergeStateStatus === "DIRTY" ||
+    row.facts.mergeStateStatus === "CONFLICTING"
+    ? "⚠️ conflict"
+    : "✅";
+}
+export function renderStatusTable(rows: T.NonEmpty<T.PrSnapshot>): string {
+  const lines = ["| PR | CI | Review | Merge |", "| --- | --- | --- | --- |"];
+  for (const row of rows) {
+    const url = `https://github.com/${row.context.owner}/${row.context.repo}/pull/${row.context.number}`;
+    lines.push(
+      `| [#${row.context.number}](${url}) | ${ciCell(row)} | ${reviewCell(row)} | ${mergeCell(row)} |`
+    );
+  }
+  return `${lines.join("\n")}\n`;
+}
+function threadLine(thread: T.ReviewThread): string {
+  const comment = thread.firstComment;
+  return [
+    thread.id,
+    comment?.path ?? "None",
+    comment?.line ?? "None",
+    comment?.authorLogin ?? "None",
+    `isBugBot=${thread.isBugbot}`,
+    `bugbotReviewPasses=${thread.bugbotReviewPasses}`,
+    (comment?.body ?? "").split(/\r?\n/, 1)[0]?.slice(0, 180) ?? "",
+  ].join(" ");
+}
+type StatusQueryBlocker = {
+  readonly kind: "status-query";
+  readonly failures: number;
+  readonly failure: { readonly detail: string };
+};
+function renderBlocker(blocker: T.MergeBlocker | StatusQueryBlocker): string {
+  switch (blocker.kind) {
+    case "merge-conflicts":
+      return [
+        "BLOCKER: merge-conflicts",
+        `pr=${blocker.pr.number}`,
+        `mergeable=${blocker.facts.mergeable}`,
+        `mergeStateStatus=${blocker.facts.mergeStateStatus}`,
+        "action=resolve merge conflicts before waiting for CI",
+      ].join("\n");
+    case "review-threads":
+      return [
+        "BLOCKER: review-threads",
+        `pr=${blocker.pr.number}`,
+        `unresolved=${blocker.threads.length}`,
+        ...blocker.threads.map(threadLine),
+      ].join("\n");
+    case "failing-checks": {
+      const failed = blocker.ci.kind === "ci-failing" ? blocker.ci.failed : [];
+      const details = failed.map(
+        (check) =>
+          `${check.name} ${check.reportedState} ${check.description} ${check.link}`
+      );
+      if (blocker.ci.kind === "ci-github-rejected")
+        details.push(
+          `mergeStateStatus=${blocker.ci.github.mergeStateStatus}`,
+          `headRollupState=${blocker.ci.github.headRollupState}`
+        );
+      return [
+        "BLOCKER: failing-checks",
+        `pr=${blocker.pr.number}`,
+        `failed=${failed.length}`,
+        ...details,
+      ].join("\n");
+    }
+    case "merge-gate": {
+      const action =
+        blocker.reason === "closed-without-merge"
+          ? "restore or remove the closed PR from the queued stack"
+          : blocker.reason === "draft-pr"
+            ? "mark the PR ready for review before waiting for the merge queue"
+            : "resolve the changes-requested review before waiting for the merge queue";
+      return [
+        `BLOCKER: ${blocker.reason}`,
+        `pr=${blocker.pr.number}`,
+        `action=${action}`,
+      ].join("\n");
+    }
+    case "status-query":
+      return [
+        "BLOCKER: status-query",
+        `failures=${blocker.failures}`,
+        `detail=${blocker.failure.detail}`,
+        "action=verify current PR context, GitHub authentication, and API availability, then rearm",
+      ].join("\n");
+    default: {
+      const exhaustive: never = blocker;
+      return exhaustive;
+    }
+  }
+}
+export function renderPretty(verdict: T.WatcherVerdict): string {
+  switch (verdict.kind) {
+    case "QUEUE":
+      return `QUEUE: captured ${verdict.queue.length} PR${verdict.queue.length === 1 ? "" : "s"} bottom-to-top: ${verdict.queue.map((pr) => `#${pr.number}`).join(",")}\n`;
+    case "STATUS":
+      return renderStatusTable(verdict.rows);
+    case "WAITING":
+      return verdict.reason.kind === "pending-checks"
+        ? `WAITING: frontier=#${verdict.frontier.number}; ${verdict.reason.pending.length} check${verdict.reason.pending.length === 1 ? "" : "s"} pending\n`
+        : `WAITING: frontier=#${verdict.frontier.number} is blocker-free; waiting for merge queue (${verdict.reason.unmergedCount} PR${verdict.reason.unmergedCount === 1 ? "" : "s"} unmerged)\n`;
+    case "ADVANCE":
+      return `ADVANCE: merged #${verdict.merged.number}; next=#${verdict.frontier.number}; remaining=${verdict.remaining}\n`;
+    case "RETRY":
+      return `RETRY: GitHub status query failed; retrying in ${verdict.retryInSeconds}s\ndetail=${verdict.failure.detail}\n`;
+    case "BLOCKER":
+      return `${renderBlocker(verdict.blocker)}\n`;
+    case "READY": {
+      const detail =
+        verdict.scope.kind === "single" && verdict.scope.pr.kind === "ready-pr"
+          ? `\nmergeStateStatus=${verdict.scope.pr.proof.ci.github.mergeStateStatus}\nreviewDecision=${verdict.scope.pr.proof.gate.reviewDecision}\nisDraft=${verdict.scope.pr.proof.gate.draft === "draft-allowed"}${verdict.scope.pr.proof.gate.draft === "draft-allowed" ? "\nnote=draft allowed (--allow-draft); leave draft \u2014 do not mark ready" : ""}`
+          : "";
+      return `READY: no merge conflicts, no unresolved review threads, no failing or pending checks${detail}\n`;
+    }
+    case "COMPLETE":
+      return `COMPLETE: queued stack merged (${verdict.queue.length} PR${verdict.queue.length === 1 ? "" : "s"})\n`;
+    case "TIMEOUT":
+      if (verdict.reason.kind === "pending-checks")
+        return "TIMEOUT: checks still pending\n";
+      if (verdict.reason.kind === "status-unavailable")
+        return "TIMEOUT: GitHub status remained unavailable\n";
+      return `TIMEOUT: queued stack still has ${verdict.reason.unmergedCount} PR${verdict.reason.unmergedCount === 1 ? "" : "s"} unmerged; frontier=#${verdict.reason.frontier.number}\n`;
+    default: {
+      const exhaustive: never = verdict;
+      return exhaustive;
+    }
+  }
+}

package/builtin/skills/pstack/dsh/skills/poteto-mode/scripts/watch-pr/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "noEmit": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "esnext",
+    "types": ["bun-types"]
+  },
+  "include": ["*.ts"]
+}

package/builtin/skills/pstack/dsh/skills/poteto-mode/scripts/watch-pr/types.compile.ts

@@ -0,0 +1,93 @@
+import { parsePrNumber } from "./types.ts";
+import type {
+  CiClean,
+  GitHubMergeAllowed,
+  PrContext,
+  ReadyPr,
+  TerminalVerdict,
+} from "./types.ts";
+
+type ReadyVerdict = Extract<TerminalVerdict, { readonly kind: "READY" }>;
+
+const context = {
+  owner: "octocat",
+  repo: "hello-world",
+  number: parsePrNumber(123),
+} satisfies PrContext;
+const cleanCi = {
+  kind: "ci-clean",
+  source: "gh-pr-checks",
+  all: [
+    {
+      kind: "passed",
+      name: "ci",
+      reportedState: "SUCCESS",
+      description: "",
+      link: "",
+      workflow: "",
+    },
+  ],
+  failed: [],
+  pending: [],
+  hadPreviousPassingCi: false,
+  github: {
+    kind: "allowed",
+    basis: "merge-state",
+    mergeStateStatus: "CLEAN",
+    headRollupState: "SUCCESS",
+  },
+} satisfies CiClean;
+const readyPr = {
+  kind: "ready-pr",
+  context,
+  proof: {
+    mergeability: "clear",
+    threads: [],
+    ci: cleanCi,
+    gate: {
+      state: "OPEN",
+      reviewDecision: "APPROVED",
+      draft: "not-draft",
+    },
+  },
+} satisfies ReadyPr;
+const ready = {
+  schemaVersion: 1,
+  sequence: 1,
+  observedAt: "2026-07-26T00:00:00.000Z",
+  mode: "single",
+  kind: "READY",
+  terminal: true,
+  exitCode: 0,
+  scope: { kind: "single", pr: readyPr },
+} satisfies ReadyVerdict;
+
+void ready;
+
+// PR 179929's shape. Each assertion below stays a single short statement so a
+// reformat cannot drift the directive away from the line that actually errors.
+const refused = {
+  kind: "allowed",
+  basis: "rollup",
+  mergeStateStatus: "BLOCKED",
+  headRollupState: "FAILURE",
+} as const;
+
+// @ts-expect-error BLOCKED with a failing rollup is a refusal, not an allowance.
+const refusalIsNotAllowed: GitHubMergeAllowed = refused;
+
+// @ts-expect-error CI cannot be clean while GitHub refuses the merge.
+const refusalIsNotClean: CiClean = { ...cleanCi, github: refused };
+
+// @ts-expect-error READY cannot carry the failing-checks exit code.
+const readyWithBlockerExit: ReadyVerdict = { ...ready, exitCode: 4 };
+
+const unprovenPr = { kind: "ready-pr", context } as const;
+
+// @ts-expect-error An open READY row must carry positive readiness proof.
+const readyWithoutProof: ReadyPr = unprovenPr;
+
+void refusalIsNotAllowed;
+void refusalIsNotClean;
+void readyWithBlockerExit;
+void readyWithoutProof;

package/builtin/skills/pstack/dsh/skills/poteto-mode/scripts/watch-pr/types.ts

@@ -0,0 +1,414 @@
+declare const prNumberBrand: unique symbol;
+export type PrNumber = number & { readonly [prNumberBrand]: "PrNumber" };
+export type NonEmpty<T> = readonly [T, ...T[]];
+export function nonEmpty<T>(items: readonly T[]): NonEmpty<T> | null {
+  return items.length === 0 ? null : [items[0], ...items.slice(1)];
+}
+export function parsePrNumber(value: unknown, label = "PR number"): PrNumber {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0)
+    throw new Error(`${label} must be a positive integer`);
+  return value as PrNumber;
+}
+export interface Repository {
+  readonly owner: string;
+  readonly repo: string;
+}
+export interface PrContext extends Repository {
+  readonly number: PrNumber;
+}
+export type MergeStateStatus =
+  | "BEHIND"
+  | "BLOCKED"
+  | "CLEAN"
+  | "CONFLICTING"
+  | "DIRTY"
+  | "DRAFT"
+  | "HAS_HOOKS"
+  | "UNKNOWN"
+  | "UNSTABLE";
+export type RollupState =
+  | "ERROR"
+  | "EXPECTED"
+  | "FAILURE"
+  | "PENDING"
+  | "SUCCESS"
+  | null;
+export type ReviewDecision =
+  | "APPROVED"
+  | "CHANGES_REQUESTED"
+  | "REVIEW_REQUIRED"
+  | null;
+export interface PullRequestFacts {
+  readonly context: PrContext;
+  readonly mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+  readonly mergeStateStatus: MergeStateStatus;
+  readonly reviewDecision: ReviewDecision;
+  readonly headRefOid: string | null;
+  readonly headRefName: string;
+  readonly baseRefName: string;
+  readonly state: "OPEN" | "CLOSED" | "MERGED";
+  readonly mergedAt: string | null;
+  readonly isDraft: boolean;
+}
+export interface OpenPullRequest {
+  readonly number: PrNumber;
+  readonly isCrossRepository: boolean;
+  readonly headRefName: string;
+  readonly baseRefName: string;
+}
+export interface ReviewComment {
+  readonly authorLogin: string | null;
+  readonly body: string;
+  readonly path: string | null;
+  readonly line: number | null;
+  readonly createdAt: string;
+}
+export interface ReviewThread {
+  readonly id: string;
+  readonly firstComment: ReviewComment | null;
+  readonly isBugbot: boolean;
+  readonly bugbotReviewPasses: number;
+}
+interface CheckDetails {
+  readonly name: string;
+  readonly reportedState: string;
+  readonly description: string;
+  readonly link: string;
+  readonly workflow: string;
+}
+export type Check =
+  | (CheckDetails & { readonly kind: "passed" })
+  | (CheckDetails & { readonly kind: "skipped" })
+  | (CheckDetails & { readonly kind: "failed" })
+  | (CheckDetails & { readonly kind: "pending" })
+  | (CheckDetails & {
+      readonly kind: "code-review-gate";
+      readonly name: "Code Review Gate";
+    });
+export type FailedCheck = Extract<Check, { readonly kind: "failed" }>;
+export type PendingCheck = Extract<Check, { readonly kind: "pending" }>;
+export interface CheckRead {
+  readonly source: "gh-pr-checks" | "graphql-rollup";
+  readonly checks: NonEmpty<Check>;
+}
+export interface CommitRollup {
+  readonly oid: string;
+  readonly state: RollupState;
+}
+export interface GitHubMergeRefusal {
+  readonly kind: "refused";
+  readonly mergeStateStatus: "BLOCKED";
+  readonly headRollupState: "ERROR" | "FAILURE";
+}
+export type GitHubMergeAllowed =
+  | {
+      readonly kind: "allowed";
+      readonly basis: "merge-state";
+      readonly mergeStateStatus: Exclude<MergeStateStatus, "BLOCKED">;
+      readonly headRollupState: RollupState;
+    }
+  | {
+      readonly kind: "allowed";
+      readonly basis: "rollup";
+      readonly mergeStateStatus: "BLOCKED";
+      readonly headRollupState: Exclude<RollupState, "ERROR" | "FAILURE">;
+    };
+export type GitHubMergeAssessment = GitHubMergeAllowed | GitHubMergeRefusal;
+interface CiBase {
+  readonly source: CheckRead["source"];
+  readonly all: NonEmpty<Check>;
+  readonly hadPreviousPassingCi: boolean;
+}
+export type CiFailing = CiBase & {
+  readonly kind: "ci-failing";
+  readonly failed: NonEmpty<FailedCheck>;
+  readonly pending: readonly PendingCheck[];
+  readonly github: GitHubMergeAssessment;
+};
+export type CiGithubRejected = CiBase & {
+  readonly kind: "ci-github-rejected";
+  readonly failed: readonly [];
+  readonly pending: readonly PendingCheck[];
+  readonly github: GitHubMergeRefusal;
+};
+export type CiPending = CiBase & {
+  readonly kind: "ci-pending";
+  readonly failed: readonly [];
+  readonly pending: NonEmpty<PendingCheck>;
+};
+export type CiClean = CiBase & {
+  readonly kind: "ci-clean";
+  readonly failed: readonly [];
+  readonly pending: readonly [];
+  readonly github: GitHubMergeAllowed;
+};
+export type CiState = CiFailing | CiGithubRejected | CiPending | CiClean;
+export type PrSnapshot =
+  | {
+      readonly kind: "merged" | "closed";
+      readonly context: PrContext;
+      readonly facts: PullRequestFacts;
+    }
+  | {
+      readonly kind: "open";
+      readonly context: PrContext;
+      readonly facts: PullRequestFacts;
+      readonly threads: readonly ReviewThread[];
+      readonly ci: CiState;
+      readonly reviewAutomationRunning: boolean;
+    };
+export interface ReadyPr {
+  readonly kind: "ready-pr";
+  readonly context: PrContext;
+  readonly proof: {
+    readonly mergeability: "clear";
+    readonly threads: readonly [];
+    readonly ci: CiClean;
+    readonly gate: {
+      readonly state: "OPEN";
+      readonly reviewDecision: Exclude<ReviewDecision, "CHANGES_REQUESTED">;
+      readonly draft: "not-draft" | "draft-allowed";
+    };
+  };
+}
+export interface MergedPr {
+  readonly kind: "merged-pr";
+  readonly context: PrContext;
+  readonly mergedAt: string | null;
+}
+export type MergeGateReason =
+  | "closed-without-merge"
+  | "draft-pr"
+  | "changes-requested";
+export type MergeBlocker =
+  | {
+      readonly kind: "merge-conflicts";
+      readonly pr: PrContext;
+      readonly facts: PullRequestFacts;
+    }
+  | {
+      readonly kind: "review-threads";
+      readonly pr: PrContext;
+      readonly threads: NonEmpty<ReviewThread>;
+    }
+  | {
+      readonly kind: "failing-checks";
+      readonly pr: PrContext;
+      readonly ci: CiFailing | CiGithubRejected;
+    }
+  | {
+      readonly kind: "merge-gate";
+      readonly pr: PrContext;
+      readonly reason: MergeGateReason;
+    };
+export type QueryFailure =
+  | {
+      readonly kind: "json-parse";
+      readonly retryable: true;
+      readonly detail: string;
+    }
+  | {
+      readonly kind: "missing-key";
+      readonly retryable: true;
+      readonly detail: string;
+      readonly rawValue?: string;
+    }
+  | {
+      readonly kind: "command-exit";
+      readonly retryable: true;
+      readonly detail: string;
+      readonly code: number;
+    }
+  | {
+      readonly kind: "checks-unavailable";
+      readonly retryable: true;
+      readonly detail: string;
+    }
+  | {
+      readonly kind: "invalid-context-url";
+      readonly retryable: false;
+      readonly detail: string;
+      readonly rawValue: string;
+    };
+/**
+ * `frontier` names the lowest unmerged PR that is actually waiting, and
+ * `pending` is that PR's checks only. Pooling every row's pending under the
+ * bottom PR's number misattributed upstack waits to the frontier.
+ *
+ * This decision serves single and `--stack` mode. Queued mode deliberately
+ * reports its own merge frontier instead: when that PR is blocker-free it
+ * emits a merge-queue wait that ignores upstack pending, because upstack
+ * checks do not block the frontier's merge. That is the Python watcher's
+ * contract, not an attribution bug.
+ */
+export interface WaitingDecision {
+  readonly kind: "waiting";
+  readonly frontier: PrContext;
+  readonly pending: NonEmpty<PendingCheck>;
+}
+export type PrDecision =
+  | { readonly kind: "blocker"; readonly blocker: MergeBlocker }
+  | WaitingDecision
+  | { readonly kind: "ready"; readonly pr: ReadyPr }
+  | { readonly kind: "merged"; readonly pr: MergedPr };
+export type StackDecision =
+  | { readonly kind: "blocker"; readonly blocker: MergeBlocker }
+  | WaitingDecision
+  | { readonly kind: "clear"; readonly prs: NonEmpty<ReadyPr | MergedPr> };
+export type WatchMode = "single" | "stack" | "queued-stack";
+interface EventBase<K extends string, M extends WatchMode = WatchMode> {
+  readonly schemaVersion: 1;
+  readonly sequence: number;
+  readonly observedAt: string;
+  readonly mode: M;
+  readonly kind: K;
+}
+interface Progress<K extends string, M extends WatchMode = WatchMode>
+  extends EventBase<K, M> {
+  readonly terminal: false;
+}
+interface Terminal<
+  K extends string,
+  C extends number,
+  M extends WatchMode = WatchMode,
+> extends EventBase<K, M> {
+  readonly terminal: true;
+  readonly exitCode: C;
+}
+export type ProgressVerdict =
+  | (Progress<"QUEUE", "queued-stack"> & {
+      readonly queue: NonEmpty<PrContext>;
+    })
+  | (Progress<"STATUS", "stack" | "queued-stack"> & {
+      readonly reason: "poll" | "whole-stack-sweep";
+      readonly rows: NonEmpty<PrSnapshot>;
+    })
+  | (Progress<"WAITING"> & {
+      readonly frontier: PrContext;
+      readonly reason:
+        | {
+            readonly kind: "pending-checks";
+            readonly pending: NonEmpty<PendingCheck>;
+          }
+        | { readonly kind: "merge-queue"; readonly unmergedCount: number };
+    })
+  | (Progress<"ADVANCE", "queued-stack"> & {
+      readonly merged: PrContext;
+      readonly frontier: PrContext;
+      readonly remaining: number;
+    })
+  | (Progress<"RETRY"> & {
+      readonly failure: QueryFailure;
+      readonly consecutiveFailures: number;
+      readonly retryInSeconds: number;
+    });
+export type BlockerVerdict =
+  | (Terminal<"BLOCKER", 2> & {
+      readonly blocker: Extract<
+        MergeBlocker,
+        { readonly kind: "merge-conflicts" }
+      >;
+    })
+  | (Terminal<"BLOCKER", 3> & {
+      readonly blocker: Extract<
+        MergeBlocker,
+        { readonly kind: "review-threads" }
+      >;
+    })
+  | (Terminal<"BLOCKER", 4> & {
+      readonly blocker: Extract<
+        MergeBlocker,
+        { readonly kind: "failing-checks" }
+      >;
+    })
+  | (Terminal<"BLOCKER", 6> & {
+      readonly blocker: Extract<MergeBlocker, { readonly kind: "merge-gate" }>;
+    })
+  | (Terminal<"BLOCKER", 7> & {
+      readonly blocker: {
+        readonly kind: "status-query";
+        readonly failures: number;
+        readonly failure: QueryFailure;
+      };
+    });
+export type TimeoutVerdict = Terminal<"TIMEOUT", 5> & {
+  readonly reason:
+    | {
+        readonly kind: "pending-checks";
+        readonly pending: NonEmpty<PendingCheck>;
+      }
+    | { readonly kind: "status-unavailable"; readonly failure: QueryFailure }
+    | {
+        readonly kind: "queued-stack";
+        readonly frontier: PrContext;
+        readonly unmergedCount: number;
+      };
+};
+export type TerminalVerdict =
+  | (Terminal<"STATUS", 0> & {
+      readonly reason: "status-only";
+      readonly rows: NonEmpty<PrSnapshot>;
+    })
+  | (Terminal<"READY", 0, "single" | "stack"> & {
+      readonly scope:
+        | { readonly kind: "single"; readonly pr: ReadyPr | MergedPr }
+        | {
+            readonly kind: "stack";
+            readonly prs: NonEmpty<ReadyPr | MergedPr>;
+          };
+    })
+  | (Terminal<"COMPLETE", 0, "queued-stack"> & {
+      readonly queue: NonEmpty<PrContext>;
+      readonly merged: NonEmpty<MergedPr>;
+    })
+  | BlockerVerdict
+  | TimeoutVerdict;
+export type WatcherVerdict = ProgressVerdict | TerminalVerdict;
+export type ExitCode = TerminalVerdict["exitCode"];
+export type QueueTerminalVerdict =
+  | Extract<TerminalVerdict, { readonly kind: "COMPLETE" }>
+  | BlockerVerdict
+  | TimeoutVerdict;
+export type ChecksFastPath =
+  | { readonly kind: "checks"; readonly checks: readonly Check[] }
+  | {
+      readonly kind: "unusable";
+      readonly exitCode: number;
+      readonly stderr: string;
+    };
+export interface RollupPage {
+  readonly checks: readonly Check[];
+  readonly endCursor: string | null;
+}
+export interface RawReviewThread {
+  readonly id: string;
+  readonly firstComment: ReviewComment | null;
+  readonly resolved: boolean;
+}
+export interface ReviewThreadPage {
+  readonly threads: readonly RawReviewThread[];
+  readonly endCursor: string | null;
+}
+export interface GitHubReader {
+  originRepo(): Promise<Repository | null>;
+  currentPr(pr: PrNumber | null): Promise<PrContext>;
+  pullRequest(context: PrContext): Promise<PullRequestFacts>;
+  openPullRequests(repository: Repository): Promise<readonly OpenPullRequest[]>;
+  checksFastPath(context: PrContext): Promise<ChecksFastPath>;
+  checkRollupPage(
+    context: PrContext,
+    after: string | null
+  ): Promise<RollupPage>;
+  reviewThreadPage(
+    context: PrContext,
+    after: string | null
+  ): Promise<ReviewThreadPage>;
+  commitRollups(context: PrContext): Promise<readonly CommitRollup[]>;
+}
+export interface PollingOptions {
+  readonly interval: number;
+  readonly sweepInterval: number;
+  readonly timeout: number;
+  readonly maxQueryErrors: number;
+  readonly allowDraft: boolean;
+}

package/builtin/skills/pstack/dsh/skills/poteto-mode/scripts/watch-pr/watch-pr

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+import { ensureDependenciesInstalled } from "../bootstrap.ts";
+
+ensureDependenciesInstalled();
+const { main } = await import("./cli.ts");
+process.exitCode = await main(process.argv.slice(2));