create-windy 0.6.12 → 0.6.15

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

@@ -0,0 +1,150 @@
+import {
+  clientAgentReceipts,
+  clientAgentSessions,
+} from "@southwind-ai/database";
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import { asc, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  ClientSessionAdmission,
+  ClientSessionFinalResult,
+  ClientSessionReceiptRecord,
+  ClientSessionRecord,
+  ClientSessionStatus,
+} from "./contracts.js";
+
+type SessionRow = typeof clientAgentSessions.$inferSelect;
+type ReceiptRow = typeof clientAgentReceipts.$inferSelect;
+
+export async function findClientSessionRecord(
+  db: NodePgDatabase,
+  sessionId: string,
+) {
+  const [row] = await db
+    .select()
+    .from(clientAgentSessions)
+    .where(eq(clientAgentSessions.sessionId, sessionId))
+    .limit(1);
+  return row ? hydrateClientSessionRecord(db, row) : undefined;
+}
+
+export async function hydrateClientSessionRecord(
+  db: NodePgDatabase,
+  row: SessionRow,
+) {
+  const receipts = await db
+    .select()
+    .from(clientAgentReceipts)
+    .where(eq(clientAgentReceipts.sessionId, row.sessionId))
+    .orderBy(asc(clientAgentReceipts.attempt));
+  return mapClientSessionRecord(row, receipts.map(mapReceipt));
+}
+
+export function clientSessionValues(record: ClientSessionRecord) {
+  const admission: ClientSessionAdmission = {
+    actorId: record.actorId,
+    operationKey: record.operationKey,
+    releaseId: record.releaseId,
+    inputCommitment: record.inputCommitment,
+    authorizationDigest: record.authorizationDigest,
+    clientBindingDigest: record.clientBindingDigest,
+    deploymentKey: record.deploymentKey,
+    providerDataPolicy: record.providerDataPolicy,
+    limits: record.limits,
+  };
+  return {
+    sessionId: record.sessionId,
+    clientRunId: record.clientRunId,
+    actorId: record.actorId,
+    operationKey: record.operationKey,
+    releaseId: record.releaseId,
+    tokenHash: record.tokenHash,
+    clientBindingDigest: record.clientBindingDigest,
+    hostSessionDigest: record.hostSessionDigest,
+    modelAlias: record.modelAlias,
+    status: record.status,
+    attemptCount: record.attemptCount,
+    activeRequests: record.activeRequests,
+    pendingAttempts: [...record.pendingAttempts],
+    admissionJson: admission as unknown as Record<string, unknown>,
+    terminalDigest: record.terminalDigest,
+    finalResultJson: record.finalResult as Record<string, unknown> | undefined,
+    createdAt: record.createdAt,
+    expiresAt: record.expiresAt,
+  };
+}
+
+export function mapClientSessionRecord(
+  row: SessionRow,
+  receipts: readonly ClientSessionReceiptRecord[],
+): ClientSessionRecord {
+  const admission = row.admissionJson as unknown as ClientSessionAdmission;
+  return {
+    ...admission,
+    sessionId: row.sessionId,
+    clientRunId: row.clientRunId,
+    actorId: row.actorId,
+    operationKey: row.operationKey,
+    releaseId: row.releaseId,
+    tokenHash: row.tokenHash as `sha256:${string}`,
+    clientBindingDigest: row.clientBindingDigest as `sha256:${string}`,
+    hostSessionDigest: row.hostSessionDigest as `sha256:${string}`,
+    modelAlias: row.modelAlias,
+    status: row.status as ClientSessionStatus,
+    attemptCount: row.attemptCount,
+    activeRequests: row.activeRequests,
+    pendingAttempts: row.pendingAttempts,
+    receipts,
+    createdAt: row.createdAt,
+    expiresAt: row.expiresAt,
+    ...(row.terminalDigest
+      ? { terminalDigest: row.terminalDigest as `sha256:${string}` }
+      : {}),
+    ...(row.finalResultJson
+      ? {
+          finalResult:
+            row.finalResultJson as unknown as ClientSessionFinalResult,
+        }
+      : {}),
+  };
+}
+
+export function clientSessionReceiptValues(
+  sessionId: string,
+  receipt: ClientSessionReceiptRecord,
+) {
+  return {
+    receiptId: receipt.receiptId,
+    sessionId,
+    clientRunId: receipt.clientRunId,
+    actorId: receipt.actorId,
+    operationKey: receipt.operationKey,
+    releaseId: receipt.releaseId,
+    clientBindingDigest: receipt.clientBindingDigest,
+    attempt: receipt.attempt,
+    requestDigest: receipt.requestDigest,
+    responseDigest: receipt.responseDigest,
+    deploymentDigest: receipt.deploymentDigest,
+    canonicalResultJson: receipt.canonicalResult,
+    issuedAt: receipt.issuedAt,
+  };
+}
+
+function mapReceipt(row: ReceiptRow): ClientSessionReceiptRecord {
+  return {
+    receiptId: row.receiptId,
+    clientRunId: row.clientRunId,
+    actorId: row.actorId,
+    operationKey: row.operationKey,
+    releaseId: row.releaseId,
+    clientBindingDigest: row.clientBindingDigest as `sha256:${string}`,
+    attempt: row.attempt,
+    requestDigest: row.requestDigest as `sha256:${string}`,
+    responseDigest: row.responseDigest as `sha256:${string}`,
+    deploymentDigest: row.deploymentDigest as `sha256:${string}`,
+    issuedAt: row.issuedAt,
+    ...(row.canonicalResultJson === null
+      ? {}
+      : { canonicalResult: row.canonicalResultJson as ModuleAiJsonValue }),
+  };
+}

