sailfork / t3code-github / apps/ server/ src/ git/ GitManager.test.ts

import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
import { SourceControlProviderKind } from "@t3tools/contracts";
// @effect-diagnostics nodeBuiltinImport:off
import * as NodeFS from "node:fs";
import * as NodePath from "node:path";
import * as NodeChildProcess from "node:child_process";

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Deferred from "effect/Deferred";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as PlatformError from "effect/PlatformError";
import * as Result from "effect/Result";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import { ChildProcessSpawner } from "effect/process";
import { expect } from "vite-plus/test";
import type {
  ChangeRequest,
  GitActionProgressEvent,
  GitPreparePullRequestThreadInput,
  ModelSelection,
} from "@t3tools/contracts";

import {
  DEFAULT_SERVER_SETTINGS,
  EventId,
  GitCommandError,
  MessageId,
  ProjectId,
  ProviderDriverKind,
  ProviderInstanceId,
  RunId,
  SourceControlProviderError as SourceControlProviderFailure,
  TextGenerationError,
  ThreadId,
  TurnItemId,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as TextGeneration from "../textGeneration/TextGeneration.ts";
import {
  fromRunner,
  decodeJsonReply,
} from "@t3tools/provider-core/server/textGenerationOperations";
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
import * as VcsProcess from "../vcs/VcsProcess.ts";
import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
import * as VcsProjectConfig from "../vcs/VcsProjectConfig.ts";
import * as GitWorkflowService from "./GitWorkflowService.ts";
import type { SourceControlProvider } from "@t3tools/source-control-core/server/SourceControlProvider";
import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import * as ServerConfig from "../config.ts";
import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
import * as ProjectStore from "../orchestration-v2/ProjectStore.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as GitManager from "./GitManager.ts";

/** A change request the fake host reports. Omitted fields read as an open, undated request. */
type FakeChangeRequest = Omit<ChangeRequest, "provider" | "state" | "updatedAt"> & {
  readonly state?: ChangeRequest["state"];
  readonly updatedAt?: string;
};

interface FakeProviderScenario {
  prListGate?: {
    readonly started: Deferred.Deferred<void>;
    readonly release: Deferred.Deferred<void>;
  };
  /** The kind the fake host reports itself as. */
  kind?: string;
  /** Answers to successive change request listings, whatever their head selector. */
  prListSequence?: ReadonlyArray<ReadonlyArray<FakeChangeRequest>>;
  prListByHeadSelector?: Record<string, ReadonlyArray<FakeChangeRequest>>;
  prListSequenceByHeadSelector?: Record<string, ReadonlyArray<ReadonlyArray<FakeChangeRequest>>>;
  /** The answer to every listing the other lists leave unanswered. */
  prListOtherwise?: ReadonlyArray<FakeChangeRequest>;
  defaultBranch?: string;
  pullRequest?: FakeChangeRequest;
  repositoryCloneUrls?: Record<string, { url: string; sshUrl: string }>;
  failWith?: string;
  failCause?: unknown;
  failAfterCalls?: number;
  /** Check out the pull request head from its pull ref: fast-forward only unless forced. */
  syncCheckoutWithPullHead?: boolean;
  /**
   * The host's `headBranchProbe`. By default the fake probes only bare branch names, a hundred
   * at a time, so tests see GitManager defer to the hook; null leaves the probe to GitManager.
   */
  headBranchProbe?: SourceControlProvider["Service"]["headBranchProbe"] | null;
}

type FakeProviderCall =
  | {
      readonly operation: "listChangeRequests";
      readonly headSelector: string;
      readonly state: string;
      readonly limit: number | undefined;
    }
  | {
      readonly operation: "createChangeRequest";
      readonly baseRefName: string;
      readonly headSelector: string;
      readonly title: string;
    }
  | { readonly operation: "getChangeRequest"; readonly reference: string }
  | {
      readonly operation: "checkoutChangeRequest";
      readonly reference: string;
      readonly force: boolean;
    }
  | { readonly operation: "getRepositoryCloneUrls"; readonly repository: string }
  | { readonly operation: "getDefaultBranch" };

const listed = (calls: ReadonlyArray<FakeProviderCall>) =>
  calls.flatMap((call) => (call.operation === "listChangeRequests" ? [call] : []));

const listedSelectors = (calls: ReadonlyArray<FakeProviderCall>) =>
  listed(calls).map((call) => call.headSelector);

const created = (calls: ReadonlyArray<FakeProviderCall>) =>
  calls.flatMap((call) =>
    call.operation === "createChangeRequest"
      ? [{ baseRefName: call.baseRefName, headSelector: call.headSelector }]
      : [],
  );

type FakeGitTextGeneration = TextGeneration.TextGeneration["Service"];

function runGitSyncForFakeCheckout(cwd: string, args: readonly string[]): void {
  const result = NodeChildProcess.spawnSync("git", args, {
    cwd,
    encoding: "utf8",
  });
  if (result.status === 0) {
    return;
  }
  throw new Error(
    `Failed to simulate a host checkout with git ${args.join(" ")}: ${result.stderr?.trim() || "unknown error"}`,
  );
}
function makeTempDir(
  prefix: string,
): Effect.Effect<string, PlatformError.PlatformError, FileSystem.FileSystem | Scope.Scope> {
  return Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    return yield* fileSystem.makeTempDirectoryScoped({ prefix });
  });
}

function removePath(
  targetPath: string,
): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem> {
  return Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    yield* fileSystem.remove(targetPath, { recursive: true, force: true });
  });
}

function makeDirectory(
  dirPath: string,
): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem> {
  return Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    yield* fileSystem.makeDirectory(dirPath, { recursive: true });
  });
}

function runGit(
  cwd: string,
  args: readonly string[],
  allowNonZeroExit = false,
): Effect.Effect<
  {
    readonly exitCode: GitVcsDriver.ExecuteGitResult["exitCode"];
    readonly stdout: string;
    readonly stderr: string;
  },
  GitCommandError,
  GitVcsDriver.GitVcsDriver
> {
  return Effect.gen(function* () {
    const git = yield* GitVcsDriver.GitVcsDriver;
    const result = yield* git.execute({
      operation: "GitManager.test.runGit",
      cwd,
      args,
      allowNonZeroExit,
    });
    return {
      exitCode: result.exitCode,
      stdout: result.stdout,
      stderr: result.stderr,
    };
  });
}

function initRepo(
  cwd: string,
): Effect.Effect<
  void,
  PlatformError.PlatformError | GitCommandError,
  FileSystem.FileSystem | Scope.Scope | GitVcsDriver.GitVcsDriver
> {
  return Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    yield* runGit(cwd, ["init", "--initial-branch=main"]);
    yield* runGit(cwd, ["config", "user.email", "test@example.com"]);
    yield* runGit(cwd, ["config", "user.name", "Test User"]);
    // Override global autocrlf on Windows for LF assertions, including linked worktrees.
    yield* runGit(cwd, ["config", "core.autocrlf", "false"]);
    yield* fs.writeFileString(NodePath.join(cwd, "README.md"), "hello\n");
    yield* runGit(cwd, ["add", "README.md"]);
    yield* runGit(cwd, ["commit", "-m", "Initial commit"]);
  });
}

