diff --git a/apps/server/src/auth/RpcAuthorization.test.ts b/apps/server/src/auth/RpcAuthorization.test.ts
index 2302170f99a97..0cd838f129340 100644
--- a/apps/server/src/auth/RpcAuthorization.test.ts
+++ b/apps/server/src/auth/RpcAuthorization.test.ts
@@ -8,6 +8,8 @@ import {
   DEFAULT_SERVER_SETTINGS,
   ProviderDriverKind,
   ProviderInstanceId,
+  ProjectId,
+  IssueTrackerKind,
   SecretProviderId,
   ThreadId,
   AuthOrchestrationOperateScope,
@@ -144,6 +146,57 @@ describe("RPC scope middleware", () => {
   );
 });
 
+it.effect("allows issue reads but requires a source-control grant before commenting", () =>
+  Effect.gen(function* () {
+    const tested = [WS_METHODS.issuesList, WS_METHODS.issuesComment] as const;
+    const group = WsRpcGroup.omit(
+      ...[...WsRpcGroup.requests.keys()].filter(
+        (tag): tag is Exclude<keyof typeof RPC_REQUIRED_SCOPES, (typeof tested)[number]> =>
+          !(tested as ReadonlyArray<string>).includes(tag),
+      ),
+    );
+    const comments: string[] = [];
+    const handlers = Layer.mergeAll(
+      group.toLayerHandler(WS_METHODS.issuesList, () =>
+        Effect.succeed({ entries: [], trackers: [], errors: [], viewers: {}, nextCursors: {} }),
+      ),
+      group.toLayerHandler(WS_METHODS.issuesComment, ({ body }) =>
+        Effect.sync(() => {
+          comments.push(body);
+        }),
+      ),
+    );
+    const reader = yield* RpcTest.makeClient(group).pipe(
+      Effect.provide(Layer.merge(handlers, RpcAuthorization.layer([AuthOrchestrationReadScope]))),
+    );
+    const comment = {
+      projectId: ProjectId.make("web"),
+      tracker: IssueTrackerKind.make("github"),
+      scope: "acme/web",
+      key: "42",
+      body: "Repro attached.",
+    };
+
+    expect((yield* reader[WS_METHODS.issuesList]({ state: "open" })).entries).toEqual([]);
+    expect(yield* reader[WS_METHODS.issuesComment](comment).pipe(Effect.flip)).toMatchObject({
+      _tag: "EnvironmentAuthorizationError",
+      requiredPermission: AuthSourceControlWriteScope,
+    });
+    expect(comments).toEqual([]);
+
+    const writer = yield* RpcTest.makeClient(group).pipe(
+      Effect.provide(
+        Layer.merge(
+          handlers,
+          RpcAuthorization.layer([AuthOrchestrationReadScope, AuthSourceControlWriteScope]),
+        ),
+      ),
+    );
+    yield* writer[WS_METHODS.issuesComment](comment);
+    expect(comments).toEqual(["Repro attached."]);
+  }).pipe(Effect.scoped),
+);
+
 it.effect.each([WS_METHODS.subscribeVcsBranch, WS_METHODS.subscribeVcsStatus] as const)(
   "enforces read permission on stream %s",
   (method) =>
diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts
index 7925fd869799f..6868a8b2e7286 100644
--- a/apps/server/src/auth/RpcAuthorization.ts
+++ b/apps/server/src/auth/RpcAuthorization.ts
@@ -132,6 +132,11 @@ export const RPC_REQUIRED_SCOPES = {
   [WS_METHODS.pullRequestsStack]: AuthOrchestrationReadScope,
   [WS_METHODS.pullRequestsLinkedThreads]: AuthOrchestrationReadScope,
   [WS_METHODS.pullRequestsDetail]: AuthOrchestrationReadScope,
+  [WS_METHODS.issuesList]: AuthOrchestrationReadScope,
+  [WS_METHODS.issuesDetail]: AuthOrchestrationReadScope,
+  [WS_METHODS.issuesComments]: AuthOrchestrationReadScope,
+  [WS_METHODS.issuesTemplates]: AuthOrchestrationReadScope,
+  [WS_METHODS.issuesCandidates]: AuthOrchestrationReadScope,
   [WS_METHODS.pullRequestsPreview]: AuthOrchestrationReadScope,
   [WS_METHODS.pullRequestsChecks]: AuthOrchestrationReadScope,
   [WS_METHODS.pullRequestsActivity]: AuthOrchestrationReadScope,
diff --git a/apps/server/src/issue/IssueService.test.ts b/apps/server/src/issue/IssueService.test.ts
new file mode 100644
index 0000000000000..133f51234838c
--- /dev/null
+++ b/apps/server/src/issue/IssueService.test.ts
@@ -0,0 +1,346 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
+import {
+  IssueTrackerKind,
+  SourceControlProviderKind,
+  type OrchestrationProjectShell,
+  type ProjectId,
+} from "@t3tools/contracts";
+import {
+  IssueTrackerError,
+  type IssueTrackerApi,
+  type TrackerIssueDetail,
+} from "@t3tools/source-control-core/server/IssueTracker";
+
+import { normalizeGitRemoteUrl } from "@t3tools/shared/git";
+
+import * as ProjectService from "../project/ProjectService.ts";
+import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
+import * as IssueService from "./IssueService.ts";
+import * as IssueTrackerRegistry from "./IssueTrackerRegistry.ts";
+
+const GITHUB = IssueTrackerKind.make("github");
+
+function project(input: {
+  readonly id: string;
+  readonly repository?: string;
+  readonly provider?: string;
+  readonly host?: string;
+}): OrchestrationProjectShell {
+  const host = input.host ?? "github.com";
+  return {
+    id: input.id as ProjectId,
+    title: input.id,
+    workspaceRoot: `/w/${input.id}`,
+    ...(input.repository
+      ? {
+          repositoryIdentity: {
+            canonicalKey: normalizeGitRemoteUrl(`https://${host}/${input.repository}.git`),
+            locator: {
+              source: "git-remote" as const,
+              remoteName: "origin",
+              remoteUrl: `https://${host}/${input.repository}.git`,
+            },
+            provider: SourceControlProviderKind.make(input.provider ?? "github"),
+            displayName: input.repository,
+          },
+        }
+      : {}),
+    defaultModelSelection: null,
+    scripts: [],
+    createdAt: "2026-07-01T00:00:00Z",
+    updatedAt: "2026-07-01T00:00:00Z",
+  };
+}
+
+function issue(key: string, updatedAt = "2026-07-02T00:00:00Z"): TrackerIssueDetail {
+  return {
+    key,
+    displayKey: `#${key}`,
+    title: `Issue ${key}`,
+    url: `https://github.com/acme/web/issues/${key}`,
+    author: null,
+    state: { category: "open", name: "open" },
+    createdAt: "2026-07-01T00:00:00Z",
+    updatedAt,
+    closedAt: null,
+    assignees: [],
+    labels: [],
+    commentCount: 0,
+    body: "",
+    viewer: "julius",
+    viewerPermissions: { setState: true, comment: true, edit: true, labels: true, assignees: true },
+    comments: [],
+    commentsCursor: null,
+    events: [],
+    linkedPullRequests: [],
+  };
+}
+
+function fakeTracker(overrides: Partial<IssueTrackerApi> = {}): IssueTrackerApi {
+  return {
+    kind: GITHUB,
+    capabilities: {
+      create: true,
+      edit: true,
+      comment: true,
+      labels: true,
+      assignees: true,
+      reactions: false,
+      templates: false,
+      linkedPullRequests: true,
+      events: true,
+      search: true,
+      states: [
+        { category: "open", name: "open" },
+        { category: "closed", name: "closed" },
+      ],
+      closeReasons: ["completed"],
+    },
+    getViewer: () => Effect.succeed("julius"),
+    listIssues: () => Effect.succeed({ items: [], nextCursor: null }),
+    getIssue: (input) => Effect.succeed(issue(input.key)),
+    getComments: () => Effect.succeed({ comments: [], nextCursor: null }),
+    comment: () => Effect.void,
+    update: () => Effect.void,
+    setState: () => Effect.void,
+    ...overrides,
+  };
+}
+
+function makeService(input: {
+  readonly projects: ReadonlyArray<OrchestrationProjectShell>;
+  readonly trackers: ReadonlyArray<IssueTrackerApi>;
+}) {
+  return IssueService.IssueService.pipe(
+    Effect.provide(
+      IssueService.layer.pipe(
+        Layer.provide(
+          Layer.mergeAll(
+            Layer.succeed(
+              IssueTrackerRegistry.IssueTrackerRegistry,
+              IssueTrackerRegistry.fromTrackers(input.trackers),
+            ),
+            Layer.mock(ProjectService.ProjectService)({
+              listShells: () => Effect.succeed(input.projects),
+              getShell: (projectId) =>
+                Effect.succeed(
+                  Option.fromNullishOr(input.projects.find((p) => p.id === projectId)),
+                ),
+            }),
+            Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({
+              resolve: () => Effect.succeed(null),
+            }),
+          ),
+        ),
+      ),
+    ),
+  );
+}
+
+describe("IssueService", () => {
+  it.effect("reads another repository on the same host but refuses to write to it", () =>
+    Effect.gen(function* () {
+      const writes: string[] = [];
+      const service = yield* makeService({
+        projects: [project({ id: "web", repository: "acme/web" })],
+        trackers: [
+          fakeTracker({
+            comment: (input) =>
+              Effect.sync(() => {
+                writes.push(`${input.scope}#${input.key}`);
+              }),
+          }),
+        ],
+      });
+      const own = { projectId: "web" as ProjectId, tracker: GITHUB, scope: "acme/web", key: "1" };
+      const external = { ...own, scope: "other/backend", key: "7" };
+
+      expect((yield* service.detail(own)).writable).toBe(true);
+      // The external issue is served by the project's checkout and credentials, read-only.
+      const detail = yield* service.detail(external);
+      expect(detail).toMatchObject({ writable: false, scope: "other/backend", key: "7" });
+
+      yield* service.comment({ ...own, body: "ok" });
+      const refused = yield* service.comment({ ...external, body: "no" }).pipe(Effect.result);
+      expect(refused).toMatchObject({
+        _tag: "Failure",
+        failure: { _tag: "IssueOperationError", reason: "read-only" },
+      });
+      expect(writes).toEqual(["acme/web#1"]);
+
+      // Another host is not reachable through this project's credentials at all.
+      const elsewhere = yield* Effect.flip(service.detail({ ...own, host: "ghe.example.test" }));
+      expect(elsewhere).toMatchObject({
+        _tag: "IssueUnavailableError",
+        reason: "tracker-unsupported",
+      });
+    }),
+  );
+
+  it.effect("sends writes as interactive requests and reads as background ones", () =>
+    Effect.gen(function* () {
+      const interactive: Array<readonly [string, boolean]> = [];
+      const record = (operation: string) =>
+        Effect.gen(function* () {
+          interactive.push([operation, yield* SourceControlRateLimit.Interactive]);
+        });
+      const service = yield* makeService({
+        projects: [project({ id: "web", repository: "acme/web" })],
+        trackers: [
+          fakeTracker({
+            getComments: () =>
+              record("comments").pipe(Effect.as({ comments: [], nextCursor: null })),
+            comment: () => record("comment"),
+          }),
+        ],
+      });
+      const ref = {
+        projectId: "web" as ProjectId,
+        tracker: GITHUB,
+        scope: "acme/web",
+        key: "42",
+      };
+      yield* service.comments({ ...ref, cursor: "next" });
+      yield* service.comment({ ...ref, body: "Repro attached." });
+      expect(interactive).toEqual([
+        ["comments", false],
+        ["comment", true],
+      ]);
+    }),
+  );
+
+  it.effect("refuses what the tracker did not declare before calling it", () =>
+    Effect.gen(function* () {
+      let calls = 0;
+      const service = yield* makeService({
+        projects: [project({ id: "web", repository: "acme/web" })],
+        trackers: [
+          fakeTracker({
+            setState: () =>
+              Effect.sync(() => {
+                calls += 1;
+              }),
+            setReaction: () =>
+              Effect.sync(() => {
+                calls += 1;
+              }),
+          }),
+        ],
+      });
+      const ref = { projectId: "web" as ProjectId, tracker: GITHUB, scope: "acme/web", key: "1" };
+
+      yield* service.setState({ ...ref, state: "closed", closeReason: "completed" });
+      const unknownState = yield* Effect.flip(service.setState({ ...ref, state: "In Review" }));
+      expect(unknownState._tag).toBe("IssueOperationError");
+      const unknownReason = yield* Effect.flip(
+        service.setState({ ...ref, state: "closed", closeReason: "not-planned" }),
+      );
+      expect(unknownReason._tag).toBe("IssueOperationError");
+      const reaction = yield* Effect.flip(
+        service.react({ ...ref, content: "heart", reacted: true }),
+      );
+      expect(reaction._tag).toBe("IssueOperationError");
+      expect(calls).toBe(1);
+    }),
+  );
+
+  it.effect("deduplicates and pages repositories despite partial failures", () =>
+    Effect.gen(function* () {
+      const listed: string[] = [];
+      let failContinuation = true;
+      const service = yield* makeService({
+        projects: [
+          project({ id: "web", repository: "Acme/Web" }),
+          project({ id: "web-worktree", repository: "acme/web" }),
+          project({ id: "api", repository: "acme/api" }),
+          project({ id: "docs", repository: "acme/docs" }),
+          project({
+            id: "gitlab",
+            repository: "acme/gl",
+            provider: "gitlab",
+            host: "gitlab.com",
+          }),
+          project({ id: "plain" }),
+        ],
+        trackers: [
+          fakeTracker({
+            listIssues: (input) =>
+              Effect.gen(function* () {
+                listed.push(input.scope);
+                if (input.scope === "acme/api")
+                  return yield* new IssueTrackerError({
+                    tracker: GITHUB,
+                    operation: "listIssues",
+                    reason: "failed",
+                    // A tracker may fail without a detail; the wire error still needs one.
+                    detail: " ",
+                  });
+                if (input.scope === "acme/docs")
+                  return { items: [issue("3", "2026-07-04T00:00:00Z")], nextCursor: null };
+                if (input.cursor === "next" && failContinuation) {
+                  failContinuation = false;
+                  return yield* new IssueTrackerError({
+                    tracker: GITHUB,
+                    operation: "listIssues",
+                    reason: "failed",
+                    detail: "try again",
+                  });
+                }
+                if (input.cursor === "next")
+                  return { items: [issue("4", "2026-07-01T00:00:00Z")], nextCursor: null };
+                return {
+                  items: [issue("1"), issue("2", "2026-07-05T00:00:00Z")],
+                  nextCursor: "next",
+                };
+              }),
+          }),
+        ],
+      });
+      const result = yield* service.list({ state: "open" });
+      expect(listed.sort()).toEqual(["Acme/Web", "acme/api", "acme/docs"]);
+      expect(result.entries.map((entry) => [entry.projectId, entry.key])).toEqual([
+        ["web", "2"],
+        ["docs", "3"],
+        ["web", "1"],
+      ]);
+      expect(
+        result.entries.filter((entry) => entry.projectId === "web").map((entry) => entry.scope),
+      ).toEqual(["Acme/Web", "Acme/Web"]);
+      expect(result.nextCursors).toEqual({ "github.com Acme/Web": "next" });
+      expect(result.errors).toEqual([
+        { projectId: "api", projectTitle: "api", message: "The issue tracker request failed." },
+      ]);
+      expect(result.viewers).toEqual({ "github.com": "julius" });
+      expect(result.trackers).toEqual([
+        expect.objectContaining({ host: "github.com", projectCount: 4, configured: true }),
+        expect.objectContaining({
+          host: "gitlab.com",
+          tracker: "gitlab",
+          projectCount: 1,
+          configured: false,
+          capabilities: null,
+        }),
+      ]);
+
+      // A continuation only reads the scopes it names.
+      listed.length = 0;
+      const failed = yield* service.list({
+        state: "open",
+        cursors: result.nextCursors,
+      });
+      expect(listed).toEqual(["Acme/Web"]);
+      expect(failed.nextCursors).toEqual(result.nextCursors);
+      expect(failed.errors).toEqual([
+        { projectId: "web", projectTitle: "web", message: "try again" },
+      ]);
+      const next = yield* service.list({ state: "open", cursors: failed.nextCursors });
+      expect(next.entries.map((entry) => [entry.projectId, entry.key])).toEqual([["web", "4"]]);
+      expect(next.nextCursors).toEqual({});
+      expect(next.errors).toEqual([]);
+    }),
+  );
+});
diff --git a/apps/server/src/issue/IssueService.ts b/apps/server/src/issue/IssueService.ts
new file mode 100644
index 0000000000000..4b1a9a1167432
--- /dev/null
+++ b/apps/server/src/issue/IssueService.ts
@@ -0,0 +1,569 @@
+// References outside the project's canonical repository may be read on the same host,
+// but every write must pass through requireWritable.
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import {
+  IssueOperationError,
+  IssueTrackerKind,
+  IssueUnavailableError,
+  type IssueCandidates,
+  type IssueCommentInput,
+  type IssueCommentsPage,
+  type IssueCommentsPageInput,
+  type IssueCreateInput,
+  type IssueCreateResult,
+  type IssueDetail,
+  type IssueError,
+  type IssueListEntry,
+  type IssueListInput,
+  type IssueListProjectError,
+  type IssueListResult,
+  type IssueReactionInput,
+  type IssueRef,
+  type IssueScopeRef,
+  type IssueSetStateInput,
+  type IssueTemplateList,
+  type IssueTrackerSummary,
+  type IssueUpdateInput,
+  type OrchestrationProjectShell,
+} from "@t3tools/contracts";
+import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
+import {
+  IssueTrackerError,
+  type IssueTrackerApi,
+} from "@t3tools/source-control-core/server/IssueTracker";
+
+import * as ProjectService from "../project/ProjectService.ts";
+import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
+import { sourceControlDefinitions } from "../sourceControl/sourceControlDefinitions.ts";
+import * as IssueTrackerRegistry from "./IssueTrackerRegistry.ts";
+
+const DEFAULT_LIST_LIMIT = 50;
+const SCOPE_CONCURRENCY = 4;
+
+const interactive =
+  <I, A>(call: (input: I) => Effect.Effect<A, IssueError>) =>
+  (input: I) =>
+    call(input).pipe(Effect.provideService(SourceControlRateLimit.Interactive, true));
+
+const traced =
+  <I, A>(operation: string, call: (input: I) => Effect.Effect<A, IssueError>) =>
+  (input: I) =>
+    call(input).pipe(Effect.withSpan(`IssueService.${operation}`));
+
+/** A tracker may fail with no detail; the wire errors carry a non-empty one. */
+function trackerDetail(error: IssueTrackerError): string {
+  return error.detail.trim() || "The issue tracker request failed.";
+}
+
+/** One project's resolved tracker: which driver, where it is served from, and its container. */
+interface ProjectTrackerBinding {
+  readonly canonicalKey: string;
+  readonly tracker: IssueTrackerKind;
+  readonly host: string;
+  readonly scope: string;
+}
+
+/** A project the registry has a tracker for, ready to serve reads and writes. */
+interface SupportedProject extends ProjectTrackerBinding {
+  readonly project: OrchestrationProjectShell;
+  readonly api: IssueTrackerApi;
+}
+
+/**
+ * The git-host path of resolution: the tracker is the host's own, named like the remote's
+ * provider kind. Null for a project with no remote or a kind no tracker claims.
+ */
+function resolveGitHostBinding(project: OrchestrationProjectShell): ProjectTrackerBinding | null {
+  const identity = project.repositoryIdentity;
+  const scope = sourceControlDefinitions.issueScope(identity);
+  const kind = identity?.provider;
+  if (!identity || kind === undefined || kind === "unknown" || scope === null) return null;
+  return {
+    canonicalKey: identity.canonicalKey,
+    tracker: IssueTrackerKind.make(kind),
+    host: sourceControlDefinitions.changeRequestHost(identity, kind),
+    scope,
+  };
+}
+
+function listCursorKey(host: string, scope: string): string {
+  return `${host} ${scope}`;
+}
+
+function isTrackerUnusable(error: IssueTrackerError): boolean {
+  return error.reason === "missing-tool" || error.reason === "unauthenticated";
+}
+
+function toIssueError(operation: string): (error: IssueTrackerError) => IssueError {
+  return (error) =>
+    isTrackerUnusable(error)
+      ? new IssueUnavailableError({
+          reason: error.reason === "missing-tool" ? "tool-missing" : "unauthenticated",
+          tracker: error.tracker,
+          cause: error,
+        })
+      : new IssueOperationError({
+          operation,
+          detail: trackerDetail(error),
+          ...(error.reason === "not-found" || error.reason === "rate-limited"
+            ? { reason: error.reason }
+            : {}),
+          ...(error.retryAt === undefined ? {} : { retryAt: error.retryAt }),
+          cause: error,
+        });
+}
+
+const readOnly = (operation: string) =>
+  new IssueOperationError({
+    operation,
+    reason: "read-only",
+    detail:
+      "This issue belongs to a repository outside the selected project and cannot be changed from here.",
+  });
+
+const unsupported = (operation: string, what: string) =>
+  new IssueOperationError({ operation, detail: `This tracker does not support ${what}.` });
+
+export class IssueService extends Context.Service<
+  IssueService,
+  {
+    readonly list: (input: IssueListInput) => Effect.Effect<IssueListResult, IssueError>;
+    readonly detail: (input: IssueRef) => Effect.Effect<IssueDetail, IssueError>;
+    readonly comments: (
+      input: IssueCommentsPageInput,
+    ) => Effect.Effect<IssueCommentsPage, IssueError>;
+    readonly templates: (input: IssueScopeRef) => Effect.Effect<IssueTemplateList, IssueError>;
+    readonly candidates: (input: IssueScopeRef) => Effect.Effect<IssueCandidates, IssueError>;
+    readonly create: (input: IssueCreateInput) => Effect.Effect<IssueCreateResult, IssueError>;
+    readonly comment: (input: IssueCommentInput) => Effect.Effect<void, IssueError>;
+    readonly update: (input: IssueUpdateInput) => Effect.Effect<void, IssueError>;
+    readonly setState: (input: IssueSetStateInput) => Effect.Effect<void, IssueError>;
+    readonly react: (input: IssueReactionInput) => Effect.Effect<void, IssueError>;
+  }
+>()("t3/issue/IssueService") {}
+
+const make = Effect.gen(function* () {
+  const registry = yield* IssueTrackerRegistry.IssueTrackerRegistry;
+  const projects = yield* ProjectService.ProjectService;
+  const repositoryIdentities = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
+
+  const resolveProjectTracker = (
+    project: OrchestrationProjectShell,
+  ): Effect.Effect<ProjectTrackerBinding | null> =>
+    (project.repositoryIdentity != null
+      ? Effect.succeed(project.repositoryIdentity)
+      : repositoryIdentities.resolve(project.workspaceRoot)
+    ).pipe(
+      Effect.map((repositoryIdentity) => resolveGitHostBinding({ ...project, repositoryIdentity })),
+    );
+
+  const listProjects = (filter: {
+    readonly projectId?: IssueListInput["projectId"];
+    readonly host?: string | undefined;
+  }) =>
+    (filter.projectId === undefined
+      ? projects.listShells()
+      : projects.getShell(filter.projectId).pipe(Effect.map(Option.toArray))
+    ).pipe(
+      Effect.mapError(
+        (cause) =>
+          new IssueOperationError({
+            operation: "listProjects",
+            detail: "The project list could not be read.",
+            cause,
+          }),
+      ),
+      Effect.flatMap((shells) =>
+        Effect.forEach(
+          shells,
+          (project) =>
+            resolveProjectTracker(project).pipe(
+              Effect.map((binding) => (binding === null ? [] : [{ project, ...binding }])),
+            ),
+          { concurrency: SCOPE_CONCURRENCY },
+        ),
+      ),
+      Effect.map((bound) => {
+        const host = filter.host?.trim().toLowerCase();
+        const supported: SupportedProject[] = [];
+        const unimplemented = new Map<
+          string,
+          { tracker: IssueTrackerKind; projectCount: number }
+        >();
+        for (const candidate of bound.flat()) {
+          if (host !== undefined && candidate.host !== host) continue;
+          const api = registry.get(candidate.tracker);
+          if (api === null) {
+            const counted = unimplemented.get(candidate.host);
+            if (counted === undefined)
+              unimplemented.set(candidate.host, { tracker: candidate.tracker, projectCount: 1 });
+            else counted.projectCount += 1;
+            continue;
+          }
+          supported.push({ ...candidate, api });
+        }
+        return { supported, unimplemented };
+      }),
+    );
+
+  /**
+   * The project whose checkout and credentials serve a reference, and whether the reference is
+   * the project's own scope. A reference naming another scope on the same tracker and host is
+   * served by the project but marked read-only.
+   */
+  const requireProject = (
+    ref: IssueScopeRef,
+  ): Effect.Effect<SupportedProject & { readonly writable: boolean }, IssueError> =>
+    listProjects({ projectId: ref.projectId }).pipe(
+      Effect.flatMap(({ supported }) => {
+        const own = supported[0];
+        if (own === undefined || own.tracker !== ref.tracker) {
+          return Effect.fail(new IssueUnavailableError({ reason: "tracker-unsupported" }));
+        }
+        const host = ref.host?.trim().toLowerCase() ?? own.host;
+        if (host !== own.host) {
+          return Effect.fail(new IssueUnavailableError({ reason: "tracker-unsupported" }));
+        }
+        const scope = ref.scope.trim();
+        const writable = scope.toLowerCase() === own.scope.toLowerCase();
+        return Effect.succeed({ ...own, scope, writable });
+      }),
+    );
+
+  const requireWritable = (ref: IssueScopeRef, operation: string) =>
+    requireProject(ref).pipe(
+      Effect.filterOrFail(
+        (project) => project.writable,
+        () => readOnly(operation),
+      ),
+    );
+
+  const list: IssueService["Service"]["list"] = Effect.fn("IssueService.list")(function* (input) {
+    const { supported, unimplemented } = yield* listProjects(input);
+    const limit = input.limit ?? DEFAULT_LIST_LIMIT;
+    // Worktrees of one repository are separate projects; read each scope once.
+    const scopes = new Map<string, SupportedProject>();
+    for (const project of supported) {
+      if (!scopes.has(project.canonicalKey)) scopes.set(project.canonicalKey, project);
+    }
+    const continuing = input.cursors;
+    const viewers = new Map<string, string>();
+    const trackers = new Map<string, IssueTrackerSummary>();
+    const entries: IssueListEntry[] = [];
+    const errors: IssueListProjectError[] = [];
+    const nextCursors: Record<string, string> = {};
+
+    const viewerRequests = new Map<string, Effect.Effect<string, IssueTrackerError>>();
+    for (const project of scopes.values()) {
+      if (viewerRequests.has(project.host)) continue;
+      const request = yield* Effect.cached(
+        project.api
+          .getViewer({ cwd: project.project.workspaceRoot, host: project.host })
+          .pipe(Effect.tap((viewer) => Effect.sync(() => viewers.set(project.host, viewer)))),
+      );
+      viewerRequests.set(project.host, request);
+    }
+
+    // Every project counts, including worktrees of a scope read once below.
+    for (const project of supported) {
+      const existing = trackers.get(project.host);
+      trackers.set(
+        project.host,
+        existing === undefined
+          ? {
+              tracker: project.tracker,
+              host: project.host,
+              projectCount: 1,
+              capabilities: project.api.capabilities,
+              configured: true,
+              detail: null,
+            }
+          : { ...existing, projectCount: existing.projectCount + 1 },
+      );
+    }
+    const recordFailure = (project: SupportedProject, failure: IssueTrackerError) => {
+      const existing = trackers.get(project.host);
+      if (existing !== undefined && isTrackerUnusable(failure))
+        trackers.set(project.host, {
+          ...existing,
+          configured: false,
+          detail: trackerDetail(failure),
+        });
+    };
+
+    yield* Effect.forEach(
+      scopes.values(),
+      (project) =>
+        Effect.gen(function* () {
+          const key = listCursorKey(project.host, project.scope);
+          // A continuation names the scopes it wants; one not named has nothing to add.
+          if (continuing !== undefined && continuing[key] === undefined) return;
+          const cursor = continuing?.[key];
+          const page = yield* viewerRequests.get(project.host)!.pipe(
+            Effect.flatMap((viewer) =>
+              project.api.listIssues({
+                cwd: project.project.workspaceRoot,
+                host: project.host,
+                scope: project.scope,
+                state: input.state,
+                involvement: input.involvement ?? "all",
+                viewer,
+                limit,
+                query: input.query,
+                cursor,
+              }),
+            ),
+            Effect.result,
+          );
+          if (page._tag === "Failure") {
+            if (cursor !== undefined) nextCursors[key] = cursor;
+            recordFailure(project, page.failure);
+            errors.push({
+              projectId: project.project.id,
+              projectTitle: project.project.title,
+              message: trackerDetail(page.failure),
+            });
+            return;
+          }
+          for (const item of page.success.items) {
+            entries.push({
+              ...item,
+              tracker: project.tracker,
+              host: project.host,
+              scope: project.scope,
+              projectId: project.project.id,
+              projectTitle: project.project.title,
+            });
+          }
+          if (page.success.nextCursor !== null) nextCursors[key] = page.success.nextCursor;
+        }),
+      { concurrency: SCOPE_CONCURRENCY, discard: true },
+    );
+
+    for (const [host, { tracker, projectCount }] of unimplemented) {
+      trackers.set(host, {
+        tracker,
+        host,
+        projectCount,
+        capabilities: null,
+        configured: false,
+        detail: "Issues cannot be browsed for this host yet.",
+      });
+    }
+    entries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return {
+      viewers: Object.fromEntries(viewers),
+      trackers: [...trackers.values()],
+      entries,
+      errors,
+      nextCursors,
+    };
+  });
+
+  const detail: IssueService["Service"]["detail"] = (input) =>
+    requireProject(input).pipe(
+      Effect.flatMap((project) =>
+        project.api
+          .getIssue({
+            cwd: project.project.workspaceRoot,
+            host: project.host,
+            scope: project.scope,
+            key: input.key,
+          })
+          .pipe(
+            Effect.mapError(toIssueError("detail")),
+            Effect.map((issue): IssueDetail => ({
+              ...issue,
+              tracker: project.tracker,
+              host: project.host,
+              scope: project.scope,
+              projectId: project.project.id,
+              projectTitle: project.project.title,
+              writable: project.writable,
+              capabilities: project.api.capabilities,
+            })),
+          ),
+      ),
+    );
+
+  const comments: IssueService["Service"]["comments"] = (input) =>
+    requireProject(input).pipe(
+      Effect.flatMap((project) =>
+        project.api
+          .getComments({
+            cwd: project.project.workspaceRoot,
+            host: project.host,
+            scope: project.scope,
+            key: input.key,
+            cursor: input.cursor,
+          })
+          .pipe(Effect.mapError(toIssueError("comments"))),
+      ),
+    );
+
+  const templates: IssueService["Service"]["templates"] = (input) =>
+    requireProject(input).pipe(
+      Effect.flatMap((project) =>
+        project.api.listTemplates === undefined || !project.api.capabilities.templates
+          ? Effect.fail(unsupported("templates", "issue templates"))
+          : project.api
+              .listTemplates({
+                cwd: project.project.workspaceRoot,
+                host: project.host,
+                scope: project.scope,
+              })
+              .pipe(Effect.mapError(toIssueError("templates"))),
+      ),
+    );
+
+  const candidates: IssueService["Service"]["candidates"] = (input) =>
+    requireProject(input).pipe(
+      Effect.flatMap((project) =>
+        project.api.listCandidates === undefined ||
+        !(project.api.capabilities.labels || project.api.capabilities.assignees)
+          ? Effect.fail(unsupported("candidates", "labels or assignees"))
+          : project.api
+              .listCandidates({
+                cwd: project.project.workspaceRoot,
+                host: project.host,
+                scope: project.scope,
+              })
+              .pipe(Effect.mapError(toIssueError("candidates"))),
+      ),
+    );
+
+  const create: IssueService["Service"]["create"] = (input) =>
+    requireWritable(input, "create").pipe(
+      Effect.flatMap((project) =>
+        project.api.create === undefined || !project.api.capabilities.create
+          ? Effect.fail(unsupported("create", "filing issues"))
+          : project.api
+              .create({
+                cwd: project.project.workspaceRoot,
+                host: project.host,
+                scope: project.scope,
+                title: input.title,
+                body: input.body,
+                labels: input.labels,
+                assignees: input.assignees,
+              })
+              .pipe(Effect.mapError(toIssueError("create"))),
+      ),
+    );
+
+  const comment: IssueService["Service"]["comment"] = (input) =>
+    requireWritable(input, "comment").pipe(
+      Effect.flatMap((project) => {
+        if (input.body.trim().length === 0) {
+          return Effect.fail(
+            new IssueOperationError({ operation: "comment", detail: "A comment needs some text." }),
+          );
+        }
+        return project.api.comment === undefined || !project.api.capabilities.comment
+          ? Effect.fail(unsupported("comment", "comments"))
+          : project.api
+              .comment({
+                cwd: project.project.workspaceRoot,
+                host: project.host,
+                scope: project.scope,
+                key: input.key,
+                body: input.body,
+              })
+              .pipe(Effect.mapError(toIssueError("comment")));
+      }),
+    );
+
+  const update: IssueService["Service"]["update"] = (input) =>
+    requireWritable(input, "update").pipe(
+      Effect.flatMap((project) => {
+        const { capabilities } = project.api;
+        const wantsWords = input.title !== undefined || input.body !== undefined;
+        if (!wantsWords && input.labels === undefined && input.assignees === undefined) {
+          return Effect.fail(
+            new IssueOperationError({ operation: "update", detail: "Nothing to change." }),
+          );
+        }
+        if (project.api.update === undefined) return Effect.fail(unsupported("update", "edits"));
+        if (wantsWords && !capabilities.edit)
+          return Effect.fail(unsupported("update", "editing the title or body"));
+        if (input.labels !== undefined && !capabilities.labels)
+          return Effect.fail(unsupported("update", "labels"));
+        if (input.assignees !== undefined && !capabilities.assignees)
+          return Effect.fail(unsupported("update", "assignees"));
+        return project.api
+          .update({
+            cwd: project.project.workspaceRoot,
+            host: project.host,
+            scope: project.scope,
+            key: input.key,
+            title: input.title,
+            body: input.body,
+            labels: input.labels,
+            assignees: input.assignees,
+          })
+          .pipe(Effect.mapError(toIssueError("update")));
+      }),
+    );
+
+  const setState: IssueService["Service"]["setState"] = (input) =>
+    requireWritable(input, "setState").pipe(
+      Effect.flatMap((project) => {
+        const { capabilities } = project.api;
+        const target = capabilities.states.find((state) => state.name === input.state);
+        if (project.api.setState === undefined || target === undefined)
+          return Effect.fail(unsupported("setState", `the state "${input.state}"`));
+        if (
+          input.closeReason !== undefined &&
+          (target.category !== "closed" || !capabilities.closeReasons.includes(input.closeReason))
+        )
+          return Effect.fail(unsupported("setState", `the close reason "${input.closeReason}"`));
+        return project.api
+          .setState({
+            cwd: project.project.workspaceRoot,
+            host: project.host,
+            scope: project.scope,
+            key: input.key,
+            state: input.state,
+            closeReason: input.closeReason,
+          })
+          .pipe(Effect.mapError(toIssueError("setState")));
+      }),
+    );
+
+  const react: IssueService["Service"]["react"] = (input) =>
+    requireWritable(input, "react").pipe(
+      Effect.flatMap((project) =>
+        project.api.setReaction === undefined || !project.api.capabilities.reactions
+          ? Effect.fail(unsupported("react", "reactions"))
+          : project.api
+              .setReaction({
+                cwd: project.project.workspaceRoot,
+                host: project.host,
+                scope: project.scope,
+                key: input.key,
+                subjectId: input.subjectId,
+                content: input.content,
+                reacted: input.reacted,
+              })
+              .pipe(Effect.mapError(toIssueError("react"))),
+      ),
+    );
+
+  return IssueService.of({
+    list,
+    detail: traced("detail", detail),
+    comments: traced("comments", comments),
+    templates: traced("templates", templates),
+    candidates: interactive(traced("candidates", candidates)),
+    create: interactive(traced("create", create)),
+    comment: interactive(traced("comment", comment)),
+    update: interactive(traced("update", update)),
+    setState: interactive(traced("setState", setState)),
+    react: interactive(traced("react", react)),
+  });
+});
+
+export const layer = Layer.effect(IssueService, make);
diff --git a/apps/server/src/issue/IssueTrackerRegistry.ts b/apps/server/src/issue/IssueTrackerRegistry.ts
new file mode 100644
index 0000000000000..58e7dbadb0463
--- /dev/null
+++ b/apps/server/src/issue/IssueTrackerRegistry.ts
@@ -0,0 +1,36 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { IssueTrackerKind } from "@t3tools/contracts";
+import type { IssueTrackerApi } from "@t3tools/source-control-core/server/IssueTracker";
+
+import * as BuiltInDrivers from "../sourceControl/builtInDrivers.ts";
+
+export class IssueTrackerRegistry extends Context.Service<
+  IssueTrackerRegistry,
+  {
+    /** Null for a kind with no implementation, which the service reports as unsupported. */
+    readonly get: (kind: IssueTrackerKind) => IssueTrackerApi | null;
+    readonly kinds: ReadonlyArray<IssueTrackerKind>;
+  }
+>()("t3/issue/IssueTrackerRegistry") {}
+
+/** Exported for tests, which stand a registry up from trackers they supply themselves. */
+export function fromTrackers(
+  trackers: ReadonlyArray<IssueTrackerApi>,
+): IssueTrackerRegistry["Service"] {
+  const byKind = new Map(trackers.map((tracker) => [tracker.kind, tracker]));
+  return {
+    get: (kind) => byKind.get(kind) ?? null,
+    kinds: trackers.map((tracker) => tracker.kind),
+  };
+}
+
+const make = Effect.gen(function* () {
+  const drivers = yield* BuiltInDrivers.SourceControlDrivers;
+  return fromTrackers(drivers.flatMap(({ instance }) => instance.issues ?? []));
+});
+
+export const layer = Layer.effect(IssueTrackerRegistry, make).pipe(
+  Layer.provide(BuiltInDrivers.layer),
+);
diff --git a/apps/server/src/observability/RpcInstrumentation.ts b/apps/server/src/observability/RpcInstrumentation.ts
index 4549ee8a33c10..2cd5497c56bd9 100644
--- a/apps/server/src/observability/RpcInstrumentation.ts
+++ b/apps/server/src/observability/RpcInstrumentation.ts
@@ -144,6 +144,16 @@ const RPC_AGGREGATES = {
   [WS_METHODS.pullRequestsRequestReviewers]: "pull-requests",
   [WS_METHODS.pullRequestsLabelCandidates]: "pull-requests",
   [WS_METHODS.pullRequestsSetLabels]: "pull-requests",
+  [WS_METHODS.issuesList]: "issues",
+  [WS_METHODS.issuesDetail]: "issues",
+  [WS_METHODS.issuesComments]: "issues",
+  [WS_METHODS.issuesTemplates]: "issues",
+  [WS_METHODS.issuesCandidates]: "issues",
+  [WS_METHODS.issuesCreate]: "issues",
+  [WS_METHODS.issuesComment]: "issues",
+  [WS_METHODS.issuesUpdate]: "issues",
+  [WS_METHODS.issuesSetState]: "issues",
+  [WS_METHODS.issuesReact]: "issues",
   [WS_METHODS.sourceControlLookupRepository]: "source-control",
   [WS_METHODS.sourceControlCloneRepository]: "source-control",
   [WS_METHODS.sourceControlPublishRepository]: "source-control",
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 30f003bf12891..863444f9d9a4d 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -54,6 +54,8 @@ import { speechHttpApiLayer } from "./speech/http.ts";
 import { speechStreamRouteLayer } from "./speech/stream.ts";
 import * as PullRequestProviderRegistry from "./pullRequest/PullRequestProviderRegistry.ts";
 import * as PullRequestService from "./pullRequest/PullRequestService.ts";
+import * as IssueService from "./issue/IssueService.ts";
+import * as IssueTrackerRegistry from "./issue/IssueTrackerRegistry.ts";
 import * as SqlitePersistence from "./persistence/Sqlite.ts";
 import * as PullRequestFilesViewed from "./persistence/PullRequestFilesViewed.ts";
 import * as PullRequestReviewGuides from "./persistence/PullRequestReviewGuides.ts";
@@ -441,6 +443,8 @@ const layerPullRequestService = PullRequestService.layer.pipe(
   Layer.provide(SourceControlRateLimit.layer),
 );
 
+const layerIssueService = IssueService.layer.pipe(Layer.provide(IssueTrackerRegistry.layer));
+
 const layerGitManager = GitManager.layer.pipe(
   Layer.provide(Layer.merge(ProjectionStoreV2.layer, ProjectStore.layer)),
   Layer.provideMerge(RuntimeLayer.layerProjectSetupScriptRunner),
@@ -862,6 +866,7 @@ const layerMakeRoutes = Layer.mergeAll(
   Layer.provide(PeerLinkRequests.layer),
   // Share the service so HTTP/WS clients single-flight reads and invalidate each other's cached patches.
   Layer.provide(layerPullRequestService),
+  Layer.provide(layerIssueService),
   // The same activity instance RunExecutionService reports to, by layer memoization.
   Layer.provide(
     ServerBrowser.layer.pipe(
diff --git a/apps/server/src/ws.test.ts b/apps/server/src/ws.test.ts
index 660548c1dd68b..31b6fca992e21 100644
--- a/apps/server/src/ws.test.ts
+++ b/apps/server/src/ws.test.ts
@@ -100,6 +100,7 @@ import * as ProviderMaintenanceRunner from "./provider/providerMaintenanceRunner
 import * as ProviderRegistry from "./provider/ProviderRegistry.ts";
 import * as ProviderSessionManager from "./orchestration-v2/ProviderSessionManager.ts";
 import * as PullRequestReviewGuideService from "./pullRequest/PullRequestReviewGuideService.ts";
+import * as IssueService from "./issue/IssueService.ts";
 import * as PullRequestService from "./pullRequest/PullRequestService.ts";
 import * as PullRequestSyncReactor from "./orchestration-v2/PullRequestSyncReactor.ts";
 import * as RelayClient from "@t3tools/shared/relayClient";
@@ -844,6 +845,7 @@ const layerUnusedConfigRpcServices = Layer.mergeAll(
   Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({}),
   Layer.mock(PullRequestReviewGuideService.PullRequestReviewGuideService)({}),
   Layer.mock(PullRequestService.PullRequestService)({}),
+  Layer.mock(IssueService.IssueService)({}),
   Layer.mock(PullRequestSyncReactor.PullRequestSyncReactor)({}),
   Layer.mock(RelayClient.RelayClient)({}),
   Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}),
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 09c6d86c050fd..0439a18188289 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -247,6 +247,7 @@ import * as UsageService from "./usage/UsageService.ts";
 import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts";
 import * as TriageService from "./triage/TriageService.ts";
 import * as PullRequestService from "./pullRequest/PullRequestService.ts";
+import * as IssueService from "./issue/IssueService.ts";
 import * as PullRequestReviewGuideService from "./pullRequest/PullRequestReviewGuideService.ts";
 import { listLinkedPullRequestThreads } from "./pullRequest/linkedThreads.ts";
 import { pullRequestSyncKey } from "./pullRequest/pullRequestSyncKey.ts";
@@ -714,7 +715,13 @@ const ServerWsRpcGroup = WsRpcGroup.middleware(RpcInstrumentation);
 // crosses TypeScript's instantiation limit and the layer's requirements degrade to
 // `any`, so the handlers are registered as two disjoint, smaller groups.
 type ServerWsRpc = RpcGroup.Rpcs<typeof ServerWsRpcGroup>;
-const SPLIT_WS_RPC_PREFIXES = ["server", "pullRequests", "provider", "orchestration"] as const;
+const SPLIT_WS_RPC_PREFIXES = [
+  "server",
+  "pullRequests",
+  "issues",
+  "provider",
+  "orchestration",
+] as const;
 type SplitWsRpc = Extract<
   ServerWsRpc,
   { readonly _tag: `${(typeof SPLIT_WS_RPC_PREFIXES)[number]}.${string}` }
@@ -1472,6 +1479,7 @@ export const layerWsRpc = (
       const secretRequests = yield* SecretRequests.SecretRequests;
       const guestShares = yield* GuestShareService.GuestShareService;
       const pullRequests = yield* PullRequestService.PullRequestService;
+      const issues = yield* IssueService.IssueService;
       const reviewGuides = yield* PullRequestReviewGuideService.PullRequestReviewGuideService;
       const pullRequestSync = yield* PullRequestSyncReactor.PullRequestSyncReactor;
       const deviceService = yield* DeviceService.DeviceService;
@@ -1951,6 +1959,16 @@ export const layerWsRpc = (
       });
 
       const handlers = ServerWsRpcGroup.of({
+        [WS_METHODS.issuesList]: (input) => issues.list(input),
+        [WS_METHODS.issuesDetail]: (input) => issues.detail(input),
+        [WS_METHODS.issuesComments]: (input) => issues.comments(input),
+        [WS_METHODS.issuesTemplates]: (input) => issues.templates(input),
+        [WS_METHODS.issuesCandidates]: (input) => issues.candidates(input),
+        [WS_METHODS.issuesCreate]: (input) => issues.create(input),
+        [WS_METHODS.issuesComment]: (input) => issues.comment(input),
+        [WS_METHODS.issuesUpdate]: (input) => issues.update(input),
+        [WS_METHODS.issuesSetState]: (input) => issues.setState(input),
+        [WS_METHODS.issuesReact]: (input) => issues.react(input),
         [ORCHESTRATION_V2_WS_METHODS.dispatchCommand]: (command) =>
           Effect.annotateCurrentSpan({
             "orchestration_v2.command_id": command.commandId,
@@ -3556,6 +3574,7 @@ export const layer = Layer.unwrap(
     const serverSelfUpdate = yield* ServerSelfUpdate.ServerSelfUpdate;
     const npmRelease = yield* NpmRelease.NpmRelease;
     const pullRequests = yield* PullRequestService.PullRequestService;
+    const issues = yield* IssueService.IssueService;
     const reviewGuides = yield* PullRequestReviewGuideService.PullRequestReviewGuideService;
     const peerLinks = yield* PeerLinks.PeerLinks;
     const peerLinkRequests = yield* PeerLinkRequests.PeerLinkRequests;
@@ -3639,6 +3658,7 @@ export const layer = Layer.unwrap(
               Layer.provide(Layer.succeed(ServerSelfUpdate.ServerSelfUpdate, serverSelfUpdate)),
               // Share server-lifetime PR caches so WS mutations invalidate every client's HTTP diffs.
               Layer.provide(Layer.succeed(PullRequestService.PullRequestService, pullRequests)),
+              Layer.provide(Layer.succeed(IssueService.IssueService, issues)),
               Layer.provide(OtlpEndpointCheck.layer),
               Layer.provide(
                 Layer.succeed(
diff --git a/packages/contracts/src/clientRpcPermissions.ts b/packages/contracts/src/clientRpcPermissions.ts
index 8681c1ea8abeb..f3ff5fa5ab42c 100644
--- a/packages/contracts/src/clientRpcPermissions.ts
+++ b/packages/contracts/src/clientRpcPermissions.ts
@@ -40,6 +40,11 @@ export const CLIENT_GUARDED_RPC_SCOPES = {
   [WS_METHODS.pullRequestsSetFilesViewed]: AuthSourceControlWriteScope,
   [WS_METHODS.pullRequestsRequestReviewers]: AuthSourceControlWriteScope,
   [WS_METHODS.pullRequestsSetLabels]: AuthSourceControlWriteScope,
+  [WS_METHODS.issuesCreate]: AuthSourceControlWriteScope,
+  [WS_METHODS.issuesComment]: AuthSourceControlWriteScope,
+  [WS_METHODS.issuesUpdate]: AuthSourceControlWriteScope,
+  [WS_METHODS.issuesSetState]: AuthSourceControlWriteScope,
+  [WS_METHODS.issuesReact]: AuthSourceControlWriteScope,
   // Writing a guide runs a model on this environment's providers, which reading one does not.
   [WS_METHODS.pullRequestsGenerateReviewGuide]: AuthOrchestrationOperateScope,
   [WS_METHODS.projectsCreateFromThread]: AuthOrchestrationOperateScope,
diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts
index 8dd47df33a21f..c005fdd03900d 100644
--- a/packages/contracts/src/index.ts
+++ b/packages/contracts/src/index.ts
@@ -36,6 +36,7 @@ export * from "./projectClone.ts";
 export * from "./speech.ts";
 export * from "./pullRequest.ts";
 export * from "./pullRequestReviewGuide.ts";
+export * from "./issue.ts";
 export * from "./orchestrationDispatch.ts";
 export * from "./orchestrationProject.ts";
 export * from "./orchestrationV2.ts";
diff --git a/packages/contracts/src/issue.ts b/packages/contracts/src/issue.ts
new file mode 100644
index 0000000000000..936c573c66e06
--- /dev/null
+++ b/packages/contracts/src/issue.ts
@@ -0,0 +1,471 @@
+import * as Schema from "effect/Schema";
+import * as HttpServerRespondable from "effect/http/HttpServerRespondable";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+
+import {
+  IsoDateTime,
+  NonNegativeInt,
+  PositiveInt,
+  ProjectId,
+  TrimmedNonEmptyString,
+} from "./baseSchemas.ts";
+import { PullRequestActor, PullRequestLabel, PullRequestState } from "./pullRequest.ts";
+
+/**
+ * Which tracker an issue lives in. Git hosts reuse their `SourceControlProviderKind` spelling
+ * (`github`, `gitlab`); standalone trackers get their own (`linear`, `jira`). Branded apart from
+ * the source control kind because the two sets are not the same: Bitbucket is a git host with no
+ * tracker, and Linear is a tracker with no git host.
+ */
+export const IssueTrackerKind = TrimmedNonEmptyString.check(
+  Schema.isMaxLength(64),
+  Schema.isPattern(/^[a-z][a-z0-9-]*$/),
+).pipe(Schema.brand("IssueTrackerKind"));
+export type IssueTrackerKind = typeof IssueTrackerKind.Type;
+
+export const IssueActor = PullRequestActor;
+export type IssueActor = typeof IssueActor.Type;
+
+export const IssueLabel = PullRequestLabel;
+export type IssueLabel = typeof IssueLabel.Type;
+
+/**
+ * Where an issue stands, in two parts: the category every tracker has, and the name this tracker
+ * gives it. GitHub only has the two; Linear and Jira have a workflow of their own ("In Review",
+ * "Backlog"), which `name` carries verbatim so the page can show the tracker's word while every
+ * filter and badge keys off `category`.
+ */
+export const IssueStateCategory = Schema.Literals(["open", "closed"]);
+export type IssueStateCategory = typeof IssueStateCategory.Type;
+
+export const IssueState = Schema.Struct({
+  category: IssueStateCategory,
+  name: TrimmedNonEmptyString,
+  /** Why it was closed, where the tracker records one (GitHub: `completed` / `not-planned`). */
+  closeReason: Schema.optional(TrimmedNonEmptyString),
+});
+export type IssueState = typeof IssueState.Type;
+
+/** What a listing asks for: either category, or both. */
+export const IssueListState = Schema.Literals(["all", "open", "closed"]);
+export type IssueListState = typeof IssueListState.Type;
+
+export const IssueInvolvement = Schema.Literals(["all", "assigned", "authored", "mentioned"]);
+export type IssueInvolvement = typeof IssueInvolvement.Type;
+
+export const IssueReactionContent = Schema.Literals([
+  "thumbs-up",
+  "thumbs-down",
+  "laugh",
+  "hooray",
+  "confused",
+  "heart",
+  "rocket",
+  "eyes",
+]);
+export type IssueReactionContent = typeof IssueReactionContent.Type;
+
+export const IssueReaction = Schema.Struct({
+  content: IssueReactionContent,
+  count: PositiveInt,
+  /** Who reacted, as far as the tracker named them; the viewer is left out and shown as "You". */
+  actors: Schema.Array(TrimmedNonEmptyString),
+  viewerHasReacted: Schema.Boolean,
+});
+export type IssueReaction = typeof IssueReaction.Type;
+
+/**
+ * Addresses one issue: `scope` is the tracker's own container (`owner/repo`, a team key) and
+ * `key` the issue's native id in it. `host` is absent for the kind's public host. `projectId`
+ * names the project whose credentials serve the read, which need not own the issue.
+ */
+export const IssueRef = Schema.Struct({
+  projectId: ProjectId,
+  tracker: IssueTrackerKind,
+  host: Schema.optional(TrimmedNonEmptyString),
+  scope: TrimmedNonEmptyString,
+  key: TrimmedNonEmptyString,
+});
+export type IssueRef = typeof IssueRef.Type;
+
+/** A scope with no issue in it, for reads about the container itself: templates, candidates. */
+export const IssueScopeRef = Schema.Struct({
+  projectId: ProjectId,
+  tracker: IssueTrackerKind,
+  host: Schema.optional(TrimmedNonEmptyString),
+  scope: TrimmedNonEmptyString,
+});
+export type IssueScopeRef = typeof IssueScopeRef.Type;
+
+/** One row of a listing. Carries everything a list needs and nothing a detail needs. */
+export const IssueSummary = Schema.Struct({
+  tracker: IssueTrackerKind,
+  host: TrimmedNonEmptyString,
+  scope: TrimmedNonEmptyString,
+  key: TrimmedNonEmptyString,
+  /** How the tracker writes the key for people: `#123` on a git host, `ENG-123` on Linear. */
+  displayKey: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  url: TrimmedNonEmptyString,
+  author: Schema.NullOr(IssueActor),
+  state: IssueState,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  closedAt: Schema.NullOr(IsoDateTime),
+  assignees: Schema.Array(IssueActor),
+  labels: Schema.Array(IssueLabel),
+  commentCount: NonNegativeInt,
+});
+export type IssueSummary = typeof IssueSummary.Type;
+
+export const IssueListEntry = Schema.Struct({
+  ...IssueSummary.fields,
+  projectId: ProjectId,
+  projectTitle: TrimmedNonEmptyString,
+});
+export type IssueListEntry = typeof IssueListEntry.Type;
+
+export const IssueComment = Schema.Struct({
+  id: TrimmedNonEmptyString,
+  author: Schema.NullOr(IssueActor),
+  body: Schema.String,
+  createdAt: IsoDateTime,
+  url: Schema.NullOr(Schema.String),
+  /** Absent from a tracker with no reactions, which differs from none on this comment. */
+  reactions: Schema.optional(Schema.Array(IssueReaction)),
+});
+export type IssueComment = typeof IssueComment.Type;
+
+/**
+ * Something that happened to an issue that nobody wrote words for: it was closed, labelled,
+ * assigned, renamed. Kinds are the common vocabulary; a tracker drops what it cannot map rather
+ * than guessing.
+ */
+export const IssueEventKind = Schema.Literals([
+  "closed",
+  "reopened",
+  "labeled",
+  "unlabeled",
+  "assigned",
+  "unassigned",
+  "renamed",
+  "referenced",
+  "state-changed",
+]);
+export type IssueEventKind = typeof IssueEventKind.Type;
+
+export const IssueEvent = Schema.Struct({
+  id: TrimmedNonEmptyString,
+  kind: IssueEventKind,
+  actor: Schema.NullOr(IssueActor),
+  createdAt: IsoDateTime,
+  /** What the event was about, where it has a subject: a label name, a login, a new title. */
+  detail: Schema.NullOr(TrimmedNonEmptyString),
+});
+export type IssueEvent = typeof IssueEvent.Type;
+
+/** A change request the tracker says closes or mentions this issue. */
+export const IssueLinkedPullRequest = Schema.Struct({
+  repository: TrimmedNonEmptyString,
+  number: PositiveInt,
+  title: TrimmedNonEmptyString,
+  url: TrimmedNonEmptyString,
+  state: PullRequestState,
+  isDraft: Schema.Boolean,
+  /** Merging it closes this issue, rather than only citing it. */
+  closesIssue: Schema.Boolean,
+});
+export type IssueLinkedPullRequest = typeof IssueLinkedPullRequest.Type;
+
+/**
+ * What a tracker can do at all, so a surface never offers an action that would fail. The
+ * service refuses a call outside these before it reaches the driver.
+ */
+export const IssueCapabilities = Schema.Struct({
+  create: Schema.Boolean,
+  /** Title and body can be rewritten after filing. */
+  edit: Schema.Boolean,
+  comment: Schema.Boolean,
+  labels: Schema.Boolean,
+  assignees: Schema.Boolean,
+  /** Reactions can be read and written on the issue and its comments. */
+  reactions: Schema.Boolean,
+  /** The scope offers starting points for a new issue. */
+  templates: Schema.Boolean,
+  /** The tracker reports linked change requests of its own accord. */
+  linkedPullRequests: Schema.Boolean,
+  /** State changes arrive as events beside the comments, not only as comments. */
+  events: Schema.Boolean,
+  /** The tracker narrows a listing by free text itself. */
+  search: Schema.Boolean,
+  /**
+   * The states this tracker can be asked to move an issue into, by name. A git host offers
+   * `open` and `closed`; a workflow tracker offers its own columns. Empty means state cannot be
+   * changed from here.
+   */
+  states: Schema.Array(IssueState),
+  /** Reasons a close can carry. Empty means a close takes none. */
+  closeReasons: Schema.Array(TrimmedNonEmptyString),
+});
+export type IssueCapabilities = typeof IssueCapabilities.Type;
+
+/**
+ * What the signed-in account may do with this issue, which `capabilities` says nothing about.
+ * A permission the tracker reports nothing about is granted, so a refusal comes from the
+ * tracker, which says why, rather than from a missing control.
+ */
+export const IssueViewerPermissions = Schema.Struct({
+  setState: Schema.Boolean,
+  comment: Schema.Boolean,
+  edit: Schema.Boolean,
+  labels: Schema.Boolean,
+  assignees: Schema.Boolean,
+});
+export type IssueViewerPermissions = typeof IssueViewerPermissions.Type;
+
+export const IssueDetail = Schema.Struct({
+  ...IssueSummary.fields,
+  projectId: ProjectId,
+  projectTitle: TrimmedNonEmptyString,
+  /** False for an issue outside every project's scope, which is read-only through this server. */
+  writable: Schema.Boolean,
+  capabilities: IssueCapabilities,
+  viewerPermissions: IssueViewerPermissions,
+  /** The signed-in account, so a comment edit is offered only on the viewer's own remarks. */
+  viewer: Schema.NullOr(TrimmedNonEmptyString),
+  body: Schema.String,
+  reactions: Schema.optional(Schema.Array(IssueReaction)),
+  comments: Schema.Array(IssueComment),
+  /** Where older comments carry on; null once the conversation is whole. */
+  commentsCursor: Schema.NullOr(TrimmedNonEmptyString),
+  events: Schema.Array(IssueEvent),
+  linkedPullRequests: Schema.Array(IssueLinkedPullRequest),
+});
+export type IssueDetail = typeof IssueDetail.Type;
+
+/** Older comments, one page past a cursor the detail or a previous page handed over. */
+export const IssueCommentsPageInput = Schema.Struct({
+  ...IssueRef.fields,
+  cursor: TrimmedNonEmptyString.check(Schema.isMaxLength(4_096)),
+});
+export type IssueCommentsPageInput = typeof IssueCommentsPageInput.Type;
+
+export const IssueCommentsPage = Schema.Struct({
+  comments: Schema.Array(IssueComment),
+  nextCursor: Schema.NullOr(TrimmedNonEmptyString),
+});
+export type IssueCommentsPage = typeof IssueCommentsPage.Type;
+
+/** Where each scope a listing already reached carries on, keyed `"<host> <scope>"`. */
+export const IssueListCursors = Schema.Record(
+  TrimmedNonEmptyString,
+  TrimmedNonEmptyString.check(Schema.isMaxLength(4_096)),
+);
+export type IssueListCursors = typeof IssueListCursors.Type;
+
+export const IssueListInput = Schema.Struct({
+  state: IssueListState,
+  involvement: Schema.optional(IssueInvolvement),
+  projectId: Schema.optional(ProjectId),
+  /** Narrows to one host, named as the host itself. Absent means every host the workspace has. */
+  host: Schema.optional(TrimmedNonEmptyString),
+  /** Rows per scope, which with a continuation is rows per slice. */
+  limit: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 200 }))),
+  /** Carry on from an earlier answer: only the scopes named here are read, one slice each. */
+  cursors: Schema.optional(IssueListCursors),
+  /** Free text the trackers themselves are asked to match. */
+  query: Schema.optional(TrimmedNonEmptyString.check(Schema.isMaxLength(200))),
+});
+export type IssueListInput = typeof IssueListInput.Type;
+
+/** One tracker account the workspace has projects on, and whether it can be read right now. */
+export const IssueTrackerSummary = Schema.Struct({
+  tracker: IssueTrackerKind,
+  host: TrimmedNonEmptyString,
+  projectCount: PositiveInt,
+  capabilities: Schema.NullOr(IssueCapabilities),
+  /** False when the tracker's tool or credentials are missing, with `detail` saying which. */
+  configured: Schema.Boolean,
+  detail: Schema.NullOr(TrimmedNonEmptyString),
+});
+export type IssueTrackerSummary = typeof IssueTrackerSummary.Type;
+
+export const IssueListProjectError = Schema.Struct({
+  projectId: ProjectId,
+  projectTitle: TrimmedNonEmptyString,
+  message: TrimmedNonEmptyString,
+});
+export type IssueListProjectError = typeof IssueListProjectError.Type;
+
+export const IssueListResult = Schema.Struct({
+  /** The signed-in account per host, which is what involvement compares against. */
+  viewers: Schema.Record(TrimmedNonEmptyString, TrimmedNonEmptyString),
+  trackers: Schema.Array(IssueTrackerSummary),
+  /** By update, newest first, across every scope this answer covers. */
+  entries: Schema.Array(IssueListEntry),
+  errors: Schema.Array(IssueListProjectError),
+  /** Where each scope carries on, sent straight back as `cursors`. Absent once a scope is done. */
+  nextCursors: IssueListCursors,
+});
+export type IssueListResult = typeof IssueListResult.Type;
+
+const IssueTitle = TrimmedNonEmptyString.check(Schema.isMaxLength(1024));
+// Not trimmed: a body is markdown, where leading spaces open a code block. The bound keeps
+// oversized payloads off the wire; the service rejects a comment that is only whitespace.
+const IssueBody = Schema.String.check(Schema.isMaxLength(65_536));
+const CommentBody = Schema.String.check(Schema.isNonEmpty()).check(Schema.isMaxLength(65_536));
+
+export const IssueCreateInput = Schema.Struct({
+  ...IssueScopeRef.fields,
+  title: IssueTitle,
+  /** May be empty: an issue with a title and nothing else is a legitimate one. */
+  body: IssueBody,
+  labels: Schema.Array(TrimmedNonEmptyString).check(Schema.isMaxLength(50)),
+  assignees: Schema.Array(TrimmedNonEmptyString).check(Schema.isMaxLength(25)),
+});
+export type IssueCreateInput = typeof IssueCreateInput.Type;
+
+export const IssueCreateResult = Schema.Struct({
+  key: TrimmedNonEmptyString,
+  displayKey: TrimmedNonEmptyString,
+  url: TrimmedNonEmptyString,
+});
+export type IssueCreateResult = typeof IssueCreateResult.Type;
+
+export const IssueCommentInput = Schema.Struct({
+  ...IssueRef.fields,
+  body: CommentBody,
+});
+export type IssueCommentInput = typeof IssueCommentInput.Type;
+
+/**
+ * Rewrites the issue's own fields. Every field is optional and only the present ones are
+ * written; `labels` and `assignees` are the whole set, which is how every tracker writes them.
+ * The service refuses a request with nothing present.
+ */
+export const IssueUpdateInput = Schema.Struct({
+  ...IssueRef.fields,
+  title: Schema.optional(IssueTitle),
+  body: Schema.optional(IssueBody),
+  labels: Schema.optional(Schema.Array(TrimmedNonEmptyString).check(Schema.isMaxLength(50))),
+  assignees: Schema.optional(Schema.Array(TrimmedNonEmptyString).check(Schema.isMaxLength(25))),
+});
+export type IssueUpdateInput = typeof IssueUpdateInput.Type;
+
+/** Moves the issue to one of the states the tracker declared in `capabilities.states`. */
+export const IssueSetStateInput = Schema.Struct({
+  ...IssueRef.fields,
+  state: TrimmedNonEmptyString,
+  /** Only meaningful for a closing state on a tracker that declared `closeReasons`. */
+  closeReason: Schema.optional(TrimmedNonEmptyString),
+});
+export type IssueSetStateInput = typeof IssueSetStateInput.Type;
+
+export const IssueReactionInput = Schema.Struct({
+  ...IssueRef.fields,
+  /** Absent reacts to the issue itself; present names a comment id as the detail carried it. */
+  subjectId: Schema.optional(TrimmedNonEmptyString),
+  content: IssueReactionContent,
+  reacted: Schema.Boolean,
+});
+export type IssueReactionInput = typeof IssueReactionInput.Type;
+
+/**
+ * One starting point a scope offers for a new issue. Only the body-shaped kind travels here:
+ * GitHub's typed issue forms are flattened to a body by the driver, so a composer on any
+ * tracker is one text box with a draft in it.
+ */
+export const IssueTemplate = Schema.Struct({
+  key: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  about: Schema.String,
+  title: Schema.String,
+  body: Schema.String,
+  labels: Schema.Array(TrimmedNonEmptyString),
+  assignees: Schema.Array(TrimmedNonEmptyString),
+});
+export type IssueTemplate = typeof IssueTemplate.Type;
+
+export const IssueTemplateList = Schema.Struct({
+  templates: Schema.Array(IssueTemplate),
+  /** False where the scope's config forbids an issue filed from nothing. */
+  blankIssuesEnabled: Schema.Boolean,
+});
+export type IssueTemplateList = typeof IssueTemplateList.Type;
+
+export const IssueLabelCandidate = Schema.Struct({
+  ...IssueLabel.fields,
+  description: Schema.NullOr(Schema.String),
+});
+export type IssueLabelCandidate = typeof IssueLabelCandidate.Type;
+
+export const IssueAssigneeCandidate = Schema.Struct({
+  ...IssueActor.fields,
+  /** How the tracker addresses this person on a write, which is not always the login. */
+  id: TrimmedNonEmptyString,
+});
+export type IssueAssigneeCandidate = typeof IssueAssigneeCandidate.Type;
+
+/** The labels and people a scope offers, read when a picker opens rather than with every issue. */
+export const IssueCandidates = Schema.Struct({
+  labels: Schema.Array(IssueLabelCandidate),
+  assignees: Schema.Array(IssueAssigneeCandidate),
+  /** The tracker has more than were read, so somebody missing is not necessarily ineligible. */
+  truncated: Schema.Boolean,
+});
+export type IssueCandidates = typeof IssueCandidates.Type;
+
+export const IssueUnavailableReason = Schema.Literals([
+  "tool-missing",
+  "unauthenticated",
+  "tracker-unsupported",
+]);
+export type IssueUnavailableReason = typeof IssueUnavailableReason.Type;
+
+/** The tracker cannot be read at all for this project, as opposed to one request failing. */
+export class IssueUnavailableError extends Schema.TaggedError<IssueUnavailableError>()(
+  "IssueUnavailableError",
+  {
+    reason: IssueUnavailableReason,
+    tracker: Schema.optional(IssueTrackerKind),
+    cause: Schema.optional(Schema.Defect()),
+  },
+  { httpApiStatus: 503 },
+) {
+  [HttpServerRespondable.symbol]() {
+    return HttpServerResponse.schemaJson(IssueUnavailableError)(this, { status: 503 });
+  }
+
+  override get message(): string {
+    switch (this.reason) {
+      case "tool-missing":
+        return "The tool this tracker is read through is not installed or set up.";
+      case "unauthenticated":
+        return "This tracker has no working credentials.";
+      case "tracker-unsupported":
+        return "Issues cannot be browsed for this project yet.";
+    }
+  }
+}
+
+export class IssueOperationError extends Schema.TaggedError<IssueOperationError>()(
+  "IssueOperationError",
+  {
+    operation: Schema.String,
+    detail: TrimmedNonEmptyString,
+    reason: Schema.optional(Schema.Literals(["not-found", "read-only", "rate-limited"])),
+    retryAt: Schema.optional(Schema.Number),
+    cause: Schema.optional(Schema.Defect()),
+  },
+  { httpApiStatus: 502 },
+) {
+  [HttpServerRespondable.symbol]() {
+    return HttpServerResponse.schemaJson(IssueOperationError)(this, { status: 502 });
+  }
+
+  override get message(): string {
+    return `Issue operation ${this.operation} failed: ${this.detail}`;
+  }
+}
+
+export type IssueError = IssueUnavailableError | IssueOperationError;
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index e1d392cd080b6..2d4e057b7ae01 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -169,6 +169,25 @@ import {
   ProviderUploadFeedbackResult,
 } from "./provider.ts";
 import { ProviderInstanceId, ProviderInstanceMutation } from "./providerInstance.ts";
+import {
+  IssueCandidates,
+  IssueCommentInput,
+  IssueCommentsPage,
+  IssueCommentsPageInput,
+  IssueCreateInput,
+  IssueCreateResult,
+  IssueDetail,
+  IssueListInput,
+  IssueListResult,
+  IssueOperationError,
+  IssueReactionInput,
+  IssueRef,
+  IssueScopeRef,
+  IssueSetStateInput,
+  IssueTemplateList,
+  IssueUnavailableError,
+  IssueUpdateInput,
+} from "./issue.ts";
 import {
   GuestShareCreateError,
   GuestShareCreateInput,
@@ -602,6 +621,18 @@ export const WS_METHODS = {
   pullRequestsLabelCandidates: "pullRequests.labelCandidates",
   pullRequestsSetLabels: "pullRequests.setLabels",
 
+  // Issue tracking methods
+  issuesList: "issues.list",
+  issuesDetail: "issues.detail",
+  issuesComments: "issues.comments",
+  issuesTemplates: "issues.templates",
+  issuesCandidates: "issues.candidates",
+  issuesCreate: "issues.create",
+  issuesComment: "issues.comment",
+  issuesUpdate: "issues.update",
+  issuesSetState: "issues.setState",
+  issuesReact: "issues.react",
+
   sourceControlLookupRepository: "sourceControl.lookupRepository",
   sourceControlCloneRepository: "sourceControl.cloneRepository",
   sourceControlPublishRepository: "sourceControl.publishRepository",
@@ -1283,6 +1314,74 @@ const WsPullRequestsSetLabelsRpc = Rpc.make(WS_METHODS.pullRequestsSetLabels, {
   error: PullRequestRpcError,
 });
 
+const IssueRpcError = Schema.Union([
+  IssueUnavailableError,
+  IssueOperationError,
+  EnvironmentAuthorizationError,
+]);
+
+const WsIssuesListRpc = Rpc.make(WS_METHODS.issuesList, {
+  payload: IssueListInput,
+  success: IssueListResult,
+  error: IssueRpcError,
+});
+
+const WsIssuesDetailRpc = Rpc.make(WS_METHODS.issuesDetail, {
+  payload: IssueRef,
+  success: IssueDetail,
+  error: IssueRpcError,
+});
+
+/** Older comments, one page at a time, past the cursor the detail handed over. */
+const WsIssuesCommentsRpc = Rpc.make(WS_METHODS.issuesComments, {
+  payload: IssueCommentsPageInput,
+  success: IssueCommentsPage,
+  error: IssueRpcError,
+});
+
+const WsIssuesTemplatesRpc = Rpc.make(WS_METHODS.issuesTemplates, {
+  payload: IssueScopeRef,
+  success: IssueTemplateList,
+  error: IssueRpcError,
+});
+
+/** Read when a label or assignee picker opens, not with every issue. */
+const WsIssuesCandidatesRpc = Rpc.make(WS_METHODS.issuesCandidates, {
+  payload: IssueScopeRef,
+  success: IssueCandidates,
+  error: IssueRpcError,
+});
+
+const WsIssuesCreateRpc = Rpc.make(WS_METHODS.issuesCreate, {
+  payload: IssueCreateInput,
+  success: IssueCreateResult,
+  error: IssueRpcError,
+});
+
+const WsIssuesCommentRpc = Rpc.make(WS_METHODS.issuesComment, {
+  payload: IssueCommentInput,
+  success: Schema.Void,
+  error: IssueRpcError,
+});
+
+const WsIssuesUpdateRpc = Rpc.make(WS_METHODS.issuesUpdate, {
+  payload: IssueUpdateInput,
+  success: Schema.Void,
+  error: IssueRpcError,
+});
+
+const WsIssuesSetStateRpc = Rpc.make(WS_METHODS.issuesSetState, {
+  payload: IssueSetStateInput,
+  success: Schema.Void,
+  error: IssueRpcError,
+});
+
+const WsIssuesReactRpc = Rpc.make(WS_METHODS.issuesReact, {
+  payload: IssueReactionInput,
+  success: Schema.Void,
+  error: IssueRpcError,
+});
+
 const WsSourceControlLookupRepositoryRpc = Rpc.make(WS_METHODS.sourceControlLookupRepository, {
   payload: SourceControlRepositoryLookupInput,
   success: SourceControlRepositoryInfo,
@@ -2111,6 +2210,16 @@ export class RpcScopeAuthorization extends RpcMiddleware.Service<RpcScopeAuthori
 ) {}
 
 export const WsRpcGroup = RpcGroup.make(
+  WsIssuesListRpc,
+  WsIssuesDetailRpc,
+  WsIssuesCommentsRpc,
+  WsIssuesTemplatesRpc,
+  WsIssuesCandidatesRpc,
+  WsIssuesCreateRpc,
+  WsIssuesCommentRpc,
+  WsIssuesUpdateRpc,
+  WsIssuesSetStateRpc,
+  WsIssuesReactRpc,
   WsGuestShareCreateRpc,
   WsServerProbeRpc,
   WsServerGetConfigRpc,
diff --git a/packages/source-control-core/package.json b/packages/source-control-core/package.json
index b16f16d10f4d4..91ba8f9216977 100644
--- a/packages/source-control-core/package.json
+++ b/packages/source-control-core/package.json
@@ -35,6 +35,10 @@
       "types": "./src/server/pullRequestChecks.ts",
       "import": "./src/server/pullRequestChecks.ts"
     },
+    "./server/IssueTracker": {
+      "types": "./src/server/IssueTracker.ts",
+      "import": "./src/server/IssueTracker.ts"
+    },
     "./server/PullRequestProvider": {
       "types": "./src/server/PullRequestProvider.ts",
       "import": "./src/server/PullRequestProvider.ts"
diff --git a/packages/source-control-core/src/server/IssueTracker.ts b/packages/source-control-core/src/server/IssueTracker.ts
new file mode 100644
index 0000000000000..6d71c2f626b04
--- /dev/null
+++ b/packages/source-control-core/src/server/IssueTracker.ts
@@ -0,0 +1,178 @@
+/**
+ * The port every issue tracker implements. A tracker hands back the neutral contract types and
+ * declares what it cannot do in `capabilities`; the service refuses a call outside them.
+ */
+import * as Schema from "effect/Schema";
+import type * as Effect from "effect/Effect";
+import type {
+  IssueCandidates,
+  IssueCapabilities,
+  IssueComment,
+  IssueCommentsPage,
+  IssueCreateResult,
+  IssueEvent,
+  IssueInvolvement,
+  IssueLinkedPullRequest,
+  IssueListState,
+  IssueReaction,
+  IssueReactionContent,
+  IssueSummary,
+  IssueTemplateList,
+  IssueTrackerKind,
+  IssueViewerPermissions,
+} from "@t3tools/contracts";
+import { IssueTrackerKind as IssueTrackerKindSchema } from "@t3tools/contracts";
+
+/**
+ * The one failure shape every tracker reports, so the service can decide what a failure means
+ * without knowing which CLI or API produced it. A missing or unauthenticated tool disables the
+ * tracker for the whole workspace; everything else is specific to the request.
+ */
+export class IssueTrackerError extends Schema.TaggedError<IssueTrackerError>()(
+  "IssueTrackerError",
+  {
+    tracker: IssueTrackerKindSchema,
+    operation: Schema.String,
+    reason: Schema.Literals([
+      "missing-tool",
+      "unauthenticated",
+      "rate-limited",
+      "not-found",
+      "failed",
+    ]),
+    detail: Schema.String,
+    retryAt: Schema.optional(Schema.Number),
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {
+  override get message(): string {
+    return `${this.tracker} failed in ${this.operation}: ${this.detail}`;
+  }
+}
+
+/**
+ * Where a tracker's issues are addressed from. `cwd` is a checkout whose credentials serve the
+ * read; `host` is where the tracker is served from (`github.com`, a GHE install, `linear.app`);
+ * `scope` is the tracker's own container — a repository path, a team or project key.
+ */
+export interface IssueScopeTarget {
+  readonly cwd: string;
+  readonly host: string;
+  readonly scope: string;
+}
+
+export interface IssueTarget extends IssueScopeTarget {
+  /** The issue's native id within the scope: `"123"` on GitHub, `"ENG-123"` on Linear. */
+  readonly key: string;
+}
+
+/** An issue as the tracker sees it, before the service attaches project context. */
+export type TrackerIssueSummary = Omit<IssueSummary, "tracker" | "host" | "scope">;
+
+export interface TrackerIssuePage {
+  readonly items: ReadonlyArray<TrackerIssueSummary>;
+  /** Where the next slice starts, or null once the tracker has nothing more. Opaque. */
+  readonly nextCursor: string | null;
+}
+
+export interface TrackerIssueDetail extends TrackerIssueSummary {
+  readonly body: string;
+  readonly viewer: string | null;
+  readonly viewerPermissions: IssueViewerPermissions;
+  readonly reactions?: ReadonlyArray<IssueReaction>;
+  readonly comments: ReadonlyArray<IssueComment>;
+  /** Where older comments carry on; null once the conversation is whole. */
+  readonly commentsCursor: string | null;
+  readonly events: ReadonlyArray<IssueEvent>;
+  readonly linkedPullRequests: ReadonlyArray<IssueLinkedPullRequest>;
+}
+
+export interface IssueTrackerApi {
+  readonly kind: IssueTrackerKind;
+  readonly capabilities: IssueCapabilities;
+
+  /** The signed-in account, which is what involvement filtering compares against. */
+  readonly getViewer: (input: {
+    readonly cwd: string;
+    readonly host: string;
+  }) => Effect.Effect<string, IssueTrackerError>;
+
+  readonly listIssues: (
+    input: IssueScopeTarget & {
+      readonly state: IssueListState;
+      readonly involvement: IssueInvolvement;
+      readonly viewer: string;
+      readonly limit: number;
+      /** Free text as the tracker understands it; ignored by a tracker without `search`. */
+      readonly query?: string | undefined;
+      /** A cursor this tracker handed back from an earlier page. Absent asks for the first. */
+      readonly cursor?: string | undefined;
+    },
+  ) => Effect.Effect<TrackerIssuePage, IssueTrackerError>;
+
+  /** The issue with its first page of conversation, in one read where the tracker allows. */
+  readonly getIssue: (input: IssueTarget) => Effect.Effect<TrackerIssueDetail, IssueTrackerError>;
+
+  /** One page of older comments past a cursor `getIssue` or a previous page handed over. */
+  readonly getComments: (
+    input: IssueTarget & { readonly cursor: string },
+  ) => Effect.Effect<IssueCommentsPage, IssueTrackerError>;
+
+  /** Only called when `capabilities.create` is true. */
+  readonly create?: (
+    input: IssueScopeTarget & {
+      readonly title: string;
+      readonly body: string;
+      readonly labels: ReadonlyArray<string>;
+      readonly assignees: ReadonlyArray<string>;
+    },
+  ) => Effect.Effect<IssueCreateResult, IssueTrackerError>;
+
+  /** Only called when `capabilities.comment` is true. */
+  readonly comment?: (
+    input: IssueTarget & { readonly body: string },
+  ) => Effect.Effect<void, IssueTrackerError>;
+
+  /**
+   * Rewrites the present fields. Only called with a field the tracker declared it can write
+   * (`edit` for title and body, `labels`, `assignees`), and never with all of them absent.
+   */
+  readonly update?: (
+    input: IssueTarget & {
+      readonly title?: string | undefined;
+      readonly body?: string | undefined;
+      readonly labels?: ReadonlyArray<string> | undefined;
+      readonly assignees?: ReadonlyArray<string> | undefined;
+    },
+  ) => Effect.Effect<void, IssueTrackerError>;
+
+  /** Only called with a state name from `capabilities.states`. */
+  readonly setState?: (
+    input: IssueTarget & {
+      readonly state: string;
+      readonly closeReason?: string | undefined;
+    },
+  ) => Effect.Effect<void, IssueTrackerError>;
+
+  /**
+   * Adds a reaction or takes it back. `subjectId` is a comment id as the detail carried it;
+   * absent means the issue itself. Only called when `capabilities.reactions` is true.
+   */
+  readonly setReaction?: (
+    input: IssueTarget & {
+      readonly subjectId?: string | undefined;
+      readonly content: IssueReactionContent;
+      readonly reacted: boolean;
+    },
+  ) => Effect.Effect<void, IssueTrackerError>;
+
+  /** Only called when `capabilities.templates` is true. */
+  readonly listTemplates?: (
+    input: IssueScopeTarget,
+  ) => Effect.Effect<IssueTemplateList, IssueTrackerError>;
+
+  /** Only called when `capabilities.labels` or `capabilities.assignees` is true. */
+  readonly listCandidates?: (
+    input: IssueScopeTarget,
+  ) => Effect.Effect<IssueCandidates, IssueTrackerError>;
+}
diff --git a/packages/source-control-core/src/server/driver.ts b/packages/source-control-core/src/server/driver.ts
index c4fb4106a2054..7f86d0fff3b9e 100644
--- a/packages/source-control-core/src/server/driver.ts
+++ b/packages/source-control-core/src/server/driver.ts
@@ -15,6 +15,7 @@ import type * as Scope from "effect/Scope";
 import type { SourceControlDefinition } from "../shared/definition.ts";
 
 import type { SourceControlProviderDiscoverySpec } from "./discovery.ts";
+import type { IssueTrackerApi } from "./IssueTracker.ts";
 import type { PullRequestProviderApi } from "./PullRequestProvider.ts";
 import type * as SourceControlHost from "./SourceControlHost.ts";
 import type * as SourceControlProvider from "./SourceControlProvider.ts";
@@ -53,6 +54,8 @@ export interface SourceControlDriverInstance {
   readonly discovery: SourceControlProviderDiscoverySpec;
   /** Null for a host whose pull requests this build cannot read. */
   readonly pullRequests: PullRequestProviderApi | null;
+  /** Absent for a host whose issues this build cannot read. */
+  readonly issues?: IssueTrackerApi;
   /**
    * Fetches media the definition's `mediaUrl` claimed, with the credential the host serves it
    * to. Null when the fetch went nowhere a response could come from, such as a redirect loop.
diff --git a/packages/source-control-core/src/shared/definition.ts b/packages/source-control-core/src/shared/definition.ts
index 167d89a67f878..a37878af7d431 100644
--- a/packages/source-control-core/src/shared/definition.ts
+++ b/packages/source-control-core/src/shared/definition.ts
@@ -341,6 +341,11 @@ export interface SourceControlDefinition {
    * path, `owner/name`.
    */
   readonly repositorySelector?: (identity: RepositorySelectorIdentity) => string | null;
+  /**
+   * The container the project's issues live in, where that is not its repository: Azure DevOps
+   * keeps work items per project. Null when the repository cannot be placed.
+   */
+  readonly issueScope?: (identity: RepositorySelectorIdentity) => string | null;
   /**
    * The key of a remote's lower case `host/path`, `.git` suffix kept, for a host that spells it
    * apart from `normalizeGitRemoteUrl`: over SSH and the web, or with `.git` as part of the name.
@@ -660,6 +665,8 @@ export interface SourceControlDefinitionRegistry {
   readonly repositorySelector: (
     identity: RepositorySelectorIdentity | null | undefined,
   ) => string | null;
+  /** Where the project's issues live: the host's `issueScope`, else its repository. */
+  readonly issueScope: (identity: RepositorySelectorIdentity | null | undefined) => string | null;
   readonly changeRequestHost: <const Kind extends string | undefined>(
     identity: ChangeRequestHostIdentity,
     kind: Kind,
@@ -725,6 +732,10 @@ export function makeSourceControlDefinitionRegistry(
   };
   const remoteOwner = (remote: GitRemoteHost) =>
     recognitionOrder.find((definition) => definition.recognizeRemote(remote) !== null);
+  const repositorySelector = (identity: RepositorySelectorIdentity | null | undefined) =>
+    identity?.provider === undefined
+      ? defaultRepositorySelector(identity)
+      : (byKind.get(identity.provider)?.repositorySelector ?? defaultRepositorySelector)(identity);
   const parseChangeRequestUrl = (value: string): ParsedChangeRequest | null => {
     const url = httpUrl(value);
     if (url === null) return null;
@@ -825,12 +836,14 @@ export function makeSourceControlDefinitionRegistry(
     },
     canonicalRepositoryKey: (key) => repositoryKeyOwner(key)?.canonical ?? canonicalKeyPath(key),
     findByRepositoryKey: (key) => repositoryKeyOwner(key)?.definition,
-    repositorySelector: (identity) =>
-      identity?.provider === undefined
-        ? defaultRepositorySelector(identity)
-        : (byKind.get(identity.provider)?.repositorySelector ?? defaultRepositorySelector)(
-            identity,
-          ),
+    repositorySelector,
+    issueScope: (identity) => {
+      const issueScope =
+        identity?.provider === undefined ? undefined : byKind.get(identity.provider)?.issueScope;
+      return issueScope === undefined || identity == null
+        ? repositorySelector(identity)
+        : issueScope(identity);
+    },
     changeRequestHost: (identity, kind) =>
       (kind === undefined ? undefined : byKind.get(kind)?.changeRequestHost?.(identity)) ??
       projectChangeRequestHost(identity, kind),
diff --git a/packages/source-control-github/package.json b/packages/source-control-github/package.json
index 61e4476bb2517..3fe7980d737ae 100644
--- a/packages/source-control-github/package.json
+++ b/packages/source-control-github/package.json
@@ -23,7 +23,8 @@
     "@t3tools/provider-core": "workspace:*",
     "@t3tools/shared": "workspace:*",
     "@t3tools/source-control-core": "workspace:*",
-    "effect": "catalog:"
+    "effect": "catalog:",
+    "yaml": "catalog:"
   },
   "devDependencies": {
     "@effect/graphql-generator": "catalog:",
diff --git a/packages/source-control-github/schema/github.graphql.ts b/packages/source-control-github/schema/github.graphql.ts
index 332060b960ff8..a2e6cb7f92e18 100644
--- a/packages/source-control-github/schema/github.graphql.ts
+++ b/packages/source-control-github/schema/github.graphql.ts
@@ -95,6 +95,17 @@ export type FileViewedState = typeof FileViewedState.Type
 export const IssueState = Schema.Literals(["CLOSED", "OPEN"])
 export type IssueState = typeof IssueState.Type
 
+/**
+ * The possible state reasons of an issue.
+ *
+ * - `COMPLETED`: An issue that has been closed as completed
+ * - `DUPLICATE`: An issue that has been closed as a duplicate.
+ * - `NOT_PLANNED`: An issue that has been closed as not planned
+ * - `REOPENED`: An issue that has been reopened
+ */
+export const IssueStateReason = Schema.Literals(["COMPLETED", "DUPLICATE", "NOT_PLANNED", "REOPENED"])
+export type IssueStateReason = typeof IssueStateReason.Type
+
 /**
  * Detailed status information about a pull request merge.
  *
@@ -298,10 +309,26 @@ export interface UpdateRefsInput extends Schema.Struct.Type<typeof UpdateRefsInp
 export declare namespace Typename {
   /** Every possible `__typename` of interface `Actor`. */
   export type Actor = "Bot" | "EnterpriseUserAccount" | "Mannequin" | "Organization" | "User"
+  /** Every possible `__typename` of union `Assignee`. */
+  export type Assignee = "Bot" | "Mannequin" | "Organization" | "User"
   /** Every possible `__typename` of interface `GitObject`. */
   export type GitObject = "Blob" | "Commit" | "Tag" | "Tree"
   /** Every possible `__typename` of union `IssueOrPullRequest`. */
   export type IssueOrPullRequest = "Issue" | "PullRequest"
+  /** Every possible `__typename` of union `IssueTimelineItems`. */
+  export type IssueTimelineItems =
+    | "AddedToProjectEvent" | "AddedToProjectV2Event" | "AssignedEvent" | "BlockedByAddedEvent"
+    | "BlockedByRemovedEvent" | "BlockingAddedEvent" | "BlockingRemovedEvent" | "ClosedEvent" | "CommentDeletedEvent"
+    | "ConnectedEvent" | "ConvertedFromDraftEvent" | "ConvertedNoteToIssueEvent" | "ConvertedToDiscussionEvent"
+    | "CrossReferencedEvent" | "DemilestonedEvent" | "DisconnectedEvent" | "IssueComment" | "IssueCommentPinnedEvent"
+    | "IssueCommentUnpinnedEvent" | "IssueFieldAddedEvent" | "IssueFieldChangedEvent" | "IssueFieldRemovedEvent"
+    | "IssueTypeAddedEvent" | "IssueTypeChangedEvent" | "IssueTypeRemovedEvent" | "LabeledEvent" | "LockedEvent"
+    | "MarkedAsDuplicateEvent" | "MentionedEvent" | "MilestonedEvent" | "MovedColumnsInProjectEvent"
+    | "ParentIssueAddedEvent" | "ParentIssueRemovedEvent" | "PinnedEvent" | "ProjectV2ItemStatusChangedEvent"
+    | "ReferencedEvent" | "RemovedFromProjectEvent" | "RemovedFromProjectV2Event" | "RenamedTitleEvent"
+    | "ReopenedEvent" | "SubIssueAddedEvent" | "SubIssueRemovedEvent" | "SubscribedEvent" | "TransferredEvent"
+    | "UnassignedEvent" | "UnlabeledEvent" | "UnlockedEvent" | "UnmarkedAsDuplicateEvent" | "UnpinnedEvent"
+    | "UnsubscribedEvent" | "UserBlockedEvent"
   /** Every possible `__typename` of interface `Node`. */
   export type Node =
     | "AddedToMergeQueueEvent" | "AddedToProjectEvent" | "AddedToProjectV2Event" | "AddedToStackEvent" | "App"
@@ -403,6 +430,8 @@ export declare namespace Typename {
     | "PullRequestReview" | "PullRequestReviewComment" | "Release"
   /** Every possible `__typename` of union `Reactor`. */
   export type Reactor = "Bot" | "Mannequin" | "Organization" | "User"
+  /** Every possible `__typename` of union `ReferencedSubject`. */
+  export type ReferencedSubject = "Issue" | "PullRequest"
   /** Every possible `__typename` of interface `RepositoryOwner`. */
   export type RepositoryOwner = "Organization" | "User"
   /** Every possible `__typename` of union `RequestedReviewer`. */
diff --git a/packages/source-control-github/src/server/GitHubIssueTracker.test.ts b/packages/source-control-github/src/server/GitHubIssueTracker.test.ts
new file mode 100644
index 0000000000000..143ea343582ae
--- /dev/null
+++ b/packages/source-control-github/src/server/GitHubIssueTracker.test.ts
@@ -0,0 +1,529 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { HttpClient, HttpClientResponse } from "effect/http";
+import { IssueTemplateList } from "@t3tools/contracts";
+import * as GitHubAppSignIn from "./GitHubAppSignIn.ts";
+import * as GitHubCredentials from "./GitHubCredentials.ts";
+import * as GitHubRest from "./GitHubRest.ts";
+import * as GitHubQuota from "./GitHubQuota.ts";
+import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
+import * as GitHubIssueTracker from "./GitHubIssueTracker.ts";
+
+const DETAIL_RESPONSE = JSON.stringify({
+  data: {
+    viewer: { login: "julius" },
+    repository: {
+      viewerPermission: "TRIAGE",
+      issue: {
+        __typename: "Issue",
+        number: 42,
+        title: "Composer loses focus",
+        url: "https://github.com/acme/web/issues/42",
+        author: {
+          __typename: "User",
+          login: "octocat",
+          avatarUrl: "https://avatars/octocat",
+          name: "Octo Cat",
+        },
+        state: "CLOSED",
+        stateReason: "DUPLICATE",
+        createdAt: "2026-07-01T00:00:00Z",
+        updatedAt: "2026-07-03T00:00:00Z",
+        closedAt: "2026-07-03T00:00:00Z",
+        comments: {
+          totalCount: 3,
+          pageInfo: { hasPreviousPage: true, startCursor: "Y3Vyc29y" },
+          nodes: [
+            {
+              __typename: "IssueComment",
+              id: "IC_1",
+              author: { __typename: "User", login: "julius", avatarUrl: "https://avatars/julius" },
+              body: "Repro attached.",
+              createdAt: "2026-07-02T00:00:00Z",
+              url: "https://github.com/acme/web/issues/42#issuecomment-1",
+              reactionGroups: [
+                {
+                  content: "THUMBS_UP",
+                  viewerHasReacted: true,
+                  reactors: {
+                    totalCount: 2,
+                    nodes: [
+                      { __typename: "User", login: "julius" },
+                      { __typename: "User", login: "theo" },
+                    ],
+                  },
+                },
+                {
+                  content: "EYES",
+                  viewerHasReacted: false,
+                  reactors: { totalCount: 0, nodes: [] },
+                },
+              ],
+            },
+          ],
+        },
+        assignees: {
+          pageInfo: { hasNextPage: false, endCursor: null },
+          nodes: [{ login: "theo", name: null, avatarUrl: "https://avatars/julius" }],
+        },
+        labels: {
+          pageInfo: { hasNextPage: true, endCursor: "labels-next" },
+          nodes: [{ name: "bug", color: "d73a4a" }, null],
+        },
+        body: "Typing in the composer drops focus after a paste.",
+        viewerCanUpdate: false,
+        reactionGroups: [],
+        closedByPullRequestsReferences: {
+          nodes: [
+            {
+              number: 50,
+              title: "fix(web): keep composer focus",
+              url: "https://github.com/acme/web/pull/50",
+              state: "MERGED",
+              isDraft: false,
+              repository: { nameWithOwner: "acme/web" },
+            },
+          ],
+        },
+        timelineItems: {
+          nodes: [
+            {
+              __typename: "LabeledEvent",
+              id: "LE_1",
+              createdAt: "2026-07-01T01:00:00Z",
+              actor: { __typename: "User", login: "theo", avatarUrl: "https://avatars/theo" },
+              label: { name: "bug" },
+            },
+            {
+              __typename: "CrossReferencedEvent",
+              id: "CRE_1",
+              createdAt: "2026-07-02T01:00:00Z",
+              actor: { __typename: "User", login: "julius", avatarUrl: "https://avatars/julius" },
+              source: {
+                __typename: "PullRequest",
+                number: 50,
+                title: "fix(web): keep composer focus",
+                url: "https://github.com/acme/web/pull/50",
+                state: "MERGED",
+                isDraft: false,
+                repository: { nameWithOwner: "acme/web" },
+              },
+            },
+            { __typename: "MentionedEvent", id: "ME_1", createdAt: "2026-07-02T02:00:00Z" },
+            {
+              __typename: "ClosedEvent",
+              id: "CE_1",
+              createdAt: "2026-07-03T00:00:00Z",
+              actor: null,
+            },
+          ],
+        },
+      },
+    },
+  },
+});
+
+const decodeVariables = Schema.decodeUnknownSync(
+  Schema.fromJsonString(
+    Schema.Struct({
+      query: Schema.String,
+      variables: Schema.Record(Schema.String, Schema.Unknown),
+    }),
+  ),
+);
+
+function transport(httpClient: HttpClient.HttpClient) {
+  return GitHubRest.layer.pipe(
+    Layer.provideMerge(
+      Layer.mergeAll(
+        GitHubQuota.layer,
+        SourceControlRateLimit.layer,
+        Layer.mock(GitHubCredentials.GitHubCredentials)({
+          saved: () => Effect.succeedNone,
+          get: (host) =>
+            Effect.succeed({
+              host,
+              token: Redacted.make("test-token"),
+              source: "gh" as const,
+              fingerprint: "test",
+            }),
+        }),
+        Layer.mock(GitHubAppSignIn.GitHubAppSignIn)({
+          enabled: false,
+          token: () => Effect.succeedNone,
+          invalidate: () => Effect.void,
+        }),
+        Layer.succeed(HttpClient.HttpClient, httpClient),
+      ),
+    ),
+  );
+}
+
+function tracker(onRequest: (variables: unknown) => void, templateRepository?: unknown) {
+  return GitHubIssueTracker.make.pipe(
+    Effect.provide(
+      transport(
+        HttpClient.make((request) => {
+          if (request.body._tag !== "Uint8Array")
+            return Effect.die("Expected a GraphQL JSON request.");
+          const { variables } = decodeVariables(new TextDecoder().decode(request.body.body));
+          onRequest(variables);
+          const body =
+            templateRepository !== undefined
+              ? JSON.stringify({ data: { repository: templateRepository } })
+              : "labelsCursor" in variables
+                ? JSON.stringify({
+                    data: {
+                      repository: {
+                        issue: {
+                          labels: {
+                            pageInfo: { hasNextPage: false, endCursor: null },
+                            nodes: [{ name: "needs repro", color: "ffffff" }],
+                          },
+                          assignees: {
+                            pageInfo: { hasNextPage: false, endCursor: null },
+                            nodes: [],
+                          },
+                        },
+                      },
+                    },
+                  })
+                : DETAIL_RESPONSE;
+          return Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              new Response(body, {
+                headers: { "content-type": "application/json" },
+              }),
+            ),
+          );
+        }),
+      ),
+    ),
+  );
+}
+
+const encodeTemplateList = Schema.encodeSync(IssueTemplateList);
+
+const decodeBody = Schema.decodeUnknownSync(
+  Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown)),
+);
+
+describe("GitHubIssueTracker", () => {
+  it.effect("writes an issue lifecycle without mutating pull requests or foreign comments", () =>
+    Effect.gen(function* () {
+      const writes: unknown[] = [];
+      const http = HttpClient.make((request) => {
+        if (request.body._tag !== "Uint8Array") return Effect.die("Expected a JSON request.");
+        const text = new TextDecoder().decode(request.body.body);
+        let response: unknown = {};
+        if (request.url === "https://api.github.com/graphql") {
+          const { query, variables } = decodeVariables(text);
+          expect(request.method).toBe("POST");
+          const operation = query.match(/(?:query|mutation)\s+(\w+)/)?.[1];
+          if (operation === "IssueNodeId" || operation === "IssueCommentScope") {
+            expect(variables).toMatchObject({ owner: "acme", name: "web" });
+            response = {
+              data: {
+                repository: { issue: variables["number"] === 42 ? { id: "I_42" } : null },
+                ...(operation === "IssueCommentScope"
+                  ? { node: { __typename: "IssueComment", issue: { id: "I_other" } } }
+                  : {}),
+              },
+            };
+          } else {
+            expect(["AddReaction", "RemoveReaction"]).toContain(operation);
+            expect(variables).toEqual({ subjectId: "I_42", content: "THUMBS_UP" });
+            writes.push(operation);
+            response = {
+              data: {
+                [operation === "AddReaction" ? "addReaction" : "removeReaction"]: {
+                  reaction: { content: "THUMBS_UP" },
+                },
+              },
+            };
+          }
+        } else {
+          writes.push([request.method, request.url, decodeBody(text)]);
+          if (request.url.endsWith("/issues")) {
+            response = { number: 42, html_url: "https://github.com/acme/web/issues/42" };
+          }
+        }
+        return Effect.succeed(
+          HttpClientResponse.fromWeb(
+            request,
+            new Response(JSON.stringify(response), {
+              headers: { "content-type": "application/json" },
+            }),
+          ),
+        );
+      });
+      const api = yield* GitHubIssueTracker.make.pipe(Effect.provide(transport(http)));
+      const target = { cwd: "/w", host: "github.com", scope: "acme/web", key: "42" };
+      expect(
+        yield* api.create({
+          ...target,
+          title: "Fixture",
+          body: "Body",
+          labels: ["bug"],
+          assignees: ["octocat"],
+        }),
+      ).toEqual({
+        key: "42",
+        displayKey: "#42",
+        url: "https://github.com/acme/web/issues/42",
+      });
+      yield* api.comment({ ...target, body: "Comment" });
+      yield* api.update({ ...target, title: "Updated", body: "Edited", labels: [], assignees: [] });
+      yield* api.setState({ ...target, state: "closed", closeReason: "not-planned" });
+      yield* api.setState({ ...target, state: "open" });
+      yield* api.setReaction({ ...target, content: "thumbs-up", reacted: true });
+      yield* api.setReaction({ ...target, content: "thumbs-up", reacted: false });
+
+      const pullRequest = { ...target, key: "50" };
+      expect(
+        yield* api.update({ ...pullRequest, title: "Do not edit" }).pipe(Effect.result),
+      ).toMatchObject({ _tag: "Failure", failure: { operation: "update", reason: "not-found" } });
+      expect(
+        yield* api.setState({ ...pullRequest, state: "closed" }).pipe(Effect.result),
+      ).toMatchObject({
+        _tag: "Failure",
+        failure: { operation: "setState", reason: "not-found" },
+      });
+      expect(
+        yield* api.comment({ ...pullRequest, body: "Do not comment" }).pipe(Effect.result),
+      ).toMatchObject({ _tag: "Failure", failure: { operation: "comment", reason: "not-found" } });
+      expect(
+        yield* Effect.flip(
+          api.setReaction({
+            ...target,
+            subjectId: "IC_other",
+            content: "thumbs-up",
+            reacted: true,
+          }),
+        ),
+      ).toMatchObject({ operation: "setReaction", reason: "failed" });
+
+      expect(writes).toEqual([
+        [
+          "POST",
+          "https://api.github.com/repos/acme/web/issues",
+          { title: "Fixture", body: "Body", labels: ["bug"], assignees: ["octocat"] },
+        ],
+        ["POST", "https://api.github.com/repos/acme/web/issues/42/comments", { body: "Comment" }],
+        [
+          "PATCH",
+          "https://api.github.com/repos/acme/web/issues/42",
+          { title: "Updated", body: "Edited", labels: [], assignees: [] },
+        ],
+        [
+          "PATCH",
+          "https://api.github.com/repos/acme/web/issues/42",
+          { state: "closed", state_reason: "not_planned" },
+        ],
+        ["PATCH", "https://api.github.com/repos/acme/web/issues/42", { state: "open" }],
+        "AddReaction",
+        "RemoveReaction",
+      ]);
+    }),
+  );
+
+  it.effect("offers YAML issue forms when blank issues are disabled", () =>
+    Effect.gen(function* () {
+      const form = {
+        __typename: "Blob",
+        isTruncated: false,
+        text: `name: Bug report
+description: Report broken behavior.
+title: "[Bug]: "
+labels: [bug, needs-triage]
+assignees: "octocat, theo"
+body:
+  - type: markdown
+    attributes:
+      value: Search existing issues first.
+  - type: checkboxes
+    attributes:
+      label: Before submitting
+      options:
+        - label: I searched existing issues.
+          required: true
+  - type: dropdown
+    attributes:
+      label: Area
+      description: Which part is affected?
+      options: [Web, Server]
+      default: 1
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      placeholder: Start the app.
+  - type: input
+    attributes:
+      label: Version
+      value: main
+  - type: upload
+    attributes:
+      label: Supporting files
+      description: Redact secrets before uploading.
+`,
+      };
+      const config = {
+        __typename: "Blob",
+        isTruncated: false,
+        text: '"blank_issues_enabled": false # use a template',
+      };
+      const repository = {
+        issueTemplates: [],
+        templateDirectory: {
+          __typename: "Tree",
+          entries: [
+            { name: "config.yml", object: config },
+            { name: "bug_report.yml", object: form },
+            {
+              name: "empty_name.yml",
+              object: { ...form, text: 'name: ""\ndescription: Empty name\nbody: []' },
+            },
+            {
+              name: "blank_name.yml",
+              object: { ...form, text: 'name: "   "\ndescription: Blank name\nbody: []' },
+            },
+            {
+              name: "invalid.yml",
+              object: { ...form, text: "name: Missing required metadata\nbody: []" },
+            },
+          ],
+        },
+      };
+      const api = yield* tracker(() => {}, repository);
+      const input = { cwd: "/w", host: "github.com", scope: "acme/web" };
+      const result = yield* api.listTemplates!(input);
+      expect(encodeTemplateList(result)).toEqual(result);
+      expect(result.blankIssuesEnabled).toBe(false);
+      expect(result.templates).toHaveLength(1);
+      expect(result.templates[0]).toMatchObject({
+        key: "bug_report.yml",
+        name: "Bug report",
+        about: "Report broken behavior.",
+        title: "[Bug]: ",
+        labels: ["bug", "needs-triage"],
+        assignees: ["octocat", "theo"],
+      });
+      expect(result.templates[0]?.body).toBe(`Search existing issues first.
+
+### Before submitting
+
+- [ ] I searched existing issues. (required)
+
+### Area
+
+Which part is affected?
+
+Required.
+
+Choose one:
+
+- Web
+- Server (default)
+
+### Steps to reproduce
+
+Example:
+> Start the app.
+
+### Version
+
+main
+
+### Supporting files
+
+Redact secrets before uploading.`);
+      config.isTruncated = true;
+      expect(yield* Effect.flip(api.listTemplates!(input))).toMatchObject({
+        reason: "failed",
+        detail: "GitHub returned incomplete issue template contents.",
+      });
+    }),
+  );
+
+  it.effect("maps a detail read to the neutral issue shape", () =>
+    Effect.gen(function* () {
+      const seen: unknown[] = [];
+      const api = yield* tracker((variables) => {
+        seen.push(variables);
+      });
+      const issue = yield* api.getIssue({
+        cwd: "/w",
+        host: "github.com",
+        scope: "acme/web",
+        key: "42",
+      });
+      expect(seen).toEqual([
+        { owner: "acme", name: "web", number: 42 },
+        {
+          owner: "acme",
+          name: "web",
+          number: 42,
+          labelsCursor: "labels-next",
+          assigneesCursor: null,
+        },
+      ]);
+      expect(issue).toMatchObject({
+        key: "42",
+        displayKey: "#42",
+        title: "Composer loses focus",
+        body: "Typing in the composer drops focus after a paste.",
+        state: { category: "closed", name: "closed", closeReason: "duplicate" },
+        author: {
+          login: "octocat",
+          name: "Octo Cat",
+          avatarUrl: "https://avatars/octocat",
+        },
+        assignees: [{ login: "theo" }],
+        labels: [
+          { name: "bug", color: "d73a4a" },
+          { name: "needs repro", color: "ffffff" },
+        ],
+        commentCount: 3,
+        viewer: "julius",
+        // Triage may label and assign; `viewerCanUpdate: false` withholds state and edits.
+        viewerPermissions: {
+          setState: false,
+          edit: false,
+          labels: true,
+          assignees: true,
+          comment: true,
+        },
+        commentsCursor: "Y3Vyc29y",
+      });
+      // The viewer is left out of `actors` and shown as "You"; an empty group is dropped.
+      expect(issue.comments[0]?.reactions).toEqual([
+        { content: "thumbs-up", count: 2, actors: ["theo"], viewerHasReacted: true },
+      ]);
+      // The closing reference wins over the cross-reference sighting of the same pull request.
+      expect(issue.linkedPullRequests).toEqual([
+        {
+          repository: "acme/web",
+          number: 50,
+          title: "fix(web): keep composer focus",
+          url: "https://github.com/acme/web/pull/50",
+          state: "merged",
+          isDraft: false,
+          closesIssue: true,
+        },
+      ]);
+      // An event kind this page has no vocabulary for is dropped rather than guessed at.
+      expect(issue.events.map((event) => [event.kind, event.detail])).toEqual([
+        ["labeled", "bug"],
+        ["referenced", "acme/web#50"],
+        ["closed", null],
+      ]);
+    }),
+  );
+});
diff --git a/packages/source-control-github/src/server/GitHubIssueTracker.ts b/packages/source-control-github/src/server/GitHubIssueTracker.ts
new file mode 100644
index 0000000000000..14526d74c2c9f
--- /dev/null
+++ b/packages/source-control-github/src/server/GitHubIssueTracker.ts
@@ -0,0 +1,426 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import { GraphQLClient, GraphQLClientError, GraphQLGroup } from "effect/graphql";
+import {
+  IssueTrackerKind,
+  type IssueCapabilities,
+  type IssueInvolvement,
+} from "@t3tools/contracts";
+import {
+  IssueTrackerError,
+  type IssueTrackerApi,
+} from "@t3tools/source-control-core/server/IssueTracker";
+
+import * as GitHubRest from "./GitHubRest.ts";
+import { readIssueTemplates } from "./gitHubIssueTemplates.ts";
+import * as GitHubRequestPolicy from "./GitHubRequestPolicy.ts";
+import * as GitHubGraphQlClient from "./gitHubGraphQlClient.ts";
+import { IssuesGraphQLGroup } from "./issues.graphql.ts";
+import { AddReaction, RemoveReaction } from "./pullRequestMutations.graphql.ts";
+import { gitHubReactionContent } from "./gitHubPullRequestJson.ts";
+import {
+  decodeCreatedIssueJson,
+  toIssueCandidates,
+  toIssueComments,
+  toIssueDetail,
+  toIssueSearch,
+} from "./gitHubIssueJson.ts";
+
+const KIND = IssueTrackerKind.make("github");
+
+const CAPABILITIES: IssueCapabilities = {
+  create: true,
+  edit: true,
+  comment: true,
+  labels: true,
+  assignees: true,
+  reactions: true,
+  templates: true,
+  linkedPullRequests: true,
+  events: true,
+  search: true,
+  states: [
+    { category: "open", name: "open" },
+    { category: "closed", name: "closed" },
+  ],
+  closeReasons: ["completed", "not-planned"],
+};
+
+const REPOSITORY = /^[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9_.-]+$/;
+
+function searchTerms(query: string): ReadonlyArray<string> {
+  return query
+    .split(/\s+/)
+    .filter((word) => word.length > 0)
+    .map((word) => `"${word.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`);
+}
+
+const INVOLVEMENT_QUALIFIER: Record<IssueInvolvement, string | null> = {
+  all: null,
+  assigned: "assignee",
+  authored: "author",
+  mentioned: "mentions",
+};
+
+function searchQuery(input: {
+  readonly scope: string;
+  readonly state: "all" | "open" | "closed";
+  readonly involvement: IssueInvolvement;
+  readonly viewer: string;
+  readonly query?: string | undefined;
+}): string {
+  const qualifier = INVOLVEMENT_QUALIFIER[input.involvement];
+  return [
+    "is:issue",
+    `repo:${input.scope.trim()}`,
+    ...(input.state === "all" ? [] : [`is:${input.state}`]),
+    ...(qualifier === null ? [] : [`${qualifier}:${input.viewer}`]),
+    "sort:updated-desc",
+    ...searchTerms(input.query ?? ""),
+  ].join(" ");
+}
+
+const CLOSE_REASON: Record<string, "completed" | "not_planned"> = {
+  completed: "completed",
+  "not-planned": "not_planned",
+};
+
+function reasonFor(
+  error: GitHubRequestPolicy.GitHubApiError | GraphQLClientError.GraphQLClientError,
+): IssueTrackerError["reason"] {
+  switch (error._tag) {
+    case "GitHubCliMissingError":
+      return "missing-tool";
+    case "GitHubNotSignedInError":
+    case "GitHubHostDisabledError":
+    case "GitHubApiAuthenticationError":
+      return "unauthenticated";
+    case "GitHubApiRateLimitError":
+    case "SourceControlRateLimitPausedError":
+      return "rate-limited";
+    case "GitHubApiNotFoundError":
+      return "not-found";
+    default:
+      return "failed";
+  }
+}
+
+const FAILURE_DETAIL: Record<IssueTrackerError["reason"], string> = {
+  "missing-tool": "GitHub CLI is not installed.",
+  unauthenticated: "GitHub authentication is unavailable. Sign in and retry.",
+  "rate-limited": "GitHub API rate limit exceeded.",
+  "not-found": "GitHub could not find the requested issue.",
+  failed: "The GitHub issue request failed.",
+};
+
+const group = GraphQLGroup.merge(
+  IssuesGraphQLGroup,
+  GraphQLGroup.make(AddReaction, RemoveReaction),
+).middleware(GitHubGraphQlClient.GitHubGraphQlAuth);
+
+export const make = Effect.gen(function* () {
+  const api = yield* GitHubRest.GitHubRest;
+  const client = yield* GraphQLClient.make(group).pipe(Effect.provide(GitHubGraphQlClient.layer));
+
+  const fail =
+    (operation: string) =>
+    (error: GitHubRequestPolicy.GitHubApiError | GraphQLClientError.GraphQLClientError) =>
+      new IssueTrackerError({
+        tracker: KIND,
+        operation,
+        reason: reasonFor(error),
+        detail: GraphQLClientError.isGraphQLClientError(error)
+          ? `GitHub returned an unreadable ${operation} response.`
+          : FAILURE_DETAIL[reasonFor(error)],
+        ...("retryAt" in error && error.retryAt !== undefined ? { retryAt: error.retryAt } : {}),
+        cause: error,
+      });
+
+  const invalid = (operation: string, detail: string, reason: "failed" | "not-found" = "failed") =>
+    new IssueTrackerError({ tracker: KIND, operation, reason, detail });
+
+  const notFound = (operation: string) =>
+    invalid(operation, "GitHub could not find the requested issue.", "not-found");
+
+  const repository = Effect.fn("GitHubIssueTracker.repository")(function* (
+    scope: string,
+    operation: string,
+  ) {
+    if (!REPOSITORY.test(scope) || scope.endsWith("/.") || scope.endsWith("/..")) {
+      return yield* invalid(operation, "A repository was named that GitHub cannot address.");
+    }
+    const [owner = "", name = ""] = scope.split("/");
+    return { owner, name };
+  });
+
+  const issue = Effect.fn("GitHubIssueTracker.issue")(function* (
+    input: { readonly scope: string; readonly key: string },
+    operation: string,
+  ) {
+    const repo = yield* repository(input.scope, operation);
+    const number = Number(input.key);
+    if (!/^[1-9]\d*$/.test(input.key) || !Number.isSafeInteger(number) || number > 2_147_483_647) {
+      return yield* notFound(operation);
+    }
+    return { ...repo, number, path: `repos/${repo.owner}/${repo.name}/issues/${number}` };
+  });
+
+  const graphql =
+    (host: string, operation: string) =>
+    <A, E extends GitHubRequestPolicy.GitHubApiError | GraphQLClientError.GraphQLClientError, R>(
+      effect: Effect.Effect<A, E, R>,
+    ) =>
+      effect.pipe(GitHubGraphQlClient.call({ host, operation }), Effect.mapError(fail(operation)));
+
+  const verifiedIssue = Effect.fn("GitHubIssueTracker.verifiedIssue")(function* (
+    input: { readonly host: string; readonly scope: string; readonly key: string },
+    operation: string,
+  ) {
+    const target = yield* issue(input, operation);
+    const { owner, name, number } = target;
+    // REST issue endpoints also accept pull requests; resolve an Issue before writing.
+    const result = yield* client
+      .IssueNodeId({ owner, name, number })
+      .pipe(graphql(input.host, operation));
+    const id = result.repository?.issue?.id;
+    if (id === undefined) return yield* notFound(operation);
+    return { ...target, id };
+  });
+
+  const patchIssue = (
+    input: { readonly host: string; readonly scope: string; readonly key: string },
+    operation: string,
+    body: Record<string, unknown>,
+  ) =>
+    verifiedIssue(input, operation).pipe(
+      Effect.flatMap(({ path }) =>
+        api
+          .rest({ host: input.host, operation, method: "PATCH", path, body })
+          .pipe(Effect.asVoid, Effect.mapError(fail(operation))),
+      ),
+    );
+
+  return {
+    kind: KIND,
+    capabilities: CAPABILITIES,
+
+    getViewer: (input) =>
+      client.IssueViewer({}).pipe(
+        graphql(input.host, "getViewer"),
+        Effect.map(({ viewer }) => viewer.login),
+      ),
+
+    listIssues: (input) =>
+      repository(input.scope, "listIssues").pipe(
+        Effect.flatMap(() =>
+          client
+            .IssueSearch({
+              q: searchQuery(input),
+              cursor: input.cursor,
+              rows: Math.min(Math.max(Math.trunc(input.limit), 1), 100),
+            })
+            .pipe(graphql(input.host, "listIssues"), Effect.map(toIssueSearch)),
+        ),
+      ),
+
+    getIssue: Effect.fn("GitHubIssueTracker.getIssue")(function* (input) {
+      const { owner, name, number } = yield* issue(input, "getIssue");
+      const result = yield* client
+        .IssueDetail({ owner, name, number })
+        .pipe(graphql(input.host, "getIssue"));
+      const detail = toIssueDetail(result);
+      const raw = result.repository?.issue;
+      if (detail === null || raw == null) return yield* notFound("getIssue");
+      // Editing replaces these sets. Finish their pages before handing them to a client.
+      let labels = raw.labels;
+      let assignees = raw.assignees;
+      const seen = new Set<string>();
+      const allLabels = [...detail.labels];
+      const allAssignees = [...detail.assignees];
+      while (labels?.pageInfo.hasNextPage === true || assignees.pageInfo.hasNextPage) {
+        const labelsCursor = labels?.pageInfo.hasNextPage ? labels.pageInfo.endCursor : null;
+        const assigneesCursor = assignees.pageInfo.hasNextPage
+          ? assignees.pageInfo.endCursor
+          : null;
+        const key = `${labelsCursor ?? ""} ${assigneesCursor ?? ""}`;
+        if (
+          (labels?.pageInfo.hasNextPage && labelsCursor === null) ||
+          (assignees.pageInfo.hasNextPage && assigneesCursor === null) ||
+          seen.has(key)
+        ) {
+          return yield* invalid(
+            "getIssue",
+            "GitHub did not return complete issue labels or assignees.",
+          );
+        }
+        seen.add(key);
+        const page = yield* client
+          .IssueCollections({ owner, name, number, labelsCursor, assigneesCursor })
+          .pipe(graphql(input.host, "getIssue"));
+        const next = page.repository?.issue;
+        if (next == null) return yield* notFound("getIssue");
+        if (labels?.pageInfo.hasNextPage) {
+          labels = next.labels;
+          if (next.labels === null) {
+            return yield* invalid("getIssue", "GitHub did not return complete issue labels.");
+          }
+          allLabels.push(
+            ...(next.labels.nodes ?? []).flatMap((node) =>
+              node === null ? [] : [{ name: node.name, color: node.color }],
+            ),
+          );
+        }
+        if (assignees.pageInfo.hasNextPage) {
+          assignees = next.assignees;
+          allAssignees.push(
+            ...(next.assignees.nodes ?? []).flatMap((node) =>
+              node === null
+                ? []
+                : [{ login: node.login, name: node.name, avatarUrl: node.avatarUrl }],
+            ),
+          );
+        }
+      }
+      return { ...detail, labels: allLabels, assignees: allAssignees };
+    }),
+
+    getComments: (input) =>
+      issue(input, "getComments").pipe(
+        Effect.flatMap(({ owner, name, number }) =>
+          client
+            .IssueComments({ owner, name, number, cursor: input.cursor })
+            .pipe(graphql(input.host, "getComments")),
+        ),
+        Effect.flatMap((result) =>
+          result.repository?.issue == null
+            ? Effect.fail(notFound("getComments"))
+            : Effect.succeed(toIssueComments(result)),
+        ),
+      ),
+
+    create: (input) =>
+      repository(input.scope, "create").pipe(
+        Effect.flatMap(({ owner, name }) =>
+          api
+            .rest({
+              host: input.host,
+              operation: "create",
+              method: "POST",
+              path: `repos/${owner}/${name}/issues`,
+              body: {
+                title: input.title,
+                body: input.body,
+                labels: input.labels,
+                assignees: input.assignees,
+              },
+            })
+            .pipe(Effect.mapError(fail("create"))),
+        ),
+        Effect.flatMap((response) => {
+          const decoded = decodeCreatedIssueJson(response.body);
+          return Result.isSuccess(decoded)
+            ? Effect.succeed({
+                key: String(decoded.success.number),
+                displayKey: `#${decoded.success.number}`,
+                url: decoded.success.url,
+              })
+            : Effect.fail(
+                new IssueTrackerError({
+                  tracker: KIND,
+                  operation: "create",
+                  reason: "failed",
+                  detail: "GitHub returned an unreadable create response.",
+                  cause: decoded.failure,
+                }),
+              );
+        }),
+      ),
+
+    comment: (input) =>
+      verifiedIssue(input, "comment").pipe(
+        Effect.flatMap(({ path }) =>
+          api
+            .rest({
+              host: input.host,
+              operation: "comment",
+              method: "POST",
+              path: `${path}/comments`,
+              body: { body: input.body },
+            })
+            .pipe(Effect.asVoid, Effect.mapError(fail("comment"))),
+        ),
+      ),
+
+    update: (input) =>
+      patchIssue(input, "update", {
+        ...(input.title === undefined ? {} : { title: input.title }),
+        ...(input.body === undefined ? {} : { body: input.body }),
+        ...(input.labels === undefined ? {} : { labels: input.labels }),
+        ...(input.assignees === undefined ? {} : { assignees: input.assignees }),
+      }),
+
+    setState: (input) =>
+      patchIssue(input, "setState", {
+        state: input.state,
+        ...(input.state === "closed" && input.closeReason !== undefined
+          ? { state_reason: CLOSE_REASON[input.closeReason] }
+          : {}),
+      }),
+
+    setReaction: Effect.fn("GitHubIssueTracker.setReaction")(function* (input) {
+      let subjectId: string;
+      if (input.subjectId === undefined) {
+        const target = yield* verifiedIssue(input, "setReaction");
+        subjectId = target.id;
+      } else {
+        const { owner, name, number } = yield* issue(input, "setReaction");
+        // Node ids are global: prove the comment belongs to this issue before writing.
+        const result = yield* client
+          .IssueCommentScope({ owner, name, number, commentId: input.subjectId })
+          .pipe(graphql(input.host, "setReaction"));
+        const expected = result.repository?.issue?.id;
+        if (
+          expected === undefined ||
+          result.node?.__typename !== "IssueComment" ||
+          result.node.issue.id !== expected
+        ) {
+          return yield* invalid(
+            "setReaction",
+            "The comment does not belong to the selected issue.",
+          );
+        }
+        subjectId = input.subjectId;
+      }
+      const variables = { subjectId, content: gitHubReactionContent(input.content) };
+      yield* (
+        input.reacted
+          ? client.AddReaction(variables).pipe(Effect.asVoid)
+          : client.RemoveReaction(variables).pipe(Effect.asVoid)
+      ).pipe(graphql(input.host, "setReaction"));
+    }),
+
+    listTemplates: (input) =>
+      repository(input.scope, "listTemplates").pipe(
+        Effect.flatMap(({ owner, name }) =>
+          client.IssueTemplates({ owner, name }).pipe(graphql(input.host, "listTemplates")),
+        ),
+        Effect.flatMap(({ repository }) =>
+          repository === null
+            ? Effect.fail(notFound("listTemplates"))
+            : readIssueTemplates(repository),
+        ),
+      ),
+
+    listCandidates: (input) =>
+      repository(input.scope, "listCandidates").pipe(
+        Effect.flatMap(({ owner, name }) =>
+          client.IssueCandidates({ owner, name }).pipe(graphql(input.host, "listCandidates")),
+        ),
+        Effect.flatMap(({ repository }) =>
+          repository === null
+            ? Effect.fail(notFound("listCandidates"))
+            : Effect.succeed(toIssueCandidates(repository)),
+        ),
+      ),
+  } satisfies IssueTrackerApi;
+});
diff --git a/packages/source-control-github/src/server/driver.ts b/packages/source-control-github/src/server/driver.ts
index 2fb2dfb2899c7..05844f6608fe6 100644
--- a/packages/source-control-github/src/server/driver.ts
+++ b/packages/source-control-github/src/server/driver.ts
@@ -17,6 +17,7 @@ import * as GitHubPullRequestApi from "./GitHubPullRequestApi.ts";
 import * as GitHubPullRequestProvider from "./GitHubPullRequestProvider.ts";
 import * as GitHubRest from "./GitHubRest.ts";
 import * as GitHubHttpClient from "./GitHubHttpClient.ts";
+import * as GitHubIssueTracker from "./GitHubIssueTracker.ts";
 import * as GitHubSourceControlProvider from "./GitHubSourceControlProvider.ts";
 
 // `GitHubRest.layerWithDependencies` carries the quota reserve every GitHub reader shares, so it
@@ -104,6 +105,7 @@ const makeInstance = Effect.gen(function* () {
       sourceControl: GitHubSourceControlProvider.make,
       discovery: GitHubSourceControlProvider.makeDiscovery,
       pullRequests: GitHubPullRequestProvider.make,
+      issues: GitHubIssueTracker.make,
       fetchMedia: GitHubMediaFetch.make.pipe(
         Effect.provideService(HttpClient.HttpClient, mediaHttpClient),
       ),
diff --git a/packages/source-control-github/src/server/gitHubIssueJson.ts b/packages/source-control-github/src/server/gitHubIssueJson.ts
new file mode 100644
index 0000000000000..3ad2ba2d22363
--- /dev/null
+++ b/packages/source-control-github/src/server/gitHubIssueJson.ts
@@ -0,0 +1,342 @@
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { TrimmedNonEmptyString } from "@t3tools/contracts";
+import type {
+  IssueActor,
+  IssueComment,
+  IssueEvent,
+  IssueEventKind,
+  IssueLabel,
+  IssueLinkedPullRequest,
+  IssueState,
+  IssueTemplate,
+  IssueViewerPermissions,
+  PullRequestState,
+} from "@t3tools/contracts";
+import { decodeJsonResult } from "@t3tools/shared/schemaJson";
+import type { TrackerIssueSummary } from "@t3tools/source-control-core/server/IssueTracker";
+
+import type * as Issues from "./issues.graphql.ts";
+import { toReactions } from "./gitHubPullRequestJson.ts";
+
+type DetailIssue = NonNullable<NonNullable<Issues.IssueDetail.Result["repository"]>["issue"]>;
+type Actor = {
+  readonly login: string;
+  readonly name?: string | null;
+  readonly avatarUrl: string | null;
+};
+type Label = NonNullable<NonNullable<NonNullable<Issues.NodesIssue["labels"]>["nodes"]>[number]>;
+type TimelineItem = NonNullable<NonNullable<DetailIssue["timelineItems"]["nodes"]>[number]>;
+type Comments = Omit<DetailIssue["comments"], "totalCount">;
+type Reference = NonNullable<
+  NonNullable<NonNullable<DetailIssue["closedByPullRequestsReferences"]>["nodes"]>[number]
+>;
+
+function trimmed(value: string | null | undefined): string | null {
+  const text = value?.trim() ?? "";
+  return text.length > 0 ? text : null;
+}
+
+function toActor(raw: Actor | null | undefined): IssueActor | null {
+  const login = trimmed(raw?.login);
+  return login === null
+    ? null
+    : {
+        login,
+        name: trimmed(raw != null && "name" in raw ? raw.name : null),
+        avatarUrl: trimmed(raw?.avatarUrl),
+      };
+}
+
+function toActors(raw: ReadonlyArray<Actor | null> | null | undefined): ReadonlyArray<IssueActor> {
+  return (raw ?? []).flatMap((entry) => toActor(entry) ?? []);
+}
+
+function toLabels(raw: ReadonlyArray<Label | null> | null | undefined): ReadonlyArray<IssueLabel> {
+  return (raw ?? []).flatMap((label) => {
+    const name = trimmed(label?.name);
+    return name === null ? [] : [{ name, color: trimmed(label?.color) }];
+  });
+}
+
+/** GitHub uses uppercase close reasons; an open issue has `""` or `REOPENED`. */
+function toIssueState(
+  state: string | null | undefined,
+  stateReason: string | null | undefined,
+): IssueState {
+  if (state?.trim().toUpperCase() !== "CLOSED") return { category: "open", name: "open" };
+  const reason = stateReason?.trim().toUpperCase();
+  return {
+    category: "closed",
+    name: "closed",
+    ...(reason === "COMPLETED"
+      ? { closeReason: "completed" }
+      : reason === "NOT_PLANNED"
+        ? { closeReason: "not-planned" }
+        : reason === "DUPLICATE"
+          ? { closeReason: "duplicate" }
+          : {}),
+  };
+}
+
+function toSummary(raw: Omit<Issues.NodesIssue, "__typename">): TrackerIssueSummary {
+  return {
+    key: String(raw.number),
+    displayKey: `#${raw.number}`,
+    title: raw.title,
+    url: raw.url,
+    author: toActor(raw.author),
+    state: toIssueState(raw.state, raw.stateReason),
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt,
+    closedAt: trimmed(raw.closedAt),
+    assignees: toActors(raw.assignees?.nodes),
+    labels: toLabels(raw.labels?.nodes),
+    commentCount: Math.max(0, raw.comments?.totalCount ?? 0),
+  };
+}
+
+function toPullRequestState(value: string | null | undefined): PullRequestState {
+  switch (value?.trim().toUpperCase()) {
+    case "MERGED":
+      return "merged";
+    case "CLOSED":
+      return "closed";
+    default:
+      return "open";
+  }
+}
+
+function toLinkedPullRequest(
+  raw: Reference | null | undefined,
+  closesIssue: boolean,
+): IssueLinkedPullRequest | null {
+  if (raw == null) return null;
+  const { title, url, number } = raw;
+  const repository = raw.repository.nameWithOwner;
+  return {
+    repository,
+    number,
+    title,
+    url,
+    state: toPullRequestState(raw.state),
+    isDraft: raw.isDraft ?? false,
+    closesIssue,
+  };
+}
+
+/** The change GitHub recorded, or null for a kind this page has no vocabulary for. */
+function toEventFields(
+  raw: TimelineItem,
+): { readonly kind: IssueEventKind; readonly detail: string | null } | null {
+  switch (raw.__typename) {
+    case "ClosedEvent":
+      return { kind: "closed", detail: null };
+    case "ReopenedEvent":
+      return { kind: "reopened", detail: null };
+    case "LabeledEvent":
+      return { kind: "labeled", detail: trimmed(raw.label?.name) };
+    case "UnlabeledEvent":
+      return { kind: "unlabeled", detail: trimmed(raw.label?.name) };
+    case "AssignedEvent":
+      return {
+        kind: "assigned",
+        detail: trimmed(
+          raw.assignee != null && "login" in raw.assignee ? raw.assignee.login : null,
+        ),
+      };
+    case "UnassignedEvent":
+      return {
+        kind: "unassigned",
+        detail: trimmed(
+          raw.assignee != null && "login" in raw.assignee ? raw.assignee.login : null,
+        ),
+      };
+    case "RenamedTitleEvent":
+      return { kind: "renamed", detail: trimmed(raw.currentTitle) };
+    case "CrossReferencedEvent": {
+      const repository = trimmed(
+        raw.source != null && "repository" in raw.source
+          ? raw.source.repository.nameWithOwner
+          : null,
+      );
+      const number = raw.source != null && "number" in raw.source ? raw.source.number : 0;
+      return {
+        kind: "referenced",
+        detail: repository === null || number <= 0 ? null : `${repository}#${number}`,
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+function toComments(
+  raw: Comments | null | undefined,
+  viewer: string | null,
+): ReadonlyArray<IssueComment> {
+  return (raw?.nodes ?? []).flatMap((comment) => {
+    const id = trimmed(comment?.id);
+    if (comment == null || id === null) return [];
+    return [
+      {
+        id,
+        author: toActor(comment.author),
+        body: comment.body ?? "",
+        createdAt: comment.createdAt,
+        url: trimmed(comment.url),
+        reactions: toReactions(comment.reactionGroups, viewer),
+      },
+    ];
+  });
+}
+
+function previousCursorOf(
+  pageInfo: { readonly hasPreviousPage: boolean; readonly startCursor: string | null } | undefined,
+) {
+  return pageInfo?.hasPreviousPage === true ? pageInfo.startCursor : null;
+}
+
+function toViewerPermissions(raw: {
+  readonly viewerPermission?: string | null | undefined;
+  readonly issue: { readonly viewerCanUpdate: boolean } | null;
+}): IssueViewerPermissions {
+  const canUpdate = raw.issue?.viewerCanUpdate !== false;
+  const canTriage = ["ADMIN", "MAINTAIN", "WRITE", "TRIAGE"].includes(
+    raw.viewerPermission?.trim().toUpperCase() ?? "",
+  );
+  return {
+    setState: canUpdate,
+    comment: true,
+    edit: canUpdate,
+    labels: canTriage,
+    assignees: canTriage,
+  };
+}
+
+interface GitHubIssueDetail extends TrackerIssueSummary {
+  readonly body: string;
+  readonly viewer: string | null;
+  readonly viewerPermissions: IssueViewerPermissions;
+  readonly reactions: ReturnType<typeof toReactions>;
+  readonly comments: ReadonlyArray<IssueComment>;
+  readonly commentsCursor: string | null;
+  readonly events: ReadonlyArray<IssueEvent>;
+  readonly linkedPullRequests: ReadonlyArray<IssueLinkedPullRequest>;
+}
+
+/** Null for a number that names no issue the viewer can see. */
+export function toIssueDetail({
+  viewer: rawViewer,
+  repository,
+}: Issues.IssueDetail.Result): GitHubIssueDetail | null {
+  const issue = repository?.issue;
+  if (issue == null) return null;
+  const viewer = trimmed(rawViewer?.login);
+
+  // Closing references lead; a cross-reference seen twice is filed under the stronger relation.
+  const links = new Map<string, IssueLinkedPullRequest>();
+  for (const node of issue.closedByPullRequestsReferences?.nodes ?? []) {
+    const link = toLinkedPullRequest(node, true);
+    if (link !== null) links.set(`${link.repository.toLowerCase()}#${link.number}`, link);
+  }
+  const events: IssueEvent[] = [];
+  for (const entry of issue.timelineItems?.nodes ?? []) {
+    if (entry === null) continue;
+    const item = entry;
+    if (item.__typename === "CrossReferencedEvent") {
+      const link =
+        item.source.__typename === "PullRequest" ? toLinkedPullRequest(item.source, false) : null;
+      const linkKey = link === null ? null : `${link.repository.toLowerCase()}#${link.number}`;
+      if (link !== null && linkKey !== null && !links.has(linkKey)) links.set(linkKey, link);
+    }
+    const fields = toEventFields(item);
+    const id = trimmed("id" in item ? item.id : null);
+    const createdAt = trimmed("createdAt" in item ? item.createdAt : null);
+    if (fields === null || id === null || createdAt === null) continue;
+    events.push({ id, ...fields, actor: toActor("actor" in item ? item.actor : null), createdAt });
+  }
+  return {
+    ...toSummary(issue),
+    body: issue.body ?? "",
+    viewer,
+    viewerPermissions: toViewerPermissions({
+      viewerPermission: repository?.viewerPermission,
+      issue,
+    }),
+    reactions: toReactions(issue.reactionGroups, viewer),
+    comments: toComments(issue.comments, viewer),
+    commentsCursor: previousCursorOf(issue.comments?.pageInfo),
+    events,
+    linkedPullRequests: [...links.values()],
+  };
+}
+
+export function toIssueSearch({ search }: Issues.IssueSearch.Result) {
+  return {
+    items: (search.nodes ?? []).flatMap((node) =>
+      node !== null && node.__typename === "Issue" ? [toSummary(node)] : [],
+    ),
+    nextCursor: search.pageInfo.hasNextPage ? search.pageInfo.endCursor : null,
+  };
+}
+
+export function toIssueComments({ viewer, repository }: Issues.IssueComments.Result) {
+  const comments = repository?.issue?.comments;
+  return {
+    comments: toComments(comments, viewer.login),
+    nextCursor: previousCursorOf(comments?.pageInfo),
+  };
+}
+
+export function toIssueCandidates(
+  repository: NonNullable<Issues.IssueCandidates.Result["repository"]>,
+) {
+  const { labels, assignableUsers } = repository;
+  return {
+    labels: (labels?.nodes ?? []).flatMap((label) =>
+      label === null
+        ? []
+        : [
+            {
+              name: label.name,
+              color: label.color,
+              description: label.description,
+            },
+          ],
+    ),
+    assignees: toActors(assignableUsers.nodes).map((actor) => ({ ...actor, id: actor.login })),
+    truncated:
+      labels?.pageInfo.hasNextPage === true || assignableUsers.pageInfo.hasNextPage === true,
+  };
+}
+
+export function toIssueTemplates(
+  repository: NonNullable<Issues.IssueTemplates.Result["repository"]>,
+): ReadonlyArray<IssueTemplate> {
+  return (repository.issueTemplates ?? []).flatMap((template) => {
+    if (template === null || template.filename.trim() === "") return [];
+    return [
+      {
+        key: template.filename,
+        name: template.name,
+        about: template.about ?? "",
+        title: template.title ?? "",
+        body: template.body ?? "",
+        labels: (template.labels?.nodes ?? []).flatMap((node) => node?.name ?? []),
+        assignees: (template.assignees.nodes ?? []).flatMap((node) => node?.login ?? []),
+      },
+    ];
+  });
+}
+
+const decodeCreatedIssue = decodeJsonResult(
+  Schema.Struct({ number: Schema.Int, html_url: TrimmedNonEmptyString }),
+);
+
+export function decodeCreatedIssueJson(raw: string) {
+  return Result.map(decodeCreatedIssue(raw), (issue) => ({
+    number: issue.number,
+    url: issue.html_url,
+  }));
+}
diff --git a/packages/source-control-github/src/server/gitHubIssueTemplates.ts b/packages/source-control-github/src/server/gitHubIssueTemplates.ts
new file mode 100644
index 0000000000000..16a2151f543ba
--- /dev/null
+++ b/packages/source-control-github/src/server/gitHubIssueTemplates.ts
@@ -0,0 +1,159 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { parse as parseYaml } from "yaml";
+import { IssueTrackerKind, TrimmedNonEmptyString, type IssueTemplate } from "@t3tools/contracts";
+import { IssueTrackerError } from "@t3tools/source-control-core/server/IssueTracker";
+
+import type * as Issues from "./issues.graphql.ts";
+import { toIssueTemplates } from "./gitHubIssueJson.ts";
+
+const Names = Schema.Union([Schema.String, Schema.Array(Schema.String)]);
+const FormOption = Schema.Union([
+  Schema.String,
+  Schema.Struct({ label: Schema.String, required: Schema.optional(Schema.Boolean) }),
+]);
+const FormField = Schema.Struct({
+  type: Schema.String,
+  id: Schema.optional(Schema.String),
+  attributes: Schema.optional(
+    Schema.Struct({
+      label: Schema.optional(Schema.String),
+      description: Schema.optional(Schema.String),
+      value: Schema.optional(Schema.String),
+      placeholder: Schema.optional(Schema.String),
+      render: Schema.optional(Schema.String),
+      multiple: Schema.optional(Schema.Boolean),
+      default: Schema.optional(Schema.Union([Schema.Int, Schema.Array(Schema.Int)])),
+      options: Schema.optional(Schema.Array(FormOption)),
+    }),
+  ),
+  validations: Schema.optional(
+    Schema.Struct({
+      required: Schema.optional(Schema.Boolean),
+      accept: Schema.optional(Schema.String),
+    }),
+  ),
+});
+const decodeForm = Schema.decodeUnknownSync(
+  Schema.Struct({
+    name: TrimmedNonEmptyString,
+    description: Schema.String,
+    title: Schema.optional(Schema.String),
+    labels: Schema.optional(Names),
+    assignees: Schema.optional(Names),
+    body: Schema.Array(FormField),
+  }),
+);
+const decodeConfig = Schema.decodeUnknownSync(
+  Schema.Struct({ blank_issues_enabled: Schema.optional(Schema.Boolean) }),
+);
+
+function names(value: string | ReadonlyArray<string> | undefined): ReadonlyArray<string> {
+  return (typeof value === "string" ? value.split(",") : (value ?? []))
+    .map((name) => name.trim())
+    .filter((name) => name.length > 0);
+}
+
+function fieldMarkdown(field: typeof FormField.Type): string {
+  const attributes = field.attributes;
+  if (field.type === "markdown") return attributes?.value ?? "";
+
+  const sections = [`### ${attributes?.label ?? field.id ?? field.type}`];
+  if (attributes?.description) sections.push(attributes.description);
+  if (field.validations?.required) sections.push("Required.");
+  if (attributes?.placeholder)
+    sections.push(`Example:\n> ${attributes.placeholder.trim().replaceAll("\n", "\n> ")}`);
+  if (attributes?.render) sections.push(`Format: ${attributes.render}`);
+  if (field.validations?.accept) sections.push(`Accepted files: ${field.validations.accept}`);
+
+  const options = attributes?.options ?? [];
+  if (field.type === "checkboxes") {
+    sections.push(
+      options
+        .map((option) => {
+          const label = typeof option === "string" ? option : option.label;
+          const required = typeof option !== "string" && option.required;
+          return `- [ ] ${label}${required ? " (required)" : ""}`;
+        })
+        .join("\n"),
+    );
+  } else if (field.type === "dropdown") {
+    const defaults = attributes?.default;
+    const defaultIndices = typeof defaults === "number" ? [defaults] : (defaults ?? []);
+    sections.push(attributes?.multiple ? "Choose one or more:" : "Choose one:");
+    sections.push(
+      options
+        .map((option, index) => {
+          const label = typeof option === "string" ? option : option.label;
+          return `- ${label}${defaultIndices.includes(index) ? " (default)" : ""}`;
+        })
+        .join("\n"),
+    );
+  }
+  if (attributes?.value) sections.push(attributes.value);
+  return sections.filter(Boolean).join("\n\n");
+}
+
+export const readIssueTemplates = Effect.fnUntraced(function* (
+  repository: NonNullable<Issues.IssueTemplates.Result["repository"]>,
+) {
+  const templates = new Map<string, IssueTemplate>(
+    toIssueTemplates(repository).map((template) => [
+      template.key.slice(template.key.lastIndexOf("/") + 1),
+      template,
+    ]),
+  );
+  let blankIssuesEnabled = true;
+  const directory = repository.templateDirectory;
+  for (const entry of directory?.__typename === "Tree" ? (directory.entries ?? []) : []) {
+    if (!/\.ya?ml$/i.test(entry.name)) continue;
+    const blob = entry.object;
+    if (blob?.__typename !== "Blob" || blob.isTruncated || blob.text === null) {
+      return yield* new IssueTrackerError({
+        tracker: IssueTrackerKind.make("github"),
+        operation: "listTemplates",
+        reason: "failed",
+        detail: "GitHub returned incomplete issue template contents.",
+      });
+    }
+    const text = blob.text;
+    const isConfig = /^config\.ya?ml$/i.test(entry.name);
+    const parsed = yield* Effect.try({
+      try: () => {
+        const document: unknown = parseYaml(text);
+        if (isConfig) {
+          return { config: decodeConfig(document ?? {}) };
+        }
+        return { form: decodeForm(document) };
+      },
+      catch: (cause) =>
+        new IssueTrackerError({
+          tracker: IssueTrackerKind.make("github"),
+          operation: "listTemplates",
+          reason: "failed",
+          detail: "The repository has an unreadable issue template or configuration.",
+          cause,
+        }),
+    }).pipe(Effect.result);
+    if (Result.isFailure(parsed)) {
+      if (isConfig) return yield* parsed.failure;
+      continue;
+    }
+    if (parsed.success.config !== undefined) {
+      blankIssuesEnabled = parsed.success.config.blank_issues_enabled ?? true;
+    } else if (parsed.success.form !== undefined) {
+      const form = parsed.success.form;
+      templates.set(entry.name, {
+        key: entry.name,
+        name: form.name,
+        about: form.description,
+        title: form.title ?? "",
+        labels: names(form.labels),
+        assignees: names(form.assignees),
+        body: form.body.map(fieldMarkdown).filter(Boolean).join("\n\n"),
+      });
+    }
+  }
+  return { templates: [...templates.values()], blankIssuesEnabled };
+});
diff --git a/packages/source-control-github/src/server/gitHubPullRequestJson.ts b/packages/source-control-github/src/server/gitHubPullRequestJson.ts
index 5321b45b8f2db..f045afd54d704 100644
--- a/packages/source-control-github/src/server/gitHubPullRequestJson.ts
+++ b/packages/source-control-github/src/server/gitHubPullRequestJson.ts
@@ -191,7 +191,7 @@ export function gitHubReactionContent(
 }
 
 /** Keep the viewer in counts, not actors, to avoid duplicating 'You'. */
-function toReactions(
+export function toReactions(
   groups: ReadonlyArray<ReactionGroup> | null | undefined,
   viewer: string | null,
 ): ReadonlyArray<PullRequestReaction> {
diff --git a/packages/source-control-github/src/server/issues.graphql b/packages/source-control-github/src/server/issues.graphql
new file mode 100644
index 0000000000000..d68597d3de775
--- /dev/null
+++ b/packages/source-control-github/src/server/issues.graphql
@@ -0,0 +1,388 @@
+fragment IssueRow on Issue {
+  number
+  title
+  url
+  state
+  stateReason
+  createdAt
+  updatedAt
+  closedAt
+  author {
+    login
+    avatarUrl
+    ... on User {
+      name
+    }
+  }
+}
+
+query IssueSearch($q: String!, $cursor: String, $rows: Int!) {
+  search(query: $q, type: ISSUE, first: $rows, after: $cursor) {
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+    nodes {
+      ... on Issue {
+        ...IssueRow
+        assignees(first: 20) {
+          nodes {
+            login
+            name
+            avatarUrl
+          }
+        }
+        labels(first: 20) {
+          nodes {
+            name
+            color
+          }
+        }
+        comments {
+          totalCount
+        }
+      }
+    }
+  }
+}
+
+query IssueDetail($owner: String!, $name: String!, $number: Int!) {
+  viewer {
+    login
+  }
+  repository(owner: $owner, name: $name) {
+    viewerPermission
+    issue(number: $number) {
+      ...IssueRow
+      assignees(first: 100) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          login
+          name
+          avatarUrl
+        }
+      }
+      labels(first: 100) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          name
+          color
+        }
+      }
+      body
+      viewerCanUpdate
+      ...Reactions
+      comments(last: 100) {
+        totalCount
+        pageInfo {
+          hasPreviousPage
+          startCursor
+        }
+        nodes {
+          id
+          author {
+            login
+            avatarUrl
+          }
+          body
+          createdAt
+          url
+          ...Reactions
+        }
+      }
+      closedByPullRequestsReferences(first: 20, includeClosedPrs: true) {
+        nodes {
+          number
+          title
+          url
+          state
+          isDraft
+          repository {
+            nameWithOwner
+          }
+        }
+      }
+      timelineItems(
+        last: 100
+        itemTypes: [
+          CLOSED_EVENT
+          REOPENED_EVENT
+          LABELED_EVENT
+          UNLABELED_EVENT
+          ASSIGNED_EVENT
+          UNASSIGNED_EVENT
+          RENAMED_TITLE_EVENT
+          CROSS_REFERENCED_EVENT
+        ]
+      ) {
+        nodes {
+          __typename
+          ... on ClosedEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+          }
+          ... on ReopenedEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+          }
+          ... on LabeledEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+            label {
+              name
+            }
+          }
+          ... on UnlabeledEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+            label {
+              name
+            }
+          }
+          ... on AssignedEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+            assignee {
+              ... on User {
+                login
+                name
+              }
+              ... on Bot {
+                login
+              }
+            }
+          }
+          ... on UnassignedEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+            assignee {
+              ... on User {
+                login
+                name
+              }
+              ... on Bot {
+                login
+              }
+            }
+          }
+          ... on RenamedTitleEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+            currentTitle
+          }
+          ... on CrossReferencedEvent {
+            id
+            createdAt
+            actor {
+              login
+              avatarUrl
+            }
+            source {
+              __typename
+              ... on PullRequest {
+                number
+                title
+                url
+                state
+                isDraft
+                repository {
+                  nameWithOwner
+                }
+              }
+              ... on Issue {
+                number
+                repository {
+                  nameWithOwner
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+query IssueComments($owner: String!, $name: String!, $number: Int!, $cursor: String!) {
+  viewer {
+    login
+  }
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      comments(last: 100, before: $cursor) {
+        pageInfo {
+          hasPreviousPage
+          startCursor
+        }
+        nodes {
+          id
+          author {
+            login
+            avatarUrl
+          }
+          body
+          createdAt
+          url
+          ...Reactions
+        }
+      }
+    }
+  }
+}
+
+query IssueNodeId($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      id
+    }
+  }
+}
+
+query IssueCommentScope($owner: String!, $name: String!, $number: Int!, $commentId: ID!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      id
+    }
+  }
+  node(id: $commentId) {
+    ... on IssueComment {
+      issue {
+        id
+      }
+    }
+  }
+}
+
+query IssueCandidates($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    labels(first: 100) {
+      pageInfo {
+        hasNextPage
+      }
+      nodes {
+        name
+        color
+        description
+      }
+    }
+    assignableUsers(first: 100) {
+      pageInfo {
+        hasNextPage
+      }
+      nodes {
+        login
+        name
+        avatarUrl
+      }
+    }
+  }
+}
+
+query IssueTemplates($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    templateDirectory: object(expression: "HEAD:.github/ISSUE_TEMPLATE") {
+      ... on Tree {
+        entries {
+          name
+          object {
+            ... on Blob {
+              text
+              isTruncated
+            }
+          }
+        }
+      }
+    }
+    issueTemplates {
+      filename
+      name
+      about
+      title
+      body
+      assignees(first: 25) {
+        nodes {
+          login
+        }
+      }
+      labels(first: 50) {
+        nodes {
+          name
+        }
+      }
+    }
+  }
+}
+
+query IssueViewer {
+  viewer {
+    login
+  }
+}
+
+query IssueCollections(
+  $owner: String!
+  $name: String!
+  $number: Int!
+  $labelsCursor: String
+  $assigneesCursor: String
+) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      labels(first: 100, after: $labelsCursor) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          name
+          color
+        }
+      }
+      assignees(first: 100, after: $assigneesCursor) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          login
+          name
+          avatarUrl
+        }
+      }
+    }
+  }
+}
diff --git a/packages/source-control-github/src/server/issues.graphql.ts b/packages/source-control-github/src/server/issues.graphql.ts
new file mode 100644
index 0000000000000..8d942e5e50b1f
--- /dev/null
+++ b/packages/source-control-github/src/server/issues.graphql.ts
@@ -0,0 +1,1007 @@
+// Generated by @effect/graphql-generator from issues.graphql. Do not edit.
+import { GraphQL, GraphQLGroup } from "effect/graphql"
+import * as Schema from "effect/Schema"
+import * as Shared from "../../schema/github.graphql.ts"
+
+/** A user is an individual's account on GitHub that owns repositories and can make new content. */
+export const AuthorUser = Schema.Struct({
+  __typename: Schema.Literal("User"),
+  /** The username used to login. */
+  login: Schema.String,
+  /** A URL pointing to the user's public avatar. */
+  avatarUrl: Shared.URI,
+  /** The user's public profile name. */
+  name: Schema.NullOr(Schema.String)
+})
+export interface AuthorUser extends Schema.Struct.Type<typeof AuthorUser.fields> {}
+
+/** Represents an object which can take actions on GitHub. Typically a User or Bot. */
+export const ActorOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.Actor>()(["User"]),
+  /** The username of the actor. */
+  login: Schema.String,
+  /** A URL pointing to the actor's public avatar. */
+  avatarUrl: Shared.URI
+})
+export interface ActorOther extends Schema.Struct.Type<typeof ActorOther.fields> {}
+
+/**
+ * `fragment IssueRow on Issue`
+ *
+ * An Issue is a place to discuss ideas, enhancements, tasks, and bugs for a project.
+ */
+export const IssueRow = Schema.Struct({
+  /** Identifies the issue number. */
+  number: Shared.Int,
+  /** Identifies the issue title. */
+  title: Schema.String,
+  /** The HTTP URL for this issue */
+  url: Shared.URI,
+  /** Identifies the state of the issue. */
+  state: GraphQL.enumLiterals(Shared.IssueState.literals),
+  /** Identifies the reason for the issue state. */
+  stateReason: Schema.NullOr(GraphQL.enumLiterals(Shared.IssueStateReason.literals)),
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the date and time when the object was last updated. */
+  updatedAt: Shared.DateTime,
+  /** Identifies the date and time when the object was closed. */
+  closedAt: Schema.NullOr(Shared.DateTime),
+  /** The actor who authored the comment. */
+  author: Schema.NullOr(Schema.Union([
+    AuthorUser,
+    ActorOther
+  ]))
+})
+export interface IssueRow extends Schema.Struct.Type<typeof IssueRow.fields> {}
+
+/** Information about pagination in a connection. */
+export const SearchPageInfoPageInfo = Schema.Struct({
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Schema.Boolean,
+  /** When paginating forwards, the cursor to continue. */
+  endCursor: Schema.NullOr(Schema.String)
+})
+export interface SearchPageInfoPageInfo extends Schema.Struct.Type<typeof SearchPageInfoPageInfo.fields> {}
+
+/** A user is an individual's account on GitHub that owns repositories and can make new content. */
+export const AssigneesNodesUser = Schema.Struct({
+  /** The username used to login. */
+  login: Schema.String,
+  /** The user's public profile name. */
+  name: Schema.NullOr(Schema.String),
+  /** A URL pointing to the user's public avatar. */
+  avatarUrl: Shared.URI
+})
+export interface AssigneesNodesUser extends Schema.Struct.Type<typeof AssigneesNodesUser.fields> {}
+
+/** A list of users. */
+export const NodesAssigneesUserConnection = Schema.Struct({
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(AssigneesNodesUser)))
+})
+export interface NodesAssigneesUserConnection extends Schema.Struct.Type<typeof NodesAssigneesUserConnection.fields> {}
+
+/** A label for categorizing Issues, Pull Requests, Milestones, or Discussions with a given Repository. */
+export const NodesLabelsNodesLabel = Schema.Struct({
+  /** Identifies the label name. */
+  name: Schema.String,
+  /** Identifies the label color. */
+  color: Schema.String
+})
+export interface NodesLabelsNodesLabel extends Schema.Struct.Type<typeof NodesLabelsNodesLabel.fields> {}
+
+/** The connection type for Label. */
+export const NodesLabelsLabelConnection = Schema.Struct({
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(NodesLabelsNodesLabel)))
+})
+export interface NodesLabelsLabelConnection extends Schema.Struct.Type<typeof NodesLabelsLabelConnection.fields> {}
+
+/** The connection type for IssueComment. */
+export const NodesCommentsIssueCommentConnection = Schema.Struct({
+  /** Identifies the total count of items in the connection. */
+  totalCount: Shared.Int
+})
+export interface NodesCommentsIssueCommentConnection extends Schema.Struct.Type<typeof NodesCommentsIssueCommentConnection.fields> {}
+
+/** An Issue is a place to discuss ideas, enhancements, tasks, and bugs for a project. */
+export const NodesIssue = Schema.Struct({
+  __typename: Schema.Literal("Issue"),
+  ...IssueRow.fields,
+  /** A list of Users assigned to this object. */
+  assignees: NodesAssigneesUserConnection,
+  /** A list of labels associated with the object. */
+  labels: Schema.NullOr(NodesLabelsLabelConnection),
+  /** A list of comments associated with the Issue. */
+  comments: NodesCommentsIssueCommentConnection
+})
+export interface NodesIssue extends Schema.Struct.Type<typeof NodesIssue.fields> {}
+
+/** The results of a search. */
+export const SearchResultItemOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.SearchResultItem>()(["Issue"])
+})
+export interface SearchResultItemOther extends Schema.Struct.Type<typeof SearchResultItemOther.fields> {}
+
+/**
+ * A list of results that matched against a search query. Regardless of the number
+ * of matches, a maximum of 1,000 results will be available across all types,
+ * potentially split across many pages.
+ */
+export const SearchResultItemConnection = Schema.Struct({
+  /** Information to aid in pagination. */
+  pageInfo: SearchPageInfoPageInfo,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(Schema.Union([
+    NodesIssue,
+    SearchResultItemOther
+  ]))))
+})
+export interface SearchResultItemConnection extends Schema.Struct.Type<typeof SearchResultItemConnection.fields> {}
+
+/** `query IssueSearch` */
+export const IssueSearch = GraphQL.query("IssueSearch", {
+  document: {
+    variables: [
+      { name: "q", body: "String!" },
+      { name: "cursor", body: "String" },
+      { name: "rows", body: "Int!" }
+    ],
+    selections: [
+      { name: "search", body: ["(query:$", "q", " type:ISSUE first:$", "rows", " after:$", "cursor", "){pageInfo{hasNextPage endCursor}nodes{__typename...on Issue{...IssueRow assignees(first:20){nodes{login name avatarUrl}}labels(first:20){nodes{name color}}comments{totalCount}}}}"] }
+    ],
+    fragments: [
+      { name: "IssueRow", body: ["on Issue{number title url state stateReason createdAt updatedAt closedAt author{__typename login avatarUrl...on User{name}}}"] }
+    ]
+  },
+  variables: {
+    q: Schema.String,
+    cursor: Schema.optional(Schema.NullOr(Schema.String)),
+    rows: Shared.Int
+  },
+  result: Schema.Struct({
+    /** Perform a search across resources, returning a maximum of 1,000 results. */
+    search: SearchResultItemConnection
+  })
+})
+export declare namespace IssueSearch {
+  export type Variables = typeof IssueSearch.variables.Type
+  export type Result = typeof IssueSearch.result.Type
+}
+
+/** A user is an individual's account on GitHub that owns repositories and can make new content. */
+export const ViewerUser = Schema.Struct({
+  /** The username used to login. */
+  login: Schema.String
+})
+export interface ViewerUser extends Schema.Struct.Type<typeof ViewerUser.fields> {}
+
+/** A list of users. */
+export const IssueAssigneesUserConnection = Schema.Struct({
+  /** Information to aid in pagination. */
+  pageInfo: SearchPageInfoPageInfo,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(AssigneesNodesUser)))
+})
+export interface IssueAssigneesUserConnection extends Schema.Struct.Type<typeof IssueAssigneesUserConnection.fields> {}
+
+/** The connection type for Label. */
+export const IssueLabelsLabelConnection = Schema.Struct({
+  /** Information to aid in pagination. */
+  pageInfo: SearchPageInfoPageInfo,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(NodesLabelsNodesLabel)))
+})
+export interface IssueLabelsLabelConnection extends Schema.Struct.Type<typeof IssueLabelsLabelConnection.fields> {}
+
+/** A user is an individual's account on GitHub that owns repositories and can make new content. */
+export const ReactorsNodesUser = Schema.Struct({
+  __typename: Schema.Literal("User"),
+  /** The username used to login. */
+  login: Schema.String
+})
+export interface ReactorsNodesUser extends Schema.Struct.Type<typeof ReactorsNodesUser.fields> {}
+
+/** A special type of user which takes actions on behalf of GitHub Apps. */
+export const Bot = Schema.Struct({
+  __typename: Schema.Literal("Bot"),
+  /** The username of the actor. */
+  login: Schema.String
+})
+export interface Bot extends Schema.Struct.Type<typeof Bot.fields> {}
+
+/** An account on GitHub, with one or more owners, that has repositories, members and teams. */
+export const Organization = Schema.Struct({
+  __typename: Schema.Literal("Organization"),
+  /** The organization's login name. */
+  login: Schema.String
+})
+export interface Organization extends Schema.Struct.Type<typeof Organization.fields> {}
+
+/** A placeholder user for attribution of imported data on GitHub. */
+export const Mannequin = Schema.Struct({
+  __typename: Schema.Literal("Mannequin"),
+  /** The username of the actor. */
+  login: Schema.String
+})
+export interface Mannequin extends Schema.Struct.Type<typeof Mannequin.fields> {}
+
+/** Types that can be assigned to reactions. */
+export const ReactorOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.Reactor>()(["User", "Bot", "Organization", "Mannequin"])
+})
+export interface ReactorOther extends Schema.Struct.Type<typeof ReactorOther.fields> {}
+
+/** The connection type for Reactor. */
+export const ReactorConnection = Schema.Struct({
+  /** Identifies the total count of items in the connection. */
+  totalCount: Shared.Int,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(Schema.Union([
+    ReactorsNodesUser,
+    Bot,
+    Organization,
+    Mannequin,
+    ReactorOther
+  ]))))
+})
+export interface ReactorConnection extends Schema.Struct.Type<typeof ReactorConnection.fields> {}
+
+/** A group of emoji reactions to a particular piece of content. */
+export const ReactionGroup = Schema.Struct({
+  /** Identifies the emoji reaction. */
+  content: GraphQL.enumLiterals(Shared.ReactionContent.literals),
+  /** Whether or not the authenticated user has left a reaction on the subject. */
+  viewerHasReacted: Schema.Boolean,
+  /** Reactors to the reaction subject with the emotion represented by this reaction group. */
+  reactors: ReactorConnection
+})
+export interface ReactionGroup extends Schema.Struct.Type<typeof ReactionGroup.fields> {}
+
+/** Information about pagination in a connection. */
+export const CommentsPageInfoPageInfo = Schema.Struct({
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Schema.Boolean,
+  /** When paginating backwards, the cursor to continue. */
+  startCursor: Schema.NullOr(Schema.String)
+})
+export interface CommentsPageInfoPageInfo extends Schema.Struct.Type<typeof CommentsPageInfoPageInfo.fields> {}
+
+/** Represents an object which can take actions on GitHub. Typically a User or Bot. */
+export const Actor = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.Actor>()([]),
+  /** The username of the actor. */
+  login: Schema.String,
+  /** A URL pointing to the actor's public avatar. */
+  avatarUrl: Shared.URI
+})
+export interface Actor extends Schema.Struct.Type<typeof Actor.fields> {}
+
+/** Represents a comment on an Issue. */
+export const NodesIssueComment = Schema.Struct({
+  /** The Node ID of the IssueComment object */
+  id: Shared.ID,
+  /** The actor who authored the comment. */
+  author: Schema.NullOr(Actor),
+  /** The body as Markdown. */
+  body: Schema.String,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** The HTTP URL for this issue comment */
+  url: Shared.URI,
+  /** A list of reactions grouped by content left on the subject. */
+  reactionGroups: Schema.NullOr(Schema.Array(ReactionGroup))
+})
+export interface NodesIssueComment extends Schema.Struct.Type<typeof NodesIssueComment.fields> {}
+
+/** The connection type for IssueComment. */
+export const IssueDetailRepositoryIssueCommentsIssueCommentConnection = Schema.Struct({
+  /** Identifies the total count of items in the connection. */
+  totalCount: Shared.Int,
+  /** Information to aid in pagination. */
+  pageInfo: CommentsPageInfoPageInfo,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(NodesIssueComment)))
+})
+export interface IssueDetailRepositoryIssueCommentsIssueCommentConnection extends Schema.Struct.Type<typeof IssueDetailRepositoryIssueCommentsIssueCommentConnection.fields> {}
+
+/** A repository contains the content for a project. */
+export const NodesRepositoryRepository = Schema.Struct({
+  /** The repository's name with owner. */
+  nameWithOwner: Schema.String
+})
+export interface NodesRepositoryRepository extends Schema.Struct.Type<typeof NodesRepositoryRepository.fields> {}
+
+/** A repository pull request. */
+export const NodesPullRequest = Schema.Struct({
+  /** Identifies the pull request number. */
+  number: Shared.Int,
+  /** Identifies the pull request title. */
+  title: Schema.String,
+  /** The HTTP URL for this pull request. */
+  url: Shared.URI,
+  /** Identifies the state of the pull request. */
+  state: GraphQL.enumLiterals(Shared.PullRequestState.literals),
+  /** Identifies if the pull request is a draft. */
+  isDraft: Schema.Boolean,
+  /** The repository associated with this node. */
+  repository: NodesRepositoryRepository
+})
+export interface NodesPullRequest extends Schema.Struct.Type<typeof NodesPullRequest.fields> {}
+
+/** The connection type for PullRequest. */
+export const PullRequestConnection = Schema.Struct({
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(NodesPullRequest)))
+})
+export interface PullRequestConnection extends Schema.Struct.Type<typeof PullRequestConnection.fields> {}
+
+/** Represents a 'closed' event on any `Closable`. */
+export const ClosedEvent = Schema.Struct({
+  __typename: Schema.Literal("ClosedEvent"),
+  /** The Node ID of the ClosedEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor)
+})
+export interface ClosedEvent extends Schema.Struct.Type<typeof ClosedEvent.fields> {}
+
+/** Represents a 'reopened' event on any `Closable`. */
+export const ReopenedEvent = Schema.Struct({
+  __typename: Schema.Literal("ReopenedEvent"),
+  /** The Node ID of the ReopenedEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor)
+})
+export interface ReopenedEvent extends Schema.Struct.Type<typeof ReopenedEvent.fields> {}
+
+/** A label for categorizing Issues, Pull Requests, Milestones, or Discussions with a given Repository. */
+export const LabelLabel = Schema.Struct({
+  /** Identifies the label name. */
+  name: Schema.String
+})
+export interface LabelLabel extends Schema.Struct.Type<typeof LabelLabel.fields> {}
+
+/** Represents a 'labeled' event on a given issue or pull request. */
+export const LabeledEvent = Schema.Struct({
+  __typename: Schema.Literal("LabeledEvent"),
+  /** The Node ID of the LabeledEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor),
+  /** Identifies the label associated with the 'labeled' event. */
+  label: LabelLabel
+})
+export interface LabeledEvent extends Schema.Struct.Type<typeof LabeledEvent.fields> {}
+
+/** Represents an 'unlabeled' event on a given issue or pull request. */
+export const UnlabeledEvent = Schema.Struct({
+  __typename: Schema.Literal("UnlabeledEvent"),
+  /** The Node ID of the UnlabeledEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor),
+  /** Identifies the label associated with the 'unlabeled' event. */
+  label: LabelLabel
+})
+export interface UnlabeledEvent extends Schema.Struct.Type<typeof UnlabeledEvent.fields> {}
+
+/** A user is an individual's account on GitHub that owns repositories and can make new content. */
+export const AssigneeUser = Schema.Struct({
+  __typename: Schema.Literal("User"),
+  /** The username used to login. */
+  login: Schema.String,
+  /** The user's public profile name. */
+  name: Schema.NullOr(Schema.String)
+})
+export interface AssigneeUser extends Schema.Struct.Type<typeof AssigneeUser.fields> {}
+
+/** Types that can be assigned to issues. */
+export const AssigneeOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.Assignee>()(["User", "Bot"])
+})
+export interface AssigneeOther extends Schema.Struct.Type<typeof AssigneeOther.fields> {}
+
+/** Represents an 'assigned' event on any assignable object. */
+export const AssignedEvent = Schema.Struct({
+  __typename: Schema.Literal("AssignedEvent"),
+  /** The Node ID of the AssignedEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor),
+  /** Identifies the user or mannequin that was assigned. */
+  assignee: Schema.NullOr(Schema.Union([
+    AssigneeUser,
+    Bot,
+    AssigneeOther
+  ]))
+})
+export interface AssignedEvent extends Schema.Struct.Type<typeof AssignedEvent.fields> {}
+
+/** Represents an 'unassigned' event on any assignable object. */
+export const UnassignedEvent = Schema.Struct({
+  __typename: Schema.Literal("UnassignedEvent"),
+  /** The Node ID of the UnassignedEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor),
+  /** Identifies the user or mannequin that was unassigned. */
+  assignee: Schema.NullOr(Schema.Union([
+    AssigneeUser,
+    Bot,
+    AssigneeOther
+  ]))
+})
+export interface UnassignedEvent extends Schema.Struct.Type<typeof UnassignedEvent.fields> {}
+
+/** Represents a 'renamed' event on a given issue or pull request */
+export const RenamedTitleEvent = Schema.Struct({
+  __typename: Schema.Literal("RenamedTitleEvent"),
+  /** The Node ID of the RenamedTitleEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor),
+  /** Identifies the current title of the issue or pull request. */
+  currentTitle: Schema.String
+})
+export interface RenamedTitleEvent extends Schema.Struct.Type<typeof RenamedTitleEvent.fields> {}
+
+/** A repository pull request. */
+export const SourcePullRequest = Schema.Struct({
+  __typename: Schema.Literal("PullRequest"),
+  /** Identifies the pull request number. */
+  number: Shared.Int,
+  /** Identifies the pull request title. */
+  title: Schema.String,
+  /** The HTTP URL for this pull request. */
+  url: Shared.URI,
+  /** Identifies the state of the pull request. */
+  state: GraphQL.enumLiterals(Shared.PullRequestState.literals),
+  /** Identifies if the pull request is a draft. */
+  isDraft: Schema.Boolean,
+  /** The repository associated with this node. */
+  repository: NodesRepositoryRepository
+})
+export interface SourcePullRequest extends Schema.Struct.Type<typeof SourcePullRequest.fields> {}
+
+/** An Issue is a place to discuss ideas, enhancements, tasks, and bugs for a project. */
+export const SourceIssue = Schema.Struct({
+  __typename: Schema.Literal("Issue"),
+  /** Identifies the issue number. */
+  number: Shared.Int,
+  /** The repository associated with this node. */
+  repository: NodesRepositoryRepository
+})
+export interface SourceIssue extends Schema.Struct.Type<typeof SourceIssue.fields> {}
+
+/** Any referencable object */
+export const ReferencedSubjectOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.ReferencedSubject>()(["PullRequest", "Issue"])
+})
+export interface ReferencedSubjectOther extends Schema.Struct.Type<typeof ReferencedSubjectOther.fields> {}
+
+/** Represents a mention made by one issue or pull request to another. */
+export const CrossReferencedEvent = Schema.Struct({
+  __typename: Schema.Literal("CrossReferencedEvent"),
+  /** The Node ID of the CrossReferencedEvent object */
+  id: Shared.ID,
+  /** Identifies the date and time when the object was created. */
+  createdAt: Shared.DateTime,
+  /** Identifies the actor who performed the event. */
+  actor: Schema.NullOr(Actor),
+  /** Issue or pull request that made the reference. */
+  source: Schema.Union([
+    SourcePullRequest,
+    SourceIssue,
+    ReferencedSubjectOther
+  ])
+})
+export interface CrossReferencedEvent extends Schema.Struct.Type<typeof CrossReferencedEvent.fields> {}
+
+/** An item in an issue timeline */
+export const IssueTimelineItemsOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.IssueTimelineItems>()(["ClosedEvent", "ReopenedEvent", "LabeledEvent", "UnlabeledEvent", "AssignedEvent", "UnassignedEvent", "RenamedTitleEvent", "CrossReferencedEvent"])
+})
+export interface IssueTimelineItemsOther extends Schema.Struct.Type<typeof IssueTimelineItemsOther.fields> {}
+
+/** The connection type for IssueTimelineItems. */
+export const IssueTimelineItemsConnection = Schema.Struct({
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(Schema.Union([
+    ClosedEvent,
+    ReopenedEvent,
+    LabeledEvent,
+    UnlabeledEvent,
+    AssignedEvent,
+    UnassignedEvent,
+    RenamedTitleEvent,
+    CrossReferencedEvent,
+    IssueTimelineItemsOther
+  ]))))
+})
+export interface IssueTimelineItemsConnection extends Schema.Struct.Type<typeof IssueTimelineItemsConnection.fields> {}
+
+/** An Issue is a place to discuss ideas, enhancements, tasks, and bugs for a project. */
+export const IssueDetailRepositoryIssueIssue = Schema.Struct({
+  ...IssueRow.fields,
+  /** A list of Users assigned to this object. */
+  assignees: IssueAssigneesUserConnection,
+  /** A list of labels associated with the object. */
+  labels: Schema.NullOr(IssueLabelsLabelConnection),
+  /** Identifies the body of the issue. */
+  body: Schema.String,
+  /** Check if the current viewer can update this object. */
+  viewerCanUpdate: Schema.Boolean,
+  /** A list of reactions grouped by content left on the subject. */
+  reactionGroups: Schema.NullOr(Schema.Array(ReactionGroup)),
+  /** A list of comments associated with the Issue. */
+  comments: IssueDetailRepositoryIssueCommentsIssueCommentConnection,
+  /** List of open pull requests referenced from this issue */
+  closedByPullRequestsReferences: Schema.NullOr(PullRequestConnection),
+  /** A list of events, comments, commits, etc. associated with the issue. */
+  timelineItems: IssueTimelineItemsConnection
+})
+export interface IssueDetailRepositoryIssueIssue extends Schema.Struct.Type<typeof IssueDetailRepositoryIssueIssue.fields> {}
+
+/** A repository contains the content for a project. */
+export const IssueDetailRepositoryRepository = Schema.Struct({
+  /** The users permission level on the repository. Will return null if authenticated as an GitHub App. */
+  viewerPermission: Schema.NullOr(GraphQL.enumLiterals(Shared.RepositoryPermission.literals)),
+  /** Returns a single issue from the current repository by number. */
+  issue: Schema.NullOr(IssueDetailRepositoryIssueIssue)
+})
+export interface IssueDetailRepositoryRepository extends Schema.Struct.Type<typeof IssueDetailRepositoryRepository.fields> {}
+
+/** `query IssueDetail` */
+export const IssueDetail = GraphQL.query("IssueDetail", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" },
+      { name: "number", body: "Int!" }
+    ],
+    selections: [
+      { name: "viewer", body: ["{login}"] },
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){viewerPermission issue(number:$", "number", "){...IssueRow assignees(first:100){pageInfo{hasNextPage endCursor}nodes{login name avatarUrl}}labels(first:100){pageInfo{hasNextPage endCursor}nodes{name color}}body viewerCanUpdate...Reactions comments(last:100){totalCount pageInfo{hasPreviousPage startCursor}nodes{id author{__typename login avatarUrl}body createdAt url...Reactions}}closedByPullRequestsReferences(first:20 includeClosedPrs:true){nodes{number title url state isDraft repository{nameWithOwner}}}timelineItems(last:100 itemTypes:[CLOSED_EVENT REOPENED_EVENT LABELED_EVENT UNLABELED_EVENT ASSIGNED_EVENT UNASSIGNED_EVENT RENAMED_TITLE_EVENT CROSS_REFERENCED_EVENT]){nodes{__typename...on ClosedEvent{id createdAt actor{__typename login avatarUrl}}...on ReopenedEvent{id createdAt actor{__typename login avatarUrl}}...on LabeledEvent{id createdAt actor{__typename login avatarUrl}label{name}}...on UnlabeledEvent{id createdAt actor{__typename login avatarUrl}label{name}}...on AssignedEvent{id createdAt actor{__typename login avatarUrl}assignee{__typename...on User{login name}...on Bot{login}}}...on UnassignedEvent{id createdAt actor{__typename login avatarUrl}assignee{__typename...on User{login name}...on Bot{login}}}...on RenamedTitleEvent{id createdAt actor{__typename login avatarUrl}currentTitle}...on CrossReferencedEvent{id createdAt actor{__typename login avatarUrl}source{__typename...on PullRequest{number title url state isDraft repository{nameWithOwner}}...on Issue{number repository{nameWithOwner}}}}}}}}"] }
+    ],
+    fragments: [
+      { name: "IssueRow", body: ["on Issue{number title url state stateReason createdAt updatedAt closedAt author{__typename login avatarUrl...on User{name}}}"] },
+      { name: "Reactions", body: ["on Reactable{__typename reactionGroups{content viewerHasReacted reactors(first:10){totalCount nodes{__typename...on User{login}...on Bot{login}...on Organization{login}...on Mannequin{login}}}}}"] }
+    ]
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String,
+    number: Shared.Int
+  },
+  result: Schema.Struct({
+    /** The currently authenticated user. */
+    viewer: ViewerUser,
+    /** Lookup a given repository by the owner and repository name. */
+    repository: Schema.NullOr(IssueDetailRepositoryRepository)
+  })
+})
+export declare namespace IssueDetail {
+  export type Variables = typeof IssueDetail.variables.Type
+  export type Result = typeof IssueDetail.result.Type
+}
+
+/** The connection type for IssueComment. */
+export const IssueCommentsRepositoryIssueCommentsIssueCommentConnection = Schema.Struct({
+  /** Information to aid in pagination. */
+  pageInfo: CommentsPageInfoPageInfo,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(NodesIssueComment)))
+})
+export interface IssueCommentsRepositoryIssueCommentsIssueCommentConnection extends Schema.Struct.Type<typeof IssueCommentsRepositoryIssueCommentsIssueCommentConnection.fields> {}
+
+/** An Issue is a place to discuss ideas, enhancements, tasks, and bugs for a project. */
+export const IssueCommentsRepositoryIssueIssue = Schema.Struct({
+  /** A list of comments associated with the Issue. */
+  comments: IssueCommentsRepositoryIssueCommentsIssueCommentConnection
+})
+export interface IssueCommentsRepositoryIssueIssue extends Schema.Struct.Type<typeof IssueCommentsRepositoryIssueIssue.fields> {}
+
+/** A repository contains the content for a project. */
+export const IssueCommentsRepositoryRepository = Schema.Struct({
+  /** Returns a single issue from the current repository by number. */
+  issue: Schema.NullOr(IssueCommentsRepositoryIssueIssue)
+})
+export interface IssueCommentsRepositoryRepository extends Schema.Struct.Type<typeof IssueCommentsRepositoryRepository.fields> {}
+
+/** `query IssueComments` */
+export const IssueComments = GraphQL.query("IssueComments", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" },
+      { name: "number", body: "Int!" },
+      { name: "cursor", body: "String!" }
+    ],
+    selections: [
+      { name: "viewer", body: ["{login}"] },
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){issue(number:$", "number", "){comments(last:100 before:$", "cursor", "){pageInfo{hasPreviousPage startCursor}nodes{id author{__typename login avatarUrl}body createdAt url...Reactions}}}}"] }
+    ],
+    fragments: [
+      { name: "Reactions", body: ["on Reactable{__typename reactionGroups{content viewerHasReacted reactors(first:10){totalCount nodes{__typename...on User{login}...on Bot{login}...on Organization{login}...on Mannequin{login}}}}}"] }
+    ]
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String,
+    number: Shared.Int,
+    cursor: Schema.String
+  },
+  result: Schema.Struct({
+    /** The currently authenticated user. */
+    viewer: ViewerUser,
+    /** Lookup a given repository by the owner and repository name. */
+    repository: Schema.NullOr(IssueCommentsRepositoryRepository)
+  })
+})
+export declare namespace IssueComments {
+  export type Variables = typeof IssueComments.variables.Type
+  export type Result = typeof IssueComments.result.Type
+}
+
+/** An Issue is a place to discuss ideas, enhancements, tasks, and bugs for a project. */
+export const IssueNodeIdRepositoryIssueIssue = Schema.Struct({
+  /** The Node ID of the Issue object */
+  id: Shared.ID
+})
+export interface IssueNodeIdRepositoryIssueIssue extends Schema.Struct.Type<typeof IssueNodeIdRepositoryIssueIssue.fields> {}
+
+/** A repository contains the content for a project. */
+export const IssueNodeIdRepositoryRepository = Schema.Struct({
+  /** Returns a single issue from the current repository by number. */
+  issue: Schema.NullOr(IssueNodeIdRepositoryIssueIssue)
+})
+export interface IssueNodeIdRepositoryRepository extends Schema.Struct.Type<typeof IssueNodeIdRepositoryRepository.fields> {}
+
+/** `query IssueNodeId` */
+export const IssueNodeId = GraphQL.query("IssueNodeId", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" },
+      { name: "number", body: "Int!" }
+    ],
+    selections: [
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){issue(number:$", "number", "){id}}"] }
+    ],
+    fragments: []
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String,
+    number: Shared.Int
+  },
+  result: Schema.Struct({
+    /** Lookup a given repository by the owner and repository name. */
+    repository: Schema.NullOr(IssueNodeIdRepositoryRepository)
+  })
+})
+export declare namespace IssueNodeId {
+  export type Variables = typeof IssueNodeId.variables.Type
+  export type Result = typeof IssueNodeId.result.Type
+}
+
+/** Represents a comment on an Issue. */
+export const NodeIssueComment = Schema.Struct({
+  __typename: Schema.Literal("IssueComment"),
+  /** Identifies the issue associated with the comment. */
+  issue: IssueNodeIdRepositoryIssueIssue
+})
+export interface NodeIssueComment extends Schema.Struct.Type<typeof NodeIssueComment.fields> {}
+
+/** An object with an ID. */
+export const NodeOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.Node>()(["IssueComment"])
+})
+export interface NodeOther extends Schema.Struct.Type<typeof NodeOther.fields> {}
+
+/** `query IssueCommentScope` */
+export const IssueCommentScope = GraphQL.query("IssueCommentScope", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" },
+      { name: "number", body: "Int!" },
+      { name: "commentId", body: "ID!" }
+    ],
+    selections: [
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){issue(number:$", "number", "){id}}"] },
+      { name: "node", body: ["(id:$", "commentId", "){__typename...on IssueComment{issue{id}}}"] }
+    ],
+    fragments: []
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String,
+    number: Shared.Int,
+    commentId: Shared.ID
+  },
+  result: Schema.Struct({
+    /** Lookup a given repository by the owner and repository name. */
+    repository: Schema.NullOr(IssueNodeIdRepositoryRepository),
+    /** Fetches an object given its ID. */
+    node: Schema.NullOr(Schema.Union([
+      NodeIssueComment,
+      NodeOther
+    ]))
+  })
+})
+export declare namespace IssueCommentScope {
+  export type Variables = typeof IssueCommentScope.variables.Type
+  export type Result = typeof IssueCommentScope.result.Type
+}
+
+/** Information about pagination in a connection. */
+export const LabelsPageInfoPageInfo = Schema.Struct({
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Schema.Boolean
+})
+export interface LabelsPageInfoPageInfo extends Schema.Struct.Type<typeof LabelsPageInfoPageInfo.fields> {}
+
+/** A label for categorizing Issues, Pull Requests, Milestones, or Discussions with a given Repository. */
+export const RepositoryLabelsNodesLabel = Schema.Struct({
+  /** Identifies the label name. */
+  name: Schema.String,
+  /** Identifies the label color. */
+  color: Schema.String,
+  /** A brief description of this label. */
+  description: Schema.NullOr(Schema.String)
+})
+export interface RepositoryLabelsNodesLabel extends Schema.Struct.Type<typeof RepositoryLabelsNodesLabel.fields> {}
+
+/** The connection type for Label. */
+export const RepositoryLabelsLabelConnection = Schema.Struct({
+  /** Information to aid in pagination. */
+  pageInfo: LabelsPageInfoPageInfo,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(RepositoryLabelsNodesLabel)))
+})
+export interface RepositoryLabelsLabelConnection extends Schema.Struct.Type<typeof RepositoryLabelsLabelConnection.fields> {}
+
+/** A list of users. */
+export const AssignableUsersUserConnection = Schema.Struct({
+  /** Information to aid in pagination. */
+  pageInfo: LabelsPageInfoPageInfo,
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(AssigneesNodesUser)))
+})
+export interface AssignableUsersUserConnection extends Schema.Struct.Type<typeof AssignableUsersUserConnection.fields> {}
+
+/** A repository contains the content for a project. */
+export const IssueCandidatesRepositoryRepository = Schema.Struct({
+  /** A list of labels associated with the repository. */
+  labels: Schema.NullOr(RepositoryLabelsLabelConnection),
+  /** A list of users that can be assigned to issues in this repository. */
+  assignableUsers: AssignableUsersUserConnection
+})
+export interface IssueCandidatesRepositoryRepository extends Schema.Struct.Type<typeof IssueCandidatesRepositoryRepository.fields> {}
+
+/** `query IssueCandidates` */
+export const IssueCandidates = GraphQL.query("IssueCandidates", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" }
+    ],
+    selections: [
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){labels(first:100){pageInfo{hasNextPage}nodes{name color description}}assignableUsers(first:100){pageInfo{hasNextPage}nodes{login name avatarUrl}}}"] }
+    ],
+    fragments: []
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String
+  },
+  result: Schema.Struct({
+    /** Lookup a given repository by the owner and repository name. */
+    repository: Schema.NullOr(IssueCandidatesRepositoryRepository)
+  })
+})
+export declare namespace IssueCandidates {
+  export type Variables = typeof IssueCandidates.variables.Type
+  export type Result = typeof IssueCandidates.result.Type
+}
+
+/** Represents a Git blob. */
+export const Blob = Schema.Struct({
+  __typename: Schema.Literal("Blob"),
+  /** UTF8 text data or null if the Blob is binary */
+  text: Schema.NullOr(Schema.String),
+  /** Indicates whether the contents is truncated */
+  isTruncated: Schema.Boolean
+})
+export interface Blob extends Schema.Struct.Type<typeof Blob.fields> {}
+
+/** Represents a Git object. */
+export const ObjectGitObjectOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.GitObject>()(["Blob"])
+})
+export interface ObjectGitObjectOther extends Schema.Struct.Type<typeof ObjectGitObjectOther.fields> {}
+
+/** Represents a Git tree entry. */
+export const TreeEntry = Schema.Struct({
+  /** Entry file name. */
+  name: Schema.String,
+  /** Entry file object. */
+  object: Schema.NullOr(Schema.Union([
+    Blob,
+    ObjectGitObjectOther
+  ]))
+})
+export interface TreeEntry extends Schema.Struct.Type<typeof TreeEntry.fields> {}
+
+/** Represents a Git tree. */
+export const Tree = Schema.Struct({
+  __typename: Schema.Literal("Tree"),
+  /** A list of tree entries. */
+  entries: Schema.NullOr(Schema.Array(TreeEntry))
+})
+export interface Tree extends Schema.Struct.Type<typeof Tree.fields> {}
+
+/** Represents a Git object. */
+export const TemplateDirectoryGitObjectOther = Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.GitObject>()(["Tree"])
+})
+export interface TemplateDirectoryGitObjectOther extends Schema.Struct.Type<typeof TemplateDirectoryGitObjectOther.fields> {}
+
+/** A list of users. */
+export const IssueTemplatesAssigneesUserConnection = Schema.Struct({
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(ViewerUser)))
+})
+export interface IssueTemplatesAssigneesUserConnection extends Schema.Struct.Type<typeof IssueTemplatesAssigneesUserConnection.fields> {}
+
+/** The connection type for Label. */
+export const IssueTemplatesLabelsLabelConnection = Schema.Struct({
+  /** A list of nodes. */
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(LabelLabel)))
+})
+export interface IssueTemplatesLabelsLabelConnection extends Schema.Struct.Type<typeof IssueTemplatesLabelsLabelConnection.fields> {}
+
+/** A repository issue template. */
+export const IssueTemplate = Schema.Struct({
+  /** The template filename. */
+  filename: Schema.String,
+  /** The template name. */
+  name: Schema.String,
+  /** The template purpose. */
+  about: Schema.NullOr(Schema.String),
+  /** The suggested issue title. */
+  title: Schema.NullOr(Schema.String),
+  /** The suggested issue body. */
+  body: Schema.NullOr(Schema.String),
+  /** The suggested assignees. */
+  assignees: IssueTemplatesAssigneesUserConnection,
+  /** The suggested issue labels */
+  labels: Schema.NullOr(IssueTemplatesLabelsLabelConnection)
+})
+export interface IssueTemplate extends Schema.Struct.Type<typeof IssueTemplate.fields> {}
+
+/** A repository contains the content for a project. */
+export const IssueTemplatesRepositoryRepository = Schema.Struct({
+  /** A Git object in the repository */
+  templateDirectory: Schema.NullOr(Schema.Union([
+    Tree,
+    TemplateDirectoryGitObjectOther
+  ])),
+  /** Returns a list of issue templates associated to the repository */
+  issueTemplates: Schema.NullOr(Schema.Array(IssueTemplate))
+})
+export interface IssueTemplatesRepositoryRepository extends Schema.Struct.Type<typeof IssueTemplatesRepositoryRepository.fields> {}
+
+/** `query IssueTemplates` */
+export const IssueTemplates = GraphQL.query("IssueTemplates", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" }
+    ],
+    selections: [
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){templateDirectory:object(expression:\"HEAD:.github/ISSUE_TEMPLATE\"){__typename...on Tree{entries{name object{__typename...on Blob{text isTruncated}}}}}issueTemplates{filename name about title body assignees(first:25){nodes{login}}labels(first:50){nodes{name}}}}"] }
+    ],
+    fragments: []
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String
+  },
+  result: Schema.Struct({
+    /** Lookup a given repository by the owner and repository name. */
+    repository: Schema.NullOr(IssueTemplatesRepositoryRepository)
+  })
+})
+export declare namespace IssueTemplates {
+  export type Variables = typeof IssueTemplates.variables.Type
+  export type Result = typeof IssueTemplates.result.Type
+}
+
+/** `query IssueViewer` */
+export const IssueViewer = GraphQL.query("IssueViewer", {
+  document: {
+    variables: [],
+    selections: [
+      { name: "viewer", body: ["{login}"] }
+    ],
+    fragments: []
+  },
+  result: Schema.Struct({
+    /** The currently authenticated user. */
+    viewer: ViewerUser
+  })
+})
+export declare namespace IssueViewer {
+  export type Variables = typeof IssueViewer.variables.Type
+  export type Result = typeof IssueViewer.result.Type
+}
+
+/** An Issue is a place to discuss ideas, enhancements, tasks, and bugs for a project. */
+export const IssueCollectionsRepositoryIssueIssue = Schema.Struct({
+  /** A list of labels associated with the object. */
+  labels: Schema.NullOr(IssueLabelsLabelConnection),
+  /** A list of Users assigned to this object. */
+  assignees: IssueAssigneesUserConnection
+})
+export interface IssueCollectionsRepositoryIssueIssue extends Schema.Struct.Type<typeof IssueCollectionsRepositoryIssueIssue.fields> {}
+
+/** A repository contains the content for a project. */
+export const IssueCollectionsRepositoryRepository = Schema.Struct({
+  /** Returns a single issue from the current repository by number. */
+  issue: Schema.NullOr(IssueCollectionsRepositoryIssueIssue)
+})
+export interface IssueCollectionsRepositoryRepository extends Schema.Struct.Type<typeof IssueCollectionsRepositoryRepository.fields> {}
+
+/** `query IssueCollections` */
+export const IssueCollections = GraphQL.query("IssueCollections", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" },
+      { name: "number", body: "Int!" },
+      { name: "labelsCursor", body: "String" },
+      { name: "assigneesCursor", body: "String" }
+    ],
+    selections: [
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){issue(number:$", "number", "){labels(first:100 after:$", "labelsCursor", "){pageInfo{hasNextPage endCursor}nodes{name color}}assignees(first:100 after:$", "assigneesCursor", "){pageInfo{hasNextPage endCursor}nodes{login name avatarUrl}}}}"] }
+    ],
+    fragments: []
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String,
+    number: Shared.Int,
+    labelsCursor: Schema.optional(Schema.NullOr(Schema.String)),
+    assigneesCursor: Schema.optional(Schema.NullOr(Schema.String))
+  },
+  result: Schema.Struct({
+    /** Lookup a given repository by the owner and repository name. */
+    repository: Schema.NullOr(IssueCollectionsRepositoryRepository)
+  })
+})
+export declare namespace IssueCollections {
+  export type Variables = typeof IssueCollections.variables.Type
+  export type Result = typeof IssueCollections.result.Type
+}
+
+/** Every operation in issues.graphql. */
+export const IssuesGraphQLGroup = GraphQLGroup.make(IssueSearch, IssueDetail, IssueComments, IssueNodeId, IssueCommentScope, IssueCandidates, IssueTemplates, IssueViewer, IssueCollections)
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 05026f5eb7123..656da278a2c7f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2405,6 +2405,9 @@ importers:
       effect:
         specifier: 4.1.3
         version: 4.1.3
+      yaml:
+        specifier: ^2.9.0
+        version: 2.9.0
     devDependencies:
       '@effect/graphql-generator':
         specifier: 'catalog:'