package/template/apps/server/src/agent/client-session/drizzle-repository.integration.test.ts

@@ -0,0 +1,197 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { resolve } from "node:path";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { Pool } from "pg";
+import type {
+  ClientSessionReceiptRecord,
+  ClientSessionRecord,
+} from "./contracts.js";
+import { DrizzleClientSessionRepository } from "./drizzle-repository.js";
+import { ClientSessionAttemptAuthorityBinding } from "./attempt-authority.js";
+
+const databaseUrl = process.env.CLIENT_AGENT_TEST_DATABASE_URL;
+const describePostgres = databaseUrl ? describe : describe.skip;
+const binding = `sha256:${"b".repeat(64)}` as const;
+const hostSession = `sha256:${"e".repeat(64)}` as const;
+const tokenHash = `sha256:${"t".repeat(64)}` as const;
+
+describePostgres("PostgreSQL Client Agent Session repository", () => {
+  let pool: Pool;
+
+  beforeAll(async () => {
+    pool = new Pool({ connectionString: databaseUrl });
+    await migrate(drizzle(pool), {
+      migrationsFolder: resolve(
+        import.meta.dir,
+        "../../../../../packages/database/drizzle",
+      ),
+      migrationsSchema: "public",
+      migrationsTable: "__client_agent_test_migrations",
+    });
+    await pool.query(
+      "truncate table client_agent_receipts, client_agent_sessions",
+    );
+  });
+
+  afterAll(async () => {
+    await pool?.end();
+  });
+
+  test("重启恢复 session/receipt，且并发预留与终态保持原子", async () => {
+    let transactionAuthorityChecks = 0;
+    const commitNow = 3_000;
+    const authority = new ClientSessionAttemptAuthorityBinding();
+    authority.bind({
+      async check() {
+        return "ordinary";
+      },
+      async checkTransaction(transaction, _facts, now) {
+        expect(transaction).toBeDefined();
+        expect(now).toBe(commitNow);
+        transactionAuthorityChecks += 1;
+        return "ordinary";
+      },
+    });
+    const first = new DrizzleClientSessionRepository(
+      drizzle(pool),
+      authority,
+      () => commitNow,
+    );
+    await first.create(session());
+    const [accepted, denied] = await Promise.all([
+      first.reserveAttempt(caller()),
+      first.reserveAttempt(caller()),
+    ]);
+    expect([accepted, denied].filter(Boolean)).toHaveLength(1);
+    expect([accepted, denied].filter((value) => !value)).toHaveLength(1);
+
+    const restarted = new DrizzleClientSessionRepository(
+      drizzle(pool),
+      authority,
+      () => commitNow,
+    );
+    expect(await restarted.find("cas_1")).toMatchObject({
+      clientRunId: "carun_1",
+      attemptCount: 1,
+      activeRequests: 1,
+      tokenHash,
+    });
+    expect(await restarted.recoverInterrupted(2_500)).toBe(1);
+    expect(await restarted.find("cas_1")).toMatchObject({
+      activeRequests: 0,
+      pendingAttempts: [],
+      attemptCount: 1,
+    });
+    expect(
+      await restarted.reserveAttempt({ ...caller(), actorId: "actor-2" }),
+    ).toBeUndefined();
+    expect(
+      await restarted.reserveAttempt({
+        ...caller(),
+        hostSessionDigest: `sha256:${"x".repeat(64)}`,
+      }),
+    ).toBeUndefined();
+    expect(await restarted.reserveAttempt(caller())).toMatchObject({
+      attemptCount: 2,
+      activeRequests: 1,
+    });
+
+    const completed = await restarted.completeAttempt("cas_1", receipt());
+    expect(transactionAuthorityChecks).toBe(1);
+    expect(completed?.receipts).toHaveLength(1);
+    const afterReceipt = new DrizzleClientSessionRepository(
+      drizzle(pool),
+      authority,
+    );
+    expect((await afterReceipt.find("cas_1"))?.receipts[0]).toEqual(receipt());
+
+    const terminal = await afterReceipt.transition(
+      "cas_1",
+      "active",
+      "completed",
+      {
+        terminalDigest: `sha256:${"f".repeat(64)}`,
+        finalResult: {
+          clientRunId: "carun_1",
+          status: "completed",
+          result: { answer: "完成" },
+          attestation: {
+            source: "provider-observed",
+            terminalReceiptId: "receipt_1",
+            providerAttested: true,
+            clientProjected: false,
+          },
+        },
+      },
+    );
+    expect(terminal?.status).toBe("completed");
+    expect(
+      await afterReceipt.transition("cas_1", "active", "cancelled"),
+    ).toBeUndefined();
+    expect((await first.find("cas_1"))?.finalResult?.result).toEqual({
+      answer: "完成",
+    });
+  });
+});
+
+function session(): ClientSessionRecord {
+  return {
+    sessionId: "cas_1",
+    clientRunId: "carun_1",
+    actorId: "actor-1",
+    operationKey: "support.answer",
+    releaseId: "release-1",
+    tokenHash,
+    inputCommitment: `sha256:${"i".repeat(64)}`,
+    authorizationDigest: `sha256:${"a".repeat(64)}`,
+    clientBindingDigest: binding,
+    hostSessionDigest: hostSession,
+    deploymentKey: "ai.openai-compatible",
+    providerDataPolicy: { inputFields: [], envelopeFields: [] },
+    limits: {
+      mode: "governed-session",
+      maxSteps: 4,
+      maxRequestBytes: 16_384,
+      maxResponseBytes: 16_384,
+      maxConcurrentRequests: 1,
+      maxDurationSeconds: 60,
+    },
+    modelAlias: "windy-client-agent-v1",
+    createdAt: 1_000,
+    expiresAt: 61_000,
+    status: "active",
+    attemptCount: 0,
+    activeRequests: 0,
+    pendingAttempts: [],
+    receipts: [],
+  };
+}
+
+function caller() {
+  return {
+    sessionId: "cas_1",
+    tokenHash,
+    actorId: "actor-1",
+    clientBindingDigest: binding,
+    hostSessionDigest: hostSession,
+    now: 2_000,
+  };
+}
+
+function receipt(): ClientSessionReceiptRecord {
+  return {
+    receiptId: "receipt_1",
+    clientRunId: "carun_1",
+    actorId: "actor-1",
+    operationKey: "support.answer",
+    releaseId: "release-1",
+    clientBindingDigest: binding,
+    attempt: 2,
+    requestDigest: `sha256:${"q".repeat(64)}`,
+    responseDigest: `sha256:${"r".repeat(64)}`,
+    deploymentDigest: `sha256:${"d".repeat(64)}`,
+    issuedAt: 3_000,
+    canonicalResult: { answer: "完成" },
+  };
+}

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

