create-windy 0.6.12 → 0.6.14

package/template/apps/server/src/agent-workflow/wait-signal-service.ts

@@ -0,0 +1,147 @@
+import { createHash } from "node:crypto";
+import type { JsonValue } from "@southwind-ai/shared";
+import { isAgentWorkflowTerminal } from "@southwind-ai/shared";
+import { canonicalJson } from "./canonical-json.js";
+import { assertCanonicalWorkflowSafeValue } from "./event-validation.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+import { nodeEventData, workflowEvent, workflowId } from "./service-support.js";
+import { transitionAgentWorkflowNodeRun } from "./state-machine.js";
+
+export class AgentWorkflowWaitSignalService {
+  constructor(private readonly repository: AgentWorkflowRepository) {}
+
+  async signal(input: {
+    readonly runId: string;
+    readonly nodeRunId: string;
+    readonly signalKey: string;
+    readonly idempotencyKey: string;
+    readonly value: JsonValue;
+    readonly at: string;
+  }) {
+    assertCanonicalWorkflowSafeValue(input.value, "waitSignal", 16 * 1024);
+    const payloadDigest = digest(input.value);
+    const signalEvent = workflowEvent({
+      runId: input.runId,
+      idempotencyKey: `wait-signal:${input.nodeRunId}:${input.idempotencyKey}`,
+      at: input.at,
+      data: {
+        type: "workflow.wait-signalled",
+        nodeRunId: input.nodeRunId,
+        signalKey: input.signalKey,
+        payloadDigest,
+        receiptId: receiptId(input),
+      },
+    });
+    const replay = await this.repository.findEvent(signalEvent.eventId);
+    if (replay) {
+      if (
+        replay.workflowRunId !== input.runId ||
+        replay.data.type !== "workflow.wait-signalled" ||
+        replay.data.nodeRunId !== input.nodeRunId ||
+        replay.data.signalKey !== input.signalKey ||
+        replay.data.payloadDigest !== payloadDigest
+      ) {
+        throw new AgentWorkflowWaitSignalError("WAIT_SIGNAL_CONFLICT", 409);
+      }
+      return { replayed: true };
+    }
+    const snapshot = await this.repository.getSnapshot(input.runId);
+    if (!snapshot) throw new AgentWorkflowWaitSignalError("RUN_NOT_FOUND", 404);
+    const release = await this.repository.getRelease(snapshot.run.releaseId);
+    const nodeRun = snapshot.nodeRuns.find(
+      ({ nodeRunId }) => nodeRunId === input.nodeRunId,
+    );
+    const node = release?.definition.nodes.find(
+      ({ id }) => id === nodeRun?.nodeId,
+    );
+    if (!release || !nodeRun || !node || node.type !== "wait") {
+      throw new AgentWorkflowWaitSignalError("WAIT_NODE_NOT_FOUND", 404);
+    }
+    if (
+      isAgentWorkflowTerminal(snapshot.run.status) ||
+      snapshot.run.cancellationRequestedAt ||
+      nodeRun.status !== "waiting" ||
+      node.signalKey !== input.signalKey ||
+      Date.parse(input.at) >=
+        nodeDeadline(
+          snapshot.run.deadlineAt,
+          nodeRun.startedAt,
+          node.timeoutSeconds,
+        )
+    ) {
+      throw new AgentWorkflowWaitSignalError("WAIT_SIGNAL_REJECTED", 409);
+    }
+    const receipt = {
+      receiptId: receiptId(input),
+      nodeRunId: nodeRun.nodeRunId,
+      resultDigest: payloadDigest,
+      ...(node.outputSchemaKey
+        ? { outputSchemaKey: node.outputSchemaKey }
+        : {}),
+      smallResult: structuredClone(input.value),
+      artifactIds: nodeRun.inputArtifacts.map(({ artifactId }) => artifactId),
+      recordedAt: input.at,
+    };
+    const completed = transitionAgentWorkflowNodeRun({
+      nodeRun,
+      expectedVersion: nodeRun.version,
+      command: {
+        type: "complete",
+        receipt,
+        outputArtifacts: nodeRun.inputArtifacts,
+      },
+      at: input.at,
+    });
+    return this.repository.commit({
+      runId: input.runId,
+      expectedSequence: snapshot.headSequence,
+      nodeUpdates: [{ expectedVersion: nodeRun.version, value: completed }],
+      events: [
+        signalEvent,
+        workflowEvent({
+          runId: input.runId,
+          idempotencyKey: `wait-signal-complete:${input.nodeRunId}:${input.idempotencyKey}`,
+          at: input.at,
+          causationEventId: signalEvent.eventId,
+          data: nodeEventData(nodeRun, {
+            type: "complete",
+            receipt,
+            outputArtifacts: nodeRun.inputArtifacts,
+          }),
+        }),
+      ],
+    });
+  }
+}
+
+function nodeDeadline(
+  runDeadline: string,
+  startedAt: string | undefined,
+  timeoutSeconds: number | undefined,
+) {
+  const runTime = Date.parse(runDeadline);
+  if (!startedAt || !timeoutSeconds) return runTime;
+  return Math.min(runTime, Date.parse(startedAt) + timeoutSeconds * 1_000);
+}
+
+function receiptId(input: { nodeRunId: string; idempotencyKey: string }) {
+  return workflowId(
+    "workflow_wait_receipt",
+    input.nodeRunId,
+    input.idempotencyKey,
+  );
+}
+
+function digest(value: JsonValue) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}
+
+export class AgentWorkflowWaitSignalError extends Error {
+  constructor(
+    readonly code: string,
+    readonly status: 404 | 409,
+  ) {
+    super(code);
+    this.name = "AgentWorkflowWaitSignalError";
+  }
+}

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

