create-windy 0.8.2 → 0.9.1

package/template/apps/server/scripts/check-dsh-platform-example.ts

@@ -0,0 +1,251 @@
+/** Synthetic acceptance: actual platform query Tool + official DSH Loop; no customer data or live model. */
+import assert from "node:assert/strict";
+import { resolve } from "node:path";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import {
+  createFoundationSnapshot,
+  loadSystemModules,
+} from "../src/foundation.ts";
+import { createServerRuntime } from "../src/runtime.ts";
+import { createSystemRepositories } from "../src/system/seed.ts";
+import { createSystemToolHandlers } from "../src/agent/routes.ts";
+import { GovernedToolRegistry } from "../src/agent/tool-registry.ts";
+import { RemoteAgentRuntime } from "../src/agent/remote-runtime.ts";
+import { toolDefinitions } from "../src/agent/run-definition-support.ts";
+import { platformBuiltinAgentSkills } from "../src/agent-skills/builtins.ts";
+
+const root = resolve(import.meta.dir, "../../..");
+const modules = loadSystemModules();
+const runtime = createServerRuntime(
+  { WINDY_DEV_ADMIN_TOKEN: "synthetic-example" },
+  { featureCatalog: modules.flatMap((module) => module.features) },
+);
+const context = await runtime.createGuardContext(
+  new Request("http://fixture/api/agent/runs", {
+    headers: { authorization: "Bearer synthetic-example" },
+  }),
+);
+const repositories = createSystemRepositories(
+  createFoundationSnapshot(undefined, modules),
+);
+const registry = new GovernedToolRegistry(
+  modules,
+  createSystemToolHandlers(repositories, runtime),
+  runtime,
+);
+const token = crypto.randomUUID() + crypto.randomUUID();
+let modelCalls = 0,
+  toolCalls = 0,
+  userCount = -1;
+const host = Bun.serve({
+  hostname: "127.0.0.1",
+  port: 0,
+  async fetch(request) {
+    const path = new URL(request.url).pathname;
+    if (path === "/api/internal/agent/tools/execute") {
+      assert.equal(request.headers.get("authorization"), `Bearer ${token}`);
+      const body = (await request.json()) as {
+        executionGrant: string;
+        toolKey: string;
+        arguments: Record<string, unknown>;
+      };
+      assert.equal(body.executionGrant, "synthetic-grant");
+      assert.equal(body.toolKey, "system.users.list");
+      const value = await registry.execute(
+        body.toolKey,
+        body.arguments,
+        context,
+      );
+      userCount = (value as { total: number }).total;
+      toolCalls++;
+      return Response.json({ value });
+    }
+    if (path !== "/v1/chat/completions")
+      return new Response(null, { status: 404 });
+    const body = (await request.json()) as {
+      messages: { role: string; content: unknown }[];
+      tools: { function: { name: string } }[];
+    };
+    modelCalls++;
+    assert(
+      JSON.stringify(body.messages).includes("平台工具查询") ||
+        JSON.stringify(body.messages).includes("当前会话实际可见的工具目录"),
+    );
+    const done = body.messages.at(-1)?.role === "tool";
+    const delta = done
+      ? {
+          content: JSON.stringify({
+            answer: `当前授权平台用户共${userCount}名`,
+          }),
+        }
+      : {
+          tool_calls: [
+            {
+              index: 0,
+              id: "synthetic-call",
+              type: "function",
+              function: {
+                name: body.tools[0]!.function.name,
+                arguments: '{"page":1,"pageSize":10}',
+              },
+            },
+          ],
+        };
+    return new Response(
+      `data: ${JSON.stringify({ choices: [{ delta, finish_reason: done ? "stop" : "tool_calls" }] })}\n\ndata: ${JSON.stringify({ choices: [], usage: { prompt_tokens: 100, completion_tokens: 10 } })}\n\ndata: [DONE]\n\n`,
+      { headers: { "content-type": "text/event-stream" } },
+    );
+  },
+});
+const outputRoot =
+  process.env.WINDY_DSH_EXAMPLE_OUTPUT ||
+  resolve(root, ".artifacts/dsh-platform-example");
+await mkdir(outputRoot, { recursive: true });
+const out = resolve(root, "apps/agent-server/.tmp/platform-example");
+await mkdir(out, { recursive: true });
+const entry = resolve(out, "entry.ts");
+await writeFile(
+  entry,
+  `import {startAgentServer} from ${JSON.stringify(resolve(root, "apps/agent-server/main.ts"))}; const a=await startAgentServer(0); console.log(JSON.stringify({port:a.server.address().port})); process.on("SIGTERM",()=>void a.close().then(()=>process.exit(0)));`,
+);
+const built = await Bun.build({
+  entrypoints: [entry],
+  target: "node",
+  outdir: out,
+  external: ["@deepseek-ai/*", "ajv", "zod", "sharp", "ws"],
+});
+assert(built.success, built.logs.map(String).join("\n"));
+const child = Bun.spawn(["node", resolve(out, "entry.js")], {
+  cwd: resolve(root, "apps/agent-server"),
+  env: {
+    ...process.env,
+    AGENT_SERVER_INTERNAL_TOKEN: token,
+    AGENT_RUNTIME_DATABASE_PATH: ":memory:",
+    QWEN_API_URL: `${host.url.origin}/v1`,
+    QWEN_MODEL: "synthetic-model",
+    AI_TOOL_HOST_URL: host.url.origin,
+    AI_PROVIDER_MAX_CONCURRENT_RUNS: "1",
+    AI_PROVIDER_MAX_QUEUE_DEPTH: "0",
+    AGENT_DSH_HOME: resolve(out, "unused-native-home"),
+  },
+  stdout: "pipe",
+  stderr: "inherit",
+});
+try {
+  const reader = child.stdout.getReader();
+  let ready = "";
+  while (!ready.includes("\n")) {
+    const chunk = await reader.read();
+    assert(!chunk.done, "agent startup failed");
+    ready += new TextDecoder().decode(chunk.value);
+  }
+  const port = JSON.parse(ready.split("\n")[0]!).port as number;
+  const remote = new RemoteAgentRuntime({
+    baseUrl: `http://127.0.0.1:${port}`,
+    internalToken: token,
+    toolHostUrl: host.url.origin,
+    compatibilityMode: "require-v1",
+  });
+  const fields = [
+    "instructions",
+    "user-prompt",
+    "tool-definitions",
+    "output-schema",
+    "provider-output",
+    "tool-results",
+  ] as const;
+  const created = await remote.start(
+    {
+      kind: "agent",
+      operationKey: "system.agent.example",
+      input: {},
+      instructions: platformBuiltinAgentSkills[0]!.markdown,
+      userPrompt: "按当前权限查询平台用户数，并形成可核验汇总",
+      inputModalities: ["text"],
+      requiredCapabilities: ["text-generation"],
+      artifacts: [],
+      outputSchemaKey: "system.agent.example.v1",
+      outputSchema: {
+        type: "object",
+        properties: { answer: { type: "string" } },
+        required: ["answer"],
+        additionalProperties: false,
+      },
+      allowedTools: toolDefinitions(modules, ["system.users.list"]),
+      limits: {
+        maxDurationSeconds: 30,
+        maxInputBytes: 65536,
+        maxOutputBytes: 65536,
+      },
+      providerEgress: {
+        mode: "configured-endpoint",
+        deploymentKey: "ai.openai-compatible",
+      },
+      providerDataPolicy: {
+        inputFields: [],
+        envelopeFields: fields.map((field) => ({
+          field,
+          classification: "internal",
+          dlpAction: "reject",
+        })),
+      },
+      toolNetworkPolicy: { mode: "forbidden" },
+      executionGrant: "synthetic-grant",
+      release: {
+        releaseId: "synthetic-release",
+        operationVersion: "1",
+        workflowVersion: "1",
+        promptVersion: "1",
+        routeVersion: "1",
+        outputSchemaVersion: "1",
+        toolSchemaVersion: "1",
+        manifestDigest: "1",
+      },
+      traceId: "synthetic-trace",
+      reporting: { actorId: context.actor.id, actorType: "user" },
+    },
+    "synthetic-platform-example",
+  );
+  const events = await remote.events(
+    created.runId,
+    0,
+    AbortSignal.timeout(45000),
+  );
+  const stream = await events.text();
+  assert.match(stream, /event: run.completed/);
+  assert.match(stream, /event: tool.completed/);
+  const response = await remote.result(created.runId);
+  const result = (await response.json()) as { output: { answer: string } };
+  assert.equal(result.output.answer, `当前授权平台用户共${userCount}名`);
+  assert.equal(toolCalls, 1);
+  assert.equal(modelCalls, 2);
+  assert(userCount > 0);
+  const evidence = {
+    synthetic: true,
+    skill: "windy-tool-query",
+    tool: "system.users.list",
+    modelCalls,
+    toolCalls,
+    userCount,
+    answer: result.output.answer,
+    checks: [
+      "actual-platform-tool-registry",
+      "manifest-schema-forwarding",
+      "official-dsh-loop",
+      "canonical-sse",
+      "typed-output",
+      "provider-synthetic",
+    ],
+  };
+  await writeFile(
+    resolve(outputRoot, "platform-example.json"),
+    JSON.stringify(evidence, null, 2),
+  );
+  console.log(JSON.stringify(evidence));
+  reader.releaseLock();
+} finally {
+  child.kill("SIGTERM");
+  await child.exited;
+  host.stop(true);
+  await rm(out, { recursive: true, force: true });
+}