@@ -0,0 +1,236 @@
+import {
+  clientAgentReceipts,
+  clientAgentSessions,
+} from "@southwind-ai/database";
+import { and, eq, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  ClientSessionReceiptRecord,
+  ClientSessionRecord,
+  ClientSessionStatus,
+} from "./contracts.js";
+import { receiptMatches, type ClientSessionRepository } from "./repository.js";
+import { sameSecret } from "./digest.js";
+import {
+  clientSessionAttemptAuthorityFacts,
+  type ClientSessionAttemptAuthorityBinding,
+} from "./attempt-authority.js";
+import {
+  clientSessionReceiptValues as receiptValues,
+  clientSessionValues as sessionValues,
+  findClientSessionRecord as findRecord,
+  hydrateClientSessionRecord as hydrateRecord,
+  mapClientSessionRecord as mapRecord,
+} from "./drizzle-records.js";
+
+export class DrizzleClientSessionRepository implements ClientSessionRepository {
+  constructor(
+    private readonly db: NodePgDatabase,
+    private readonly attemptAuthority?: ClientSessionAttemptAuthorityBinding,
+    private readonly now: () => number = Date.now,
+  ) {}
+
+  async recoverInterrupted(now: number): Promise<number> {
+    return this.db.transaction(async (transaction) => {
+      await transaction
+        .update(clientAgentSessions)
+        .set({ status: "expired", activeRequests: 0, pendingAttempts: [] })
+        .where(
+          and(
+            eq(clientAgentSessions.status, "active"),
+            sql`${clientAgentSessions.expiresAt} <= ${now}`,
+          ),
+        );
+      const recovered = await transaction
+        .update(clientAgentSessions)
+        .set({ activeRequests: 0, pendingAttempts: [] })
+        .where(
+          and(
+            eq(clientAgentSessions.status, "active"),
+            sql`${clientAgentSessions.activeRequests} > 0`,
+          ),
+        )
+        .returning({ sessionId: clientAgentSessions.sessionId });
+      return recovered.length;
+    });
+  }
+
+  async create(record: ClientSessionRecord): Promise<void> {
+    await this.db.insert(clientAgentSessions).values(sessionValues(record));
+  }
+
+  find(sessionId: string): Promise<ClientSessionRecord | undefined> {
+    return findRecord(this.db, sessionId);
+  }
+
+  async reserveAttempt(
+    input: Parameters<ClientSessionRepository["reserveAttempt"]>[0],
+  ) {
+    return this.lock(input.sessionId, async (db) => {
+      const record = await findRecord(db, input.sessionId);
+      if (
+        !record ||
+        record.status !== "active" ||
+        record.expiresAt <= input.now ||
+        !sameSecret(record.tokenHash, input.tokenHash) ||
+        record.actorId !== input.actorId ||
+        !sameSecret(record.clientBindingDigest, input.clientBindingDigest) ||
+        !sameSecret(record.hostSessionDigest, input.hostSessionDigest) ||
+        record.attemptCount >= record.limits.maxSteps ||
+        record.activeRequests >= record.limits.maxConcurrentRequests
+      ) {
+        return undefined;
+      }
+      const attempt = record.attemptCount + 1;
+      const [updated] = await db
+        .update(clientAgentSessions)
+        .set({
+          attemptCount: attempt,
+          activeRequests: record.activeRequests + 1,
+          pendingAttempts: [...record.pendingAttempts, attempt],
+        })
+        .where(eq(clientAgentSessions.sessionId, input.sessionId))
+        .returning();
+      return updated ? mapRecord(updated, record.receipts) : undefined;
+    });
+  }
+
+  async completeAttempt(
+    sessionId: string,
+    receipt: ClientSessionReceiptRecord,
+  ) {
+    return this.lock(sessionId, async (db) => {
+      const record = await findRecord(db, sessionId);
+      if (
+        !record ||
+        record.status !== "active" ||
+        record.activeRequests < 1 ||
+        !record.pendingAttempts.includes(receipt.attempt) ||
+        !receiptMatches(record, receipt)
+      ) {
+        return undefined;
+      }
+      const authority = await this.attemptAuthority?.checkTransaction(
+        db,
+        clientSessionAttemptAuthorityFacts(record),
+        this.now(),
+      );
+      if (authority === "revoked") return undefined;
+      await db
+        .insert(clientAgentReceipts)
+        .values(receiptValues(sessionId, receipt));
+      const [updated] = await db
+        .update(clientAgentSessions)
+        .set({
+          activeRequests: record.activeRequests - 1,
+          pendingAttempts: record.pendingAttempts.filter(
+            (attempt) => attempt !== receipt.attempt,
+          ),
+        })
+        .where(eq(clientAgentSessions.sessionId, sessionId))
+        .returning();
+      return updated
+        ? mapRecord(updated, [...record.receipts, receipt])
+        : undefined;
+    });
+  }
+
+  async failAttempt(sessionId: string, attempt: number): Promise<void> {
+    await this.lock(sessionId, async (db) => {
+      const record = await findRecord(db, sessionId);
+      if (
+        !record ||
+        record.activeRequests < 1 ||
+        !record.pendingAttempts.includes(attempt)
+      ) {
+        return;
+      }
+      await db
+        .update(clientAgentSessions)
+        .set({
+          activeRequests: record.activeRequests - 1,
+          pendingAttempts: record.pendingAttempts.filter(
+            (pending) => pending !== attempt,
+          ),
+        })
+        .where(eq(clientAgentSessions.sessionId, sessionId));
+    });
+  }
+
+  async transition(
+    sessionId: string,
+    expected: "active",
+    status: ClientSessionStatus,
+    patch: Pick<ClientSessionRecord, "terminalDigest" | "finalResult"> = {},
+  ) {
+    return this.lock(sessionId, async (db) => {
+      const record = await findRecord(db, sessionId);
+      if (
+        !record ||
+        record.status !== expected ||
+        (status === "completed" && record.activeRequests > 0)
+      ) {
+        return undefined;
+      }
+      const [updated] = await db
+        .update(clientAgentSessions)
+        .set({
+          status,
+          activeRequests: 0,
+          pendingAttempts: [],
+          terminalDigest: patch.terminalDigest,
+          finalResultJson: patch.finalResult as
+            | Record<string, unknown>
+            | undefined,
+        })
+        .where(eq(clientAgentSessions.sessionId, sessionId))
+        .returning();
+      return updated ? mapRecord(updated, record.receipts) : undefined;
+    });
+  }
+
+  revokeActor(actorId: string) {
+    return this.revokeBy(eq(clientAgentSessions.actorId, actorId));
+  }
+
+  revokeBinding(bindingDigest: `sha256:${string}`, actorId: string) {
+    return this.revokeBy(
+      and(
+        eq(clientAgentSessions.actorId, actorId),
+        eq(clientAgentSessions.clientBindingDigest, bindingDigest),
+      )!,
+    );
+  }
+
+  revokeHostSession(hostSessionDigest: `sha256:${string}`, actorId: string) {
+    return this.revokeBy(
+      and(
+        eq(clientAgentSessions.actorId, actorId),
+        eq(clientAgentSessions.hostSessionDigest, hostSessionDigest),
+      )!,
+    );
+  }
+
+  private async revokeBy(
+    predicate: ReturnType<typeof eq>,
+  ): Promise<ClientSessionRecord[]> {
+    const updated = await this.db
+      .update(clientAgentSessions)
+      .set({ status: "revoked", activeRequests: 0, pendingAttempts: [] })
+      .where(and(eq(clientAgentSessions.status, "active"), predicate))
+      .returning();
+    return Promise.all(updated.map((row) => hydrateRecord(this.db, row)));
+  }
+
+  private lock<T>(
+    sessionId: string,
+    callback: (db: NodePgDatabase) => Promise<T>,
+  ): Promise<T> {
+    return this.db.transaction(async (transaction) => {
+      await transaction.execute(
+        sql`select session_id from client_agent_sessions where session_id = ${sessionId} for update`,
+      );
+      return callback(transaction as unknown as NodePgDatabase);
+    });
+  }
+}

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

