create-windy 0.6.14 → 0.6.15

package/template/apps/server/src/agent/session-projection-access.ts

@@ -14,15 +14,11 @@ import {
 
 export interface CurrentSourceAuthorizationPort {
   /** Resolve the current canonical authorization generation, never a client claim. */
-  current(
-    context: RequestGuardContext,
-  ): Promise<SourceAuthorizationCoordinate>;
+  current(context: RequestGuardContext): Promise<SourceAuthorizationCoordinate>;
 }
 
 /** Re-resolves the Actor from the canonical user/role repositories per read. */
-export class ResolvingCurrentSourceAuthorizationPort
-  implements CurrentSourceAuthorizationPort
-{
+export class ResolvingCurrentSourceAuthorizationPort implements CurrentSourceAuthorizationPort {
   constructor(
     private readonly resolveActor: (
       actorId: string,
@@ -34,7 +30,7 @@ export class ResolvingCurrentSourceAuthorizationPort
   ): Promise<SourceAuthorizationCoordinate> {
     const actor = await this.resolveActor(context.actor.id);
     if (!actor || actor.type === "anonymous") throw unavailable();
-    return authorizationCoordinateForActor(actor);
+    return authorizationReadCoordinateForActor(actor);
   }
 }
 
@@ -76,9 +72,9 @@ export class SessionProjectionSourceAuthorizer {
     } catch {
       throw unavailable();
     }
-    const expectedScope = `sha256:${captureAuthorizationScope(
-      context.actor.scopeContext,
-    ).hash}`;
+    const expectedScope = `sha256:${
+      captureAuthorizationScope(context.actor.scopeContext).hash
+    }`;
     if (
       authorization.actorId !== context.actor.id ||
       authorization.scopeDigest !== expectedScope ||
@@ -91,11 +87,17 @@ export class SessionProjectionSourceAuthorizer {
     for (const coordinate of coordinates) {
       if (!validCoordinate(coordinate)) throw unavailable();
       try {
-        await requireAuthoritativeSourceRead(this.sources, withSourceChainAudit({
-          source: causalSource(coordinate),
-          authorization,
-          requestId: context.requestId,
-        }, chainAudit));
+        await requireAuthoritativeSourceRead(
+          this.sources,
+          withSourceChainAudit(
+            {
+              source: causalSource(coordinate),
+              authorization,
+              requestId: context.requestId,
+            },
+            chainAudit,
+          ),
+        );
       } catch {
         throw unavailable();
       }
@@ -136,9 +138,8 @@ function unavailable(): SessionProjectionSourceUnavailableError {
 export function authorizationCoordinateForActor(
   actor: RequestActor,
 ): SourceAuthorizationCoordinate {
-  const scopeDigest = `sha256:${captureAuthorizationScope(
-    actor.scopeContext,
-  ).hash}`;
+  const scope = captureAuthorizationScope(actor.scopeContext);
+  const scopeDigest = `sha256:${scope.hash}`;
   const fingerprint = JSON.stringify({
     actorId: actor.id,
     actorType: actor.type,
@@ -146,10 +147,21 @@ export function authorizationCoordinateForActor(
     roles: [...actor.roleCodes].sort(),
     scopeDigest,
   });
-  const prefix = createHash("sha256").update(fingerprint).digest("hex").slice(0, 13);
+  const prefix = createHash("sha256")
+    .update(fingerprint)
+    .digest("hex")
+    .slice(0, 13);
   return {
     actorId: actor.id,
     scopeDigest,
     generation: Math.max(1, Number.parseInt(prefix, 16)),
   };
 }
+
+/** Read-only authority coordinate may carry the server-captured scope; invalidation envelopes stay small. */
+export function authorizationReadCoordinateForActor(actor: RequestActor) {
+  return {
+    ...authorizationCoordinateForActor(actor),
+    scopeSnapshot: captureAuthorizationScope(actor.scopeContext).snapshot,
+  } satisfies SourceAuthorizationCoordinate;
+}

package/template/apps/server/src/agent/unavailable-routes.ts

@@ -11,6 +11,12 @@ const clientSessionUnavailableRoutes = [
   ["POST", "/agent/client-sessions/:sessionId/cancel"],
 ] as const;
 
+const clientWorkflowArtifactUnavailableRoutes = [
+  ["POST", "/agent/client-workflow-artifacts/claim"],
+  ["POST", "/agent/client-workflow-artifacts/advance"],
+  ["POST", "/agent/client-workflow-artifacts/cancel"],
+] as const;
+
 const longSessionUnavailableRoutes = [
   ["GET", "/agent/harness/sessions"],
   ["GET", "/agent/harness/sessions/:sessionId"],
@@ -65,6 +71,21 @@ export function registerUnavailableAiRoutes(app: RouteApp): void {
     "AI Runtime 未启用",
   );
   registerUnavailableClientAgentSessionRoutes(app, "AI Runtime 未启用");
+  registerUnavailableClientAgentWorkflowArtifactRoutes(
+    app,
+    "AI Runtime 未启用",
+  );
+}
+
+export function registerUnavailableClientAgentWorkflowArtifactRoutes(
+  app: RouteApp,
+  message = "Client Agent Workflow Artifact 未装配",
+): void {
+  registerUnavailableRoutes(
+    app,
+    clientWorkflowArtifactUnavailableRoutes,
+    message,
+  );
 }
 
 export function registerUnavailableClientAgentSessionRoutes(

package/template/apps/server/src/agent/workflow-runtime-bootstrap.ts

@@ -43,6 +43,8 @@ export function registerProductionAgentWorkflowRuntime(
     modelPricingJson: input.platformConfig.agentWorkflow?.modelPricingJson,
     evaluationTools: resolveProductionEvaluationToolRegistration(tools),
     workspacePolicies: input.agentWorkflowWorkspacePolicies,
+    clientAgentWorkflowArtifactBindings:
+      input.clientAgentWorkflowArtifactBindings,
     ...dependencies,
     ...(dependencies
       ? {

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

@@ -1,9 +1,12 @@
 import { randomUUID } from "node:crypto";
 import type { AgentWorkflowArtifactRef } from "@southwind-ai/shared";
+import type { AuthorizationScopeSnapshot } from "@southwind-ai/shared";
 import type { RequestActor } from "../guards.js";
 import type { AuthoritativeSourceAccessPort } from "../agent/session-invalidation/contracts.js";
 import { requireAuthoritativeSourceRead } from "../agent/session-invalidation/read-guard.js";
-import { authorizationCoordinateForActor } from "../agent/session-projection-access.js";
+import { authorizationReadCoordinateForActor } from "../agent/session-projection-access.js";
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import { authorizationScopeContains } from "../data-access/scope-containment.js";
 
 type CausalArtifactSource = AgentWorkflowArtifactRef["source"] & {
   readonly sequence: number;
@@ -14,7 +17,7 @@ export interface AgentWorkflowArtifactSourceAuthorizationPort {
   requireCurrent(input: {
     readonly artifact: AgentWorkflowArtifactRef;
     readonly actorId: string;
-    readonly scopeDigest: string;
+    readonly frozenScope: AuthorizationScopeSnapshot;
   }): Promise<void>;
 }
 
@@ -30,20 +33,23 @@ export class ProductionAgentWorkflowArtifactSourceAuthorization implements Agent
   async requireCurrent(input: {
     readonly artifact: AgentWorkflowArtifactRef;
     readonly actorId: string;
-    readonly scopeDigest: string;
+    readonly frozenScope: AuthorizationScopeSnapshot;
   }) {
     try {
       const source = causalSource(input.artifact);
       assertSource(source);
       const actor = await this.resolveActor(input.actorId);
       if (!actor || actor.type === "anonymous") throw denied();
-      const authorization = authorizationCoordinateForActor(actor);
+      const currentScope = captureAuthorizationScope(actor.scopeContext);
       if (
-        authorization.actorId !== input.actorId ||
-        authorization.scopeDigest !== input.scopeDigest
+        !authorizationScopeContains(currentScope.snapshot, input.frozenScope)
       ) {
         throw denied();
       }
+      const authorization = authorizationReadCoordinateForActor(actor);
+      if (authorization.actorId !== input.actorId) {
+        throw denied();
+      }
       await requireAuthoritativeSourceRead(this.sources, {
         source: {
           moduleKey: source.moduleKey,

package/template/apps/server/src/agent-workflow/command-facade.ts

@@ -38,11 +38,11 @@ import {
   workflowRequestText,
 } from "./command-input.js";
 import { governedDefinitionToolSchemaVersion } from "./governed-tool-schema.js";
+import { buildAgentWorkflowRelease } from "./release.js";
+import type { ProjectAgentWorkflowLaunchAuthority } from "./project-launch-authority.js";
 
 export { AgentWorkflowCommandError } from "./command-error.js";
 
-type ServerRuntime = ReturnType<typeof createServerRuntime>;
-
 export class ProductionAgentWorkflowCommandFacade {
   constructor(
     private readonly repository: AgentWorkflowRepository,
@@ -51,20 +51,37 @@ export class ProductionAgentWorkflowCommandFacade {
     private readonly evaluations: AgentWorkflowEvaluationService,
     private readonly evaluationRepository: AgentWorkflowEvaluationRepository,
     private readonly modules: readonly ModuleManifest[],
-    private readonly runtime: ServerRuntime,
+    private readonly runtime: ReturnType<typeof createServerRuntime>,
     private readonly tools: GovernedToolRegistry,
     private readonly waitSignals: AgentWorkflowWaitSignalService,
     private readonly artifacts: AgentWorkflowArtifactPort,
     private readonly workspacePolicies: AgentWorkflowWorkspacePolicyPort,
+    private readonly projectAuthority: ProjectAgentWorkflowLaunchAuthority,
     private readonly schedulerFor: (
       context: RequestGuardContext,
     ) => AgentWorkflowSchedulerCommandPort,
   ) {}
 
-  publish(body: unknown, context: RequestGuardContext) {
+  async publish(body: unknown, context: RequestGuardContext) {
+    return this.publishWithAuthority(body, context);
+  }
+
+  async publishProject(
+    body: unknown,
+    context: RequestGuardContext,
+    signal: AbortSignal,
+  ) {
+    return this.publishWithAuthority(body, context, signal);
+  }
+
+  private async publishWithAuthority(
+    body: unknown,
+    context: RequestGuardContext,
+    signal?: AbortSignal,
+  ) {
     const value = workflowRequestObject(body);
     const coordinates = workflowRequestObject(value.coordinates);
-    return this.service.publish({
+    const publishInput = {
       definition: value.definition as AgentWorkflowDefinition,
       coordinates: {
         runtimeVersion: workflowRequestText(
@@ -87,23 +104,66 @@ export class ProductionAgentWorkflowCommandFacade {
       } satisfies AgentWorkflowReleaseCoordinates,
       publishedBy: workflowActor(context),
       publishedAt: new Date().toISOString(),
-    });
+    };
+    const release = buildAgentWorkflowRelease(publishInput);
+    if (signal) {
+      await this.projectAuthority.authorizeRelease({
+        definition: release.definition,
+        coordinates: release.coordinates,
+        releaseDigest: release.releaseDigest,
+        actorId: context.actor.id,
+        signal,
+      });
+    } else {
+      this.projectAuthority.requireDirect(release.definition.workflowKey);
+    }
+    return this.service.publish(publishInput);
   }
 
   async createRun(
     body: unknown,
     context: RequestGuardContext,
     signal: AbortSignal,
+  ) {
+    return this.createRunWithAuthority(body, context, signal, false);
+  }
+
+  async createProjectRun(
+    body: unknown,
+    context: RequestGuardContext,
+    signal: AbortSignal,
+  ) {
+    return this.createRunWithAuthority(body, context, signal, true);
+  }
+
+  private async createRunWithAuthority(
+    body: unknown,
+    context: RequestGuardContext,
+    signal: AbortSignal,
+    project: boolean,
   ) {
     const value = workflowRequestObject(body);
     const releaseId = workflowRequestText(value.releaseId, "releaseId");
     const release = await this.repository.getRelease(releaseId);
     if (!release) throw new AgentWorkflowCommandError("RELEASE_NOT_FOUND", 404);
-    const authorization = await this.authorization(context, release);
+    const inputValue = (value.input ?? {}) as JsonValue;
+    const inputArtifacts = workflowArtifactRefs(value.inputArtifacts);
+    const authorizedContext = project
+      ? await this.projectAuthority.authorizeRun({
+          release,
+          workflowInput: inputValue,
+          inputArtifacts,
+          context,
+          signal,
+        })
+      : context;
+    if (!project) {
+      this.projectAuthority.requireDirect(release.definition.workflowKey);
+    }
+    const authorization = await this.authorization(authorizedContext, release);
     const now = new Date();
     const budget = optionalWorkflowBudget(value.budget);
     const effectiveBudget = budget ?? release.definition.budget;
-    const inputValue = (value.input ?? {}) as JsonValue;
     const entry = release.definition.nodes.find(
       ({ id }) => id === release.definition.entryNodeId,
     )!;
@@ -113,7 +173,6 @@ export class ProductionAgentWorkflowCommandFacade {
       at: now.toISOString(),
     });
     const inputDigest = inputReceipt.valueDigest;
-    const inputArtifacts = workflowArtifactRefs(value.inputArtifacts);
     if (
       inputArtifacts.length &&
       !(await this.artifacts.reauthorize({
@@ -150,12 +209,12 @@ export class ProductionAgentWorkflowCommandFacade {
     });
     await driveWorkflowBatch({
       repository: this.repository,
-      scheduler: this.schedulerFor(context),
+      scheduler: this.schedulerFor(authorizedContext),
       runId: result.record.run.runId,
       authorizationFence: authorization.fence,
       signal,
     });
-    return this.query.detail(result.record.run.runId, context);
+    return this.query.detail(result.record.run.runId, authorizedContext);
   }
 
   async cancel(

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

@@ -155,15 +155,6 @@ export class DrizzleAgentWorkflowArtifactPort implements AgentWorkflowArtifactPo
   ) {
     const durable = await this.durableById(artifact.artifactId);
     if (!durable || !sameWorkflowArtifact(durable, artifact)) return undefined;
-    try {
-      await this.sourceAuthorization.requireCurrent({
-        artifact,
-        actorId,
-        scopeDigest,
-      });
-    } catch {
-      return undefined;
-    }
     const [job] = await this.db
       .select({ authorizationScope: durableJobs.authorizationScope })
       .from(durableJobs)
@@ -175,6 +166,15 @@ export class DrizzleAgentWorkflowArtifactPort implements AgentWorkflowArtifactPo
     ) {
       return undefined;
     }
+    try {
+      await this.sourceAuthorization.requireCurrent({
+        artifact,
+        actorId,
+        frozenScope: job.authorizationScope,
+      });
+    } catch {
+      return undefined;
+    }
     const inspected = await this.durableArtifacts
       .inspect(durable.jobId, durable.kind, actorId)
       .catch(() => undefined);

package/template/apps/server/src/agent-workflow/drizzle-delegation-completion.ts

@@ -46,7 +46,7 @@ export async function completeDelegation(input: {
     await input.artifactSources!.requireCurrent({
       artifact,
       actorId: parent.actorId,
-      scopeDigest: input.row.grantJson.capabilityCeiling.scopeDigest,
+      frozenScope: input.row.grantJson.capabilityCeiling.scopeSnapshot,
     });
   }
   await bindDelegationChild({

package/template/apps/server/src/agent-workflow/platform-node-adapters.ts

@@ -18,6 +18,7 @@ import type {
   AgentWorkflowNodeAdapterContext,
 } from "./adapter-dispatch.js";
 import type { WorkflowEffectCommandFence } from "./effect-command-fence.js";
+import { CLIENT_AGENT_WORKFLOW_ARTIFACT_TASK_KEY } from "@southwind-ai/server-sdk";
 import { createAgentWorkflowNodeAdapterRegistry } from "./node-adapter-factory.js";
 import {
   directPlatformNodeAdapter,
@@ -93,7 +94,11 @@ function jobAdapter(
   const scope = captureAuthorizationScope(context.actor.scopeContext);
   const submit = async (
     nodeContext: AgentWorkflowNodeAdapterContext,
-    commandId: string,
+    command: {
+      readonly commandId: string;
+      readonly generation: number;
+      readonly requestDigest: string;
+    },
     idempotencyKey: string,
   ) => {
     const node = nodeContext.node;
@@ -103,13 +108,16 @@ function jobAdapter(
       queue: "agent-workflow",
       idempotencyKey,
       payload: {
-        commandId,
+        commandId: command.commandId,
         runId: nodeContext.run.runId,
         nodeRunId: nodeContext.nodeRun.nodeRunId,
+        effectGeneration: command.generation,
+        requestDigest: command.requestDigest,
       },
       requestedBy: context.actor.id,
       authorizationScope: scope.snapshot,
-      maxAttempts: 1,
+      maxAttempts:
+        node.taskKey === CLIENT_AGENT_WORKFLOW_ARTIFACT_TASK_KEY ? 3 : 1,
       timeoutSeconds: node.timeoutSeconds ?? 900,
     });
     if (
@@ -140,7 +148,7 @@ function jobAdapter(
     async dispatch({ context: nodeContext, command, fence }) {
       const submitted = await submit(
         nodeContext,
-        command.commandId,
+        { ...command, generation: fence.generation },
         command.idempotencyKey,
       );
       return jobResult(nodeContext, fence, await jobs.get(submitted.job.id));
@@ -153,7 +161,7 @@ function jobAdapter(
     }) {
       const submitted = await submit(
         nodeContext,
-        command.commandId,
+        command,
         command.idempotencyKey,
       );
       const snapshot = await jobs.get(submitted.job.id);
@@ -171,7 +179,7 @@ function jobAdapter(
       if (!command) return { cancelled: true };
       const submitted = await submit(
         nodeContext,
-        command.commandId,
+        command,
         command.idempotencyKey,
       );
       const snapshot = await jobs.get(submitted.job.id);

package/template/apps/server/src/agent-workflow/project-launch-authority.contract.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from "bun:test";
+import type { ModuleClientAgentWorkflowArtifactProjectBinding } from "@southwind-ai/server-sdk";
+import { ClientAgentWorkflowArtifactBindingRegistry } from "../agent/client-workflow-artifact/binding-registry.js";
+import { ProjectAgentWorkflowLaunchAuthority } from "./project-launch-authority.js";
+
+const binding = {
+  workflowKey: "analysis.full-case",
+  nodeId: "client-artifact",
+  operationKey: "analysis.page-agent",
+  releaseDigest: `sha256:${"d".repeat(64)}`,
+  scopeContainmentContractVersion: 1,
+  terminalResultAuthority: {
+    version: "sharp.result.v1",
+    digest: `sha256:${"e".repeat(64)}`,
+    async canonicalize({ proposedResult }) {
+      return proposedResult;
+    },
+  },
+  clientTaskAuthority: {
+    version: "sharp.task.v1",
+    digest: `sha256:${"f".repeat(64)}`,
+    async build({ workflowInput }) {
+      return { taskKey: "sharp.full-case", input: workflowInput };
+    },
+  },
+  launchAuthority: {
+    version: "sharp.launch.v1",
+    digest: `sha256:${"a".repeat(64)}`,
+    async authorizeRelease() {},
+    async authorizeRun({ currentAuthorizationScope }) {
+      return {
+        authorizationScope: currentAuthorizationScope,
+      };
+    },
+  },
+  artifact: {
+    kind: "analysis",
+    contentType: "application/json",
+    filename: "analysis.json",
+    retentionPolicyKey: "case-analysis",
+    maxByteSize: 65_536,
+  },
+} satisfies ModuleClientAgentWorkflowArtifactProjectBinding;
+
+test("generic command 对 project-protected Workflow 始终隐藏", () => {
+  const authority = new ProjectAgentWorkflowLaunchAuthority(
+    new ClientAgentWorkflowArtifactBindingRegistry([binding]),
+  );
+  expect(() => authority.requireDirect(binding.workflowKey)).toThrow(
+    "RELEASE_NOT_FOUND",
+  );
+  expect(() => authority.requireDirect("analysis.direct")).not.toThrow();
+});

package/template/apps/server/src/agent-workflow/project-launch-authority.ts

@@ -0,0 +1,92 @@
+import type {
+  AgentWorkflowArtifactRef,
+  AgentWorkflowDefinition,
+  AgentWorkflowRelease,
+  AgentWorkflowReleaseCoordinates,
+  JsonValue,
+} from "@southwind-ai/shared";
+import { authorizationScopeContains } from "../data-access/scope-containment.js";
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import { restoreServerScopeContext } from "../data-access/context.js";
+import type { RequestGuardContext } from "../guards.js";
+import { ClientAgentWorkflowArtifactBindingRegistry } from "../agent/client-workflow-artifact/binding-registry.js";
+import { AgentWorkflowCommandError } from "./command-error.js";
+
+export class ProjectAgentWorkflowLaunchAuthority {
+  constructor(
+    private readonly bindings: ClientAgentWorkflowArtifactBindingRegistry,
+  ) {}
+
+  requireDirect(workflowKey: string) {
+    if (this.bindings.findWorkflow(workflowKey)) throw hidden();
+  }
+
+  async authorizeRelease(input: {
+    definition: AgentWorkflowDefinition;
+    coordinates: AgentWorkflowReleaseCoordinates;
+    actorId: string;
+    releaseDigest: string;
+    signal: AbortSignal;
+  }) {
+    const binding = this.requireBinding(
+      input.definition.workflowKey,
+      input.releaseDigest,
+    );
+    try {
+      await binding.launchAuthority.authorizeRelease(input);
+    } catch {
+      throw hidden();
+    }
+  }
+
+  async authorizeRun(input: {
+    release: AgentWorkflowRelease;
+    workflowInput: JsonValue;
+    inputArtifacts: readonly AgentWorkflowArtifactRef[];
+    context: RequestGuardContext;
+    signal: AbortSignal;
+  }): Promise<RequestGuardContext> {
+    const binding = this.requireBinding(
+      input.release.definition.workflowKey,
+      input.release.releaseDigest,
+    );
+    try {
+      const current = captureAuthorizationScope(
+        input.context.actor.scopeContext,
+      ).snapshot;
+      const decision = await binding.launchAuthority.authorizeRun({
+        releaseId: input.release.releaseId,
+        releaseDigest: input.release.releaseDigest,
+        workflowInput: input.workflowInput,
+        inputArtifacts: input.inputArtifacts,
+        actorId: input.context.actor.id,
+        currentAuthorizationScope: structuredClone(current),
+        signal: input.signal,
+      });
+      if (!authorizationScopeContains(current, decision.authorizationScope)) {
+        throw hidden();
+      }
+      const scope = restoreServerScopeContext(decision.authorizationScope);
+      return {
+        ...input.context,
+        actor: {
+          ...input.context.actor,
+          dataAccess: scope,
+          scopeContext: scope,
+        },
+      };
+    } catch {
+      throw hidden();
+    }
+  }
+
+  private requireBinding(workflowKey: string, releaseDigest: string) {
+    const binding = this.bindings.findWorkflow(workflowKey);
+    if (!binding || binding.releaseDigest !== releaseDigest) throw hidden();
+    return binding;
+  }
+}
+
+function hidden() {
+  return new AgentWorkflowCommandError("RELEASE_NOT_FOUND", 404);
+}

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

@@ -1,4 +1,5 @@
 import type { ModuleManifest } from "@southwind-ai/modules";
+import type { ModuleClientAgentWorkflowArtifactProjectBinding } from "@southwind-ai/server-sdk";
 import {
   DurableHandlerError,
   type DurableHandlerRegistry,
@@ -55,6 +56,8 @@ import {
   createProductionWorkflowConditions,
   createProductionWorkspacePolicies,
 } from "./production-node-policies.js";
+import { ClientAgentWorkflowArtifactBindingRegistry } from "../agent/client-workflow-artifact/binding-registry.js";
+import { ProjectAgentWorkflowLaunchAuthority } from "./project-launch-authority.js";
 
 export function composeProductionAgentWorkflowRuntime(input: {
   readonly db?: NodePgDatabase;
@@ -80,6 +83,7 @@ export function composeProductionAgentWorkflowRuntime(input: {
   readonly resolveActor?: (
     actorId: string,
   ) => Promise<RequestActor | undefined>;
+  readonly clientAgentWorkflowArtifactBindings?: readonly ModuleClientAgentWorkflowArtifactProjectBinding[];
 }) {
   if (
     !input.db ||
@@ -119,6 +123,11 @@ export function composeProductionAgentWorkflowRuntime(input: {
     artifactSourceAuthorization,
     input.artifactAccessSecret,
   );
+  const projectAuthority = new ProjectAgentWorkflowLaunchAuthority(
+    new ClientAgentWorkflowArtifactBindingRegistry(
+      input.clientAgentWorkflowArtifactBindings ?? [],
+    ),
+  );
   const modelPricing = AgentWorkflowModelPricingCatalog.fromJson(
     input.modelPricingJson,
   );
@@ -275,6 +284,21 @@ export function composeProductionAgentWorkflowRuntime(input: {
     return port;
   }
   continuations.start();
+  const commands = new ProductionAgentWorkflowCommandFacade(
+    repository,
+    service,
+    query,
+    evaluations,
+    evaluationRepository,
+    input.modules,
+    input.runtime,
+    input.tools,
+    waitSignals,
+    artifacts,
+    workspacePolicies,
+    projectAuthority,
+    schedulerFor,
+  );
   return {
     query,
     artifacts,
@@ -290,19 +314,11 @@ export function composeProductionAgentWorkflowRuntime(input: {
             safeCode: "MODEL_PRICING_UNAVAILABLE",
           },
     },
-    commands: new ProductionAgentWorkflowCommandFacade(
-      repository,
-      service,
-      query,
-      evaluations,
-      evaluationRepository,
-      input.modules,
-      input.runtime,
-      input.tools,
-      waitSignals,
-      artifacts,
-      workspacePolicies,
-      schedulerFor,
-    ),
+    commands,
+    /** Project-owned application Seam; intentionally not mounted on generic routes. */
+    projectCommands: {
+      publish: commands.publishProject.bind(commands),
+      createRun: commands.createProjectRun.bind(commands),
+    },
   };
 }