@@ -0,0 +1,109 @@
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  randomBytes,
+} from "node:crypto";
+
+interface WorkflowArtifactTokenClaims {
+  readonly version: 1;
+  readonly artifactId: string;
+  readonly actorId: string;
+  readonly scopeDigest: string;
+  readonly expiresAt: string;
+}
+
+const aad = Buffer.from("southwind-agent-workflow-artifact-v1");
+
+export class AgentWorkflowArtifactTokenCodec {
+  readonly #key: Buffer;
+
+  constructor(secret: string) {
+    if (new TextEncoder().encode(secret).byteLength < 32) {
+      throw new Error("Agent Workflow Artifact Secret 至少需要 32 字节");
+    }
+    this.#key = createHash("sha256")
+      .update("agent-workflow-artifact\u0000")
+      .update(secret)
+      .digest();
+  }
+
+  issue(input: Omit<WorkflowArtifactTokenClaims, "version">) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", this.#key, iv);
+    cipher.setAAD(aad);
+    const encrypted = Buffer.concat([
+      cipher.update(JSON.stringify({ version: 1, ...input }), "utf8"),
+      cipher.final(),
+    ]);
+    return [
+      "wfa1",
+      iv.toString("base64url"),
+      encrypted.toString("base64url"),
+      cipher.getAuthTag().toString("base64url"),
+    ].join(".");
+  }
+
+  verify(token: string): WorkflowArtifactTokenClaims {
+    try {
+      if (token.length > 2_048) throw new Error("token too large");
+      const [version, iv, encrypted, tag, extra] = token.split(".");
+      if (version !== "wfa1" || !iv || !encrypted || !tag || extra) {
+        throw new Error("token shape");
+      }
+      const decipher = createDecipheriv(
+        "aes-256-gcm",
+        this.#key,
+        canonicalBase64url(iv, 12),
+      );
+      decipher.setAAD(aad);
+      decipher.setAuthTag(canonicalBase64url(tag, 16));
+      const value = JSON.parse(
+        Buffer.concat([
+          decipher.update(canonicalBase64url(encrypted)),
+          decipher.final(),
+        ]).toString("utf8"),
+      );
+      return claims(value);
+    } catch {
+      throw new AgentWorkflowArtifactTokenError();
+    }
+  }
+}
+
+export class AgentWorkflowArtifactTokenError extends Error {
+  constructor() {
+    super("Agent Workflow Artifact Token 无效");
+    this.name = "AgentWorkflowArtifactTokenError";
+  }
+}
+
+function claims(value: unknown): WorkflowArtifactTokenClaims {
+  if (!record(value) || value.version !== 1) throw new Error("claims");
+  const result = value as unknown as WorkflowArtifactTokenClaims;
+  if (
+    !result.artifactId.trim() ||
+    !result.actorId.trim() ||
+    !/^sha256:[a-f0-9]{64}$/.test(result.scopeDigest) ||
+    !Number.isFinite(Date.parse(result.expiresAt))
+  ) {
+    throw new Error("claims");
+  }
+  return result;
+}
+
+function canonicalBase64url(value: string, bytes?: number) {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("base64url");
+  const decoded = Buffer.from(value, "base64url");
+  if (
+    decoded.toString("base64url") !== value ||
+    (bytes !== undefined && decoded.byteLength !== bytes)
+  ) {
+    throw new Error("canonical");
+  }
+  return decoded;
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/template/apps/server/src/agent-workflow/workflow-value-validation.ts

@@ -0,0 +1,101 @@
+const FORBIDDEN_KEYS = new Set([
+  "reasoning",
+  "rawreasoning",
+  "chainofthought",
+  "cot",
+  "privatereasoning",
+  "deliberation",
+  "analysis",
+  "thoughts",
+  "prompt",
+  "systemprompt",
+  "userprompt",
+  "messages",
+  "arguments",
+  "toolarguments",
+  "rawtoolarguments",
+  "rawtoolargs",
+  "rawoutput",
+  "input",
+  "toolinput",
+  "payload",
+  "body",
+  "executiongrant",
+  "authorizationproofid",
+  "fencetoken",
+  "bearerref",
+  "bearertoken",
+  "token",
+  "accesstoken",
+  "refreshtoken",
+  "securitytoken",
+  "signedurl",
+  "downloadurl",
+  "authorizationstatus",
+  "expiresat",
+  "secret",
+  "secretkey",
+  "apikey",
+  "password",
+  "credential",
+  "privatekey",
+]);
+
+const SENSITIVE_VALUE =
+  /(?:\bbearer\s+[a-z0-9._~+/=-]+|\b(?:grant_|car_|bax_|oa1\.|sk-[a-z0-9_-]{12,})|\beyJ[a-z0-9_-]+\.[a-z0-9_-]+\.[a-z0-9_-]+|https?:\/\/[^\s]+[?&](?:x-amz-signature|x-amz-credential|x-goog-signature|x-cos-security-token|signature|access_token|token|sig)=)/i;
+
+export function assertCanonicalWorkflowSafeValue(
+  value: unknown,
+  path: string,
+  maximumBytes: number,
+) {
+  const encoded = JSON.stringify(value);
+  if (
+    encoded === undefined ||
+    new TextEncoder().encode(encoded).byteLength > maximumBytes
+  ) {
+    throw invalid(`${path} 不可序列化或超过大小上限`);
+  }
+  assertSafeValue(value, path, new Set());
+}
+
+function assertSafeValue(value: unknown, path: string, seen: Set<object>) {
+  if (["undefined", "bigint", "function", "symbol"].includes(typeof value)) {
+    throw invalid(`${path} 含不可序列化值`);
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw invalid(`${path} 含非有限数值`);
+  }
+  if (typeof value === "string") {
+    if (SENSITIVE_VALUE.test(value)) throw invalid(`${path} 含敏感引用或凭据`);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  if (seen.has(value)) throw invalid(`${path} 含循环对象`);
+  if (
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) !== Object.prototype
+  ) {
+    throw invalid(`${path} 必须是普通 JSON 对象`);
+  }
+  seen.add(value);
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    const normalized = key.replace(/[-_.]/g, "").toLowerCase();
+    if (FORBIDDEN_KEYS.has(normalized))
+      throw invalid(`${path}.${key} 禁止持久化`);
+    assertSafeValue(child, `${path}.${key}`, seen);
+  }
+  seen.delete(value);
+}
+
+export class WorkflowEventValidationError extends Error {
+  readonly code = "INVALID_WORKFLOW_EVENT";
+  constructor(message: string) {
+    super(message);
+    this.name = "WorkflowEventValidationError";
+  }
+}
+
+function invalid(message: string) {
+  return new WorkflowEventValidationError(message);
+}

