create-windy 0.6.14 → 0.6.16

package/template/apps/server/src/jobs/drizzle-execution.integration.test.ts

@@ -14,6 +14,7 @@ import { artifactRef } from "@southwind-ai/storage";
 import { DrizzleDurableExecutionRepository } from "./drizzle-execution-repository.js";
 import { DrizzleDurableJobRepository } from "./drizzle-repository.js";
 import { DurableJobService } from "./service.js";
+import { DurableArtifactPublicationConflictError } from "./execution-repository.js";
 
 const databaseUrl = process.env.JOBS_TEST_DATABASE_URL;
 const describePostgres = databaseUrl ? describe : describe.skip;
@@ -38,6 +39,7 @@ describePostgres("PostgreSQL durable execution", () => {
     await pool.query(`truncate table
       governed_export_requests,
       bulk_data_artifacts, bulk_data_jobs, scheduled_task_runs,
+      client_agent_workflow_artifacts,
       durable_job_recoveries, durable_job_failures, durable_job_artifacts,
       durable_job_progress, durable_job_leases, durable_job_attempts,
       durable_job_stages, durable_jobs`);
@@ -170,6 +172,69 @@ describePostgres("PostgreSQL durable execution", () => {
     expect((await service.get(cancelled.job.id))?.artifacts).toEqual([]);
   });
 
+  test("artifact once 重放首发事实且拒绝覆盖", async () => {
+    const service = jobService(pool);
+    const submitted = await service.submit(jobInput("pg-artifact-once"));
+    const execution = new DrizzleDurableExecutionRepository(drizzle(pool));
+    const claim = await execution.claim(claimInput("artifact-once", base));
+    if (!claim) throw new Error("artifact once worker 未领取任务");
+    const publication = {
+      id: "dap_pg_stable",
+      jobId: claim.jobId,
+      stageId: claim.stageId,
+      kind: "result",
+      artifactRef: artifactRef("blob_0123456789abcdef0123456789abcdef"),
+      filename: "result.json",
+      contentType: "application/json",
+      byteSize: 10,
+      sha256: "a".repeat(64),
+      ownerId: "user_pg",
+      metadata: { second: 2, first: 1 },
+    };
+
+    await expect(
+      execution.publishArtifactOnce(
+        claim,
+        { ...publication, jobId: "job_forged" },
+        base,
+      ),
+    ).rejects.toBeInstanceOf(DurableArtifactPublicationConflictError);
+    await expect(
+      execution.publishArtifactOnce(
+        claim,
+        { ...publication, stageId: "stage_forged" },
+        base,
+      ),
+    ).rejects.toBeInstanceOf(DurableArtifactPublicationConflictError);
+    expect((await service.get(submitted.job.id))?.artifacts).toEqual([]);
+
+    const first = await execution.publishArtifactOnce(claim, publication, base);
+    expect(
+      await execution.publishArtifactOnce(
+        claim,
+        { ...publication, metadata: { first: 1, second: 2 } },
+        new Date(base.getTime() + 1),
+      ),
+    ).toEqual(first);
+    await expect(
+      execution.publishArtifactOnce(
+        claim,
+        { ...publication, byteSize: 11 },
+        new Date(base.getTime() + 2),
+      ),
+    ).rejects.toBeInstanceOf(DurableArtifactPublicationConflictError);
+    await expect(
+      execution.publishArtifactOnce(
+        claim,
+        { ...publication, kind: "other-result" },
+        new Date(base.getTime() + 3),
+      ),
+    ).rejects.toBeInstanceOf(DurableArtifactPublicationConflictError);
+    expect((await service.get(submitted.job.id))?.artifacts).toEqual([
+      expect.objectContaining({ id: "dap_pg_stable", byteSize: 10 }),
+    ]);
+  });
+
   test("timeout、running cancel 与人工恢复保留最终事实", async () => {
     const service = jobService(pool);
     const submitted = await service.submit({

package/template/apps/server/src/jobs/drizzle-repository.integration.test.ts

@@ -27,6 +27,7 @@ describePostgres("PostgreSQL durable job repository", () => {
     await pool.query(`truncate table
       governed_export_requests,
       bulk_data_artifacts, bulk_data_jobs, scheduled_task_runs,
+      client_agent_workflow_artifacts,
       durable_job_recoveries, durable_job_failures, durable_job_artifacts, durable_job_progress,
       durable_job_leases, durable_job_attempts, durable_job_stages, durable_jobs`);
   });

package/template/apps/server/src/jobs/execution-repository.ts

@@ -12,6 +12,29 @@ export type LeaseResult =
   | { ok: true; cancelRequested: boolean; expiresAt: string }
   | { ok: false; reason: LeaseRejection };
 
+export type DurableArtifactPublication = Omit<DurableJobArtifact, "createdAt">;
+
+export type DurableArtifactPublicationResult =
+  | Exclude<LeaseResult, { ok: true }>
+  | {
+      ok: true;
+      cancelRequested: true;
+      expiresAt: string;
+    }
+  | {
+      ok: true;
+      cancelRequested: false;
+      expiresAt: string;
+      artifact: DurableJobArtifact;
+    };
+
+export class DurableArtifactPublicationConflictError extends Error {
+  constructor(message = "同一任务产物发布坐标已绑定不同内容") {
+    super(message);
+    this.name = "DurableArtifactPublicationConflictError";
+  }
+}
+
 export interface ClaimDurableJob {
   queue: string;
   workerId: string;
@@ -75,6 +98,11 @@ export interface DurableExecutionRepository {
     artifact: DurableJobArtifact,
     now: Date,
   ): Promise<LeaseResult>;
+  publishArtifactOnce(
+    identity: DurableLeaseIdentity,
+    artifact: DurableArtifactPublication,
+    now: Date,
+  ): Promise<DurableArtifactPublicationResult>;
   complete(identity: DurableLeaseIdentity, now: Date): Promise<LeaseResult>;
   fail(
     identity: DurableLeaseIdentity,

package/template/apps/server/src/jobs/execution.test.ts

@@ -216,7 +216,9 @@ describe("durable job execution", () => {
         expiredAt,
       ),
     ).toMatchObject({ ok: true });
-    expect((await service.get(submitted.job.id))?.artifacts).toHaveLength(1);
+    expect((await service.get(submitted.job.id))?.artifacts).toEqual([
+      expect.objectContaining({ id: "artifact-replay" }),
+    ]);
 
     const cancelled = await service.submit(jobInput("artifact-cancelled"));
     const cancelledClaim = await repository.claim(

package/template/apps/server/src/jobs/in-memory-execution.ts

@@ -17,6 +17,7 @@ import { leaseIdentity, startInMemoryAttempt } from "./in-memory-claim.js";
 import {
   inMemoryLeaseSuccess,
   publishInMemoryArtifact,
+  publishInMemoryArtifactOnce,
   validateInMemoryLease,
 } from "./in-memory-lease.js";
 import {
@@ -121,6 +122,21 @@ export class InMemoryDurableExecutionRepository
     );
   }
 
+  async publishArtifactOnce(
+    identity: DurableLeaseIdentity,
+    artifact: Parameters<DurableExecutionRepository["publishArtifactOnce"]>[1],
+    now: Date,
+  ) {
+    return publishInMemoryArtifactOnce(
+      this.leases,
+      this.artifacts,
+      this.jobs,
+      identity,
+      artifact,
+      now,
+    );
+  }
+
   async complete(identity: DurableLeaseIdentity, now: Date) {
     const validated = validateInMemoryLease(this.leases, identity, now);
     if (!validated.ok) return validated;

package/template/apps/server/src/jobs/in-memory-lease.ts

@@ -4,7 +4,16 @@ import type {
   DurableLeaseIdentity,
 } from "@southwind-ai/jobs";
 import type { LeaseResult } from "./execution-repository.js";
+import type {
+  DurableArtifactPublication,
+  DurableArtifactPublicationResult,
+} from "./execution-repository.js";
+import { DurableArtifactPublicationConflictError } from "./execution-repository.js";
 import { hashLeaseToken } from "./in-memory-claim.js";
+import {
+  assertArtifactPublicationIdentity,
+  sameArtifactPublication,
+} from "./artifact-publication.js";
 
 export function validateInMemoryLease(
   leases: Map<string, DurableJobLease>,
@@ -34,7 +43,7 @@ export function inMemoryLeaseSuccess(
   jobs: Map<string, { cancelRequestedAt?: string }>,
   jobId: string,
   expiresAt: string,
-): LeaseResult {
+): Extract<LeaseResult, { ok: true }> {
   return {
     ok: true,
     cancelRequested: Boolean(jobs.get(jobId)?.cancelRequestedAt),
@@ -64,3 +73,38 @@ export function publishInMemoryArtifact(
   );
   return result;
 }
+
+export function publishInMemoryArtifactOnce(
+  leases: Map<string, DurableJobLease>,
+  artifacts: Map<string, DurableJobArtifact>,
+  jobs: Map<string, { cancelRequestedAt?: string }>,
+  identity: DurableLeaseIdentity,
+  artifact: DurableArtifactPublication,
+  now: Date,
+): DurableArtifactPublicationResult {
+  const validated = validateInMemoryLease(leases, identity, now);
+  if (!validated.ok) return validated;
+  assertArtifactPublicationIdentity(identity, artifact);
+  const lease = inMemoryLeaseSuccess(
+    jobs,
+    identity.jobId,
+    validated.lease.expiresAt,
+  );
+  if (lease.cancelRequested) {
+    return { ...lease, cancelRequested: true };
+  }
+  const publicationLease = { ...lease, cancelRequested: false } as const;
+  const candidate = { ...artifact, createdAt: now.toISOString() };
+  const coordinate = `${artifact.jobId}:${artifact.kind}`;
+  const existing =
+    artifacts.get(coordinate) ||
+    [...artifacts.values()].find(({ id }) => id === artifact.id);
+  if (existing) {
+    if (!sameArtifactPublication(existing, artifact)) {
+      throw new DurableArtifactPublicationConflictError();
+    }
+    return { ...publicationLease, artifact: structuredClone(existing) };
+  }
+  artifacts.set(coordinate, structuredClone(candidate));
+  return { ...publicationLease, artifact: candidate };
+}

package/template/apps/server/src/jobs/legacy-adapter.integration.test.ts

@@ -34,9 +34,11 @@ describePostgres("PostgreSQL legacy durable adapter", () => {
     });
     await pool.query(`
       truncate table
+        governed_export_requests,
         bulk_data_artifacts,
         bulk_data_jobs,
         scheduled_task_runs,
+        client_agent_workflow_artifacts,
         durable_job_recoveries,
         durable_job_failures,
         durable_job_artifacts,

package/template/apps/server/src/jobs/postgres-cleanup-contract.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+
+const integrationFiles = new Bun.Glob("**/*.integration.test.ts");
+const migrationFiles = new Bun.Glob("*.sql");
+
+describe("PostgreSQL durable job test cleanup", () => {
+  test("所有显式 durable_jobs TRUNCATE 同批清理受限子表且不使用 CASCADE", async () => {
+    const serverSourceRoot = new URL("../", import.meta.url).pathname;
+    const migrationsRoot = new URL(
+      "../../../../packages/database/drizzle/",
+      import.meta.url,
+    ).pathname;
+    const durableJobChildTables = new Set<string>();
+    const harnesses: string[] = [];
+
+    for await (const path of migrationFiles.scan(migrationsRoot)) {
+      const migration = await Bun.file(`${migrationsRoot}/${path}`).text();
+      for (const match of migration.matchAll(
+        /ALTER TABLE "([^"]+)" ADD CONSTRAINT [^\n]+ REFERENCES "public"\."durable_jobs"/g,
+      )) {
+        durableJobChildTables.add(match[1]!);
+      }
+    }
+    expect(durableJobChildTables).toContain("client_agent_workflow_artifacts");
+
+    for await (const path of integrationFiles.scan(serverSourceRoot)) {
+      const source = await Bun.file(`${serverSourceRoot}/${path}`).text();
+      if (!source.toLowerCase().includes("truncate table")) continue;
+      if (!source.includes("durable_jobs")) continue;
+
+      harnesses.push(path);
+      const cleanup = source.match(
+        /`(?=[^`]*truncate table)(?=[^`]*durable_jobs)[^`]+`/is,
+      )?.[0];
+      expect(cleanup, `${path} 缺少可审计的显式清理 SQL`).toBeDefined();
+      for (const childTable of durableJobChildTables) {
+        expect(cleanup, `${path} 缺少 ${childTable}`).toContain(childTable);
+      }
+      expect(cleanup, `${path} 不得用 CASCADE 掩盖清理闭包漂移`).not.toMatch(
+        /\bcascade\b/i,
+      );
+    }
+
+    expect(
+      harnesses.length,
+      "至少应发现一个 durable_jobs 清理 harness",
+    ).toBeGreaterThan(0);
+    for (const coreHarness of [
+      "jobs/drizzle-execution.integration.test.ts",
+      "jobs/drizzle-repository.integration.test.ts",
+      "workflow/drizzle-repository.integration.test.ts",
+    ]) {
+      expect(harnesses, `缺少核心清理 harness：${coreHarness}`).toContain(
+        coreHarness,
+      );
+    }
+  });
+});

package/template/apps/server/src/jobs/worker.ts

@@ -4,6 +4,7 @@ import type {
   LeaseResult,
   ManualJobRecovery,
 } from "./execution-repository.js";
+import { createDurableArtifactPublisher } from "./artifact-publisher.js";
 import {
   DurableHandlerError,
   type DurableHandlerContext,
@@ -158,20 +159,13 @@ export class DurableJobWorker {
           );
           assertLease(result, abort);
         },
-        publishArtifact: async (artifact) => {
-          const result = await this.repository.publishArtifact(
-            identity,
-            {
-              id: Bun.randomUUIDv7(),
-              jobId: identity.jobId,
-              stageId: identity.stageId,
-              ...artifact,
-              createdAt: this.now().toISOString(),
-            },
-            this.now(),
-          );
-          assertLease(result, abort);
-        },
+        ...createDurableArtifactPublisher({
+          repository: this.repository,
+          identity,
+          stageKey: claim.stage.key,
+          now: this.now,
+          assertLease: (result) => assertLease(result, abort),
+        }),
       };
       await Promise.race([
         (async () => {

package/template/apps/server/src/module-host/background-ai-unavailable.ts

@@ -0,0 +1,18 @@
+import {
+  ModuleBackgroundAiError,
+  type ModuleBackgroundAiPort,
+} from "@southwind-ai/server-sdk";
+
+export function unavailableModuleBackgroundAiPort(
+  moduleName: string,
+): ModuleBackgroundAiPort {
+  return {
+    async enqueueOperation() {
+      throw new ModuleBackgroundAiError(
+        "AI_OPERATION_UNAVAILABLE",
+        `模块 ${moduleName} 的后台 AI Operation Port 未挂载`,
+        true,
+      );
+    },
+  };
+}

package/template/apps/server/src/module-host/durable-context.ts

@@ -14,17 +14,14 @@ import type {
 // @windy-module system.storage begin
 import type { ModuleReportStagingPortV1 } from "@southwind-ai/server-sdk";
 // @windy-module system.storage end
-import { ModuleBackgroundAiError } from "@southwind-ai/server-sdk";
 // @windy-module system.storage begin
 import { ModuleReportStagingError } from "@southwind-ai/server-sdk";
 // @windy-module system.storage end
 import { evaluateAccessGuards } from "../access-guards.js";
-import {
-  captureAuthorizationScope,
-  hashAuthorizationScope,
-} from "../data-access/scope-snapshot.js";
+import * as scopeSnapshot from "../data-access/scope-snapshot.js";
 import type { RequestActor, RequestGuardContext } from "../guards.js";
 import type { createServerRuntime } from "../runtime.js";
+import { unavailableModuleBackgroundAiPort } from "./background-ai-unavailable.js";
 import type { InitializedModuleHosts } from "./initialize.js";
 import {
   createModuleStoragePort,
@@ -36,6 +33,9 @@ import { createModuleStorageWritePort } from "./storage-write-port.js";
 import { unavailableModuleStorageWritePort } from "./storage-write-unavailable.js";
 import { toModuleActor } from "./request-context.js";
 import { createModuleSecretPort } from "./module-secret-port.js";
+// @windy-module system.agent begin
+import { moduleWorkflowInputArtifactContext } from "./workflow-input-artifact-port.js";
+// @windy-module system.agent end
 // @windy-module system.storage begin
 import type { ReportStagingService } from "../report-staging/service.js";
 import { createModuleReportStagingPort } from "./report-staging-port.js";
@@ -87,8 +87,8 @@ export function createModuleDurableContextualizer(
     ) {
       throw denied("MODULE_ACTOR_UNAVAILABLE");
     }
-    const current = captureAuthorizationScope(actor.scopeContext);
-    if (current.hash !== hashAuthorizationScope(snapshot)) {
+    const current = scopeSnapshot.captureAuthorizationScope(actor.scopeContext);
+    if (current.hash !== scopeSnapshot.hashAuthorizationScope(snapshot)) {
       throw denied("MODULE_AUTHORIZATION_SCOPE_CHANGED");
     }
     const request = new Request(
@@ -216,6 +216,15 @@ export function createModuleDurableContextualizer(
       }),
       storage,
       storageWriter,
+      // @windy-module system.agent begin
+      ...moduleWorkflowInputArtifactContext(
+        input.moduleName,
+        actor.id,
+        storage,
+        services.storage?.blobStore,
+        input.context,
+      ),
+      // @windy-module system.agent end
       // @windy-module system.storage begin
       reportStaging,
       // @windy-module system.storage end
@@ -224,7 +233,7 @@ export function createModuleDurableContextualizer(
           input.moduleName,
           guardContext,
           input.context.signal,
-        ) ?? unavailableBackgroundAi(input.moduleName),
+        ) ?? unavailableModuleBackgroundAiPort(input.moduleName),
     };
     return moduleContext;
   };
@@ -249,8 +258,8 @@ async function resolveDurableReportAccess(
   const snapshot = input.claim.job.authorizationScope;
   if (
     !snapshot ||
-    captureAuthorizationScope(actor.scopeContext).hash !==
-      hashAuthorizationScope(snapshot)
+    scopeSnapshot.captureAuthorizationScope(actor.scopeContext).hash !==
+      scopeSnapshot.hashAuthorizationScope(snapshot)
   ) {
     return false;
   }
@@ -322,18 +331,6 @@ function unavailableDurableStoragePort(
   };
 }
 
-function unavailableBackgroundAi(moduleName: string): ModuleBackgroundAiPort {
-  return {
-    async enqueueOperation() {
-      throw new ModuleBackgroundAiError(
-        "AI_OPERATION_UNAVAILABLE",
-        `模块 ${moduleName} 的后台 AI Operation Port 未挂载`,
-        true,
-      );
-    },
-  };
-}
-
 function denied(code: string, details?: Record<string, unknown>) {
   return new DurableHandlerError(
     code,

package/template/apps/server/src/module-host/implementation-completeness.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, test } from "bun:test";
-import type { ModuleHost } from "@southwind-ai/server-sdk";
+import {
+  // @windy-module system.agent begin
+  defineModuleWorkflowInputMaterializationHandlerV1,
+  // @windy-module system.agent end
+  type ModuleHost,
+} from "@southwind-ai/server-sdk";
 import { featureKey } from "@southwind-ai/shared";
 import { initializeModuleHosts } from "./initialize.js";
 import {
@@ -130,6 +135,80 @@ describe("Server Module 实现完整性", () => {
       });
     }
   });
+
+  // @windy-module system.agent begin
+  test("固定 materialization task 由同 capability Durable Handler 完整实现", async () => {
+    const moduleManifest = manifest("case", {
+      features: [
+        {
+          key: featureKey("case.materialize"),
+          label: "案件输入物化",
+          module: "case",
+          visible: "hidden",
+          enabled: true,
+          stage: "stable",
+        },
+      ],
+      permissions: [
+        {
+          key: "case.materialize.execute",
+          label: "物化案件输入",
+          module: "case",
+          moduleLabel: "案件",
+          resource: "materialization",
+          resourceLabel: "输入物化",
+          action: "execute",
+        },
+      ],
+      tasks: [
+        {
+          key: "case.workflow-input-materialize",
+          label: "案件输入物化",
+          description: "物化受治理 Workflow 输入。",
+          featureKey: "case.materialize",
+          permissionKey: "case.materialize.execute",
+          auditAction: "case.materialize.execute",
+          intervalSeconds: 60,
+          maxAttempts: 3,
+          retryDelaySeconds: 5,
+        },
+      ],
+      auditActions: ["case.materialize.execute"],
+    });
+    const installation = {
+      manifest: moduleManifest,
+      setup(host: ModuleHost) {
+        host.registerDurableHandler(
+          defineModuleWorkflowInputMaterializationHandlerV1({
+            moduleName: "case",
+            featureKey: "case.materialize",
+            permissionKey: "case.materialize.execute",
+            auditAction: "case.materialize.execute",
+          }),
+        );
+      },
+    };
+    const hosts = await initializeModuleHosts({
+      modules: [moduleManifest],
+      installations: [installation],
+    });
+    expect(() =>
+      validateHostedModuleImplementations([installation], hosts),
+    ).not.toThrow();
+    expect(() =>
+      validateHostedModuleImplementations([installation], {
+        ...hosts,
+        durableHandlers: hosts.durableHandlers.map((entry) => ({
+          ...entry,
+          definition: {
+            ...entry.definition,
+            auditAction: "case.materialize.drifted",
+          },
+        })),
+      }),
+    ).toThrow("定时任务 case.workflow-input-materialize 缺少 Handler");
+  });
+  // @windy-module system.agent end
 });
 
 function completeRouteModule() {

package/template/apps/server/src/module-host/implementation-completeness.ts

@@ -4,6 +4,9 @@ import type {
   InstallableServerModule,
   ModuleGovernedResourceRegistration,
 } from "@southwind-ai/server-sdk";
+// @windy-module system.agent begin
+import { moduleWorkflowInputMaterializationHandlerKey } from "@southwind-ai/server-sdk";
+// @windy-module system.agent end
 import type { InitializedModuleHosts } from "./initialize-contracts.js";
 
 /**
@@ -42,7 +45,10 @@ export function validateHostedModuleImplementations(
       installation.manifest.tasks.map(({ key }) => key),
       hosts.taskHandlers
         .filter((entry) => entry.moduleName === moduleName)
-        .map(({ registration }) => registration.taskKey),
+        .map(({ registration }) => registration.taskKey)
+        // @windy-module system.agent begin
+        .concat(materializationDurableTaskKeys(installation.manifest, hosts)),
+      // @windy-module system.agent end
     );
     assertComplete(
       "Agent Tool",
@@ -69,6 +75,27 @@ export function validateHostedModuleImplementations(
   validateDurableHandlerInstallations(hosts);
 }
 
+// @windy-module system.agent begin
+function materializationDurableTaskKeys(
+  manifest: ModuleManifest,
+  hosts: InitializedModuleHosts,
+) {
+  const key = moduleWorkflowInputMaterializationHandlerKey(manifest.name);
+  const task = manifest.tasks.find((candidate) => candidate.key === key);
+  if (!task) return [];
+  return hosts.durableHandlers
+    .filter(
+      ({ moduleName, definition }) =>
+        moduleName === manifest.name &&
+        definition.key === key &&
+        definition.featureKey === task.featureKey &&
+        definition.permissionKey === task.permissionKey &&
+        definition.auditAction === task.auditAction,
+    )
+    .map(({ definition }) => definition.key);
+}
+// @windy-module system.agent end
+
 export function governedResourceRouteKeys(
   registration: Pick<
     ModuleGovernedResourceRegistration,

package/template/apps/server/src/module-host/request-context.ts

@@ -40,6 +40,9 @@ import {
 import { unavailableModuleSecretPort } from "./module-secret-port.js";
 import { unavailableModuleStoragePort } from "./storage-port.js";
 import { unavailableModuleStorageWritePort } from "./storage-write-unavailable.js";
+// @windy-module system.agent begin
+import { createModuleWorkflowInputMaterializationPort } from "./workflow-input-materialization.js";
+// @windy-module system.agent end
 
 type ServerRuntime = ReturnType<typeof createServerRuntime>;
 
@@ -115,6 +118,17 @@ export interface ModuleRequestContextInput {
 export function buildModuleRequestContext(
   input: ModuleRequestContextInput,
 ): ModuleRequestContext {
+  const jobs = createModuleJobPort({
+    moduleName: input.moduleName,
+    guardContext: input.guardContext,
+    runtime: input.runtime,
+    jobs: input.jobs,
+    control: input.jobControl,
+    reauthorize: input.reauthorizeJobs,
+  });
+  // @windy-module system.agent begin
+  const materializationHandlerKey = `${input.moduleName}.workflow-input-materialize`;
+  // @windy-module system.agent end
   return {
     requestId: input.guardContext.requestId,
     signal: input.signal ?? new AbortController().signal,
@@ -136,14 +150,24 @@ export function buildModuleRequestContext(
     ...(input.sourceInvalidation
       ? { sourceInvalidation: input.sourceInvalidation }
       : {}),
-    jobs: createModuleJobPort({
-      moduleName: input.moduleName,
-      guardContext: input.guardContext,
-      runtime: input.runtime,
-      jobs: input.jobs,
-      control: input.jobControl,
-      reauthorize: input.reauthorizeJobs,
-    }),
+    jobs,
+    // @windy-module system.agent begin
+    ...(input.jobs &&
+    input.manifest.tasks.some(({ key }) => key === materializationHandlerKey)
+      ? {
+          workflowInputMaterialization:
+            createModuleWorkflowInputMaterializationPort({
+              moduleName: input.moduleName,
+              guardContext: input.guardContext,
+              jobs: input.jobs,
+              moduleJobs: jobs,
+              ...(input.reauthorizeJobs
+                ? { reauthorize: input.reauthorizeJobs }
+                : {}),
+            }),
+        }
+      : {}),
+    // @windy-module system.agent end
     secrets: input.secrets ?? unavailableModuleSecretPort(),
     storage: input.storage ?? unavailableModuleStoragePort(input.moduleName),
     storageWriter: