@kirrosh/zond 0.22.0 → 0.26.0

package/src/cli/commands/api/annotate/lifecycle.ts

@@ -0,0 +1,74 @@
+/**
+ * ARV-187 / lifecycle: parser + expected shape. No prompts inside zond.
+ */
+
+import { z } from "zod";
+import type { ResourcePatch } from "./overlay.ts";
+import type { ResourceSlice } from "./prompts.ts";
+
+const ActionSchema = z.object({
+  endpoint: z.string(),
+  expected_state: z.string(),
+  body: z.record(z.string(), z.unknown()).optional(),
+});
+
+const LifecycleSchema = z.object({
+  field: z.string(),
+  states: z.array(z.string()).min(2),
+  transitions: z.array(z.object({ from: z.string(), to: z.array(z.string()) })),
+  actions: z.record(z.string(), ActionSchema).default({}),
+});
+
+const ResponseSchema = z.object({
+  resource: z.string(),
+  lifecycle: LifecycleSchema.nullable(),
+  rationale: z.string().optional(),
+  confidence: z.enum(["low", "medium", "high"]).optional(),
+});
+
+export const EXPECTED_OUTPUT_SHAPE = {
+  resource: "string (echo input)",
+  lifecycle: {
+    field: "string (response field holding state, e.g. 'status')",
+    states: "string[] (≥2 enum values)",
+    transitions: "[{from: state, to: state[]}]",
+    actions: "{ <verb>: { endpoint: 'METHOD /path', expected_state: state, body?: object } } — return {} for read-only state machines (observation mode walks the list endpoint and asserts observed ⊆ states; cannot verify transitions in this mode)",
+  },
+  rationale: "string (optional)",
+  confidence: "low | medium | high",
+  null_form: "if no observable state machine, return { resource, lifecycle: null }",
+};
+
+export function parseLifecycleResponse(parsed: unknown, slice: ResourceSlice): { patch: ResourcePatch; audit: Record<string, unknown> } {
+  const validated = ResponseSchema.safeParse(parsed);
+  if (!validated.success) {
+    throw new Error(`lifecycle response failed schema for ${slice.resource}: ${validated.error.message}`);
+  }
+  const v = validated.data;
+  if (v.lifecycle == null) {
+    return {
+      patch: { resource: slice.resource },
+      audit: { resource: slice.resource, rationale: v.rationale, confidence: v.confidence, dropped: "no state machine" },
+    };
+  }
+  return {
+    patch: {
+      resource: slice.resource,
+      lifecycle: {
+        field: v.lifecycle.field,
+        states: v.lifecycle.states,
+        transitions: v.lifecycle.transitions,
+        actions: Object.fromEntries(
+          Object.entries(v.lifecycle.actions).map(([name, a]) => [name, {
+            endpoint: a.endpoint,
+            expected_state: a.expected_state,
+            body: a.body,
+          }]),
+        ),
+      },
+    },
+    audit: { resource: slice.resource, rationale: v.rationale, confidence: v.confidence },
+  };
+}
+
+export function isApplicable(_slice: ResourceSlice): boolean { return true; }

package/src/cli/commands/api/annotate/overlay.ts