package/template/apps/server/src/agent-workflow/workspace-policy.ts

@@ -0,0 +1,109 @@
+import type { RequestGuardContext } from "../guards.js";
+
+export interface AgentWorkflowWorkspacePolicyDecision {
+  readonly allowed: boolean;
+  readonly policyDigest: string;
+  readonly workspaceId?: string;
+  readonly parentScopeDigest: string;
+  readonly narrowedScopeDigest: string;
+  readonly scopeRelation: "same" | "subset";
+  readonly safeCode?: string;
+}
+
+export interface AgentWorkflowWorkspacePolicyPort {
+  authorize(input: {
+    readonly workspacePolicyKey: string;
+    readonly scopePolicyKey: string;
+    readonly parentScopeDigest: string;
+    /** Internal, deterministic coordinate proposed for a concrete Delegation. */
+    readonly workspaceGrantId?: string;
+    readonly context: RequestGuardContext;
+  }): Promise<AgentWorkflowWorkspacePolicyDecision>;
+}
+
+export interface AgentWorkflowWorkspacePolicyDefinition {
+  readonly key: string;
+  authorize(input: {
+    readonly scopePolicyKey: string;
+    readonly parentScopeDigest: string;
+    /** Stable request coordinate; the authoritative policy returns its own Workspace ID. */
+    readonly workspaceGrantId?: string;
+    readonly context: RequestGuardContext;
+  }): Promise<Omit<AgentWorkflowWorkspacePolicyDecision, "policyDigest">>;
+  readonly policyDigest: string;
+}
+
+export class AgentWorkflowWorkspacePolicyRegistry implements AgentWorkflowWorkspacePolicyPort {
+  readonly #policies: ReadonlyMap<
+    string,
+    AgentWorkflowWorkspacePolicyDefinition
+  >;
+
+  constructor(definitions: readonly AgentWorkflowWorkspacePolicyDefinition[]) {
+    this.#policies = new Map(definitions.map((item) => [item.key, item]));
+    if (this.#policies.size !== definitions.length) {
+      throw new Error("Agent Workflow Workspace Policy Key 重复");
+    }
+  }
+
+  async authorize(
+    input: Parameters<AgentWorkflowWorkspacePolicyPort["authorize"]>[0],
+  ) {
+    const policy = this.#policies.get(input.workspacePolicyKey);
+    if (!policy)
+      return denied(input.parentScopeDigest, "WORKSPACE_POLICY_UNKNOWN");
+    const decision = await policy.authorize(input);
+    if (
+      !decision.allowed ||
+      decision.parentScopeDigest !== input.parentScopeDigest ||
+      !["same", "subset"].includes(decision.scopeRelation) ||
+      !digest(decision.narrowedScopeDigest) ||
+      !digest(policy.policyDigest) ||
+      (decision.workspaceId !== undefined &&
+        !validCoordinate(decision.workspaceId)) ||
+      (input.workspaceGrantId !== undefined &&
+        (!validCoordinate(input.workspaceGrantId) || !decision.workspaceId))
+    ) {
+      return denied(
+        input.parentScopeDigest,
+        decision.safeCode ?? "WORKSPACE_POLICY_DENIED",
+      );
+    }
+    if (
+      (decision.scopeRelation === "same" &&
+        decision.narrowedScopeDigest !== input.parentScopeDigest) ||
+      (decision.scopeRelation === "subset" && !decision.workspaceId)
+    ) {
+      return denied(
+        input.parentScopeDigest,
+        "WORKSPACE_SCOPE_EXPANSION_UNPROVEN",
+      );
+    }
+    return {
+      ...decision,
+      policyDigest: policy.policyDigest,
+    };
+  }
+}
+
+function denied(
+  parentScopeDigest: string,
+  safeCode: string,
+): AgentWorkflowWorkspacePolicyDecision {
+  return {
+    allowed: false,
+    policyDigest: "sha256:" + "0".repeat(64),
+    parentScopeDigest,
+    narrowedScopeDigest: parentScopeDigest,
+    scopeRelation: "same",
+    safeCode,
+  };
+}
+
+function digest(value: string) {
+  return /^sha256:[a-f0-9]{64}$/.test(value);
+}
+
+function validCoordinate(value: string) {
+  return value.trim() === value && value.length > 0 && value.length <= 160;
+}