function createBareRemote(): Effect.Effect<
  string,
  PlatformError.PlatformError | GitCommandError,
  FileSystem.FileSystem | Scope.Scope | GitVcsDriver.GitVcsDriver
> {
  return Effect.gen(function* () {
    const remoteDir = yield* makeTempDir("t3code-git-remote-");
    yield* runGit(remoteDir, ["init", "--bare"]);
    return remoteDir;
  });
}

function configureRemote(
  cwd: string,
  remoteName: string,
  remotePath: string,
  fetchNamespace: string,
): Effect.Effect<void, GitCommandError, GitVcsDriver.GitVcsDriver> {
  return Effect.gen(function* () {
    yield* runGit(cwd, ["config", `remote.${remoteName}.url`, remotePath]);
    yield* runGit(cwd, [
      "config",
      "--replace-all",
      `remote.${remoteName}.fetch`,
      `+refs/heads/*:refs/remotes/${fetchNamespace}/*`,
    ]);
  });
}

function configureVisibleRemoteUrlWithLocalRewrite(
  cwd: string,
  remoteName: string,
  visibleUrl: string,
  localRemotePath: string,
): Effect.Effect<void, GitCommandError, GitVcsDriver.GitVcsDriver> {
  return Effect.gen(function* () {
    yield* runGit(cwd, ["config", `remote.${remoteName}.url`, visibleUrl]);
    yield* runGit(cwd, ["config", `url.${localRemotePath}.insteadOf`, visibleUrl]);
  });
}

function createTextGeneration(
  overrides: Partial<FakeGitTextGeneration> = {},
): TextGeneration.TextGeneration["Service"] {
  const implementation: FakeGitTextGeneration = {
    generateCommitMessage: (input) =>
      Effect.succeed({
        subject: "Implement stacked git actions",
        body: "",
        ...(input.includeBranch ? { branch: "feature/implement-stacked-git-actions" } : {}),
      }),
    generatePrContent: () =>
      Effect.succeed({
        title: "Add stacked git actions",
        body: "## Summary\n- Add stacked git workflow\n\n## Testing\n- Not run",
      }),
    generateBranchName: () =>
      Effect.succeed({
        branch: "update-workflow",
      }),
    generateThreadTitle: () =>
      Effect.succeed({
        title: "Update workflow",
      }),
    generateReviewGuide: () => Effect.succeed({ stops: [] }),
    generateTranscriptionPostProcessing: () =>
      Effect.succeed({ transcription: "processed transcript" }),
    ...overrides,
  };

  return {
    generateCommitMessage: (input) =>
      implementation.generateCommitMessage(input).pipe(
        Effect.mapError(
          (cause) =>
            new TextGenerationError({
              operation: "generateCommitMessage",
              detail: "fake text generation failed",
              ...(cause !== undefined ? { cause } : {}),
            }),
        ),
      ),
    generatePrContent: (input) =>
      implementation.generatePrContent(input).pipe(
        Effect.mapError(
          (cause) =>
            new TextGenerationError({
              operation: "generatePrContent",
              detail: "fake text generation failed",
              ...(cause !== undefined ? { cause } : {}),
            }),
        ),
      ),
    generateBranchName: (input) =>
      implementation.generateBranchName(input).pipe(
        Effect.mapError(
          (cause) =>
            new TextGenerationError({
              operation: "generateBranchName",
              detail: "fake text generation failed",
              ...(cause !== undefined ? { cause } : {}),
            }),
        ),
      ),
    generateThreadTitle: (input) =>
      implementation.generateThreadTitle(input).pipe(
        Effect.mapError(
          (cause) =>
            new TextGenerationError({
              operation: "generateThreadTitle",
              detail: "fake text generation failed",
              ...(cause !== undefined ? { cause } : {}),
            }),
        ),
      ),
    generateReviewGuide: (input) => implementation.generateReviewGuide(input),
    generateTranscriptionPostProcessing: (input) =>
      implementation.generateTranscriptionPostProcessing(input),
  };
}

/**
 * A host that answers from the scenario and records what it was asked, so tests assert on the
 * selectors GitManager chose rather than on any host's wire format.
 */
