import { describe, expect, vi } from "vitest";

// Mock the db prisma client. The service is constructed against a real
// testcontainer prisma instead — these empty singletons only satisfy the
// module-level imports of the production wiring (infrastructure boundary).
vi.mock("~/db.server", () => ({
  prisma: {},
  $replica: {},
  runOpsNewPrisma: {},
  runOpsLegacyPrisma: {},
  runOpsNewReplica: {},
  runOpsLegacyReplica: {},
}));
// Inherited harness boilerplate. The parent read under test takes the
// findRun(where, client) overload with this.prisma, so it does not consult this
// flag; the mock only satisfies other wiring imported transitively.
vi.mock("~/v3/runOpsMigration/splitMode.server", () => ({ isSplitEnabled: async () => false }));

vi.mock("~/services/platform.v3.server", async (importOriginal) => {
  const actual = (await importOriginal()) as Record<string, unknown>;
  return {
    ...actual,
    getEntitlement: vi.fn(),
  };
});

import { RunEngine } from "@internal/run-engine";
import { setupAuthenticatedEnvironment, setupBackgroundWorker } from "@internal/run-engine/tests";
import { assertNonNullable, containerTest } from "@internal/testcontainers";
import { trace } from "@opentelemetry/api";
import type { IOPacket } from "@trigger.dev/core/v3";
import type { TaskRun } from "@trigger.dev/database";
import { IdempotencyKeyConcern } from "~/runEngine/concerns/idempotencyKeys.server";
import { DefaultQueueManager } from "~/runEngine/concerns/queues.server";
import type {
  EntitlementValidationParams,
  MaxAttemptsValidationParams,
  ParentRunValidationParams,
  PayloadProcessor,
  TagValidationParams,
  TracedEventSpan,
  TraceEventConcern,
  TriggerTaskRequest,
  TriggerTaskValidator,
  ValidationResult,
} from "~/runEngine/types";
import { RunEngineTriggerTaskService } from "./triggerTask.server";

vi.setConfig({ testTimeout: 60_000 }); // 60 seconds timeout

class MockPayloadProcessor implements PayloadProcessor {
  async process(request: TriggerTaskRequest): Promise<IOPacket> {
    return {
      data: JSON.stringify(request.body.payload),
      dataType: "application/json",
    };
  }
}

// Captures the `parentRun` the service resolved (via runStore.findRun) and
// passed into validation, so a test can assert on the resolved parent without
// mocking the read itself. Returns ok so the child triggers regardless.
class CapturingParentRunValidator implements TriggerTaskValidator {
  public capturedParentRun: ParentRunValidationParams["parentRun"] | "unset" = "unset";

  validateTags(_params: TagValidationParams): ValidationResult {
    return { ok: true };
  }
  validateEntitlement(_params: EntitlementValidationParams): Promise<ValidationResult> {
    return Promise.resolve({ ok: true });
  }
  validateMaxAttempts(_params: MaxAttemptsValidationParams): ValidationResult {
    return { ok: true };
  }
  validateParentRun(params: ParentRunValidationParams): ValidationResult {
    this.capturedParentRun = params.parentRun;
    return { ok: true };
  }
}

class MockTraceEventConcern implements TraceEventConcern {
  async traceRun<T>(
    _request: TriggerTaskRequest,
    _parentStore: string | undefined,
    callback: (span: TracedEventSpan, store: string) => Promise<T>
  ): Promise<T> {
    return await callback(
      {
        traceId: "test",
        spanId: "test",
        traceContext: {},
        traceparent: undefined,
        setAttribute: () => {},
        failWithError: () => {},
        stop: () => {},
      },
      "test"
    );
  }

  async traceIdempotentRun<T>(
    _request: TriggerTaskRequest,
    _parentStore: string | undefined,
    _options: {
      existingRun: TaskRun;
      idempotencyKey: string;
      incomplete: boolean;
      isError: boolean;
    },
    callback: (span: TracedEventSpan, store: string) => Promise<T>
  ): Promise<T> {
    return await callback(
      {
        traceId: "test",
        spanId: "test",
        traceContext: {},
        traceparent: undefined,
        setAttribute: () => {},
        failWithError: () => {},
        stop: () => {},
      },
      "test"
    );
  }