package/template/apps/server/src/ai-runtime-report/remote-parser.ts

@@ -89,13 +89,54 @@ export function parseReportRunDetail(
     traceId: text(root.traceId),
     safeErrorCode: nullableText(root.safeErrorCode),
     attempts: array(root.attempts).map(parseAttempt),
+    trajectory: parseTrajectory(root.trajectory),
   };
 }
 
+function parseTrajectory(value: unknown) {
+  const trajectory = record(value);
+  if (typeof trajectory.available !== "boolean") invalid();
+  return {
+    available: trajectory.available,
+    events: array(trajectory.events).map((raw) => {
+      const event = record(raw);
+      const sequence = integer(event.sequence);
+      const sequenceEnd = integer(event.sequenceEnd);
+      if (sequence < 1 || sequenceEnd < sequence) invalid();
+      return {
+        sequence,
+        sequenceEnd,
+        type: text(event.type),
+        title: text(event.title),
+        ...optionalTextField(event, "toolKey"),
+        ...optionalTextField(event, "approvalOutcome"),
+        ...optionalTextField(event, "errorCode"),
+        ...optionalIntegerField(event, "attemptSequence"),
+        ...optionalIntegerField(event, "totalTokens"),
+        ...optionalIntegerField(event, "artifactCount"),
+        ...optionalIntegerField(event, "deltaCount"),
+        ...optionalIntegerField(event, "outputCharacters"),
+        ...(event.inputModalities === undefined
+          ? {}
+          : { inputModalities: array(event.inputModalities).map(text) }),
+      };
+    }),
+  };
+}
+
+function optionalTextField(value: Record<string, unknown>, key: string) {
+  return value[key] === undefined ? {} : { [key]: text(value[key]) };
+}
+
+function optionalIntegerField(value: Record<string, unknown>, key: string) {
+  return value[key] === undefined ? {} : { [key]: integer(value[key]) };
+}
+
 function parseReportRun(value: unknown): InternalAiRuntimeRunListItem {
   const item = record(value);
   return {
     runId: text(item.runId),
+    engineId: text(item.engineId),
     operationKey: text(item.operationKey),
     actorId: nullableText(item.actorId),
     departmentId: nullableText(item.departmentId),

package/template/apps/server/src/ai-runtime-report/service.test.ts

@@ -246,6 +246,7 @@ function context(permitted: boolean) {
 function runDetail(departmentId: string): InternalAiRuntimeRunDetail {
   return {
     runId: "run_1",
+    engineId: "windy.direct.openai-compatible.v1",
     operationKey: "business.answer",
     actorId: "user-a",
     departmentId,
@@ -268,5 +269,6 @@ function runDetail(departmentId: string): InternalAiRuntimeRunDetail {
     traceId: "trace_1",
     safeErrorCode: null,
     attempts: [],
+    trajectory: { available: true, events: [] },
   };
 }

package/template/apps/server/src/app/agent-runtime-composition.ts

@@ -0,0 +1,38 @@
+import { registerAgentPlatformRuntime } from "../agent/runtime-bootstrap.js";
+import type { AgentPlatformRuntimeInput } from "../agent/runtime-bootstrap-input.js";
+import type { AgentAuthorizationInvalidationTarget } from "../system/authorization-invalidation-bridge.js";
+import {
+  projectAiScreenshotIntakeFactoryV1,
+  projectAiScreenshotPageRegistryV2,
+} from "./ai-screenshot-intake-binding.js";
+import { projectClientAgentHostAuthAdapter } from "./client-agent-host-auth-binding.js";
+
+export function composeApplicationAgentRuntime(
+  input: Omit<
+    AgentPlatformRuntimeInput,
+    "clientAgentHostAuth" | "screenshotPageRegistry"
+  > & {
+    readonly bindAuthorizationInvalidation: (
+      target: AgentAuthorizationInvalidationTarget | undefined,
+    ) => void;
+    readonly bindClientAgentSessions: (
+      service: { revokeActor(actorId: string): Promise<number> } | undefined,
+    ) => void;
+  },
+) {
+  const runtime = registerAgentPlatformRuntime({
+    ...input,
+    clientAgentHostAuth: projectClientAgentHostAuthAdapter,
+    screenshotPageRegistry: input.platformConfig.enableAI
+      ? projectAiScreenshotPageRegistryV2
+      : undefined,
+  });
+  input.bindAuthorizationInvalidation(runtime.invalidateAuthorization);
+  input.bindClientAgentSessions(runtime.clientAgentSessions);
+  return {
+    ...runtime,
+    screenshots: input.platformConfig.enableAI
+      ? projectAiScreenshotIntakeFactoryV1
+      : undefined,
+  };
+}

package/template/apps/server/src/app/client-agent-host-auth-binding.ts

@@ -0,0 +1,10 @@
+import type { ModuleClientAgentHostAuthAdapter } from "@southwind-ai/server-sdk";
+
+/**
+ * Project-owned Browser Assistant seam. The base platform intentionally keeps
+ * this undefined, so pageAgentClientRun is unavailable until a paired bax_
+ * installation adapter is assembled by the host product.
+ */
+export const projectClientAgentHostAuthAdapter:
+  | ModuleClientAgentHostAuthAdapter
+  | undefined = undefined;

package/template/apps/server/src/auth/actor-resolver.test.ts

@@ -60,6 +60,39 @@ describe("actor resolver", () => {
     expect(hashSessionToken("session_token_1")).toHaveLength(64);
   });
 
+  test("bax_ 与 car_ token 即使出现在会话库也不能认证普通业务 API", async () => {
+    const repository = new InMemoryAuthRepository([
+      {
+        id: "user_1",
+        username: "tester",
+        displayName: "测试员",
+        status: "active",
+        credentialState: "active",
+        roleCodes: [],
+        permissionKeys: ["system.user.read"],
+      },
+    ]);
+    for (const token of ["bax_installation", "car_single-run"]) {
+      await repository.createSession({
+        id: token,
+        userId: "user_1",
+        tokenHash: hashSessionToken(token),
+        status: "active",
+        issuedAt: new Date("2026-08-26T08:00:00.000Z"),
+        expiresAt: new Date("2026-08-26T10:00:00.000Z"),
+      });
+    }
+    const resolver = new RepositoryActorResolver(repository, {
+      now: () => new Date("2026-08-26T09:00:00.000Z"),
+    });
+    await expect(
+      resolver.resolve(bearerRequest("bax_installation")),
+    ).resolves.toBeUndefined();
+    await expect(
+      resolver.resolve(bearerRequest("car_single-run")),
+    ).resolves.toBeUndefined();
+  });
+
   test("过期会话和已吊销会话均被拒绝", async () => {
     const now = new Date("2026-07-10T08:00:00.000Z");
     const repository = new InMemoryAuthRepository([

package/template/apps/server/src/auth/actor-resolver.ts

@@ -96,7 +96,12 @@ export function readRequestSessionToken(
   request: Request,
   cookieName: string,
 ): string | undefined {
-  return readBearerToken(request) || readCookie(request, cookieName);
+  const bearer = readBearerToken(request);
+  return (
+    (bearer?.startsWith("car_") || bearer?.startsWith("bax_")
+      ? undefined
+      : bearer) || readCookie(request, cookieName)
+  );
 }
 
 function readCookie(request: Request, name: string): string | undefined {

package/template/apps/server/src/auth/composition.ts

@@ -0,0 +1,36 @@
+import type { PlatformConfig } from "@southwind-ai/config";
+import type { ServerPersistence } from "../persistence.js";
+import type { createServerRuntime } from "../runtime.js";
+import { createAuthRuntime } from "./runtime.js";
+
+export function createComposedAuthRuntime(input: {
+  platformConfig: PlatformConfig;
+  persistence?: ServerPersistence;
+  runtime: ReturnType<typeof createServerRuntime>;
+}) {
+  let revokeClientSessions: (actorId: string) => Promise<void> = async () =>
+    undefined;
+  const auth = createAuthRuntime({
+    repository: input.persistence?.authRepository,
+    sessionTtlSeconds: () => input.platformConfig.security.sessionTtlSeconds,
+    passwordPolicy: () => ({
+      minLength: input.platformConfig.security.passwordMinLength,
+      maxLength: input.platformConfig.security.passwordMaxLength,
+    }),
+    auditWriter: (event) => input.runtime.auditSink.recordCriticalEvent(event),
+    // @windy-module system.audit begin
+    auditReader: input.persistence?.auditReader,
+    // @windy-module system.audit end
+    onSessionsRevoked: (actorId) => revokeClientSessions(actorId),
+  });
+  return {
+    ...auth,
+    bindClientAgentSessions(
+      service: { revokeActor(actorId: string): Promise<number> } | undefined,
+    ) {
+      revokeClientSessions = async (actorId) => {
+        await service?.revokeActor(actorId);
+      };
+    },
+  };
+}