package/template/apps/server/src/agent/admin-catalog-bootstrap.ts

@@ -0,0 +1,25 @@
+import type { ModuleAiOperationReadinessPortV1 } from "@southwind-ai/server-sdk";
+import type { AgentPlatformRuntimeInput } from "./runtime-bootstrap-input.js";
+import type { composeAgentToolRuntime } from "./runtime-tool-composition.js";
+import { registerAgentAdminCatalogRoutes } from "./tool-catalog-routes.js";
+
+export interface AgentAdminReadinessRef {
+  current?: ModuleAiOperationReadinessPortV1;
+}
+
+export function registerAgentAdminCatalogRuntime(
+  input: AgentPlatformRuntimeInput,
+  tools: ReturnType<typeof composeAgentToolRuntime>,
+  readiness: AgentAdminReadinessRef,
+) {
+  registerAgentAdminCatalogRoutes(input.app, {
+    modules: input.modules,
+    hosts: input.hosts,
+    runtime: input.runtime,
+    registry: tools.toolRegistry,
+    authorizer: tools.routeAuthorizer,
+    runtimeAvailable: () => input.platformConfig.enableAI,
+    operationReadiness: async (operationKey) =>
+      (await readiness.current?.inspect({ operationKey }))?.status === "ready",
+  });
+}

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