function createFakeSourceControlProvider(scenario: FakeProviderScenario = {}): {
  service: SourceControlProvider["Service"];
  calls: FakeProviderCall[];
} {
  const kind = SourceControlProviderKind.make(scenario.kind ?? "github");
  const prListQueue = [...(scenario.prListSequence ?? [])];
  const prListQueueByHeadSelector = new Map(
    Object.entries(scenario.prListSequenceByHeadSelector ?? {}).map(([headSelector, values]) => [
      headSelector,
      [...values],
    ]),
  );
  const calls: FakeProviderCall[] = [];

  const record = (cwd: string, call: FakeProviderCall) =>
    Effect.suspend(() => {
      calls.push(call);
      return scenario.failWith && calls.length > (scenario.failAfterCalls ?? 0)
        ? Effect.fail(
            new SourceControlProviderFailure({
              provider: kind,
              operation: call.operation,
              cwd,
              detail: scenario.failWith,
              cause: scenario.failCause,
            }),
          )
        : Effect.void;
    });

  const toChangeRequest = (summary: FakeChangeRequest): ChangeRequest => ({
    ...summary,
    provider: kind,
    state: summary.state ?? "open",
    closedAt: summary.closedAt ?? null,
    mergedAt: summary.mergedAt ?? null,
    updatedAt:
      summary.updatedAt === undefined
        ? Option.none()
        : Option.some(DateTime.makeUnsafe(summary.updatedAt)),
  });

  const pullRequest = (): FakeChangeRequest =>
    scenario.pullRequest ?? {
      number: 101,
      title: "Pull request",
      url: "https://github.com/pingdotgg/codething-mvp/pull/101",
      baseRefName: "main",
      headRefName: "feature/pull-request",
      state: "open",
    };

  const checkout = (cwd: string, force: boolean) => {
    const headBranch = scenario.pullRequest?.headRefName;
    if (!headBranch) return;
    const existingBranch = NodeChildProcess.spawnSync(
      "git",
      ["show-ref", "--verify", "--quiet", `refs/heads/${headBranch}`],
      { cwd },
    );
    if (scenario.syncCheckoutWithPullHead) {
      runGitSyncForFakeCheckout(cwd, [
        "fetch",
        "origin",
        `refs/pull/${scenario.pullRequest?.number}/head`,
      ]);
      if (existingBranch.status === 0) {
        runGitSyncForFakeCheckout(cwd, ["checkout", headBranch]);
        runGitSyncForFakeCheckout(
          cwd,
          force ? ["reset", "--hard", "FETCH_HEAD"] : ["merge", "--ff-only", "FETCH_HEAD"],
        );
      } else {
        runGitSyncForFakeCheckout(cwd, ["checkout", "-b", headBranch, "FETCH_HEAD"]);
      }
    } else if (existingBranch.status === 0) {
      runGitSyncForFakeCheckout(cwd, ["checkout", headBranch]);
    } else {
      runGitSyncForFakeCheckout(cwd, ["checkout", "-b", headBranch]);
    }
  };

  const headBranchProbe =
    scenario.headBranchProbe === null
      ? {}
      : {
          headBranchProbe:
            scenario.headBranchProbe ??
            (({ headSelectors }: { readonly headSelectors: ReadonlyArray<string> }) => ({
              headSelectors: headSelectors.filter((selector) => !selector.includes(":")),
              limit: 100,
            })),
        };

  return {
    service: {
      kind,
      ...headBranchProbe,
      listChangeRequests: (input) =>
        record(input.cwd, {
          operation: "listChangeRequests",
          headSelector: input.headSelector,
          state: input.state,
          limit: input.limit,
        }).pipe(
          Effect.map(() =>
            (
              prListQueueByHeadSelector.get(input.headSelector)?.shift() ??
              scenario.prListByHeadSelector?.[input.headSelector] ??
              prListQueue.shift() ??
              scenario.prListOtherwise ??
              []
            ).map(toChangeRequest),
          ),
          Effect.tap(() =>
            scenario.prListGate
              ? Deferred.succeed(scenario.prListGate.started, undefined).pipe(
                  Effect.andThen(Deferred.await(scenario.prListGate.release)),
                )
              : Effect.void,
          ),
        ),
      createChangeRequest: (input) =>
        record(input.cwd, {
          operation: "createChangeRequest",
          baseRefName: input.baseRefName,
          headSelector: input.headSelector,
          title: input.title,
        }),
      getDefaultBranch: (input) =>
        record(input.cwd, { operation: "getDefaultBranch" }).pipe(
          Effect.map(() => {
            const value = (scenario.defaultBranch ?? "main").trim();
            return value.length > 0 ? value : null;
          }),
        ),
      getChangeRequest: (input) =>
        record(input.cwd, { operation: "getChangeRequest", reference: input.reference }).pipe(
          Effect.map(() => toChangeRequest(pullRequest())),
        ),
      getRepositoryCloneUrls: (input) =>
        record(input.cwd, {
          operation: "getRepositoryCloneUrls",
          repository: input.repository,
        }).pipe(
          Effect.flatMap(() => {
            const repository = input.host ? `${input.host}/${input.repository}` : input.repository;
            const cloneUrls =
              scenario.repositoryCloneUrls?.[repository] ??
              (input.host === "github.com"
                ? scenario.repositoryCloneUrls?.[input.repository]
                : undefined);
            return cloneUrls
              ? Effect.succeed({ nameWithOwner: input.repository, ...cloneUrls })
              : Effect.fail(
                  new SourceControlProviderFailure({
                    provider: kind,
                    operation: "getRepositoryCloneUrls",
                    cwd: input.cwd,
                    detail: `Unexpected repository lookup: ${input.repository}`,
                  }),
                );
          }),
        ),
      createRepository: (input) =>
        Effect.fail(
          new SourceControlProviderFailure({
            provider: kind,
            operation: "createRepository",
            cwd: input.cwd,
            detail: `Unexpected repository create: ${input.repository}`,
          }),
        ),
      checkoutChangeRequest: (input) =>
        record(input.cwd, {
          operation: "checkoutChangeRequest",
          reference: input.reference,
          force: input.force ?? false,
        }).pipe(
          Effect.flatMap(() =>
            Effect.try({
              try: () => checkout(input.cwd, input.force ?? false),
              catch: (cause) =>
                new SourceControlProviderFailure({
                  provider: kind,
                  operation: "checkoutChangeRequest",
                  cwd: input.cwd,
                  detail: "Host checkout failed.",
                  cause,
                }),
            }),
          ),
        ),
    },
    calls,
  };
}

/**
 * Reads a template from the base tree the way a host would, without any host's own lookup
 * rules, so tests see which tree GitManager reads it from.
 */
const readFakeChangeRequestTemplate = Effect.fnUntraced(function* (input: {
  readonly cwd: string;
  readonly treeish: string;
}) {
  const git = yield* GitVcsDriver.GitVcsDriver;
  const result = yield* git
    .execute({
      operation: "GitManager.test.readTemplate",
      cwd: input.cwd,
      args: ["show", `${input.treeish}:.github/pull_request_template.md`],
      allowNonZeroExit: true,
    })
    .pipe(Effect.orDie);
  const template = result.stdout.trim();
  return result.exitCode === 0 && template.length > 0 ? Option.some(template) : Option.none();
});
function runStackedAction(
  manager: GitManager.GitManager["Service"],
  input: {
    cwd: string;
    action: "commit" | "push" | "create_pr" | "commit_push" | "commit_push_pr";
    actionId?: string;
    commitMessage?: string;
    featureBranch?: boolean;
    filePaths?: readonly string[];
  },
  options?: Parameters<GitManager.GitManager["Service"]["runStackedAction"]>[1],
) {
  return manager.runStackedAction(
    {
      ...input,
      actionId: input.actionId ?? "test-action-id",
    },
    options,
  );
}

function preparePullRequestThread(
  manager: GitManager.GitManager["Service"],
  input: GitPreparePullRequestThreadInput,
) {
  return manager.preparePullRequestThread(input);
}