@@ -0,0 +1,28 @@
+export class ClientAgentSessionError extends Error {
+  constructor(
+    readonly code:
+      | "INVALID_INPUT"
+      | "FORBIDDEN"
+      | "NOT_FOUND"
+      | "CONFLICT"
+      | "LIMIT_EXCEEDED"
+      | "PROVIDER_FAILED",
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+    this.name = "ClientAgentSessionError";
+  }
+}
+
+export function clientSessionInvalid(message: string) {
+  return new ClientAgentSessionError("INVALID_INPUT", message, 400);
+}
+
+export function clientSessionConflict(message: string) {
+  return new ClientAgentSessionError("CONFLICT", message, 409);
+}
+
+export function clientSessionHidden() {
+  return new ClientAgentSessionError("NOT_FOUND", "会话不存在或不可访问", 404);
+}

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

@@ -0,0 +1,99 @@
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import type {
+  ClientSessionAdmissionPort,
+  ClientSessionFinalResult,
+  ClientSessionRecord,
+} from "./contracts.js";
+import { clientSessionTerminalDigest } from "./digest.js";
+import {
+  clientSessionConflict as conflict,
+  clientSessionInvalid as invalid,
+} from "./errors.js";
+import { sessionView } from "./presentation.js";
+import type { ClientSessionRepository } from "./repository.js";
+
+export async function finalizeClientSession(input: {
+  record: ClientSessionRecord;
+  repository: ClientSessionRepository;
+  admission: ClientSessionAdmissionPort;
+  receiptIds: readonly string[];
+  clientResult?: ModuleAiJsonValue;
+  canonicalizeResult?: (
+    proposedResult: ModuleAiJsonValue,
+  ) => Promise<ModuleAiJsonValue>;
+  audit(
+    record: ClientSessionRecord,
+    metadata: Readonly<Record<string, string | number | boolean>>,
+  ): Promise<void> | void;
+}) {
+  const terminalDigest = clientSessionTerminalDigest(
+    input.receiptIds,
+    input.clientResult,
+  );
+  if (input.record.status === "completed") {
+    if (input.record.terminalDigest === terminalDigest) {
+      return sessionView(input.record);
+    }
+    throw conflict("会话已完成，终态不可改写");
+  }
+  if (input.record.status !== "active" || input.record.activeRequests) {
+    throw conflict("会话当前不能 finalize");
+  }
+  const receipts = [...input.record.receipts].sort(
+    (left, right) => left.attempt - right.attempt,
+  );
+  if (
+    !receipts.length ||
+    input.receiptIds.length !== receipts.length ||
+    receipts.some(
+      (receipt, index) => receipt.receiptId !== input.receiptIds[index],
+    )
+  ) {
+    throw invalid("Finalize 必须提交本 Run 的完整终末 receipt 链");
+  }
+  const terminal = receipts.at(-1)!;
+  const projected = terminal.canonicalResult;
+  const proposedResult = projected ?? input.clientResult;
+  if (proposedResult === undefined) throw invalid("Finalize 缺少可公开结果");
+  await input.admission.validateResult(
+    input.record.operationKey,
+    proposedResult,
+  );
+  const result = input.canonicalizeResult
+    ? await input.canonicalizeResult(proposedResult)
+    : proposedResult;
+  await input.admission.validateResult(input.record.operationKey, result);
+  const finalResult: ClientSessionFinalResult = {
+    clientRunId: input.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 input.repository.transition(
+    input.record.sessionId,
+    "active",
+    "completed",
+    { terminalDigest, finalResult },
+  );
+  if (!completed) {
+    const concurrent = await input.repository.find(input.record.sessionId);
+    if (
+      concurrent?.status === "completed" &&
+      concurrent.terminalDigest === terminalDigest
+    ) {
+      return sessionView(concurrent);
+    }
+    throw conflict("Finalize 与其它终态操作冲突");
+  }
+  await input.audit(completed, {
+    terminalReceiptId: terminal.receiptId,
+    clientProjected: projected === undefined,
+  });
+  return sessionView(completed);
+}