create-windy 0.6.0 → 0.6.2

package/template/apps/embedding-server/tests/test_run_http.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 import httpx
 import pytest
+from fastapi import FastAPI
 
 os.environ.setdefault("EMBEDDING_SERVER_INTERNAL_TOKEN", "test-internal")
 os.environ.setdefault("EMBEDDING_RUN_ENCRYPTION_SECRET", "x" * 32)
@@ -19,6 +20,11 @@ from southwind_embedding_server.app import create_app
 from southwind_embedding_server.config import EmbeddingConfig
 from southwind_embedding_server.contracts import EmbeddingRequest, EmbeddingResponse
 from southwind_embedding_server.error import SafeEmbeddingError
+from southwind_embedding_server.readiness import EmbeddingReadinessInspection
+
+IDENTITY = "windy-deployment-v1_0f26eb34-f384-4ec9-98f3-caf8d582291f"
+DIGEST_A = f"sha256:{'a' * 64}"
+DIGEST_B = f"sha256:{'b' * 64}"
 
 
 def config(path: str) -> EmbeddingConfig:
@@ -28,7 +34,10 @@ def config(path: str) -> EmbeddingConfig:
         run_artifact_url="http://server:9747/api/internal/embeddings/runs",
         adapter_url="http://adapter:9000",
         adapter_token=None,
-        deployment_key=None,
+        deployment_key="embedding.primary",
+        deployment_identity=IDENTITY,
+        release_digest=DIGEST_A,
+        offers_digest=DIGEST_B,
         deployment_alias="intranet-v1",
         model="embedding-model",
         version="2026-08",
@@ -56,6 +65,12 @@ def request() -> dict[str, object]:
             "maxUnits": 10,
         },
         "providerEgress": {"mode": "forbidden"},
+        "readinessPin": {
+            "key": "embedding.primary",
+            "identity": IDENTITY,
+            "releaseDigest": DIGEST_A,
+            "offersDigest": DIGEST_B,
+        },
     }
 
 
@@ -78,7 +93,7 @@ def response() -> EmbeddingResponse:
 @pytest.mark.asyncio
 async def test_run_http_success_events_result_and_cancel(tmp_path: Path) -> None:
     adapter = Adapter(response())
-    app = create_app(config(str(tmp_path / "runs.sqlite3")), adapter)
+    app = create_app(config(str(tmp_path / "runs.sqlite3")), adapter, ReadyReadiness())
     async with client(app) as remote:
         denied = await remote.post("/api/embeddings/runs", json=request())
         assert denied.status_code == 403
@@ -103,7 +118,9 @@ async def test_run_http_success_events_result_and_cancel(tmp_path: Path) -> None
         assert result.json()["output"]["batchId"] == "batch-1"
 
         waiting = Adapter(response(), block=True)
