create-windy 0.6.14 → 0.6.15

package/template/apps/server/src/agent/client-session/host-revocation-composition.test.ts

@@ -0,0 +1,77 @@
+import { expect, test } from "bun:test";
+import type {
+  ModuleClientAgentHostAuthAdapter,
+  ModuleClientAgentHostPrincipal,
+} from "@southwind-ai/server-sdk";
+import { bindClientAgentHostRevocations } from "./host-revocation-composition.js";
+
+test("单监听 Host Auth Adapter 通过 Composition fan-out 撤销 Session 与 Workflow", async () => {
+  let listener:
+    | ((principal: ModuleClientAgentHostPrincipal) => Promise<void> | void)
+    | undefined;
+  const adapter = {
+    ready: async () => true,
+    authenticate: async () => undefined,
+    bindRevocations(next) {
+      listener = next;
+      return () => {
+        listener = undefined;
+      };
+    },
+  } satisfies ModuleClientAgentHostAuthAdapter;
+  const calls: string[] = [];
+  const dispose = bindClientAgentHostRevocations({
+    adapter,
+    revokeSessionHost: async () => {
+      calls.push("session");
+    },
+    revokeWorkflowHost: async () => {
+      calls.push("workflow");
+    },
+  });
+
+  await listener?.({
+    actorId: "actor-1",
+    installationId: "installation-1",
+    sessionId: "host-session-1",
+  });
+  expect(calls).toEqual(["session", "workflow"]);
+  dispose?.();
+  expect(listener).toBeUndefined();
+});
+
+test("Session 撤销失败时仍尝试 Workflow 撤销并汇总失败", async () => {
+  let listener:
+    | ((principal: ModuleClientAgentHostPrincipal) => Promise<void> | void)
+    | undefined;
+  const adapter = {
+    ready: async () => true,
+    authenticate: async () => undefined,
+    bindRevocations(next) {
+      listener = next;
+      return () => {
+        listener = undefined;
+      };
+    },
+  } satisfies ModuleClientAgentHostAuthAdapter;
+  const calls: string[] = [];
+  bindClientAgentHostRevocations({
+    adapter,
+    revokeSessionHost: async () => {
+      calls.push("session");
+      throw new Error("session revoke failed");
+    },
+    revokeWorkflowHost: async () => {
+      calls.push("workflow");
+    },
+  });
+
+  await expect(
+    listener?.({
+      actorId: "actor-1",
+      installationId: "installation-1",
+      sessionId: "host-session-1",
+    }),
+  ).rejects.toBeInstanceOf(AggregateError);
+  expect(calls).toEqual(["session", "workflow"]);
+});

package/template/apps/server/src/agent/client-session/host-revocation-composition.ts