@@ -11,13 +11,12 @@ export function registerAgentSessions(input: {
   runtime: ReturnType<typeof createServerRuntime>;
   secret: string;
 }) {
-  if (!input.hosts.agentSessionProviders.length) return;
-  registerAgentSessionRoutesV1(
-    input.app,
-    new AgentSessionFacadeV1(
-      input.hosts,
-      input.runtime,
-      new AgentSessionIdCodecV1(input.secret),
-    ),
+  const facade = new AgentSessionFacadeV1(
+    input.hosts,
+    input.runtime,
+    new AgentSessionIdCodecV1(input.secret),
   );
+  if (!input.hosts.agentSessionProviders.length) return facade;
+  registerAgentSessionRoutesV1(input.app, facade);
+  return facade;
 }

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

@@ -2,6 +2,8 @@ import { randomUUIDv7 } from "bun";
 import {
   MODULE_AGENT_SESSION_SCHEMA_VERSION,
   type ModuleAgentSessionSummaryV1,
+  type ModuleAgentSessionRunReferenceV1,
+  type ModuleAgentSessionWorkflowReferenceV1,
 } from "@southwind-ai/server-sdk";
 import { evaluateAccessGuards } from "../access-guards.js";
 import { auditActor, type RequestGuardContext } from "../guards.js";
@@ -33,12 +35,15 @@ export interface AgentSessionSummaryDtoV1 {
 }
 
 export interface AgentSessionDetailDtoV1 extends AgentSessionSummaryDtoV1 {
+  readonly truncated?: boolean;
   readonly messages: readonly {
     sequence: number;
     role: "user" | "assistant";
     content: string;
     createdAt: string;
   }[];
+  readonly runRefs?: readonly ModuleAgentSessionRunReferenceV1[];
+  readonly workflowRefs?: readonly ModuleAgentSessionWorkflowReferenceV1[];
 }
 
 export class AgentSessionFacadeError extends Error {
@@ -156,6 +161,13 @@ export class AgentSessionFacadeV1 {
             session: {
               ...this.project(entry, actor.id, validated),
               messages: validated.messages,
+              ...(validated.truncated !== undefined
+                ? { truncated: validated.truncated }
+                : {}),
+              ...(validated.runRefs ? { runRefs: validated.runRefs } : {}),
+              ...(validated.workflowRefs
+                ? { workflowRefs: validated.workflowRefs }
+                : {}),
             } satisfies AgentSessionDetailDtoV1,
           };
         } catch (error) {

package/template/apps/server/src/agent/agent-session-validation.ts

@@ -66,6 +66,49 @@ export function validateAgentSessionDetail(
     previousSequence = message.sequence;
   }
   if (totalChars > MAX_TOTAL_MESSAGE_CHARS) invalidProvider();
+  if (value.truncated !== undefined && typeof value.truncated !== "boolean")
+    invalidProvider();
+  const messageSequences = new Set(
+    value.messages.map(({ sequence }) => sequence),
+  );
+  if (value.runRefs !== undefined) {
+    if (!Array.isArray(value.runRefs) || value.runRefs.length > 200)
+      invalidProvider();
+    const ids = new Set<string>();
+    for (const ref of value.runRefs) {
+      if (
+        !ref ||
+        !validText(ref.runId, 200) ||
+        !validText(ref.operationKey, 200) ||
+        !/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(ref.operationKey) ||
+        ids.has(ref.runId) ||
+        (ref.sessionId !== undefined && !validText(ref.sessionId, 200)) ||
+        (ref.turnId !== undefined && !validText(ref.turnId, 200)) ||
+        (ref.workflowRunId !== undefined &&
+          !validText(ref.workflowRunId, 200)) ||
+        (ref.messageSequence !== undefined &&
+          !messageSequences.has(ref.messageSequence))
+      )
+        invalidProvider();
+      ids.add(ref.runId);
+    }
+  }
+  if (value.workflowRefs !== undefined) {
+    if (!Array.isArray(value.workflowRefs) || value.workflowRefs.length > 100)
+      invalidProvider();
+    const ids = new Set<string>();
+    for (const ref of value.workflowRefs) {
+      if (
+        !ref ||
+        !validText(ref.workflowRunId, 200) ||
+        ids.has(ref.workflowRunId) ||
+        (ref.messageSequence !== undefined &&
+          !messageSequences.has(ref.messageSequence))
+      )
+        invalidProvider();
+      ids.add(ref.workflowRunId);
+    }
+  }
   return value;
 }
 

package/template/apps/server/src/agent/dsh-runtime-wire.test.ts

@@ -0,0 +1,33 @@
+import { expect, test } from "bun:test";
+import { loadSystemModules } from "../foundation.js";
+import { toolDefinitions } from "./run-definition-support.js";
+import { parseRemoteStatus } from "./remote-runtime-response.js";
+
+test("Operation将Manifest工具输入Schema传到DSH，缺失Schema时拒绝装配", () => {
+  const modules = loadSystemModules();
+  const [tool] = toolDefinitions(modules, ["system.users.list"]);
+  expect(tool?.inputSchema).toMatchObject({ type: "object" });
+  const missing = modules.map((module) => ({ ...module, jsonSchemas: [] }));
+  expect(() => toolDefinitions(missing, ["system.users.list"])).toThrow(
+    "输入 Schema",
+  );
+});
+
+test("Node运行中状态的null终态不会被误解析为已完成，终态仍必须匹配事件", () => {
+  expect(
+    parseRemoteStatus({
+      runId: "run_synthetic",
+      status: "running",
+      lastSequence: 1,
+      terminalEvent: null,
+    }),
+  ).toEqual({ runId: "run_synthetic", status: "running", lastSequence: 1 });
+  expect(() =>
+    parseRemoteStatus({
+      runId: "run_synthetic",
+      status: "completed",
+      lastSequence: 1,
+      terminalEvent: null,
+    }),
+  ).toThrow();
+});

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

@@ -0,0 +1,41 @@
+import type { ModuleManifest } from "@southwind-ai/modules";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { bootstrapAgentSkills } from "../agent-skills/bootstrap.js";
+import { platformBuiltinAgentSkills } from "../agent-skills/builtins.js";
+import type { AgentSkillService } from "../agent-skills/service.js";
+import type { GovernedToolRegistry } from "./tool-registry.js";
+import type { createServerRuntime } from "../runtime.js";
+
+type Runtime = ReturnType<typeof createServerRuntime>;
+interface Governance {
+  readonly skills: AgentSkillService;
+  tools?: GovernedToolRegistry;
+}
+// Runtime-scoped ownership lets asynchronous platform startup precede Tool Host binding.
+const runtimes = new WeakMap<Runtime, Governance>();
+export async function prepareAgentGovernance(input: {
+  runtime: Runtime;
+  modules: readonly ModuleManifest[];
+  db?: NodePgDatabase;
+}) {
+  const previous = runtimes.get(input.runtime);
+  if (previous) return previous;
+  const governance: Governance = {
+    skills: bootstrapAgentSkills({
+      ...input,
+      tools: () => governance.tools,
+    }),
+  };
+  await governance.skills.registerBuiltins(platformBuiltinAgentSkills, {
+    tenantId: "single-tenant",
+  });
+  runtimes.set(input.runtime, governance);
+  return governance;
+}
+export function bindAgentGovernanceTools(
+  runtime: Runtime,
+  tools: GovernedToolRegistry,
+) {
+  const governance = runtimes.get(runtime);
+  if (governance) governance.tools = tools;
+}

package/template/apps/server/src/agent/operation-catalog.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test";
+import { createServerRuntime } from "../runtime.js";
+import { AgentAdminOperationCatalog } from "./operation-catalog.js";
+import {
+  createRunFacadeFixture,
+  runFacadeManifest,
+} from "./run-facade.test-support.js";
+
+async function fixture(
+  options: { workflowOnly?: boolean; runtimeAvailable?: boolean } = {},
+) {
+  const run = await createRunFacadeFixture(undefined, {
+    workflowOnly: options.workflowOnly,
+  });
+  const module = runFacadeManifest(options.workflowOnly);
+  const catalog = new AgentAdminOperationCatalog({
+    modules: [module],
+    hosts: run.hosts,
+    runtime: run.runtime,
+    runtimeAvailable: () => options.runtimeAvailable ?? true,
+  });
+  return { ...run, catalog, module };
+}
+
+describe("Admin Operation catalogue uses production registration", () => {
+  test("Registered and governed agent exposes real Schema/limits/tools, without preparing or running", async () => {
+    const { catalog, context, prepared, module, remote } = await fixture();
+    const [operation] = await catalog.list(context);
+    expect(operation).toMatchObject({
+      key: "business.answer",
+      module: "business",
+      inputSchemaKey: "business.input.v1",
+      inputSchema: module.jsonSchemas!.find(
+        ({ key }) => key === "business.input.v1",
+      )!.schema,
+      outputSchemaKey: "business.output.v1",
+      allowedToolKeys: ["business.records.list"],
+      limits: module.aiOperations![0]!.limits,
+      selectable: true,
+      availabilityReason: "allowed",
+    });
+    expect(prepared).toHaveLength(0);
+    expect(remote.started).toHaveLength(0);
+  });
+
+  test("Catalog read capability cannot start an unauthorized operation", async () => {
+    const { catalog, context, facade } = await fixture();
+    context.actor.permissionKeys = ["system.agent-debug.read"];
+    const [operation] = await catalog.list(context);
+    expect(operation).toMatchObject({
+      selectable: false,
+      availabilityReason: "permission-denied",
+    });
+    await expect(
+      facade.start(
+        "business.answer",
+        { question: "测试" },
+        "catalog-no-grant",
+        context,
+      ),
+    ).rejects.toMatchObject({ code: "FORBIDDEN" });
+  });
+
+  test("Workflow-only operation and unavailable Runtime are unselectable", async () => {
+    const workflow = await fixture({ workflowOnly: true });
+    expect((await workflow.catalog.list(workflow.context))[0]).toMatchObject({
+      selectable: false,
+      availabilityReason: "workflow-only",
+      launchAuthority: "workflow-artifact",
+    });
+    const unavailable = await fixture({ runtimeAvailable: false });
+    expect(
+      (await unavailable.catalog.list(unavailable.context))[0],
+    ).toMatchObject({
+      selectable: false,
+      availabilityReason: "runtime-unavailable",
+    });
+  });
+
+  test("Declared readiness needs a current successful projection", async () => {
+    const { module, hosts, runtime, context } = await fixture();
+    module.aiOperations![0]!.readiness = {
+      contractVersion: 1,
+      variant: "test",
+      inputModalities: ["text"],
+      outputModalities: ["text"],
+      expectedDeployment: {
+        key: "test",
+        identity: "test",
+        releaseDigest: `sha256:${"a".repeat(64)}`,
+        offersDigest: `sha256:${"b".repeat(64)}`,
+      },
+      minConcurrentRuns: 1,
+      minQueueDepth: 1,
+    };
+    const input = {
+      modules: [module],
+      hosts,
+      runtime,
+      runtimeAvailable: () => true,
+    };
+    expect(
+      (await new AgentAdminOperationCatalog(input).list(context))[0],
+    ).toMatchObject({
+      selectable: false,
+      availabilityReason: "runtime-unavailable",
+    });
+    expect(
+      (
+        await new AgentAdminOperationCatalog({
+          ...input,
+          operationReadiness: async () => false,
+        }).list(context)
+      )[0],
+    ).toMatchObject({
+      selectable: false,
+      availabilityReason: "runtime-unavailable",
+    });
+    expect(
+      (
+        await new AgentAdminOperationCatalog({
+          ...input,
+          operationReadiness: async () => true,
+        }).list(context)
+      )[0],
+    ).toMatchObject({ selectable: true });
+  });
+
+  test("Unregistered handler, unsupported kind, invalid scope fail closed", async () => {
+    const { module, hosts, runtime, context } = await fixture();
+    const catalog = (current = module, currentHosts = hosts) =>
+      new AgentAdminOperationCatalog({
+        modules: [current],
+        hosts: currentHosts,
+        runtime,
+        runtimeAvailable: () => true,
+      });
+    expect(
+      (
+        await catalog(module, { ...hosts, aiOperationHandlers: [] }).list(
+          context,
+        )
+      )[0],
+    ).toMatchObject({
+      selectable: false,
+      availabilityReason: "handler-unavailable",
+    });
+    const speech = structuredClone(module);
+    speech.aiOperations![0]!.kind = "speech";
+    expect((await catalog(speech).list(context))[0]).toMatchObject({
+      selectable: false,
+      availabilityReason: "unsupported-operation",
+    });
+    delete context.actor.scopeContext;
+    expect((await catalog().list(context))[0]).toMatchObject({
+      selectable: false,
+      availabilityReason: "scope-unavailable",
+    });
+  });
+
+  test("Feature closure and missing registered output Schema fail closed", async () => {
+    const { module, hosts, runtime, context } = await fixture();
+    const missingSchema = structuredClone(module);
+    missingSchema.jsonSchemas = missingSchema.jsonSchemas!.filter(
+      ({ key }) => key !== "business.output.v1",
+    );
+    expect(
+      () =>
+        new AgentAdminOperationCatalog({
+          modules: [missingSchema],
+          hosts,
+          runtime,
+          runtimeAvailable: () => true,
+        }),
+    ).toThrow();
+    const disabledModule = structuredClone(module);
+    disabledModule.features = disabledModule.features.map((feature) => ({
+      ...feature,
+      enabled: false,
+    }));
+    const disabledRuntime = createServerRuntime(
+      {},
+      { featureCatalog: disabledModule.features },
+    );
+    const missing = new AgentAdminOperationCatalog({
+      modules: [disabledModule],
+      hosts,
+      runtime: disabledRuntime,
+      runtimeAvailable: () => true,
+    });
+    expect((await missing.list(context))[0]).toMatchObject({
+      selectable: false,
+      availabilityReason: "feature-unavailable",
+    });
+    context.license = { status: "expired", restricted: true };
+    context.licenseEnforced = true;
+    expect((await missing.list(context))[0]).toMatchObject({
+      selectable: false,
+      availabilityReason: "license-unavailable",
+    });
+  });
+});