-        cancelled_app = create_app(config(str(tmp_path / "cancel.sqlite3")), waiting)
+        cancelled_app = create_app(
+            config(str(tmp_path / "cancel.sqlite3")), waiting, ReadyReadiness()
+        )
         async with client(cancelled_app) as cancel_remote:
             accepted = await cancel_remote.post(
                 "/api/embeddings/runs", headers=headers("cancel-1"), json=request()
@@ -122,6 +139,7 @@ async def test_run_http_exposes_safe_remote_failure_only(tmp_path: Path) -> None
     app = create_app(
         config(str(tmp_path / "failed.sqlite3")),
         Adapter(None, failure=True),
+        ReadyReadiness(),
     )
     async with client(app) as remote:
         started = await remote.post(
@@ -143,6 +161,24 @@ async def test_run_http_exposes_safe_remote_failure_only(tmp_path: Path) -> None
         assert result.json()["code"] == "RUN_NOT_READY"
 
 
+@pytest.mark.asyncio
+async def test_unready_request_does_not_create_run(tmp_path: Path) -> None:
+    app = create_app(
+        config(str(tmp_path / "unready.sqlite3")),
+        Adapter(response()),
+        UnreadyReadiness(),
+    )
+    async with client(app) as remote:
+        rejected = await remote.post(
+            "/api/embeddings/runs", headers=headers("unready"), json=request()
+        )
+        assert rejected.status_code == 503
+        missing = await remote.get(
+            "/api/embeddings/runs/embedding_unready/result", headers=headers()
+        )
+        assert missing.status_code == 404
+
+
 class Adapter:
     def __init__(
         self,
@@ -171,6 +207,42 @@ class Adapter:
         return self.value
 
 
+class ReadyReadiness:
+    async def inspect(self) -> EmbeddingReadinessInspection:
+        return EmbeddingReadinessInspection(
+            {
+                "status": "ready",
+                "deployment": {
+                    "key": "embedding.primary",
+                    "identity": IDENTITY,
+                    "releaseDigest": DIGEST_A,
+                    "offersDigest": DIGEST_B,
+                },
+            },
+            ({"variant": "text"},),
+        )
+
+    def supports(
+        self, _inspection: EmbeddingReadinessInspection, request: EmbeddingRequest
+    ) -> bool:
+        return bool(
+            request.readiness_pin
+            and request.readiness_pin.identity == IDENTITY
+            and request.readiness_pin.release_digest == DIGEST_A
+            and request.readiness_pin.offers_digest == DIGEST_B
+        )
+
+
+class UnreadyReadiness(ReadyReadiness):
+    async def inspect(self) -> EmbeddingReadinessInspection:
+        return EmbeddingReadinessInspection({"status": "unavailable"})
+
+    def supports(
+        self, _inspection: EmbeddingReadinessInspection, _request: EmbeddingRequest
+    ) -> bool:
+        return False
+
+
 def headers(key: str = "read") -> dict[str, str]:
     return {
         "authorization": "Bearer internal",
@@ -179,7 +251,7 @@ def headers(key: str = "read") -> dict[str, str]:
     }
 
 
-def client(app: object) -> httpx.AsyncClient:
+def client(app: FastAPI) -> httpx.AsyncClient:
     return httpx.AsyncClient(
         transport=httpx.ASGITransport(app=app), base_url="http://embedding"
     )

package/template/apps/embedding-server/tests/test_run_service.py

@@ -181,7 +181,9 @@ async def test_recovery_fails_closed_when_deployment_pin_drifts(tmp_path: Path)
         await asyncio.sleep(0)
     events = await restarted.store.events_after(pending.run_id, 0)
     assert events[-1]["type"] == "run.failed"
-    assert events[-1]["error"]["code"] == "CAPABILITY_UNAVAILABLE"
+    error = events[-1]["error"]
+    assert isinstance(error, dict)
+    assert error["code"] == "CAPABILITY_UNAVAILABLE"
 
 
 def response() -> EmbeddingResponse:

package/template/apps/server/Dockerfile

@@ -1,6 +1,6 @@
 # syntax=docker/dockerfile:1
 
-FROM oven/bun:1.3.14-alpine AS deps
+FROM oven/bun:1.3.14 AS deps
 WORKDIR /app
 
 COPY package.json bun.lock ./
@@ -23,12 +23,16 @@ COPY packages/server-sdk/package.json packages/server-sdk/package.json
 COPY packages/shared/package.json packages/shared/package.json
 COPY packages/storage/package.json packages/storage/package.json
 # windy-copy:deps end
-RUN --mount=type=cache,id=windy-bun-1.3.14,target=/root/.bun/install/cache,sharing=shared bun -e 'const child=Bun.spawn(["bun","install","--frozen-lockfile","--no-progress"],{stdin:"inherit",stdout:"inherit",stderr:"inherit"});const heartbeat=setInterval(()=>console.log("[windy] Bun 依赖安装仍在进行"),15000);const exitCode=await child.exited;clearInterval(heartbeat);process.exit(exitCode)'
+RUN --mount=type=cache,id=windy-bun-1.3.14,target=/root/.bun/install/cache,sharing=shared bun -e 'const child=Bun.spawn(["bun","install","--frozen-lockfile","--no-progress","--backend=copyfile","--linker=hoisted"],{stdin:"inherit",stdout:"inherit",stderr:"inherit"});const heartbeat=setInterval(()=>console.log("[windy] Bun 依赖安装仍在进行"),15000);const exitCode=await child.exited;clearInterval(heartbeat);process.exit(exitCode)'
 
 FROM deps AS runner
 # @windy-module system.storage begin
-RUN apk add --no-cache libarchive=3.8.3-r0 libarchive-tools=3.8.3-r0 \
-    && apk add --no-cache --virtual .windy-report-staging-build build-base=0.5-r3 libarchive-dev=3.8.3-r0
+# The native archive helper needs a compiler. Avoid Alpine apk here: its source
+# transfer can stall indefinitely under cross-architecture BuildKit emulation.
+RUN set -eu; \
+    if ! timeout --kill-after=5s 90s sh -c 'apt-get update -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30 -o Acquire::Retries=0 && DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends --yes build-essential libarchive-dev libarchive-tools'; then \
+      echo "APT 包源不可用或 90 秒总时限已到：无法安装 report-staging 依赖" >&2; exit 70; \
+    fi
 # @windy-module system.storage end
 COPY drizzle.config.ts drizzle.config.ts
 COPY apps/server apps/server
@@ -40,7 +44,8 @@ RUN cc -std=c11 -O2 -Wall -Wextra -Werror \
     && strip /usr/local/bin/windy-report-archive-stream \
     && chown root:root /usr/local/bin/windy-report-archive-stream \
     && chmod 0555 /usr/local/bin/windy-report-archive-stream \
-    && apk del .windy-report-staging-build
+    && apt-get purge --auto-remove --yes build-essential libarchive-dev \
+    && rm -rf /var/lib/apt/lists/*
 # @windy-module system.storage end
 COPY --chmod=0555 deploy/production/server-entrypoint.sh /usr/local/bin/windy-server-entrypoint
 RUN mkdir -p /app/data/audit /app/data/license && chown -R bun:bun /app/data

package/template/apps/server/src/agent/drizzle-screenshot-intake-repository.integration.test.ts

@@ -154,6 +154,7 @@ describePostgres("Screenshot Intake V2 真实 PostgreSQL 重启与 TTL", () => {
         plan.intakeToken,
         "evidence.image.inspect",
         screenshotDeployment,
+        declaration(bytes).contextDigest,
         context,
       );
       expect(first.artifact.value).toStartWith("v1.");
@@ -167,6 +168,7 @@ describePostgres("Screenshot Intake V2 真实 PostgreSQL 重启与 TTL", () => {
         plan.intakeToken,
         "evidence.image.inspect",
         screenshotDeployment,
+        declaration(bytes).contextDigest,
         context,
       );
       await recovered.bind("run-canonical");
@@ -177,6 +179,7 @@ describePostgres("Screenshot Intake V2 真实 PostgreSQL 重启与 TTL", () => {
         plan.intakeToken,
         "evidence.image.inspect",
         screenshotDeployment,
+        declaration(bytes).contextDigest,
         context,
       );
       await idempotent.bind("run-canonical");

package/template/apps/server/src/agent/run-facade.ts

@@ -200,7 +200,8 @@ export class AgentRunFacade {
       screenshot = await reserveScreenshotForRun(
         this.screenshots,
         screenshotIntakeToken,
-        operationKey,
+        operation.definition,
+        input,
         readinessPin,
         context,
         signal,

package/template/apps/server/src/agent/run-route-screenshot-context.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from "bun:test";
+import { parseStartRequest } from "./run-route-input.js";
+
+test("Run route 不接受客户端自报 Screenshot context 已验证", () => {
+  expect(() =>
+    parseStartRequest({
+      operationKey: "evidence.image.inspect",
+      input: { uiContext: { version: 1 } },
+      screenshotIntakeToken: "0198c47d-7d51-7000-8000-000000000001",
+      screenshotContextDigest: `sha256:${"a".repeat(64)}`,
+    }),
+  ).toThrow("请求格式无效");
+});

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

@@ -263,6 +263,7 @@ export function registerAgentPlatformRuntime(input: {
         : new InMemoryEmbeddingRunBindingRepository(),
       internalToken,
     ),
+    aiReadiness,
   );
   registerEmbeddingRoutes(aiRouteApp, embeddingFacade);
   registerEmbeddingRunArtifactRoutes(
@@ -316,6 +317,7 @@ export function registerAgentPlatformRuntime(input: {
       speechFacade,
       speechRemote,
       embeddingFacade,
+      modules: input.modules,
     });
   const aiReadinessForModule = (
     moduleName: string,

package/template/apps/server/src/agent/screenshot-context-admission.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, test } from "bun:test";
+import type { ModuleManifest } from "@southwind-ai/modules";
+import { computeScreenshotContextDigestV1 } from "@southwind-ai/shared";
+import type { ModuleAiScreenshotIntakeProducerV2 } from "@southwind-ai/server-sdk";
+import { buildScopeContext } from "../data-access/context.js";
+import { createRequestGuardContext } from "../guards.js";
+import { createServerRuntime } from "../runtime.js";
+import { ScreenshotIntakeRuntimeV2 } from "./screenshot-intake-v2.js";
+import { reserveScreenshotForRun } from "./screenshot-run-binding.js";
+import {
+  screenshotDeployment,
+  screenshotVisionManifest,
+} from "./screenshot-intake-test-support.js";
+
+describe("Screenshot context Run admission", () => {
+  test("Host 重算 Manifest 指向的结构化上下文后才允许绑定", async () => {
+    const producer = fakeProducer();
+    const intake = runtime(producer);
+    const context = guard();
+    const uiContext = {
+      version: 1,
+      pageKey: "case.detail",
+      overlayStack: [{ title: "导入物证", kind: "dialog" }],
+    };
+    const plan = await intake.create(
+      declaration(await computeScreenshotContextDigestV1(uiContext)),
+      context,
+      signal(),
+    );
+    await intake.upload(plan.intakeToken, "image/png", png(), context);
+
+    const binding = await reserveScreenshotForRun(
+      intake,
+      plan.intakeToken,
+      operation(),
+      {
+        uiContext: {
+          overlayStack: [{ kind: "dialog", title: "导入物证" }],
+          pageKey: "case.detail",
+          version: 1,
+        },
+        uiContextDigest: `sha256:${"0".repeat(64)}`,
+      },
+      screenshotDeployment,
+      context,
+      signal(),
+    );
+    expect(binding?.artifact.value).toBe("opaque-screenshot-artifact");
+    await binding?.bind("run-canonical");
+    expect(producer.bound).toEqual(["run-canonical"]);
+    await intake.dispose();
+  });
+
+  test("上下文漂移或只提交自报 digest 会消费 token 并拒绝重放", async () => {
+    const producer = fakeProducer();
+    const intake = runtime(producer);
+    const context = guard();
+    const uiContext = { version: 1, pageKey: "case.detail" };
+    const first = await intake.create(
+      declaration(await computeScreenshotContextDigestV1(uiContext)),
+      context,
+      signal(),
+    );
+    await intake.upload(first.intakeToken, "image/png", png(), context);
+
+    await expect(
+      reserveScreenshotForRun(
+        intake,
+        first.intakeToken,
+        operation(),
+        { uiContext: { version: 1, pageKey: "case.list" } },
+        screenshotDeployment,
+        context,
+        signal(),
+      ),
+    ).rejects.toMatchObject({ code: "RUNTIME_UNAVAILABLE", status: 503 });
+    await expect(
+      reserveScreenshotForRun(
+        intake,
+        first.intakeToken,
+        operation(),
+        { uiContext },
+        screenshotDeployment,
+        context,
+        signal(),
+      ),
+    ).rejects.toMatchObject({ code: "RUNTIME_UNAVAILABLE", status: 503 });
+
+    const second = await intake.create(
+      declaration(await computeScreenshotContextDigestV1(uiContext)),
+      context,
+      signal(),
+    );
+    await intake.upload(second.intakeToken, "image/png", png(), context);
+    await expect(
+      reserveScreenshotForRun(
+        intake,
+        second.intakeToken,
+        operation(),
+        { uiContextDigest: await computeScreenshotContextDigestV1(uiContext) },
+        screenshotDeployment,
+        context,
+        signal(),
+      ),
+    ).rejects.toMatchObject({ code: "RUNTIME_UNAVAILABLE", status: 503 });
+    expect(producer.cancelled).toEqual(["producer-plan", "producer-plan"]);
+    await intake.dispose();
+  });
+
+  test("未 opt-in 的 0.6.0 Screenshot Operation 保留既有兼容边界", async () => {
+    const producer = fakeProducer();
+    const manifest = legacyManifest();
+    const intake = runtime(producer, manifest);
+    const context = guard();
+    const plan = await intake.create(
+      declaration(`sha256:${"f".repeat(64)}`),
+      context,
+      signal(),
+    );
+    await intake.upload(plan.intakeToken, "image/png", png(), context);
+    const binding = await reserveScreenshotForRun(
+      intake,
+      plan.intakeToken,
+      manifest.aiOperations![0]!,
+      { uiContext: { version: 1, pageKey: "legacy" } },
+      screenshotDeployment,
+      context,
+      signal(),
+    );
+    expect(binding?.artifact.value).toBe("opaque-screenshot-artifact");
+    await binding?.bind("run-legacy");
+    await intake.dispose();
+  });
+});
+
+function operation() {
+  const value = screenshotVisionManifest().aiOperations?.[0];
+  if (!value) throw new Error("测试 Manifest 缺少 Vision Operation");
+  return value;
+}
+
+function runtime(
+  producer: ReturnType<typeof fakeProducer>,
+  manifest = screenshotVisionManifest(),
+) {
+  return new ScreenshotIntakeRuntimeV2(
+    [manifest],
+    createServerRuntime(
+      {},
+      {
+        featureCatalog: manifest.features,
+        licenseResolver: { resolve: () => ({ status: "valid" }) },
+      },
+    ),
+    () => producer,
+    (reference) => reference,
+  );
+}
+
+function legacyManifest(): ModuleManifest {
+  const manifest = screenshotVisionManifest();
+  const definition = manifest.aiOperations?.[0];
+  if (!definition) throw new Error("测试 Manifest 缺少 Vision Operation");
+  return {
+    ...manifest,
+    aiOperations: [{ ...definition, screenshotContext: undefined }],
+  };
+}
+
+function fakeProducer(): ModuleAiScreenshotIntakeProducerV2 & {
+  bound: string[];
+  cancelled: string[];
+} {
+  return {
+    bound: [],
+    cancelled: [],
+    async create() {
+      return {
+        contractVersion: 2,
+        intakeToken: "producer-plan",
+        operationKey: "evidence.image.inspect",
+        expiresAt: new Date(Date.now() + 30_000).toISOString(),
+      };
+    },
+    async upload() {
+      return {
+        value: "opaque-screenshot-artifact",
+        mediaType: "image/png",
+        byteSize: png().byteLength,
+        sha256:
+          "b1ff9c8ea3a780bad09b346c423d2d0e46815926879b18e841d928376a946640",
+        expiresAt: new Date(Date.now() + 20_000).toISOString(),
+      };
+    },
+    async bind({ runId }) {
+      this.bound.push(runId);
+    },
+    async cancel({ intakeToken }) {
+      this.cancelled.push(intakeToken);
+    },
+  };
+}
+
+function declaration(contextDigest: `sha256:${string}`) {
+  return {
+    pageId: "case-detail",
+    contextDigest,
+    mediaType: "image/png" as const,
+    byteSize: png().byteLength,
+    pixels: 1,
+  };
+}
+
+function guard() {
+  return createRequestGuardContext(
+    new Request("http://windy.test/api/agent/screenshots"),
+    {
+      resolveActor: () => ({
+        id: "actor-1",
+        type: "user",
+        name: "测试用户",
+        roleCodes: ["user"],
+        permissionKeys: ["evidence.ai.execute"],
+        scopeContext: buildScopeContext("actor-1", undefined, [
+          {
+            id: "role-user",
+            code: "user",
+            dataScope: "self",
+            departmentIds: [],
+          },
+        ]),
+      }),
+      resolveLicense: () => ({ status: "valid" }),
+    },
+  );
+}
+
+function signal() {
+  return AbortSignal.timeout(1_000);
+}
+
+function png(): Uint8Array {
+  return Uint8Array.from(
+    Buffer.from(
+      "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC",
+      "base64",
+    ),
+  );
+}

package/template/apps/server/src/agent/screenshot-context-attestation.ts

@@ -0,0 +1,60 @@
+import { timingSafeEqual } from "node:crypto";
+import {
+  parseAiScreenshotContextInputPointer,
+  type ModuleAiOperationDefinition,
+} from "@southwind-ai/modules";
+import {
+  computeScreenshotContextDigestV1,
+  isScreenshotContextDigestV1,
+  type JsonValue,
+  type ScreenshotContextDigestV1,
+} from "@southwind-ai/shared";
+
+/** null 表示 legacy 未 opt-in；undefined 表示已 opt-in 但上下文不能形成证明。 */
+export async function expectedScreenshotContextDigest(
+  definition: ModuleAiOperationDefinition,
+  input: JsonValue,
+): Promise<ScreenshotContextDigestV1 | null | undefined> {
+  const binding = definition.screenshotContext;
+  if (!binding) return null;
+  try {
+    const context = readPointer(
+      input,
+      parseAiScreenshotContextInputPointer(binding.contextInputPointer),
+    );
+    if (!isRecord(context)) return undefined;
+    return await computeScreenshotContextDigestV1(context);
+  } catch {
+    return undefined;
+  }
+}
+
+export function sameScreenshotContextDigest(
+  actual: string,
+  expected: string | undefined,
+): boolean {
+  if (
+    !isScreenshotContextDigestV1(actual) ||
+    !isScreenshotContextDigestV1(expected)
+  ) {
+    return false;
+  }
+  const actualBytes = Buffer.from(actual.slice("sha256:".length), "hex");
+  const expectedBytes = Buffer.from(expected.slice("sha256:".length), "hex");
+  return timingSafeEqual(actualBytes, expectedBytes);
+}
+
+function readPointer(value: JsonValue, segments: readonly string[]): JsonValue {
+  let current = value;
+  for (const segment of segments) {
+    if (!isRecord(current) || !Object.hasOwn(current, segment)) {
+      throw new Error("Screenshot context input 缺失");
+    }
+    current = current[segment] as JsonValue;
+  }
+  return current;
+}
+
+function isRecord(value: JsonValue): value is Record<string, JsonValue> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/template/apps/server/src/agent/screenshot-intake-bootstrap.ts

@@ -9,10 +9,8 @@ import {
   PersistentScreenshotIntakeProducer,
   type ScreenshotPageRegistryV2,
 } from "./persistent-screenshot-intake-producer.js";
-import {
-  ScreenshotIntakeRuntimeV2,
-  type ProjectAiScreenshotIntakeFactoryV2,
-} from "./screenshot-intake-v2.js";
+import { type ProjectAiScreenshotIntakeFactoryV2 } from "./screenshot-intake-durable.js";
+import { ScreenshotIntakeRuntimeV2 } from "./screenshot-intake-v2.js";
 
 export function createScreenshotIntakeRuntimeV2(input: {
   readonly modules: readonly ModuleManifest[];

package/template/apps/server/src/agent/screenshot-intake-test-support.ts

@@ -81,6 +81,10 @@ export function screenshotVisionManifest(): ModuleManifest {
           minConcurrentRuns: 1,
           minQueueDepth: 0,
         },
+        screenshotContext: {
+          contractVersion: 1,
+          contextInputPointer: "/uiContext",
+        },
       },
     ],
   };

package/template/apps/server/src/agent/screenshot-intake-v2-validation.ts

@@ -8,6 +8,8 @@ import type {
   ModuleAiScreenshotPlanV2,
 } from "@southwind-ai/server-sdk";
 import type { RequestGuardContext } from "../guards.js";
+import { sameScreenshotContextDigest } from "./screenshot-context-attestation.js";
+import type { ScreenshotIntakeRecordV2 } from "./screenshot-intake-record.js";
 
 const MAX_BYTES = 8 * 1_024 * 1_024;
 const MAX_PIXELS = 20_000_000;
@@ -114,6 +116,28 @@ export function sameScreenshotDeployment(
   );
 }
 
+export function canReserveScreenshot(
+  record: ScreenshotIntakeRecordV2,
+  operationKey: string,
+  deployment: AiRuntimeDeploymentV1 | undefined,
+  expectedContextDigest: string | null | undefined,
+): record is ScreenshotIntakeRecordV2 & { artifact: ModuleAiArtifactRef } {
+  return Boolean(
+    record.artifact &&
+    (record.durable
+      ? ["uploaded", "reserving", "bound"].includes(record.state)
+      : record.state === "uploaded") &&
+    record.operationKey === operationKey &&
+    (expectedContextDigest === null ||
+      sameScreenshotContextDigest(
+        record.contextDigest,
+        expectedContextDigest,
+      )) &&
+    deployment &&
+    sameScreenshotDeployment(record.deployment, deployment),
+  );
+}
+
 export function sameScreenshotArtifact(
   value: ModuleAiArtifactRef,
   record: {

package/template/apps/server/src/agent/screenshot-intake-v2.test.ts

@@ -35,6 +35,7 @@ describe("Screenshot Intake V2", () => {
           ...deployment,
           offersDigest: `sha256:${"b".repeat(64)}` as `sha256:${string}`,
         },
+        declaration().contextDigest,
         context,
       ),
     ).rejects.toThrow("Screenshot Intake");
@@ -50,6 +51,7 @@ describe("Screenshot Intake V2", () => {
       second.intakeToken,
       "evidence.image.inspect",
       deployment,
+      declaration().contextDigest,
       context,
     );
     expect(reserved.artifact.value).toBe("opaque-screenshot-artifact");
@@ -59,6 +61,7 @@ describe("Screenshot Intake V2", () => {
         second.intakeToken,
         "evidence.image.inspect",
         deployment,
+        declaration().contextDigest,
         context,
       ),
     ).rejects.toThrow("Screenshot Intake");
@@ -332,6 +335,10 @@ function manifest(): ModuleManifest {
           minConcurrentRuns: 1,
           minQueueDepth: 0,
         },
+        screenshotContext: {
+          contractVersion: 1,
+          contextInputPointer: "/uiContext",
+        },
       },
     ],
   };