  async traceDebouncedRun<T>(
    _request: TriggerTaskRequest,
    _parentStore: string | undefined,
    _options: {
      existingRun: TaskRun;
      debounceKey: string;
      incomplete: boolean;
      isError: boolean;
    },
    callback: (span: TracedEventSpan, store: string) => Promise<T>
  ): Promise<T> {
    return await callback(
      {
        traceId: "test",
        spanId: "test",
        traceContext: {},
        traceparent: undefined,
        setAttribute: () => {},
        failWithError: () => {},
        stop: () => {},
      },
      "test"
    );
  }
}

function buildEngine(prisma: any, redisOptions: any) {
  return new RunEngine({
    prisma,
    worker: {
      redis: redisOptions,
      workers: 1,
      tasksPerWorker: 10,
      pollIntervalMs: 100,
    },
    queue: {
      redis: redisOptions,
    },
    runLock: {
      redis: redisOptions,
    },
    machines: {
      defaultMachine: "small-1x",
      machines: {
        "small-1x": {
          name: "small-1x" as const,
          cpu: 0.5,
          memory: 0.5,
          centsPerMs: 0.0001,
        },
      },
      baseCostInCents: 0.0005,
    },
    tracer: trace.getTracer("test", "0.0.0"),
  });
}

describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
  containerTest(
    "resolves the parent run through the run-ops store by minted run id",
    async ({ prisma, redisOptions }) => {
      const engine = buildEngine(prisma, redisOptions);

      try {
        const environment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        const taskIdentifier = "test-task";
        await setupBackgroundWorker(engine, environment, taskIdentifier);

        const validator = new CapturingParentRunValidator();
        const triggerTaskService = new RunEngineTriggerTaskService({
          engine,
          prisma,
          payloadProcessor: new MockPayloadProcessor(),
          queueConcern: new DefaultQueueManager(prisma, engine),
          idempotencyKeyConcern: new IdempotencyKeyConcern(
            prisma,
            engine,
            new MockTraceEventConcern()
          ),
          validator,
          traceEventConcern: new MockTraceEventConcern(),
          tracer: trace.getTracer("test", "0.0.0"),
          metadataMaximumSize: 1024 * 1024 * 1,
        });

        // Trigger a ROOT run first to create a real parent TaskRun.
        const parentResult = await triggerTaskService.call({
          taskId: taskIdentifier,
          environment,
          body: { payload: { kind: "parent" } },
        });
        assertNonNullable(parentResult);

        // Trigger a CHILD pointing at the parent's friendlyId. The service must
        // resolve the parent via runStore.findRun (minted RunId, env-scoped).
        const childResult = await triggerTaskService.call({
          taskId: taskIdentifier,
          environment,
          body: {
            payload: { kind: "child" },
            options: { parentRunId: parentResult.run.friendlyId },
          },
        });
        assertNonNullable(childResult);

        // The capturing validator observed the resolved parent — proving the
        // read ran (against the container DB) and returned the right row.
        expect(validator.capturedParentRun).not.toBe("unset");
        const capturedParent = validator.capturedParentRun;
        assertNonNullable(capturedParent);
        expect(capturedParent.id).toBe(parentResult.run.id);
        expect(capturedParent.friendlyId).toBe(parentResult.run.friendlyId);

        // depth and root carry through — proving parentRun.depth and the parent
        // id were read off the resolved row and threaded into the child.
        const parentRow = await prisma.taskRun.findUniqueOrThrow({
          where: { id: parentResult.run.id },
        });
        const childRow = await prisma.taskRun.findUniqueOrThrow({
          where: { id: childResult.run.id },
        });

        expect(childRow.depth).toBe(parentRow.depth + 1);
        expect(childRow.parentTaskRunId).toBe(parentRow.id);
        expect(childRow.rootTaskRunId).toBe(parentRow.id);
      } finally {
        await engine.quit();
      }
    }
  );

  containerTest(
    "scopes the parent lookup to the run's environment (cross-env parent is not resolved)",
    async ({ prisma, redisOptions }) => {
      const engine = buildEngine(prisma, redisOptions);

      try {
        // Two independent authenticated environments. The setup helper hardcodes
        // several globally-unique fields (org/project slug, env apiKey/pkApiKey,
        // worker-group token hash), so rename envA's before the second call to
        // avoid unique-constraint collisions.
        const envA = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        await prisma.organization.update({
          where: { id: envA.organizationId },
          data: { slug: `${envA.organization.slug}-a` },
        });
        await prisma.project.update({
          where: { id: envA.projectId },
          data: { slug: `${envA.project.slug}-a`, externalRef: `${envA.project.externalRef}-a` },
        });
        await prisma.runtimeEnvironment.update({
          where: { id: envA.id },
          data: { apiKey: `${envA.apiKey}-a`, pkApiKey: `${envA.pkApiKey}-a` },
        });
        await prisma.workerGroupToken.updateMany({
          where: { tokenHash: "token_hash" },
          data: { tokenHash: "token_hash_a" },
        });
        await prisma.workerInstanceGroup.updateMany({
          where: { masterQueue: "default" },
          data: { masterQueue: "default_a" },
        });
        const envB = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        expect(envA.id).not.toBe(envB.id);
        expect(envA.organizationId).not.toBe(envB.organizationId);

        const taskIdentifier = "test-task";
        await setupBackgroundWorker(engine, envA, taskIdentifier);
        await setupBackgroundWorker(engine, envB, taskIdentifier);

        const validator = new CapturingParentRunValidator();
        const triggerTaskService = new RunEngineTriggerTaskService({
          engine,
          prisma,
          payloadProcessor: new MockPayloadProcessor(),
          queueConcern: new DefaultQueueManager(prisma, engine),
          idempotencyKeyConcern: new IdempotencyKeyConcern(
            prisma,
            engine,
            new MockTraceEventConcern()
          ),
          validator,
          traceEventConcern: new MockTraceEventConcern(),
          tracer: trace.getTracer("test", "0.0.0"),
          metadataMaximumSize: 1024 * 1024 * 1,
        });

        // A real parent run in envA.
        const parentResult = await triggerTaskService.call({
          taskId: taskIdentifier,
          environment: envA,
          body: { payload: { kind: "parent" } },
        });
        assertNonNullable(parentResult);

        // Trigger a child in envB pointing at the envA parent's friendlyId. The
        // env guard in runStore.findRun's `where` rejects the cross-env parent
        // in a single query, so the resolved parentRun is null.
        const childResult = await triggerTaskService.call({
          taskId: taskIdentifier,
          environment: envB,
          body: {
            payload: { kind: "child" },
            options: { parentRunId: parentResult.run.friendlyId },
          },
        });
        assertNonNullable(childResult);

        // validateParentRun was called with no resolved parent.
        expect(validator.capturedParentRun).not.toBe("unset");
        expect(validator.capturedParentRun ?? null).toBeNull();

        // The child still triggered, at the root depth with no parent linkage —
        // confirming the cross-env parent was dropped, not silently joined.
        const childRow = await prisma.taskRun.findUniqueOrThrow({
          where: { id: childResult.run.id },
        });
        expect(childRow.depth).toBe(0);
        expect(childRow.parentTaskRunId).toBeNull();
      } finally {
        await engine.quit();
      }
    }
  );

  containerTest(
    "resolves the locked background worker on the control-plane client with no cross-DB join",
    async ({ prisma, redisOptions }) => {
      const engine = buildEngine(prisma, redisOptions);

      try {
        const environment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        const taskIdentifier = "test-task";
        const { worker } = await setupBackgroundWorker(engine, environment, taskIdentifier);

        // Read the seeded worker row to get its real version/id.
        const workerRow = await prisma.backgroundWorker.findUniqueOrThrow({
          where: { id: worker.id },
        });

        // Counting proxy over the control-plane client. `this.prisma` is ALWAYS
        // the control-plane client; the locked-worker lookup is a DIRECT
        // backgroundWorker.findFirst on it. The parent read uses a DIFFERENT
        // call (runStore.findRun → taskRun), so a single call() issues two
        // separate single-table reads — never one cross-seam join. Here we count
        // the findFirst calls and capture their args to assert no include/join.
        let backgroundWorkerFindFirstCalls = 0;
        const findFirstArgs: any[] = [];
        const countingPrisma = new Proxy(prisma, {
          get(target, prop, receiver) {
            if (prop === "backgroundWorker") {
              const delegate = Reflect.get(target, prop, receiver);
              return new Proxy(delegate, {
                get(bwTarget, bwProp, bwReceiver) {
                  if (bwProp === "findFirst") {
                    return async (args: any) => {
                      backgroundWorkerFindFirstCalls += 1;
                      findFirstArgs.push(args);
                      return (delegate as any).findFirst(args);
                    };
                  }
                  const value = Reflect.get(bwTarget, bwProp, bwReceiver);
                  return typeof value === "function" ? value.bind(bwTarget) : value;
                },
              });
            }
            const value = Reflect.get(target, prop, receiver);
            return typeof value === "function" ? value.bind(target) : value;
          },
        }) as typeof prisma;

        const triggerTaskService = new RunEngineTriggerTaskService({
          engine,
          prisma: countingPrisma,
          payloadProcessor: new MockPayloadProcessor(),
          // The queue manager gets the real (unproxied) prisma so the counting
          // proxy only observes reads issued by the service itself.
          queueConcern: new DefaultQueueManager(prisma, engine),
          idempotencyKeyConcern: new IdempotencyKeyConcern(
            prisma,
            engine,
            new MockTraceEventConcern()
          ),
          validator: new CapturingParentRunValidator(),
          traceEventConcern: new MockTraceEventConcern(),
          tracer: trace.getTracer("test", "0.0.0"),
          metadataMaximumSize: 1024 * 1024 * 1,
        });

        const result = await triggerTaskService.call({
          taskId: taskIdentifier,
          environment,
          body: {
            payload: { kind: "locked" },
            options: { lockToVersion: workerRow.version },
          },
        });
        assertNonNullable(result);

        // Observable proof the locked worker was resolved on the control-plane
        // client: the created run records the worker id in lockedToVersionId.
        const runRow = await prisma.taskRun.findUniqueOrThrow({
          where: { id: result.run.id },
        });
        expect(runRow.lockedToVersionId).toBe(workerRow.id);
        expect(runRow.taskVersion).toBe(workerRow.version);

        // Exactly one backgroundWorker.findFirst fired for the locked-worker read.
        expect(backgroundWorkerFindFirstCalls).toBe(1);

        // NO-JOIN assertion: the read referenced ONLY the backgroundWorker table.
        // No `include` (which would join into another table); the `select` lists
        // only backgroundWorker scalar columns.
        const args = findFirstArgs[0];
        assertNonNullable(args);
        expect(args.include).toBeUndefined();
        expect(Object.keys(args.select ?? {}).sort()).toEqual([
          "cliVersion",
          "id",
          "sdkVersion",
          "version",
        ]);
      } finally {
        await engine.quit();
      }
    }
  );

  containerTest(
    "issues two independent single-table reads when one call supplies both parentRunId and lockToVersion",
    async ({ prisma, redisOptions }) => {
      const engine = buildEngine(prisma, redisOptions);

      try {
        const environment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        const taskIdentifier = "test-task";
        const { worker } = await setupBackgroundWorker(engine, environment, taskIdentifier);

        const workerRow = await prisma.backgroundWorker.findUniqueOrThrow({
          where: { id: worker.id },
        });

        // Count BOTH reads issued by the service on the control-plane client:
        // the parent read (runStore.findRun → taskRun.findFirst) and the
        // locked-worker read (backgroundWorker.findFirst). Capture every
        // findFirst arg so we can assert no read carries a cross-seam include.
        let taskRunFindFirstCalls = 0;
        let backgroundWorkerFindFirstCalls = 0;
        const findFirstArgs: any[] = [];
        const countingPrisma = new Proxy(prisma, {
          get(target, prop, receiver) {
            if (prop === "backgroundWorker") {
              const delegate = Reflect.get(target, prop, receiver);
              return new Proxy(delegate, {
                get(bwTarget, bwProp, bwReceiver) {
                  if (bwProp === "findFirst") {
                    return async (args: any) => {
                      backgroundWorkerFindFirstCalls += 1;
                      findFirstArgs.push(args);
                      return (delegate as any).findFirst(args);
                    };
                  }
                  const value = Reflect.get(bwTarget, bwProp, bwReceiver);
                  return typeof value === "function" ? value.bind(bwTarget) : value;
                },
              });
            }
            if (prop === "taskRun") {
              const delegate = Reflect.get(target, prop, receiver);
              return new Proxy(delegate, {
                get(trTarget, trProp, trReceiver) {
                  if (trProp === "findFirst") {
                    return async (args: any) => {
                      taskRunFindFirstCalls += 1;
                      findFirstArgs.push(args);
                      return (delegate as any).findFirst(args);
                    };
                  }
                  const value = Reflect.get(trTarget, trProp, trReceiver);
                  return typeof value === "function" ? value.bind(trTarget) : value;
                },
              });
            }
            const value = Reflect.get(target, prop, receiver);
            return typeof value === "function" ? value.bind(target) : value;
          },
        }) as typeof prisma;

        const triggerTaskService = new RunEngineTriggerTaskService({
          engine,
          prisma: countingPrisma,
          payloadProcessor: new MockPayloadProcessor(),
          // queueConcern/idempotency get the real unproxied prisma so the
          // counting proxy only observes reads issued by the service itself.
          queueConcern: new DefaultQueueManager(prisma, engine),
          idempotencyKeyConcern: new IdempotencyKeyConcern(
            prisma,
            engine,
            new MockTraceEventConcern()
          ),
          validator: new CapturingParentRunValidator(),
          traceEventConcern: new MockTraceEventConcern(),
          tracer: trace.getTracer("test", "0.0.0"),
          metadataMaximumSize: 1024 * 1024 * 1,
        });

        // ROOT parent first (uses the unproxied prisma via a separate service so
        // its internal reads don't pollute the child's counts).
        const parentService = new RunEngineTriggerTaskService({
          engine,
          prisma,
          payloadProcessor: new MockPayloadProcessor(),
          queueConcern: new DefaultQueueManager(prisma, engine),
          idempotencyKeyConcern: new IdempotencyKeyConcern(
            prisma,
            engine,
            new MockTraceEventConcern()
          ),
          validator: new CapturingParentRunValidator(),
          traceEventConcern: new MockTraceEventConcern(),
          tracer: trace.getTracer("test", "0.0.0"),
          metadataMaximumSize: 1024 * 1024 * 1,
        });
        const parentResult = await parentService.call({
          taskId: taskIdentifier,
          environment,
          body: { payload: { kind: "parent" } },
        });
        assertNonNullable(parentResult);

        // CHILD supplying BOTH parentRunId AND lockToVersion in one call.
        const childResult = await triggerTaskService.call({
          taskId: taskIdentifier,
          environment,
          body: {
            payload: { kind: "child" },
            options: {
              parentRunId: parentResult.run.friendlyId,
              lockToVersion: workerRow.version,
            },
          },
        });
        assertNonNullable(childResult);

        const parentRow = await prisma.taskRun.findUniqueOrThrow({
          where: { id: parentResult.run.id },
        });
        const childRow = await prisma.taskRun.findUniqueOrThrow({
          where: { id: childResult.run.id },
        });

        // Child resolved the parent (single-table parent read).
        expect(childRow.parentTaskRunId).toBe(parentRow.id);
        expect(childRow.depth).toBe(parentRow.depth + 1);

        // Child locked to the worker (single-table worker read).
        expect(childRow.lockedToVersionId).toBe(workerRow.id);
        expect(childRow.taskVersion).toBe(workerRow.version);

        // Exactly one backgroundWorker.findFirst fired for the locked-worker read,
        // and at least one taskRun.findFirst fired for the parent read.
        expect(backgroundWorkerFindFirstCalls).toBe(1);
        expect(taskRunFindFirstCalls).toBeGreaterThanOrEqual(1);

        // NO-JOIN proof: no captured read carried an `include` joining
        // taskRun <-> backgroundWorker. Every findFirst arg has include undefined.
        for (const args of findFirstArgs) {
          expect(args?.include).toBeUndefined();
        }
      } finally {
        await engine.quit();
      }
    }
  );

  containerTest(
    "lockToVersion matching no worker rejects the trigger after a single scalar-only worker read",
    async ({ prisma, redisOptions }) => {
      const engine = buildEngine(prisma, redisOptions);

      try {
        const environment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        const taskIdentifier = "test-task";
        await setupBackgroundWorker(engine, environment, taskIdentifier);

        let backgroundWorkerFindFirstCalls = 0;
        const findFirstArgs: any[] = [];
        const countingPrisma = new Proxy(prisma, {
          get(target, prop, receiver) {
            if (prop === "backgroundWorker") {
              const delegate = Reflect.get(target, prop, receiver);
              return new Proxy(delegate, {
                get(bwTarget, bwProp, bwReceiver) {
                  if (bwProp === "findFirst") {
                    return async (args: any) => {
                      backgroundWorkerFindFirstCalls += 1;
                      findFirstArgs.push(args);
                      return (delegate as any).findFirst(args);
                    };
                  }
                  const value = Reflect.get(bwTarget, bwProp, bwReceiver);
                  return typeof value === "function" ? value.bind(bwTarget) : value;
                },
              });
            }
            const value = Reflect.get(target, prop, receiver);
            return typeof value === "function" ? value.bind(target) : value;
          },
        }) as typeof prisma;

        const triggerTaskService = new RunEngineTriggerTaskService({
          engine,
          prisma: countingPrisma,
          payloadProcessor: new MockPayloadProcessor(),
          queueConcern: new DefaultQueueManager(prisma, engine),
          idempotencyKeyConcern: new IdempotencyKeyConcern(
            prisma,
            engine,
            new MockTraceEventConcern()
          ),
          validator: new CapturingParentRunValidator(),
          traceEventConcern: new MockTraceEventConcern(),
          tracer: trace.getTracer("test", "0.0.0"),
          metadataMaximumSize: 1024 * 1024 * 1,
        });

        const bogusVersion = "v-does-not-exist-0000";
        // The no-match worker read returns null; the queue concern then rejects
        // the trigger rather than silently locking the run to a phantom version.
        await expect(
          triggerTaskService.call({
            taskId: taskIdentifier,
            environment,
            body: {
              payload: { kind: "locked" },
              options: { lockToVersion: bogusVersion },
            },
          })
        ).rejects.toThrow(/no worker found with that version/);

        // No run was locked to the bogus version (none was created).
        const lockedRuns = await prisma.taskRun.findMany({
          where: { runtimeEnvironmentId: environment.id, taskVersion: bogusVersion },
        });
        expect(lockedRuns).toEqual([]);

        // The lone worker read fired exactly once with the scalar-only select and
        // no cross-seam include.
        expect(backgroundWorkerFindFirstCalls).toBe(1);
        const args = findFirstArgs[0];
        assertNonNullable(args);
        expect(args.include).toBeUndefined();
        expect(Object.keys(args.select ?? {}).sort()).toEqual([
          "cliVersion",
          "id",
          "sdkVersion",
          "version",
        ]);
      } finally {
        await engine.quit();
      }
    }
  );

  containerTest(
    "does not resolve a locked worker from a different environment",
    async ({ prisma, redisOptions }) => {
      const engine = buildEngine(prisma, redisOptions);

      try {
        // Two independent authenticated environments. Rename envA's globally-unique
        // fields before the second setup call to avoid unique-constraint collisions.
        const envA = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        await prisma.organization.update({
          where: { id: envA.organizationId },
          data: { slug: `${envA.organization.slug}-a` },
        });
        await prisma.project.update({
          where: { id: envA.projectId },
          data: { slug: `${envA.project.slug}-a`, externalRef: `${envA.project.externalRef}-a` },
        });
        await prisma.runtimeEnvironment.update({
          where: { id: envA.id },
          data: { apiKey: `${envA.apiKey}-a`, pkApiKey: `${envA.pkApiKey}-a` },
        });
        await prisma.workerGroupToken.updateMany({
          where: { tokenHash: "token_hash" },
          data: { tokenHash: "token_hash_a" },
        });
        await prisma.workerInstanceGroup.updateMany({
          where: { masterQueue: "default" },
          data: { masterQueue: "default_a" },
        });
        const envB = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
        expect(envA.id).not.toBe(envB.id);
        expect(envA.organizationId).not.toBe(envB.organizationId);

        const taskIdentifier = "test-task";
        const { worker: workerA } = await setupBackgroundWorker(engine, envA, taskIdentifier);
        const { worker: workerB } = await setupBackgroundWorker(engine, envB, taskIdentifier);

        const workerARow = await prisma.backgroundWorker.findUniqueOrThrow({
          where: { id: workerA.id },
        });
        const workerBRow = await prisma.backgroundWorker.findUniqueOrThrow({
          where: { id: workerB.id },
        });
        // Both seeded workers share the same version string.
        expect(workerARow.version).toBe(workerBRow.version);
        expect(workerARow.id).not.toBe(workerBRow.id);

        const triggerTaskService = new RunEngineTriggerTaskService({
          engine,
          prisma,
          payloadProcessor: new MockPayloadProcessor(),
          queueConcern: new DefaultQueueManager(prisma, engine),
          idempotencyKeyConcern: new IdempotencyKeyConcern(
            prisma,
            engine,
            new MockTraceEventConcern()
          ),
          validator: new CapturingParentRunValidator(),
          traceEventConcern: new MockTraceEventConcern(),
          tracer: trace.getTracer("test", "0.0.0"),
          metadataMaximumSize: 1024 * 1024 * 1,
        });

        // Trigger in envB locking to the shared version string.
        const result = await triggerTaskService.call({
          taskId: taskIdentifier,
          environment: envB,
          body: {
            payload: { kind: "locked" },
            options: { lockToVersion: workerBRow.version },
          },
        });
        assertNonNullable(result);

        const runRow = await prisma.taskRun.findUniqueOrThrow({
          where: { id: result.run.id },
        });
        // The projectId + runtimeEnvironmentId guard in the single-table worker
        // read resolves envB's worker, never envA's same-version worker.
        expect(runRow.lockedToVersionId).toBe(workerBRow.id);
        expect(runRow.lockedToVersionId).not.toBe(workerARow.id);
        expect(runRow.taskVersion).toBe(workerBRow.version);
      } finally {
        await engine.quit();
      }
    }
  );

  containerTest("a root trigger issues no parent lookup", async ({ prisma, redisOptions }) => {
    const engine = buildEngine(prisma, redisOptions);

    try {
      const environment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
      const taskIdentifier = "test-task";
      await setupBackgroundWorker(engine, environment, taskIdentifier);

      const validator = new CapturingParentRunValidator();
      const triggerTaskService = new RunEngineTriggerTaskService({
        engine,
        prisma,
        payloadProcessor: new MockPayloadProcessor(),
        queueConcern: new DefaultQueueManager(prisma, engine),
        idempotencyKeyConcern: new IdempotencyKeyConcern(
          prisma,
          engine,
          new MockTraceEventConcern()
        ),
        validator,
        traceEventConcern: new MockTraceEventConcern(),
        tracer: trace.getTracer("test", "0.0.0"),
        metadataMaximumSize: 1024 * 1024 * 1,
      });

      // Trigger with NO parentRunId.
      const result = await triggerTaskService.call({
        taskId: taskIdentifier,
        environment,
        body: { payload: { kind: "root" } },
      });
      assertNonNullable(result);

      // The validator ran but received no resolved parent: the parent read was
      // skipped because no parentRunId was supplied.
      expect(validator.capturedParentRun).not.toBe("unset");
      expect(validator.capturedParentRun).toBeUndefined();

      const runRow = await prisma.taskRun.findUniqueOrThrow({
        where: { id: result.run.id },
      });
      expect(runRow.depth).toBe(0);
      expect(runRow.parentTaskRunId).toBeNull();
    } finally {
      await engine.quit();
    }
  });
});