@@ -0,0 +1,206 @@
+/**
+ * ARV-187: read / merge / write `.api-resources.local.yaml`.
+ *
+ * The annotate command writes _only_ into the `patches:` block. That's
+ * the ARV-169 field-level overlay (see discover.ts:readResourcePatches)
+ * — strictly additive, doesn't touch the upstream `.api-resources.yaml`.
+ * The `extensions:` block (ARV-111, full-resource replacement) is left
+ * intact when we re-write the file, so users can mix annotate-generated
+ * patches with hand-written extensions.
+ *
+ * Idempotent re-annotation: when a patch field already exists in the
+ * overlay, we compare values. Equal → no-op (keep existing). Different
+ * → conflict (surface in diff, requires --yes to overwrite, or --keep
+ * to skip).
+ */
+
+import { join } from "node:path";
+import { writeFile } from "node:fs/promises";
+import type { ResourceYaml } from "../../discover.ts";
+
+export type ResourcePatch = Partial<ResourceYaml> & { resource: string };
+
+export interface LocalOverlayFile {
+  extensions?: ResourceYaml[];
+  patches?: ResourcePatch[];
+  /** Any other top-level keys the user added (preserved on rewrite). */
+  [key: string]: unknown;
+}
+
+const FILENAME = ".api-resources.local.yaml";
+
+export async function readLocalOverlay(apiDir: string): Promise<LocalOverlayFile> {
+  const file = Bun.file(join(apiDir, FILENAME));
+  if (!(await file.exists())) return {};
+  const parsed = Bun.YAML.parse(await file.text());
+  if (!parsed || typeof parsed !== "object") return {};
+  return parsed as LocalOverlayFile;
+}
+
+export async function writeLocalOverlay(apiDir: string, overlay: LocalOverlayFile): Promise<void> {
+  const path = join(apiDir, FILENAME);
+  const header = `# .api-resources.local.yaml — local overlay (ARV-111 / ARV-169 / ARV-187)
+#
+# extensions: full ResourceYaml entries that REPLACE the upstream entry
+#             (by resource name) or ADD a new one.
+# patches:    partial overlay — fields here are merged onto the matching
+#             upstream entry (idempotency / pagination / lifecycle /
+#             readback_diff / seed_body).
+#
+# This file is checked into git. Edit by hand or via \`zond api annotate\`.
+`;
+  // Bun.YAML doesn't have a stringify; use the yaml package.
+  const { stringify } = await import("yaml");
+  const body = stringify(overlay, { lineWidth: 0, defaultStringType: "PLAIN" });
+  await writeFile(path, header + "\n" + body, "utf-8");
+}
+
+export interface MergeConflict {
+  resource: string;
+  field: string;
+  existing: unknown;
+  proposed: unknown;
+}
+
+export interface MergeResult {
+  /** New patches array, with proposed merged over existing. */
+  patches: ResourcePatch[];
+  /** Per-resource per-field conflicts (existing value differs from proposed). */
+  conflicts: MergeConflict[];
+  /** Per-resource per-field accepted changes (new field, or overwrite when force=true). */
+  changes: MergeConflict[];
+}
+
+/**
+ * Merge proposed patches into existing patches.
+ *
+ * Conflict policy:
+ *   - Field absent in existing → added (counts as a `change`).
+ *   - Field present and structurally equal → kept (no-op).
+ *   - Field present and different → if force=true, overwritten and
+ *     counted as both `change` and `conflict`; else kept and counted
+ *     as `conflict` only.
+ *
+ * "Structural equality" uses JSON stringification with stable key order;
+ * good enough for yaml-roundtrip data which is plain JSON-shaped.
+ */
+export function mergePatches(
+  existing: ResourcePatch[],
+  proposed: ResourcePatch[],
+  opts: { force?: boolean } = {},
+): MergeResult {
+  const force = opts.force === true;
+  const byName = new Map<string, ResourcePatch>();
+  for (const p of existing) byName.set(p.resource, deepClone(p));
+  const conflicts: MergeConflict[] = [];
+  const changes: MergeConflict[] = [];
+
+  for (const proposedPatch of proposed) {
+    const name = proposedPatch.resource;
+    const current = byName.get(name) ?? { resource: name };
+    for (const [field, proposedVal] of Object.entries(proposedPatch)) {
+      if (field === "resource") continue;
+      const existingVal = (current as Record<string, unknown>)[field];
+      if (existingVal === undefined) {
+        (current as Record<string, unknown>)[field] = proposedVal;
+        changes.push({ resource: name, field, existing: undefined, proposed: proposedVal });
+        continue;
+      }
+      if (structurallyEqual(existingVal, proposedVal)) continue;
+      // Conflict.
+      conflicts.push({ resource: name, field, existing: existingVal, proposed: proposedVal });
+      if (force) {
+        (current as Record<string, unknown>)[field] = proposedVal;
+        changes.push({ resource: name, field, existing: existingVal, proposed: proposedVal });
+      }
+    }
+    byName.set(name, current);
+  }
+
+  return { patches: [...byName.values()], conflicts, changes };
+}
+
+function structurallyEqual(a: unknown, b: unknown): boolean {
+  return stableJson(a) === stableJson(b);
+}
+
+function stableJson(v: unknown): string {
+  if (v === null || typeof v !== "object") return JSON.stringify(v);
+  if (Array.isArray(v)) return "[" + v.map(stableJson).join(",") + "]";
+  const obj = v as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableJson(obj[k])).join(",") + "}";
+}
+
+function deepClone<T>(v: T): T {
+  return structuredClone(v);
+}
+
+/**
+ * Render a unified, human-readable diff of the changes a merge produced.
+ * Returns "" when there are no changes.
+ *
+ * Format (kept simple so it works in plain stdout, no chalk dep):
+ *
+ *   resource: customers
+ *     + seed_body:
+ *         content_type: application/x-www-form-urlencoded
+ *         body:
+ *           description: 'zond probe customer'
+ *           email: 'probe@example.com'
+ *     ~ idempotency: (conflict — kept existing)
+ *         existing: { header: Idempotency-Key }
+ *         proposed: { header: X-Idempotency }
+ */
+export function renderChangesDiff(result: MergeResult): string {
+  const lines: string[] = [];
+  const byResource = new Map<string, { changes: MergeConflict[]; conflicts: MergeConflict[] }>();
+  for (const c of result.changes) {
+    if (!byResource.has(c.resource)) byResource.set(c.resource, { changes: [], conflicts: [] });
+    byResource.get(c.resource)!.changes.push(c);
+  }
+  for (const c of result.conflicts) {
+    if (!byResource.has(c.resource)) byResource.set(c.resource, { changes: [], conflicts: [] });
+    byResource.get(c.resource)!.conflicts.push(c);
+  }
+  for (const [resource, group] of byResource) {
+    lines.push(`resource: ${resource}`);
+    for (const ch of group.changes) {
+      const op = ch.existing === undefined ? "+" : "~";
+      lines.push(`  ${op} ${ch.field}:`);
+      lines.push(indent(yamlSnippet(ch.proposed), 6));
+    }
+    for (const cf of group.conflicts) {
+      // Skip if already rendered as a change (force=true case).
+      if (group.changes.some((c) => c.field === cf.field && c.existing !== undefined)) continue;
+      lines.push(`  ! ${cf.field}: (conflict — kept existing; pass --yes to overwrite)`);
+      lines.push(`      existing: ${oneLineYaml(cf.existing)}`);
+      lines.push(`      proposed: ${oneLineYaml(cf.proposed)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function yamlSnippet(v: unknown): string {
+  // Reuse yaml package for nested rendering.
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { stringify } = require("yaml") as { stringify: (v: unknown, opts?: unknown) => string };
+    return stringify(v, { lineWidth: 0 }).trimEnd();
+  } catch {
+    return JSON.stringify(v, null, 2);
+  }
+}
+
+function oneLineYaml(v: unknown): string {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+function indent(text: string, n: number): string {
+  const pad = " ".repeat(n);
+  return text.split("\n").map((l) => pad + l).join("\n");
+}

package/src/cli/commands/api/annotate/pagination.ts

@@ -0,0 +1,64 @@
+/**
+ * ARV-187 / pagination: parser + expected shape.
+ */
+
+import { z } from "zod";
+import type { ResourcePatch } from "./overlay.ts";
+import type { ResourceSlice } from "./prompts.ts";
+
+const PaginationSchema = z.object({
+  type: z.enum(["cursor", "page", "offset", "token"]),
+  cursor_param: z.string().optional(),
+  cursor_field: z.string().optional(),
+  has_more_field: z.string().optional(),
+  limit_param: z.string().optional(),
+  default_limit: z.number().int().positive().optional(),
+  items_field: z.string().optional(),
+  page_param: z.string().optional(),
+  start_page: z.number().int().nonnegative().optional(),
+});
+
+const ResponseSchema = z.object({
+  resource: z.string(),
+  pagination: PaginationSchema.nullable(),
+  rationale: z.string().optional(),
+  confidence: z.enum(["low", "medium", "high"]).optional(),
+});
+
+export const EXPECTED_OUTPUT_SHAPE = {
+  resource: "string (echo input)",
+  pagination: {
+    type: "cursor | page | offset | token (cursor and page are implemented; offset/token short-circuit)",
+    cursor_param: "string (optional — only for type=cursor; query param carrying cursor value)",
+    cursor_field: "string (optional — for cursor: next-cursor field; for page: dedupe key across pages; default `id`)",
+    has_more_field: "string (optional — only for type=cursor; boolean response field signalling more)",
+    limit_param: "string (optional — page size param; default `limit` for cursor, `per_page` for page)",
+    default_limit: "integer (optional — probe page size; default 2)",
+    items_field: "string (optional — response field carrying array)",
+    page_param: "string (optional — only for type=page; default `page`)",
+    start_page: "integer (optional — only for type=page; first page number, default 1; some APIs use 0)",
+  },
+  rationale: "string (optional)",
+  confidence: "low | medium | high",
+  null_form: "if list endpoint doesn't paginate, return { resource, pagination: null }",
+};
+
+export function parsePaginationResponse(parsed: unknown, slice: ResourceSlice): { patch: ResourcePatch; audit: Record<string, unknown> } {
+  const validated = ResponseSchema.safeParse(parsed);
+  if (!validated.success) {
+    throw new Error(`pagination response failed schema for ${slice.resource}: ${validated.error.message}`);
+  }
+  const v = validated.data;
+  if (v.pagination == null) {
+    return {
+      patch: { resource: slice.resource },
+      audit: { resource: slice.resource, rationale: v.rationale, confidence: v.confidence, dropped: "endpoint does not paginate" },
+    };
+  }
+  return {
+    patch: { resource: slice.resource, pagination: v.pagination },
+    audit: { resource: slice.resource, rationale: v.rationale, confidence: v.confidence },
+  };
+}
+
+export function isApplicable(slice: ResourceSlice): boolean { return Boolean(slice.endpoints.list); }

package/src/cli/commands/api/annotate/prompts.ts

@@ -0,0 +1,220 @@
+/**
+ * ARV-187: shared prompt utilities — extract per-resource CRUD slices
+ * from a parsed OpenAPI document so each subcommand can build a tight,
+ * cheap prompt for the LLM.
+ *
+ * Per-resource slicing (vs. send-the-whole-spec) is the cost-control
+ * pattern AutoRestTest / KAT both use: keeps each call <4k tokens and
+ * lets us cache by `sha256(slice + prompt_version + model)`.
+ */
+
+import type { OpenAPIV3 } from "openapi-types";
+import type { ResourceYaml } from "../../discover.ts";
+
+export interface ResourceSlice {
+  resource: string;
+  basePath: string;
+  itemPath: string;
+  /** Concrete EndpointInfo-like dump per role with the *relevant* spec
+   *  bits inlined (summary, description, parameters, request schema,
+   *  example bodies, x-codeSamples). Designed to be JSON.stringify'd
+   *  straight into the prompt. */
+  endpoints: {
+    list?: EndpointDump;
+    create?: EndpointDump;
+    read?: EndpointDump;
+    update?: EndpointDump;
+    delete?: EndpointDump;
+  };
+}
+
+export interface EndpointDump {
+  method: string;
+  path: string;
+  operationId?: string;
+  summary?: string;
+  description?: string;
+  parameters?: Array<{
+    name: string;
+    in: string;
+    required?: boolean;
+    description?: string;
+    schema?: unknown;
+  }>;
+  requestBody?: {
+    contentType?: string;
+    description?: string;
+    schema?: unknown;
+    example?: unknown;
+  };
+  responses?: Record<string, { description?: string; schema?: unknown }>;
+  /** Stripe/Redocly convention — prose curl examples live here. */
+  xCodeSamples?: unknown;
+}
+
+/**
+ * Build per-resource CRUD slices from spec + the upstream resource map.
+ * We trust the resource map's endpoint pointers (already computed by
+ * the catalog builder) rather than re-doing path-grouping. Each slice
+ * carries the spec-fragments the LLM needs to reason about that
+ * resource — no more, no less.
+ */
+export function buildResourceSlices(
+  doc: OpenAPIV3.Document,
+  resources: ResourceYaml[],
+): ResourceSlice[] {
+  return resources.map((r) => {
+    const out: ResourceSlice = {
+      resource: r.resource,
+      basePath: r.basePath,
+      itemPath: r.itemPath,
+      endpoints: {},
+    };
+    for (const role of ["list", "create", "read", "update", "delete"] as const) {
+      const label = r.endpoints[role];
+      if (!label) continue;
+      const parsed = parseLabel(label);
+      if (!parsed) continue;
+      const dump = dumpEndpoint(doc, parsed.method, parsed.path);
+      if (dump) out.endpoints[role] = dump;
+    }
+    return out;
+  });
+}
+
+function parseLabel(label: string): { method: string; path: string } | null {
+  const parts = label.trim().split(/\s+/);
+  if (parts.length < 2) return null;
+  return { method: parts[0]!.toLowerCase(), path: parts[1]! };
+}
+
+function dumpEndpoint(doc: OpenAPIV3.Document, method: string, path: string): EndpointDump | null {
+  const pathItem = doc.paths?.[path] as OpenAPIV3.PathItemObject | undefined;
+  if (!pathItem) return null;
+  const op = (pathItem as Record<string, unknown>)[method] as OpenAPIV3.OperationObject | undefined;
+  if (!op) return null;
+
+  const parameters: EndpointDump["parameters"] = [];
+  for (const raw of [...(pathItem.parameters ?? []), ...(op.parameters ?? [])]) {
+    const p = resolveParameter(doc, raw);
+    if (!p) continue;
+    parameters.push({
+      name: p.name,
+      in: p.in,
+      required: p.required,
+      description: truncate(p.description, 240),
+      schema: simplifySchema(p.schema as OpenAPIV3.SchemaObject | undefined),
+    });
+  }
+
+  let requestBody: EndpointDump["requestBody"];
+  if (op.requestBody && !("$ref" in op.requestBody)) {
+    const rb = op.requestBody as OpenAPIV3.RequestBodyObject;
+    const contentEntries = Object.entries(rb.content ?? {});
+    const [ct, media] = contentEntries[0] ?? [];
+    if (media) {
+      requestBody = {
+        contentType: ct,
+        description: truncate(rb.description, 240),
+        schema: simplifySchema(media.schema as OpenAPIV3.SchemaObject | undefined),
+        example: media.example,
+      };
+    }
+  }
+
+  const responses: EndpointDump["responses"] = {};
+  for (const [code, resp] of Object.entries(op.responses ?? {})) {
+    if (resp && !("$ref" in resp)) {
+      const r = resp as OpenAPIV3.ResponseObject;
+      const content = Object.values(r.content ?? {})[0];
+      responses[code] = {
+        description: truncate(r.description, 240),
+        schema: simplifySchema(content?.schema as OpenAPIV3.SchemaObject | undefined),
+      };
+    }
+  }
+
+  return {
+    method: method.toUpperCase(),
+    path,
+    operationId: op.operationId,
+    summary: truncate(op.summary, 240),
+    description: truncate(op.description, 600),
+    parameters: parameters.length > 0 ? parameters : undefined,
+    requestBody,
+    responses: Object.keys(responses).length > 0 ? responses : undefined,
+    xCodeSamples: (op as Record<string, unknown>)["x-codeSamples"],
+  };
+}
+
+/**
+ * Strip refs and nested noise from a schema dump. We don't need full
+ * fidelity — the LLM just needs to know the field names + types + any
+ * descriptions that hint at example values. Drops `additionalProperties`,
+ * collapses `oneOf/anyOf` to the first variant, truncates descriptions.
+ */
+function simplifySchema(s: OpenAPIV3.SchemaObject | undefined): unknown {
+  if (!s) return undefined;
+  if ((s as OpenAPIV3.ReferenceObject).$ref) return { $ref: (s as OpenAPIV3.ReferenceObject).$ref };
+  const out: Record<string, unknown> = {};
+  if (s.type) out.type = s.type;
+  if (s.format) out.format = s.format;
+  if (s.enum) out.enum = s.enum;
+  if (s.example !== undefined) out.example = s.example;
+  if (s.default !== undefined) out.default = s.default;
+  if (s.description) out.description = truncate(s.description, 240);
+  if (s.required) out.required = s.required;
+  if (s.properties) {
+    out.properties = Object.fromEntries(
+      Object.entries(s.properties).map(([k, v]) => [k, simplifySchema(v as OpenAPIV3.SchemaObject)]),
+    );
+  }
+  const asArr = s as OpenAPIV3.ArraySchemaObject;
+  if (asArr.items) out.items = simplifySchema(asArr.items as OpenAPIV3.SchemaObject);
+  const o = s as Record<string, unknown>;
+  if (Array.isArray(o.oneOf) && o.oneOf.length > 0) out.oneOf_first = simplifySchema(o.oneOf[0] as OpenAPIV3.SchemaObject);
+  if (Array.isArray(o.anyOf) && o.anyOf.length > 0) out.anyOf_first = simplifySchema(o.anyOf[0] as OpenAPIV3.SchemaObject);
+  return out;
+}
+
+function truncate(s: string | undefined, n: number): string | undefined {
+  if (!s) return undefined;
+  return s.length > n ? s.slice(0, n) + "…" : s;
+}
+
+/**
+ * Resolve a parameter that may be inline or a $ref. Handles
+ * `#/components/parameters/X` (canonical) and, leniently,
+ * `#/components/headers/X` — some specs (Stripe) keep their
+ * `Idempotency-Key` declaration under `components.headers` and reuse
+ * it as a parameter $ref. Returns null on unresolvable refs.
+ */
+function resolveParameter(
+  doc: OpenAPIV3.Document,
+  raw: OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject,
+): OpenAPIV3.ParameterObject | null {
+  if (!("$ref" in raw)) return raw;
+  const ref = raw.$ref;
+  const paramMatch = ref.match(/^#\/components\/parameters\/(.+)$/);
+  if (paramMatch) {
+    const target = doc.components?.parameters?.[paramMatch[1]!];
+    if (target && !("$ref" in target)) return target as OpenAPIV3.ParameterObject;
+  }
+  const headerMatch = ref.match(/^#\/components\/headers\/(.+)$/);
+  if (headerMatch) {
+    const name = headerMatch[1]!;
+    const target = doc.components?.headers?.[name];
+    if (target && !("$ref" in target)) {
+      const h = target as OpenAPIV3.HeaderObject;
+      return {
+        name,
+        in: "header",
+        required: h.required,
+        description: h.description,
+        schema: h.schema,
+      } as OpenAPIV3.ParameterObject;
+    }
+  }
+  return null;
+}
+

package/src/cli/commands/api/annotate/readback.ts

@@ -0,0 +1,58 @@
+/**
+ * ARV-187 / readback: parser + expected shape.
+ */
+
+import { z } from "zod";
+import type { ResourcePatch } from "./overlay.ts";
+import type { ResourceSlice } from "./prompts.ts";
+
+const ReadbackSchema = z.object({
+  ignore_fields: z.array(z.string()).default([]),
+  write_to_read_map: z.record(z.string(), z.string()).default({}),
+});
+
+const ResponseSchema = z.object({
+  resource: z.string(),
+  readback_diff: ReadbackSchema.nullable(),
+  rationale: z.string().optional(),
+  confidence: z.enum(["low", "medium", "high"]).optional(),
+});
+
+export const EXPECTED_OUTPUT_SHAPE = {
+  resource: "string (echo input)",
+  readback_diff: {
+    ignore_fields: "string[] (write-only fields cross_call_references should ignore)",
+    write_to_read_map: "{ <write_field>: <read_field> } (renames on the read shape)",
+  },
+  rationale: "string (optional)",
+  confidence: "low | medium | high",
+  null_form: "if read shape echoes write shape, return { resource, readback_diff: null }",
+};
+
+export function parseReadbackResponse(parsed: unknown, slice: ResourceSlice): { patch: ResourcePatch; audit: Record<string, unknown> } {
+  const validated = ResponseSchema.safeParse(parsed);
+  if (!validated.success) {
+    throw new Error(`readback response failed schema for ${slice.resource}: ${validated.error.message}`);
+  }
+  const v = validated.data;
+  if (v.readback_diff == null) {
+    return {
+      patch: { resource: slice.resource },
+      audit: { resource: slice.resource, rationale: v.rationale, confidence: v.confidence, dropped: "no drift expected" },
+    };
+  }
+  if ((v.readback_diff.ignore_fields?.length ?? 0) === 0 && Object.keys(v.readback_diff.write_to_read_map ?? {}).length === 0) {
+    return {
+      patch: { resource: slice.resource },
+      audit: { resource: slice.resource, rationale: v.rationale, confidence: v.confidence, dropped: "empty readback hints" },
+    };
+  }
+  return {
+    patch: { resource: slice.resource, readback_diff: v.readback_diff },
+    audit: { resource: slice.resource, rationale: v.rationale, confidence: v.confidence },
+  };
+}
+
+export function isApplicable(slice: ResourceSlice): boolean {
+  return Boolean(slice.endpoints.create && slice.endpoints.read);
+}