function makeManager(input?: {
  providerScenario?: FakeProviderScenario;
  sourceControlProvider?: SourceControlProvider["Service"];
  textGeneration?: Partial<FakeGitTextGeneration>;
  serverSettings?: Parameters<typeof ServerSettings.layerTest>[0];
  setupScriptRunner?: ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"];
  gitConfigReads?: string[];
  gitCommands?: string[];
  gitSpawnGate?: {
    readonly matches: (args: ReadonlyArray<string>) => boolean;
    readonly reached: Deferred.Deferred<void>;
    readonly release: Deferred.Deferred<void>;
  };
  seed?: Effect.Effect<
    void,
    ProjectionStore.ProjectionStoreV2Error | ProjectStore.ProjectStoreV2Error,
    ProjectionStore.ProjectionStoreV2 | ProjectStore.ProjectStoreV2
  >;
}) {
  const { service: fakeProvider, calls: providerCalls } = createFakeSourceControlProvider(
    input?.providerScenario,
  );
  const textGeneration = createTextGeneration(input?.textGeneration);
  const layerServerConfig = ServerConfig.layerTest(process.cwd(), {
    prefix: "t3-git-manager-test-",
  });

  const layerServerSettings = ServerSettings.ServerSettingsService.layerTest(input?.serverSettings);

  const gitCommands = input?.gitCommands;
  const gitSpawnGate = input?.gitSpawnGate;
  const watchesGitSpawns = gitCommands !== undefined || gitSpawnGate !== undefined;
  const layerGitDriverSpawner = watchesGitSpawns
    ? Layer.effect(
        ChildProcessSpawner.ChildProcessSpawner,
        Effect.gen(function* () {
          const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
          return ChildProcessSpawner.make((command) => {
            // On Windows the driver starts git by its full path to git.exe.
            const args =
              command._tag === "StandardCommand" &&
              NodePath.parse(command.command).name.toLowerCase() === "git"
                ? command.args.map(String)
                : null;
            if (args !== null) gitCommands?.push(args.join(" "));
            if (args === null || gitSpawnGate === undefined || !gitSpawnGate.matches(args)) {
              return spawner.spawn(command);
            }
            return spawner
              .spawn(command)
              .pipe(
                Effect.tap((handle) =>
                  handle.exitCode.pipe(
                    Effect.andThen(Deferred.succeed(gitSpawnGate.reached, undefined)),
                    Effect.andThen(Deferred.await(gitSpawnGate.release)),
                  ),
                ),
              );
          });
        }),
      ).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)))
    : Layer.empty;
  const gitVcsDriver = input?.gitConfigReads
    ? Layer.effect(
        GitVcsDriver.GitVcsDriver,
        GitVcsDriver.make.pipe(
          Effect.map((service) =>
            GitVcsDriver.GitVcsDriver.of({
              ...service,
              readConfigValue: (cwd, key) =>
                Effect.sync(() => input.gitConfigReads?.push(key)).pipe(
                  Effect.andThen(service.readConfigValue(cwd, key)),
                ),
            }),
          ),
        ),
      )
    : GitVcsDriver.layer;
  const layerVcsDriver = (watchesGitSpawns ? Layer.fresh(gitVcsDriver) : gitVcsDriver).pipe(
    Layer.provide(layerGitDriverSpawner),
    Layer.provideMerge(VcsProcess.layer),
    Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
    Layer.provideMerge(layerServerConfig),
  );
  const layerSourceControlRegistry = Layer.effect(
    SourceControlProviderRegistry.SourceControlProviderRegistry,
    Effect.gen(function* () {
      const context = yield* Effect.context<GitVcsDriver.GitVcsDriver>();
      return (
        input?.sourceControlProvider ?? {
          ...fakeProvider,
          readChangeRequestTemplate: (template: { cwd: string; treeish: string }) =>
            readFakeChangeRequestTemplate(template).pipe(Effect.provideContext(context)),
        }
      );
    }).pipe(
      Effect.map((provider) =>
        SourceControlProviderRegistry.SourceControlProviderRegistry.of({
          resolveLink: (input) => provider.resolveLink?.(input),
          get: () => Effect.succeed(provider),
          resolveHandle: () => Effect.succeed({ provider, context: null }),
          resolve: () => Effect.succeed(provider),
          discover: Effect.succeed([]),
        }),
      ),
    ),
  );

  const layerManager = Layer.mergeAll(
    Layer.succeed(TextGeneration.TextGeneration, textGeneration),
    Layer.mock(ProviderRegistry.ProviderRegistry)({
      getProviders: Effect.succeed([]),
    }),
    Layer.succeed(
      ProjectSetupScriptRunner.ProjectSetupScriptRunner,
      input?.setupScriptRunner ?? {
        runForThread: () => Effect.succeed({ status: "no-script" as const }),
      },
    ),
    layerServerSettings,
  ).pipe(
    Layer.provideMerge(layerSourceControlRegistry),
    Layer.provideMerge(layerVcsDriver),
    Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
  );
  const layerStores = Layer.merge(ProjectionStore.layer, ProjectStore.layer).pipe(
    Layer.provideMerge(SqlitePersistence.layerMemory),
  );

  return Effect.gen(function* () {
    const stores = yield* Layer.build(layerStores);
    if (input?.seed !== undefined) {
      yield* input.seed.pipe(Effect.provideContext(stores), Effect.orDie);
    }
    const manager = yield* GitManager.make.pipe(
      Effect.provide(layerManager),
      Effect.provideContext(stores),
    );
    return { manager, providerCalls };
  });
}

const asThreadId = (threadId: string) => threadId as ThreadId;

const layerGitManagerTest = GitVcsDriver.layer.pipe(
  Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-git-manager-test-" })),
  Layer.provideMerge(VcsProcess.layer),
  Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);