@@ -0,0 +1,28 @@
+import type {
+  ModuleClientAgentHostAuthAdapter,
+  ModuleClientAgentHostPrincipal,
+} from "@southwind-ai/server-sdk";
+
+export function bindClientAgentHostRevocations(input: {
+  adapter?: ModuleClientAgentHostAuthAdapter;
+  revokeSessionHost?(
+    principal: ModuleClientAgentHostPrincipal,
+  ): Promise<unknown>;
+  revokeWorkflowHost?(
+    principal: ModuleClientAgentHostPrincipal,
+  ): Promise<unknown>;
+}) {
+  return input.adapter?.bindRevocations(async (principal) => {
+    const errors: unknown[] = [];
+    for (const revoke of [input.revokeSessionHost, input.revokeWorkflowHost]) {
+      try {
+        await revoke?.(principal);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length) {
+      throw new AggregateError(errors, "Client Agent Host 撤销未完全收敛");
+    }
+  });
+}

package/template/apps/server/src/agent/client-session/launch-authority.contract.test.ts

@@ -0,0 +1,21 @@
+import { expect, test } from "bun:test";
+import { createFixture } from "./service.test-support.js";
+import { binding, hostSession } from "./service.test-support.js";
+
+test("普通 Client Session create 不能启动 workflow-only Operation", async () => {
+  const fixture = await createFixture();
+  const input = {
+    operationKey: "analysis.page-agent",
+    input: { question: "绕过 Workflow" },
+    clientBindingDigest: binding,
+    hostSessionDigest: hostSession,
+    actorId: "actor-1",
+  } as const;
+
+  await expect(fixture.service.create(input)).rejects.toMatchObject({
+    code: "FORBIDDEN",
+  });
+  await expect(fixture.service.createWorkflow(input)).resolves.toMatchObject({
+    capabilities: ["pageAgentClientRun"],
+  });
+});

package/template/apps/server/src/agent/client-session/manifest-admission.ts

@@ -63,8 +63,19 @@ export class ManifestClientSessionAdmission implements ClientSessionAdmissionPor
     input: ModuleAiJsonValue;
     clientBindingDigest: `sha256:${string}`;
     actorId: string;
+    launchAuthority: "direct" | "workflow-artifact";
   }) {
     const operation = this.operation(input.operationKey);
+    if (
+      (operation.definition.clientExecution!.launchAuthority ?? "direct") !==
+      input.launchAuthority
+    ) {
+      throw new ClientAgentSessionError(
+        "FORBIDDEN",
+        "Operation 不允许从当前入口启动 Client Agent Session",
+        403,
+      );
+    }
     const context = await this.resolveContext(input.actorId);
     await this.authorize(operation, context, input.actorId);
     const inputBytes = new TextEncoder().encode(

package/template/apps/server/src/agent/client-session/service.test-support.ts

@@ -2,6 +2,7 @@ import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
 import type {
   ClientAgentProviderPort,
   ClientSessionAdmissionPort,
+  ClientSessionAttemptAuthorityChecker,
   ClientSessionAuditPort,
   ClientSessionCaller,
   ClientSessionRecord,
@@ -10,6 +11,7 @@ import { digestJson } from "./digest.js";
 import { ClientAgentSessionError } from "./errors.js";
 import { InMemoryClientSessionRepository } from "./repository.js";
 import { GovernedClientAgentSessionService } from "./service.js";
+import { ClientSessionAttemptAuthorityBinding } from "./attempt-authority.js";
 
 export const binding = `sha256:${"b".repeat(64)}` as const;
 export const hostSession = `sha256:${"e".repeat(64)}` as const;
@@ -26,6 +28,7 @@ export async function createFixture(
       signal: AbortSignal,
     ) => Promise<ModuleAiJsonValue>;
     providerReady?: boolean;
+    attemptAuthority?: ClientSessionAttemptAuthorityChecker;
   } = {},
 ) {
   const clock = { value: options.now ?? 1_000 };
@@ -39,6 +42,10 @@ export async function createFixture(
     options.providerReady ?? true,
   );
   const audits: Parameters<ClientSessionAuditPort["record"]>[0][] = [];
+  const attemptAuthority = new ClientSessionAttemptAuthorityBinding();
+  if (options.attemptAuthority) {
+    attemptAuthority.bind(options.attemptAuthority);
+  }
   const service = new GovernedClientAgentSessionService(
     repository,
     admission,
@@ -49,6 +56,7 @@ export async function createFixture(
       },
     },
     "https://windy.example/api/agent/client-sessions/",
+    attemptAuthority,
     () => clock.value,
     options.maxTtlMs,
   );
@@ -70,6 +78,7 @@ export async function createFixture(
     repository,
     admission,
     provider,
+    attemptAuthority,
     audits,
     grant,
     caller,
@@ -90,7 +99,19 @@ class FakeAdmission implements ClientSessionAdmissionPort {
     input: ModuleAiJsonValue;
     clientBindingDigest: `sha256:${string}`;
     actorId: string;
+    launchAuthority: "direct" | "workflow-artifact";
   }) {
+    const expectedAuthority: "direct" | "workflow-artifact" =
+      input.operationKey === "analysis.page-agent"
+        ? "workflow-artifact"
+        : "direct";
+    if (input.launchAuthority !== expectedAuthority) {
+      throw new ClientAgentSessionError(
+        "FORBIDDEN",
+        "launch authority mismatch",
+        403,
+      );
+    }
     return {
       actorId: input.actorId,
       operationKey: input.operationKey,
@@ -121,6 +142,7 @@ class FakeAdmission implements ClientSessionAdmissionPort {
       },
       limits: {
         mode: "governed-session" as const,
+        launchAuthority: expectedAuthority,
         maxSteps: this.maxSteps,
         maxRequestBytes: 16_384,
         maxResponseBytes: 16_384,

package/template/apps/server/src/agent/client-session/service.ts

@@ -1,31 +1,25 @@
-import { randomBytes, randomUUID } from "node:crypto";
 import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
 import type {
   ClientSessionAdmissionPort,
+  ClientSessionAttemptAuthorityChecker,
   ClientSessionAuditPort,
   ClientSessionCaller,
-  ClientSessionFinalResult,
   ClientSessionRecord,
 } from "./contracts.js";
-import { digestJson, digestText, validDigest } from "./digest.js";
+import { digestText } from "./digest.js";
 import type { ClientSessionRepository } from "./repository.js";
 import { clientAgentCapabilities } from "./capabilities.js";
 import { authorizeClientSession } from "./authorization.js";
 import { abortClientSession, auditRevokedSessions } from "./revocation.js";
-import {
-  ensureTrailingSlash,
-  publicLimits,
-  sessionView,
-} from "./presentation.js";
-import {
-  ClientAgentSessionError,
-  clientSessionConflict as conflict,
-  clientSessionInvalid as invalid,
-} from "./errors.js";
+import { sessionView } from "./presentation.js";
+import { clientSessionConflict as conflict } from "./errors.js";
 import {
   consumeClientAgentCompletion,
   runClientAgentCompletion,
 } from "./completion.js";
+import { finalizeClientSession } from "./finalization.js";
+import { createClientAgentSession } from "./creation.js";
+
 export class GovernedClientAgentSessionService {
   readonly #attemptControllers = new Map<string, AbortController>();
   readonly #recovery: Promise<number>;
@@ -35,6 +29,7 @@ export class GovernedClientAgentSessionService {
     private readonly provider: import("./contracts.js").ClientAgentProviderPort,
     private readonly audit: ClientSessionAuditPort,
     private readonly trustedBaseUrl: string,
+    private readonly attemptAuthority: ClientSessionAttemptAuthorityChecker,
     private readonly now: () => number = Date.now,
     private readonly maxTtlMs = 5 * 60_000,
   ) {
@@ -60,73 +55,44 @@ export class GovernedClientAgentSessionService {
     hostSessionDigest: `sha256:${string}`;
     actorId: string;
   }) {
-    await this.#recovery;
-    if (!(await this.provider.ready())) {
-      throw new ClientAgentSessionError(
-        "PROVIDER_FAILED",
-        "Client Agent Provider 尚未就绪",
-        503,
-      );
-    }
-    if (
-      !validDigest(input.clientBindingDigest) ||
-      !validDigest(input.hostSessionDigest) ||
-      !input.actorId.trim()
-    ) {
-      throw invalid("Client Agent binding 或 Actor 无效");
-    }
-    const admission = await this.admission.admit({
-      operationKey: input.operationKey,
-      input: input.input,
-      actorId: input.actorId,
-      clientBindingDigest: input.clientBindingDigest,
-    });
-    if (
-      admission.actorId !== input.actorId ||
-      admission.operationKey !== input.operationKey ||
-      admission.clientBindingDigest !== input.clientBindingDigest
-    ) {
-      throw new Error("Client Agent admission 返回了不一致的绑定");
-    }
-    const createdAt = this.now();
-    const expiresAt =
-      createdAt +
-      Math.min(admission.limits.maxDurationSeconds * 1_000, this.maxTtlMs);
-    const accessToken = `car_${randomBytes(32).toString("base64url")}`;
-    const record: ClientSessionRecord = {
-      ...admission,
-      sessionId: `cas_${randomUUID()}`,
-      clientRunId: `carun_${randomUUID()}`,
-      tokenHash: digestText(accessToken),
-      hostSessionDigest: input.hostSessionDigest,
-      modelAlias: this.provider.modelAlias,
-      createdAt,
-      expiresAt,
-      status: "active",
-      attemptCount: 0,
-      activeRequests: 0,
-      pendingAttempts: [],
-      receipts: [],
-    };
-    await this.repository.create(record);
-    await this.recordAudit("create", record, "success", {
-      inputCommitment: record.inputCommitment,
-      authorizationDigest: record.authorizationDigest,
-      bindingDigest: record.clientBindingDigest,
+    return this.createWithAuthority(input, "direct");
+  }
+
+  /** 仅供固定 Workflow Artifact service 使用；路由不得暴露。 */
+  async createWorkflow(input: {
+    operationKey: string;
+    input: ModuleAiJsonValue;
+    clientBindingDigest: string;
+    hostSessionDigest: `sha256:${string}`;
+    actorId: string;
+  }) {
+    return this.createWithAuthority(input, "workflow-artifact");
+  }
+
+  private async createWithAuthority(
+    input: {
+      operationKey: string;
+      input: ModuleAiJsonValue;
+      clientBindingDigest: string;
+      hostSessionDigest: `sha256:${string}`;
+      actorId: string;
+    },
+    launchAuthority: "direct" | "workflow-artifact",
+  ) {
+    return createClientAgentSession({
+      request: input,
+      launchAuthority,
+      recovery: this.#recovery,
+      provider: this.provider,
+      admission: this.admission,
+      repository: this.repository,
+      trustedBaseUrl: this.trustedBaseUrl,
+      now: this.now,
+      maxTtlMs: this.maxTtlMs,
+      audit: async (record, metadata) => {
+        await this.recordAudit("create", record, "success", metadata);
+      },
     });
-    return {
-      clientRunId: record.clientRunId,
-      sessionId: record.sessionId,
-      trustedBaseUrl: new URL(
-        `${encodeURIComponent(record.sessionId)}/v1/`,
-        ensureTrailingSlash(this.trustedBaseUrl),
-      ).toString(),
-      modelAlias: record.modelAlias,
-      limits: publicLimits(record),
-      expiresAt: new Date(record.expiresAt).toISOString(),
-      accessToken,
-      capabilities: ["pageAgentClientRun"] as const,
-    };
   }
 
   async complete(
@@ -152,6 +118,7 @@ export class GovernedClientAgentSessionService {
       caller,
       signal,
       current: await this.authorize(sessionId, caller, true),
+      attemptAuthority: this.attemptAuthority,
       repository: this.repository,
       admission: this.admission,
       provider: this.provider,
@@ -172,66 +139,49 @@ export class GovernedClientAgentSessionService {
   ) {
     await this.#recovery;
     const record = await this.authorize(sessionId, caller, false);
-    const terminalDigest = digestJson({
-      receiptIds: [...receiptIds],
-      ...(clientResult === undefined ? {} : { result: clientResult }),
+    return finalizeClientSession({
+      record,
+      repository: this.repository,
+      admission: this.admission,
+      receiptIds,
+      clientResult,
+      audit: (completed, metadata) =>
+        this.recordAudit("finalize", completed, "success", metadata),
     });
-    if (record.status === "completed") {
-      if (record.terminalDigest === terminalDigest) return sessionView(record);
-      throw conflict("会话已完成，终态不可改写");
-    }
-    if (record.status !== "active" || record.activeRequests) {
-      throw conflict("会话当前不能 finalize");
-    }
-    const receipts = [...record.receipts].sort((a, b) => a.attempt - b.attempt);
+  }
+
+  async finalizeWorkflow(
+    sessionId: string,
+    caller: Omit<ClientSessionCaller, "token">,
+    receiptIds: readonly string[],
+    clientResult: ModuleAiJsonValue | undefined,
+    canonicalizeResult: (
+      proposedResult: ModuleAiJsonValue,
+    ) => Promise<ModuleAiJsonValue>,
+  ) {
+    await this.#recovery;
+    const record = await this.repository.find(sessionId);
     if (
-      !receipts.length ||
-      receiptIds.length !== receipts.length ||
-      receipts.some((receipt, index) => receipt.receiptId !== receiptIds[index])
+      !record ||
+      record.actorId !== caller.actorId ||
+      record.clientBindingDigest !== caller.clientBindingDigest ||
+      record.hostSessionDigest !== caller.hostSessionDigest ||
+      (record.status !== "completed" &&
+        (record.status !== "active" || record.expiresAt <= this.now())) ||
+      !(await this.admission.reauthorize(record, caller.actorId))
     ) {
-      throw invalid("Finalize 必须提交本 Run 的完整终末 receipt 链");
+      throw conflict("Workflow Client Agent Session 绑定已失效");
     }
-    const terminal = receipts.at(-1)!;
-    const projected = terminal.canonicalResult;
-    const result = projected ?? clientResult;
-    if (result === undefined) throw invalid("Finalize 缺少可公开结果");
-    await this.admission.validateResult(record.operationKey, result);
-    const finalResult: ClientSessionFinalResult = {
-      clientRunId: record.clientRunId,
-      status: "completed",
-      result,
-      attestation: {
-        source:
-          projected === undefined ? "client-projected" : "provider-observed",
-        terminalReceiptId: terminal.receiptId,
-        providerAttested: projected !== undefined,
-        clientProjected: projected === undefined,
-      },
-    };
-    const completed = await this.repository.transition(
-      sessionId,
-      "active",
-      "completed",
-      {
-        terminalDigest,
-        finalResult,
-      },
-    );
-    if (!completed) {
-      const concurrent = await this.repository.find(sessionId);
-      if (
-        concurrent?.status === "completed" &&
-        concurrent.terminalDigest === terminalDigest
-      ) {
-        return sessionView(concurrent);
-      }
-      throw conflict("Finalize 与其它终态操作冲突");
-    }
-    await this.recordAudit("finalize", completed, "success", {
-      terminalReceiptId: terminal.receiptId,
-      clientProjected: projected === undefined,
+    return finalizeClientSession({
+      record,
+      repository: this.repository,
+      admission: this.admission,
+      receiptIds,
+      clientResult,
+      canonicalizeResult,
+      audit: (completed, metadata) =>
+        this.recordAudit("finalize", completed, "success", metadata),
     });
-    return sessionView(completed);
   }
 
   async cancel(
@@ -310,6 +260,26 @@ export class GovernedClientAgentSessionService {
     });
   }
 
+  /** Host-internal revocation for a fenced Workflow claim; no browser token is accepted. */
+  async revokeSession(sessionId: string, cause: string) {
+    await this.#recovery;
+    const record = await this.repository.find(sessionId);
+    if (!record || record.status === "revoked") return;
+    if (record.status !== "active") return;
+    abortClientSession(this.#attemptControllers, sessionId);
+    const revoked = await this.repository.transition(
+      sessionId,
+      "active",
+      "revoked",
+      { terminalDigest: digestText(`revoke\0${cause.slice(0, 120)}`) },
+    );
+    if (revoked) {
+      await this.recordAudit("revoke", revoked, "success", {
+        cause: cause.slice(0, 120),
+      });
+    }
+  }
+
   private async authorize(
     sessionId: string,
     caller: ClientSessionCaller,

package/template/apps/server/src/agent/client-session/terminal-digest.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { clientSessionTerminalDigest } from "./digest.js";
+
+describe("Client Session terminal digest", () => {
+  test("canonical result key 顺序不改变 digest，receipt 顺序仍参与绑定", () => {
+    const left = clientSessionTerminalDigest(["receipt_1", "receipt_2"], {
+      answer: "done",
+      evidence: { b: 2, a: 1 },
+    });
+    const same = clientSessionTerminalDigest(["receipt_1", "receipt_2"], {
+      evidence: { a: 1, b: 2 },
+      answer: "done",
+    });
+    const reordered = clientSessionTerminalDigest(["receipt_2", "receipt_1"], {
+      answer: "done",
+      evidence: { a: 1, b: 2 },
+    });
+
+    expect(left).toBe(same);
+    expect(left).toMatch(/^sha256:[a-f0-9]{64}$/u);
+    expect(reordered).not.toBe(left);
+  });
+});

package/template/apps/server/src/agent/client-workflow-artifact/active-blob-references.ts

@@ -0,0 +1,8 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { DrizzleClientAgentWorkflowArtifactRepository } from "./drizzle-repository.js";
+
+export function clientWorkflowArtifactActiveBlobReferences(
+  db: NodePgDatabase | undefined,
+) {
+  return db ? [new DrizzleClientAgentWorkflowArtifactRepository(db)] : [];
+}

package/template/apps/server/src/agent/client-workflow-artifact/artifact-builder.ts

@@ -0,0 +1,60 @@
+import { createHash } from "node:crypto";
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import { artifactRef, type BlobStore } from "@southwind-ai/storage";
+import { canonicalJson, digestJson } from "../client-session/digest.js";
+import type {
+  ClientAgentWorkflowArtifactBinding,
+  ClientAgentWorkflowArtifactRecord,
+} from "./contracts.js";
+import { ClientAgentWorkflowArtifactError } from "./error.js";
+
+export function clientWorkflowTerminalReceipt(
+  record: ClientAgentWorkflowArtifactRecord,
+  historyHeadDigest: string,
+) {
+  return `cawr_${digestJson({
+    workId: record.workId,
+    claimGeneration: record.claimGeneration,
+    historyHeadDigest,
+  }).slice("sha256:".length, 53)}`;
+}
+
+export async function storeClientWorkflowArtifact(input: {
+  blobs: BlobStore;
+  result: ModuleAiJsonValue;
+  binding: ClientAgentWorkflowArtifactBinding;
+  terminalReceiptDigest: `sha256:${string}`;
+}) {
+  const bytes = new TextEncoder().encode(canonicalJson(input.result));
+  if (bytes.byteLength > input.binding.artifact.maxByteSize) {
+    throw new ClientAgentWorkflowArtifactError(
+      "ARTIFACT_TOO_LARGE",
+      "Client Agent Workflow 产物超过策略上限",
+      413,
+    );
+  }
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  if (!input.blobs.putOnce) {
+    throw new ClientAgentWorkflowArtifactError(
+      "ARTIFACT_STORE_UNAVAILABLE",
+      "Client Agent Workflow 稳定产物存储未装配",
+      503,
+    );
+  }
+  const stableRef = artifactRef(
+    `blob_${input.terminalReceiptDigest.slice("sha256:".length, 39)}`,
+  );
+  const stored = await input.blobs.putOnce({
+    ref: stableRef,
+    body: new Blob([bytes]).stream(),
+    expectedByteSize: bytes.byteLength,
+    expectedContentHash: { algorithm: "sha256", value: sha256 },
+  });
+  return {
+    artifactRef: stored.ref,
+    filename: input.binding.artifact.filename,
+    contentType: input.binding.artifact.contentType,
+    byteSize: stored.byteSize,
+    sha256,
+  };
+}

package/template/apps/server/src/agent/client-workflow-artifact/authority-current.ts

@@ -0,0 +1,59 @@
+import {
+  agentWorkflowNodeRuns,
+  agentWorkflowRuns,
+  agentWorkflowSideEffectCommands,
+} from "@southwind-ai/database";
+import { eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { ClientAgentWorkflowArtifactRecord } from "./contracts.js";
+
+export async function clientWorkflowAuthorityCurrent(
+  db: NodePgDatabase,
+  record: ClientAgentWorkflowArtifactRecord,
+  now: number,
+) {
+  const [command] = await db
+    .select()
+    .from(agentWorkflowSideEffectCommands)
+    .where(eq(agentWorkflowSideEffectCommands.commandId, record.commandId))
+    .for("update")
+    .limit(1);
+  if (!command) return false;
+  const [run] = await db
+    .select()
+    .from(agentWorkflowRuns)
+    .where(eq(agentWorkflowRuns.runId, record.runId))
+    .for("update")
+    .limit(1);
+  if (!run) return false;
+  const [nodeRun] = await db
+    .select()
+    .from(agentWorkflowNodeRuns)
+    .where(eq(agentWorkflowNodeRuns.nodeRunId, record.nodeRunId))
+    .for("update")
+    .limit(1);
+  return Boolean(
+    nodeRun &&
+    command.status === "dispatched" &&
+    command.runId === record.runId &&
+    command.nodeRunId === record.nodeRunId &&
+    command.effectKind === record.effectKind &&
+    command.adapterKind === "durable-job" &&
+    command.generation === record.effectGeneration &&
+    command.requestDigest === record.requestDigest &&
+    command.fenceTokenDigest === record.effectFenceTokenDigest &&
+    command.authorizationSnapshotDigest ===
+      record.authorizationSnapshotDigest &&
+    command.runPolicyDigest === record.runPolicyDigest &&
+    ["accepted", "running", "waiting"].includes(run.status) &&
+    !run.cancellationRequestedAt &&
+    run.deadlineAt > now &&
+    run.actorId === record.actorId &&
+    run.scopeDigest === record.scopeDigest &&
+    run.authorizationSnapshotDigest === record.authorizationSnapshotDigest &&
+    run.executionPolicyDigest === record.runPolicyDigest &&
+    nodeRun.runId === record.runId &&
+    nodeRun.nodeType === "job" &&
+    ["running", "waiting"].includes(nodeRun.status),
+  );
+}