it.layer(layerGitManagerTest)("GitManager", (it) => {
  it.effect(
    "publishes local Git changes during a held PR lookup without caching its old branch",
    () =>
      Effect.gen(function* () {
        const repoDir = yield* makeTempDir("t3code-refresh-status-gh-gate-");
        yield* initRepo(repoDir);
        yield* runGit(repoDir, ["checkout", "-b", "release"]);
        const remoteDir = yield* createBareRemote();
        yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
        yield* runGit(repoDir, ["push", "-u", "origin", "release"]);
        yield* runGit(repoDir, ["tag", "release"]);
        const oldPr = {
          number: 613,
          title: "Release PR",
          url: "https://github.com/pingdotgg/codething-mvp/pull/613",
          baseRefName: "main",
          headRefName: "release",
        };
        const newPr = { ...oldPr, number: 614, headRefName: "heads/release" };
        const providerScenario: FakeProviderScenario = {
          prListSequence: [oldPr, oldPr, newPr].map((pr) => [pr]),
        };
        const { manager } = yield* makeManager({ providerScenario });
        const context = yield* Layer.build(
          VcsStatusBroadcaster.layer.pipe(
            Layer.provide(
              GitWorkflowService.layer.pipe(
                Layer.provide(Layer.succeed(GitManager.GitManager, manager)),
                Layer.provide(
                  VcsDriverRegistry.layer.pipe(
                    Layer.provide(VcsProjectConfig.layer),
                    Layer.provide(VcsProcess.layer),
                  ),
                ),
              ),
            ),
            Layer.provide(
              Layer.mock(BackgroundPolicy.BackgroundPolicy)({
                shouldRunScopeWork: () => Effect.succeed(true),
              }),
            ),
          ),
        );
        const broadcaster = Context.get(context, VcsStatusBroadcaster.VcsStatusBroadcaster);
        const initial = yield* broadcaster.getStatus({ cwd: repoDir });
        expect(initial.refName).toBe("release");
        expect(initial.pr?.number).toBe(613);

        const subscribed = yield* Deferred.make<void>();
        const published = yield* Deferred.make<void>();
        yield* broadcaster.streamStatus({ cwd: repoDir, includeRemote: false }).pipe(
          Stream.runForEach((event) => {
            if (event._tag === "snapshot") return Deferred.succeed(subscribed, undefined);
            if (event._tag === "localUpdated" && event.local.hasWorkingTreeChanges) {
              return Deferred.succeed(published, undefined);
            }
            return Effect.void;
          }),
          Effect.forkScoped,
        );
        yield* Deferred.await(subscribed);
        const gate = {
          started: yield* Deferred.make<void>(),
          release: yield* Deferred.make<void>(),
        };
        providerScenario.prListGate = gate;
        const fs = yield* FileSystem.FileSystem;
        yield* fs.writeFileString(NodePath.join(repoDir, "README.md"), "changed before refresh\n");
        const completed = yield* Deferred.make<void>();
        const refresh = yield* broadcaster
          .refreshStatus(repoDir)
          .pipe(Effect.ensuring(Deferred.succeed(completed, undefined)), Effect.forkScoped);
        yield* Deferred.await(gate.started);
        const pending = Option.getOrThrow(
          yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
        );
        expect(pending._tag).toBe("snapshot");
        if (pending._tag === "snapshot") expect(pending.local.hasWorkingTreeChanges).toBe(true);
        yield* Deferred.await(published);
        expect(yield* Deferred.isDone(completed)).toBe(false);

        yield* runGit(repoDir, ["checkout", "-b", "heads/release"]);
        yield* runGit(repoDir, ["push", "-u", "origin", "refs/heads/heads/release"]);
        yield* Deferred.succeed(gate.release, undefined);
        const refreshed = yield* Fiber.join(refresh);
        expect(refreshed.refName).toBe("heads/release");
        expect(refreshed.hasWorkingTreeChanges).toBe(true);
        expect(refreshed.pr).toBeNull();
        const snapshot = Option.getOrThrow(
          yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
        );
        expect(snapshot._tag).toBe("snapshot");
        if (snapshot._tag === "snapshot") expect(snapshot.remote).toBeNull();

        delete providerScenario.prListGate;
        const recovered = yield* broadcaster.getStatus({ cwd: repoDir });
        expect(recovered.refName).toBe("heads/release");
        expect(recovered.pr?.number).toBe(614);
        expect((yield* broadcaster.getStatus({ cwd: repoDir })).pr?.number).toBe(614);
      }),
  );

  it.effect("status reports the listed PR whose head is the branch", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      yield* runGit(repoDir, ["checkout", "-b", "feature/status-valid-pr-entry"]);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/status-valid-pr-entry"]);

      const { manager } = yield* makeManager({
        providerScenario: {
          prListSequence: [
            [
              {
                number: 14,
                title: "Another branch",
                url: "https://github.com/pingdotgg/codething-mvp/pull/14",
                baseRefName: "main",
                headRefName: "feature/another-branch",
              },
              {
                number: 15,
                title: "Valid PR title",
                url: "https://github.com/pingdotgg/codething-mvp/pull/15",
                baseRefName: "main",
                headRefName: "feature/status-valid-pr-entry",
              },
            ],
          ],
        },
      });

      const status = yield* manager.status({ cwd: repoDir });

      expect(status.pr).toEqual({
        number: 15,
        title: "Valid PR title",
        url: "https://github.com/pingdotgg/codething-mvp/pull/15",
        baseRef: "main",
        headRef: "feature/status-valid-pr-entry",
        state: "open",
        updatedAt: null,
      });
    }),
  );

  it.effect("status reports the latest of a branch's closed and merged PRs", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      yield* runGit(repoDir, ["checkout", "-b", "feature/status-lowercase-state"]);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/status-lowercase-state"]);

      const { manager } = yield* makeManager({
        providerScenario: {
          prListSequence: [
            [
              {
                number: 16,
                title: "Closed PR",
                url: "https://github.com/pingdotgg/codething-mvp/pull/16",
                baseRefName: "main",
                headRefName: "feature/status-lowercase-state",
                state: "closed",
                updatedAt: "2026-01-01T00:00:00.000Z",
              },
              {
                number: 17,
                title: "Merged PR",
                url: "https://github.com/pingdotgg/codething-mvp/pull/17",
                baseRefName: "main",
                headRefName: "feature/status-lowercase-state",
                state: "merged",
                updatedAt: "2026-01-02T00:00:00.000Z",
              },
            ],
          ],
        },
      });

      const status = yield* manager.status({ cwd: repoDir });

      expect(status.pr).toEqual({
        number: 17,
        title: "Merged PR",
        url: "https://github.com/pingdotgg/codething-mvp/pull/17",
        baseRef: "main",
        headRef: "feature/status-lowercase-state",
        state: "merged",
        updatedAt: "2026-01-02T00:00:00.000Z",
      });
    }),
  );

  it.effect("status returns an explicit non-repo result for deleted directories", () =>
    Effect.gen(function* () {
      const rootDir = yield* makeTempDir("t3code-git-manager-missing-dir-");
      const cwd = NodePath.join(rootDir, "deleted-repo");
      yield* makeDirectory(cwd);
      yield* removePath(cwd);
      const { manager } = yield* makeManager();

      const status = yield* manager.status({ cwd });

      expect(status).toEqual({
        isRepo: false,
        hasPrimaryRemote: false,
        isDefaultRef: false,
        refName: null,
        hasWorkingTreeChanges: false,
        workingTree: {
          files: [],
          insertions: 0,
          deletions: 0,
        },
        hasUpstream: false,
        aheadCount: 0,
        behindCount: 0,
        aheadOfDefaultCount: 0,
        pr: null,
      });
    }),
  );

  it.effect("a git read in flight during a T3 git action does not outlive it", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/racing-upstream"]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/racing-upstream"]);
      yield* runGit(repoDir, ["push", "origin", "HEAD:refs/heads/feature/raced-head"]);
      const pullRequest = (number: number, headRefName: string): FakeChangeRequest[] => [
        {
          number,
          title: headRefName,
          url: `https://github.com/pingdotgg/codething-mvp/pull/${number}`,
          baseRefName: "main",
          headRefName,
          state: "open",
          updatedAt: "2026-04-07T15:00:00Z",
        },
      ];
      const gate = {
        matches: (args: ReadonlyArray<string>) =>
          args[0] === "for-each-ref" && args.at(-1) === "refs/heads/feature/racing-upstream",
        reached: yield* Deferred.make<void>(),
        release: yield* Deferred.make<void>(),
      };
      const { manager } = yield* makeManager({
        gitSpawnGate: gate,
        providerScenario: {
          prListByHeadSelector: {
            "feature/racing-upstream": pullRequest(237, "feature/racing-upstream"),
            "feature/raced-head": pullRequest(238, "feature/raced-head"),
          },
        },
      });
      const lookup = manager.branchPullRequest({
        cwd: repoDir,
        branch: "feature/racing-upstream",
      });

      const inFlight = yield* Effect.forkChild(lookup);
      yield* Deferred.await(gate.reached);
      yield* runGit(repoDir, ["branch", "--set-upstream-to=origin/feature/raced-head"]);
      yield* manager.invalidateStatus(repoDir);
      yield* Deferred.succeed(gate.release, undefined);
      yield* Fiber.join(inFlight);

      expect((yield* lookup)?.number).toBe(238);
    }),
  );

  it.effect("branch PR lookup notifies linked threads when draft status changes", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      yield* runGit(repoDir, ["checkout", "-b", "feature/draft-status"]);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/draft-status"]);
      const drafts = [false, true, true, false, false, true];
      const pullRequest: FakeChangeRequest = {
        number: 1,
        title: "Draft status",
        url: "https://github.com/pingdotgg/codething-mvp/pull/1",
        baseRefName: "main",
        headRefName: "feature/draft-status",
        state: "open",
      };
      const { manager } = yield* makeManager({
        providerScenario: {
          prListSequence: [
            ...drafts.map((isDraft) => [{ ...pullRequest, isDraft }]),
            [
              {
                ...pullRequest,
                number: 2,
                url: "https://github.com/pingdotgg/codething-mvp/pull/2",
                state: "merged",
              },
            ],
          ],
        },
      });
      const changes = yield* manager.subscribePullRequestStateChanges;
      for (const isDraft of drafts) {
        const pr = yield* manager.branchPullRequest(
          { cwd: repoDir, branch: "feature/draft-status" },
          { refresh: true },
        );
        expect(pr?.isDraft === true).toBe(isDraft);
      }
      // A different PR ends collection without waiting on a background stream consumer.
      yield* manager.branchPullRequest(
        { cwd: repoDir, branch: "feature/draft-status" },
        { refresh: true },
      );
      const events = yield* Stream.runCollect(
        changes.pipe(Stream.takeUntil((event) => event.number === 2, { excludeLast: true })),
      );
      expect(events).toEqual([
        { host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
        { host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
        { host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
      ]);
    }),
  );

  it.effect("a settled branch PR is rechecked only when the branch moves or every 15 minutes", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/settled"]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/settled"]);
      const pullRequest = (number: number, state: "open" | "merged"): FakeChangeRequest => ({
        number,
        title: "Settled",
        url: `https://github.com/pingdotgg/codething-mvp/pull/${number}`,
        baseRefName: "main",
        headRefName: "feature/settled",
        state,
        updatedAt: `2026-04-0${number}T15:00:00Z`,
      });
      const gitCommands: string[] = [];
      const { manager } = yield* makeManager({
        gitCommands,
        providerScenario: {
          prListSequence: [
            [pullRequest(1, "merged")],
            [pullRequest(1, "merged")],
            [pullRequest(1, "merged")],
          ],
          prListOtherwise: [pullRequest(2, "open")],
        },
      });
      const lookup = manager.branchPullRequest({ cwd: repoDir, branch: "feature/settled" });
      const freshLookups = () => gitCommands.filter((args) => args === "remote").length;

      expect((yield* lookup)?.state).toBe("merged");
      gitCommands.length = 0;
      expect((yield* lookup)?.state).toBe("merged");
      expect((yield* lookup)?.state).toBe("merged");
      expect(gitCommands.map((args) => args.split(" ", 1)[0]).toSorted()).toEqual([
        "config",
        "config",
        "for-each-ref",
        "for-each-ref",
      ]);
      expect(freshLookups()).toBe(0);

      NodeFS.writeFileSync(NodePath.join(repoDir, "settled.txt"), "new work\n");
      yield* runGit(repoDir, ["add", "settled.txt"]);
      yield* runGit(repoDir, ["commit", "-m", "New work"]);
      gitCommands.length = 0;
      expect((yield* lookup)?.state).toBe("merged");
      expect(freshLookups()).toBe(1);
      gitCommands.length = 0;
      yield* lookup;
      expect(freshLookups()).toBe(0);

      // Remembered git state expires after 5 minutes; that rereads git without a recheck.
      yield* TestClock.adjust("10 minutes");
      gitCommands.length = 0;
      expect((yield* lookup)?.state).toBe("merged");
      expect(freshLookups()).toBe(1);

      yield* TestClock.adjust("5 minutes");
      gitCommands.length = 0;
      expect((yield* lookup)?.state).toBe("merged");
      expect(freshLookups()).toBe(2);

      // A new PR from the reused branch shows on the next host query.
      yield* TestClock.adjust("5 minutes");
      expect((yield* lookup)?.number).toBe(2);
    }),
  );

  it.effect("branch PR lookup uses a saved tracked branch without changing checkout", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/saved-branch"]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/saved-branch"]);
      yield* runGit(repoDir, ["checkout", "main"]);

      const { manager } = yield* makeManager({
        providerScenario: {
          prListSequence: [
            [
              {
                number: 216,
                title: "Saved branch PR",
                url: "https://github.com/pingdotgg/t3code/pull/216",
                baseRefName: "main",
                headRefName: "feature/saved-branch",
                headSha: "a".repeat(40),
                state: "open",
                updatedAt: "2026-04-03T15:00:00Z",
              },
            ],
          ],
        },
      });

      const pullRequest = yield* manager.branchPullRequest({
        cwd: repoDir,
        branch: "feature/saved-branch",
      });

      expect(pullRequest).toMatchObject({
        number: 216,
        title: "Saved branch PR",
        url: "https://github.com/pingdotgg/t3code/pull/216",
        baseRef: "main",
        headRef: "feature/saved-branch",
        headSha: "a".repeat(40),
        state: "open",
        closedAt: null,
        mergedAt: null,
        updatedAt: "2026-04-03T15:00:00.000Z",
      });
      expect((yield* runGit(repoDir, ["branch", "--show-current"])).stdout.trim()).toBe("main");
    }),
  );

  it.effect("branch PR lookup uses the default branch from a non-origin remote", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "upstream", remoteDir]);
      yield* runGit(repoDir, ["push", "-u", "upstream", "main"]);
      yield* runGit(repoDir, ["checkout", "-b", "develop"]);
      yield* runGit(repoDir, ["push", "-u", "upstream", "develop"]);
      yield* runGit(remoteDir, ["--git-dir=.", "symbolic-ref", "HEAD", "refs/heads/develop"]);
      yield* runGit(repoDir, ["remote", "set-head", "upstream", "develop"]);

      const { manager } = yield* makeManager({
        providerScenario: {
          prListSequence: [
            [
              {
                number: 221,
                title: "Merged main PR",
                url: "https://github.com/pingdotgg/codething-mvp/pull/221",
                baseRefName: "develop",
                headRefName: "main",
                state: "merged",
                mergedAt: "2026-04-07T15:00:00Z",
                updatedAt: "2026-04-08T15:00:00Z",
              },
            ],
          ],
        },
      });

      const pullRequest = yield* manager.branchPullRequest({ cwd: repoDir, branch: "main" });

      expect(pullRequest).toMatchObject({
        state: "merged",
        closedAt: null,
        mergedAt: "2026-04-07T15:00:00Z",
        updatedAt: "2026-04-08T15:00:00.000Z",
      });
    }),
  );

  it.effect("branch PR lookup uses the saved name after the local branch is deleted", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const remoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/deleted-local-branch"]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/deleted-local-branch"]);
      yield* runGit(repoDir, ["checkout", "main"]);
      yield* runGit(repoDir, ["branch", "-D", "feature/deleted-local-branch"]);
      yield* runGit(repoDir, ["branch", "feature/deleted-local-branch/child"]);
      yield* runGit(repoDir, [
        "branch",
        "--set-upstream-to",
        "origin/main",
        "feature/deleted-local-branch/child",
      ]);

      const { manager, providerCalls } = yield* makeManager({
        providerScenario: {
          prListSequence: [
            [
              {
                number: 217,
                title: "Deleted local branch PR",
                url: "https://github.com/pingdotgg/t3code/pull/217",
                baseRefName: "main",
                headRefName: "feature/deleted-local-branch",
                state: "merged",
                updatedAt: "2026-04-04T15:00:00Z",
              },
            ],
          ],
        },
      });

      const pullRequest = yield* manager.branchPullRequest({
        cwd: repoDir,
        branch: "feature/deleted-local-branch",
      });

      expect(pullRequest).toMatchObject({
        state: "merged",
        closedAt: null,
        mergedAt: null,
        updatedAt: "2026-04-04T15:00:00.000Z",
      });
      expect(listedSelectors(providerCalls).includes("feature/deleted-local-branch")).toBe(true);
    }),
  );

  it.effect("branch PR lookup recovers a deleted fork branch from its remote-tracking ref", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const originDir = yield* createBareRemote();
      const forkDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* configureRemote(repoDir, "team/fork", forkDir, "team/fork");
      yield* runGit(repoDir, ["checkout", "-b", "feature/deleted-fork-branch"]);
      yield* runGit(repoDir, ["push", "-u", "team/fork", "feature/deleted-fork-branch"]);
      yield* runGit(repoDir, ["checkout", "main"]);
      yield* runGit(repoDir, ["branch", "-D", "feature/deleted-fork-branch"]);
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "origin",
        "git@github.com:pingdotgg/codething-mvp.git",
        originDir,
      );
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "team/fork",
        "git@github.com:contributor/codething-mvp.git",
        forkDir,
      );

      const { manager, providerCalls } = yield* makeManager({
        providerScenario: {
          prListByHeadSelector: {
            "feature/deleted-fork-branch": [
              {
                number: 218,
                title: "Deleted fork branch PR",
                url: "https://github.com/pingdotgg/codething-mvp/pull/218",
                baseRefName: "main",
                headRefName: "feature/deleted-fork-branch",
                state: "merged",
                updatedAt: "2026-04-05T15:00:00Z",
                isCrossRepository: true,
                headRepositoryNameWithOwner: "contributor/codething-mvp",
                headRepositoryOwnerLogin: "contributor",
              },
            ],
          },
        },
      });

      const pullRequest = yield* manager.branchPullRequest({
        cwd: repoDir,
        branch: "feature/deleted-fork-branch",
      });

      expect(pullRequest).toMatchObject({
        state: "merged",
        closedAt: null,
        mergedAt: null,
        updatedAt: "2026-04-05T15:00:00.000Z",
      });
      expect(
        listed(providerCalls).some(
          (call) => call.headSelector === "feature/deleted-fork-branch" && call.state === "all",
        ),
      ).toBe(true);
      expect(
        listedSelectors(providerCalls).some((selector) => selector.startsWith("contributor:")),
      ).toBe(false);
    }),
  );

  it.effect("branch PR lookup rejects ambiguous deleted-branch remote refs", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const originDir = yield* createBareRemote();
      const forkDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
      yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/ambiguous-remote"]);
      yield* runGit(repoDir, ["push", "origin", "feature/ambiguous-remote"]);
      yield* runGit(repoDir, ["push", "fork", "feature/ambiguous-remote"]);
      yield* runGit(repoDir, ["checkout", "main"]);
      yield* runGit(repoDir, ["branch", "-D", "feature/ambiguous-remote"]);
      const { manager, providerCalls } = yield* makeManager();

      const error = yield* manager
        .branchPullRequest({ cwd: repoDir, branch: "feature/ambiguous-remote" })
        .pipe(Effect.flip);

      expect(error).toMatchObject({
        _tag: "GitManagerError",
        detail: "Multiple remotes track feature/ambiguous-remote. Its pull request is ambiguous.",
      });
      expect(providerCalls).toHaveLength(0);
    }),
  );

  it.effect("finds a fork PR for a branch pushed without an upstream", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const originDir = yield* createBareRemote();
      const forkDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/no-upstream-fork"]);
      yield* runGit(repoDir, ["push", "fork", "feature/no-upstream-fork"]);
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "origin",
        "git@github.com:pingdotgg/codething-mvp.git",
        originDir,
      );
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "fork",
        "git@github.com:contributor/codething-mvp.git",
        forkDir,
      );

      const providerScenario: FakeProviderScenario = {
        prListByHeadSelector: {
          "feature/no-upstream-fork": [
            {
              number: 40,
              title: "Another fork's PR",
              url: "https://github.com/pingdotgg/codething-mvp/pull/40",
              baseRefName: "main",
              headRefName: "feature/no-upstream-fork",
              state: "open",
              isCrossRepository: true,
              headRepositoryNameWithOwner: "someone-else/codething-mvp",
              headRepositoryOwnerLogin: "someone-else",
            },
            {
              number: 41,
              title: "Our fork's PR",
              url: "https://github.com/pingdotgg/codething-mvp/pull/41",
              baseRefName: "main",
              headRefName: "feature/no-upstream-fork",
              state: "open",
              isCrossRepository: true,
              headRepositoryNameWithOwner: "contributor/codething-mvp",
              headRepositoryOwnerLogin: "contributor",
            },
          ],
        },
      };
      const { manager } = yield* makeManager({ providerScenario });

      const pullRequest = yield* manager.branchPullRequest({
        cwd: repoDir,
        branch: "feature/no-upstream-fork",
      });
      expect(pullRequest?.number).toBe(41);
      expect((yield* manager.status({ cwd: repoDir })).pr?.number).toBe(41);

      yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Continue feature"]);
      const localHead = yield* runGit(repoDir, ["rev-parse", "HEAD"]);
      const pushedHead = yield* runGit(repoDir, [
        "rev-parse",
        "refs/remotes/fork/feature/no-upstream-fork",
      ]);
      expect(localHead.stdout.trim()).not.toBe(pushedHead.stdout.trim());
      const { manager: aheadManager } = yield* makeManager({ providerScenario });
      expect(
        (yield* aheadManager.branchPullRequest({
          cwd: repoDir,
          branch: "feature/no-upstream-fork",
        }))?.number,
      ).toBe(41);
      expect((yield* aheadManager.status({ cwd: repoDir })).pr?.number).toBe(41);

      yield* runGit(repoDir, ["config", "branch.feature/no-upstream-fork.remote", "origin"]);
      const upstream = yield* runGit(repoDir, [
        "for-each-ref",
        "--format=%(upstream:short)",
        "refs/heads/feature/no-upstream-fork",
      ]);
      expect(upstream.stdout.trim()).toBe("");
      const { manager: staleRemoteManager } = yield* makeManager({ providerScenario });
      expect(
        (yield* staleRemoteManager.branchPullRequest({
          cwd: repoDir,
          branch: "feature/no-upstream-fork",
        }))?.number,
      ).toBe(41);

      yield* runGit(repoDir, ["config", "--unset", "branch.feature/no-upstream-fork.remote"]);
      yield* runGit(repoDir, ["checkout", "-b", "diverged-push", "main"]);
      yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Rewrite fork head"]);
      yield* runGit(repoDir, [
        "push",
        "--force",
        "fork",
        "HEAD:refs/heads/feature/no-upstream-fork",
      ]);
      yield* runGit(repoDir, ["checkout", "feature/no-upstream-fork"]);
      const { manager: divergedManager } = yield* makeManager({ providerScenario });
      expect(
        yield* divergedManager.branchPullRequest({
          cwd: repoDir,
          branch: "feature/no-upstream-fork",
        }),
      ).toBeNull();
    }),
  );

  it.effect("prefers an exact fork ref but does not guess between equal refs", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const originDir = yield* createBareRemote();
      const firstForkDir = yield* createBareRemote();
      const secondForkDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* runGit(repoDir, ["remote", "add", "first-fork", firstForkDir]);
      yield* runGit(repoDir, ["remote", "add", "second-fork", secondForkDir]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/ambiguous-fork"]);
      yield* runGit(repoDir, ["push", "first-fork", "feature/ambiguous-fork"]);
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "origin",
        "git@github.com:pingdotgg/codething-mvp.git",
        originDir,
      );
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "first-fork",
        "git@github.com:contributor/codething-mvp.git",
        firstForkDir,
      );
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "second-fork",
        "git@github.com:someone-else/codething-mvp.git",
        secondForkDir,
      );

      const providerScenario: FakeProviderScenario = {
        prListByHeadSelector: {
          "feature/ambiguous-fork": [
            {
              number: 41,
              title: "One fork's PR",
              url: "https://github.com/pingdotgg/codething-mvp/pull/41",
              baseRefName: "main",
              headRefName: "feature/ambiguous-fork",
              state: "open",
              isCrossRepository: true,
              headRepositoryNameWithOwner: "contributor/codething-mvp",
              headRepositoryOwnerLogin: "contributor",
            },
          ],
        },
      };
      const { manager: singleRemoteManager } = yield* makeManager({ providerScenario });
      expect(
        (yield* singleRemoteManager.branchPullRequest({
          cwd: repoDir,
          branch: "feature/ambiguous-fork",
        }))?.number,
      ).toBe(41);

      yield* runGit(repoDir, ["push", "second-fork", "feature/ambiguous-fork"]);
      const { manager } = yield* makeManager({ providerScenario });
      expect(
        yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/ambiguous-fork" }),
      ).toBeNull();

      yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Continue feature"]);
      yield* runGit(repoDir, ["push", "first-fork", "feature/ambiguous-fork"]);
      const { manager: exactManager } = yield* makeManager({ providerScenario });
      expect(
        (yield* exactManager.branchPullRequest({
          cwd: repoDir,
          branch: "feature/ambiguous-fork",
        }))?.number,
      ).toBe(41);
    }),
  );

  it.effect("does not guess a fork when an ancestry probe fails", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const originDir = yield* createBareRemote();
      const forkDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/failed-probe"]);
      yield* runGit(repoDir, ["push", "fork", "feature/failed-probe"]);
      yield* runGit(repoDir, ["push", "origin", "feature/failed-probe"]);
      yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Local work"]);
      const treeOid = (yield* runGit(repoDir, ["rev-parse", "HEAD^{tree}"])).stdout.trim();
      yield* runGit(repoDir, ["update-ref", "refs/remotes/origin/feature/failed-probe", treeOid]);
      const forkProbe = yield* runGit(
        repoDir,
        ["merge-base", "--is-ancestor", "refs/remotes/fork/feature/failed-probe", "HEAD"],
        true,
      );
      expect(forkProbe.exitCode).toBe(0);
      const originProbe = yield* runGit(
        repoDir,
        ["merge-base", "--is-ancestor", "refs/remotes/origin/feature/failed-probe", "HEAD"],
        true,
      );
      expect(originProbe.exitCode).not.toBe(0);
      expect(originProbe.exitCode).not.toBe(1);
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "origin",
        "git@github.com:pingdotgg/codething-mvp.git",
        originDir,
      );
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "fork",
        "git@github.com:contributor/codething-mvp.git",
        forkDir,
      );

      const providerScenario: FakeProviderScenario = {
        prListByHeadSelector: {
          "feature/failed-probe": [
            {
              number: 43,
              title: "Failed probe PR",
              url: "https://github.com/pingdotgg/codething-mvp/pull/43",
              baseRefName: "main",
              headRefName: "feature/failed-probe",
              state: "open",
              isCrossRepository: true,
              headRepositoryNameWithOwner: "contributor/codething-mvp",
              headRepositoryOwnerLogin: "contributor",
            },
          ],
        },
      };
      const { manager } = yield* makeManager({ providerScenario });
      expect(
        yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/failed-probe" }),
      ).toBeNull();
    }),
  );

  it.effect("finds a fork PR when the remote name contains a slash", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const originDir = yield* createBareRemote();
      const forkDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
      yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
      yield* runGit(repoDir, ["remote", "add", "team/fork", forkDir]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/slash-remote"]);
      yield* runGit(repoDir, ["push", "team/fork", "feature/slash-remote"]);
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "origin",
        "git@github.com:pingdotgg/codething-mvp.git",
        originDir,
      );
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "team/fork",
        "git@github.com:contributor/codething-mvp.git",
        forkDir,
      );

      const { manager } = yield* makeManager({
        providerScenario: {
          prListByHeadSelector: {
            "feature/slash-remote": [
              {
                number: 42,
                title: "Slash remote PR",
                url: "https://github.com/pingdotgg/codething-mvp/pull/42",
                baseRefName: "main",
                headRefName: "feature/slash-remote",
                state: "open",
                isCrossRepository: true,
                headRepositoryNameWithOwner: "contributor/codething-mvp",
                headRepositoryOwnerLogin: "contributor",
              },
            ],
          },
        },
      });

      expect(
        (yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/slash-remote" }))
          ?.number,
      ).toBe(42);
    }),
  );

  it.effect("branch PR lookup does not reuse a cached PR after the remote is repointed", () =>
    Effect.gen(function* () {
      const repoDir = yield* makeTempDir("t3code-git-manager-");
      yield* initRepo(repoDir);
      const originalRemoteDir = yield* createBareRemote();
      yield* runGit(repoDir, ["remote", "add", "origin", originalRemoteDir]);
      yield* runGit(repoDir, ["checkout", "-b", "feature/repointed-lookup"]);
      yield* runGit(repoDir, ["push", "-u", "origin", "feature/repointed-lookup"]);
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "origin",
        "git@github.com:old-owner/old-repository.git",
        originalRemoteDir,
      );
      const { manager, providerCalls } = yield* makeManager({
        providerScenario: {
          prListSequence: [
            [
              {
                number: 219,
                title: "Old repository PR",
                url: "https://github.com/old-owner/old-repository/pull/219",
                baseRefName: "main",
                headRefName: "feature/repointed-lookup",
                state: "merged",
                updatedAt: "2026-04-06T15:00:00Z",
              },
            ],
            [],
          ],
        },
      });

      const first = yield* manager.branchPullRequest({
        cwd: repoDir,
        branch: "feature/repointed-lookup",
      });
      expect(first?.state).toBe("merged");

      const replacementRemoteDir = yield* createBareRemote();
      yield* configureVisibleRemoteUrlWithLocalRewrite(
        repoDir,
        "origin",
        "git@github.com:new-owner/new-repository.git",
        replacementRemoteDir,
      );

      const second = yield* manager.branchPullRequest({
        cwd: repoDir,
        branch: "feature/repointed-lookup",
      });

      expect(second).toBeNull();
      expect(listed(providerCalls)).toHaveLength(2);
    }),
  );

  // regression: #8600 settle threads server-side
  it.effect("branch PR lookup propagates provider failures", () =>