@felspar/sdk 0.1.1 → 0.2.0

package/dist/chunks/{chunk-C2VMKF3S.js → chunk-HACK7D24.js}

@@ -505,16 +505,16 @@ async function packContentParts(value) {
 }
 
 // ../schemas/src/draft-application-access.ts
-import { z as z41 } from "zod";
+import { z as z43 } from "zod";
 
 // ../schemas/src/draft-job-handoff.ts
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 
 // ../schemas/src/draft-requirements.ts
-import { z as z34 } from "zod";
+import { z as z37 } from "zod";
 
 // ../schemas/src/draft-required-origins.ts
-import { z as z32 } from "zod";
+import { z as z35 } from "zod";
 
 // ../schemas/src/draft-required-decision.ts
 import { z as z15 } from "zod";
@@ -1513,7 +1513,7 @@ function inspectScoredPolicy(proposal, context3) {
   }
   inspectScoringReferences(scoring, proposal.requirements, context3);
   const ids3 = new Set(rules2.map((rule3) => rule3.id));
-  if (gates.some((id11) => !ids3.has(id11))) {
+  if (gates.some((id12) => !ids3.has(id12))) {
     fail("Unknown mandatory gate rule");
   }
   if (rules2.every((rule3) => gates.includes(rule3.id))) {
@@ -1526,7 +1526,7 @@ function inspectScoredPolicy(proposal, context3) {
     if (isGate ? hasRange || rule3.when.length === 0 : !hasRange) {
       fail("Mandatory gates require fact predicates only; other rules require score ranges");
     }
-    if (rule3.overrides.some((id11) => gates.includes(id11) !== isGate)) {
+    if (rule3.overrides.some((id12) => gates.includes(id12) !== isGate)) {
       fail("Explicit overrides cannot cross mandatory-gate and score-band classes");
     }
     const range2 = rule3.scoreRange;
@@ -1614,19 +1614,19 @@ function hasCycle(rules2) {
   const graph = new Map(rules2.map((item) => [item.id, item.overrides]));
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const hasPathCycle = (id11) => {
-    if (visiting.has(id11)) {
+  const hasPathCycle = (id12) => {
+    if (visiting.has(id12)) {
       return true;
     }
-    if (visited.has(id11)) {
+    if (visited.has(id12)) {
       return false;
     }
-    visiting.add(id11);
-    if ((graph.get(id11) ?? []).some(hasPathCycle)) {
+    visiting.add(id12);
+    if ((graph.get(id12) ?? []).some(hasPathCycle)) {
       return true;
     }
-    visiting.delete(id11);
-    visited.add(id11);
+    visiting.delete(id12);
+    visited.add(id12);
     return false;
   };
   return rules2.some((item) => hasPathCycle(item.id));
@@ -1655,11 +1655,11 @@ function inspectRules(proposal, context3) {
         fail("Undeclared condition key or value");
       }
     }
-    if (item.overrides.some((id11) => id11 === item.id || !ids3.has(id11))) {
+    if (item.overrides.some((id12) => id12 === item.id || !ids3.has(id12))) {
       fail("Unknown or self override");
     }
-    if (item.overrides.some((id11) => {
-      const target = byId.get(id11);
+    if (item.overrides.some((id12) => {
+      const target = byId.get(id12);
       return target !== void 0 && draftRulePriority(target) > draftRulePriority(item);
     })) {
       fail("Override points to a higher priority tier");
@@ -1832,8 +1832,8 @@ function checkExpected(candidate2, context3) {
   }
   unique2(result.observationIds, context3, ["expected", "observationIds"]);
   const observationIds = new Set(candidate2.observations.map((entry2) => entry2.id));
-  for (const [index, id11] of result.observationIds.entries()) {
-    requireBinding2(observationIds.has(id11), context3, {
+  for (const [index, id12] of result.observationIds.entries()) {
+    requireBinding2(observationIds.has(id12), context3, {
       path: ["expected", "observationIds", index],
       message: "Unknown observation"
     });
@@ -2475,17 +2475,17 @@ var DraftRequiredNormalizationSchema = z25.strictObject({
 });
 
 // ../schemas/src/draft-required-context.ts
-import { z as z31 } from "zod";
+import { z as z34 } from "zod";
 
 // ../schemas/src/draft-context-selection.ts
-import { z as z28 } from "zod";
+import { z as z31 } from "zod";
 
 // ../schemas/src/draft-context.ts
 import { z as z27 } from "zod";
 
 // ../schemas/src/draft-primitive-mapping.ts
 import { z as z26 } from "zod";
-var authorityPrimitives = [
+var requiredAuthorityPrimitives = [
   "actors",
   "decision_criteria",
   "source_signals",
@@ -2497,6 +2497,14 @@ var authorityPrimitives = [
   "gaps",
   "evaluations"
 ];
+var authorityPrimitives = [
+  ...requiredAuthorityPrimitives,
+  "subjects"
+];
+function coversAuthorityPrimitives(listed) {
+  const isSized = listed.length >= requiredAuthorityPrimitives.length && listed.length <= authorityPrimitives.length;
+  return isSized && requiredAuthorityPrimitives.every((primitive) => listed.includes(primitive));
+}
 var label = z26.string().trim().min(1).max(2e3);
 var id = z26.string().min(1).max(200);
 var reference5 = z26.discriminatedUnion("kind", [
@@ -2519,7 +2527,8 @@ var kinds = {
   output_contracts: ["outcomes"],
   routing_jobs: ["job"],
   gaps: ["expectation"],
-  evaluations: ["expectation"]
+  evaluations: ["expectation"],
+  subjects: []
 };
 var category = z26.enum(authorityPrimitives);
 var row = z26.discriminatedUnion("status", [
@@ -2535,8 +2544,11 @@ var row = z26.discriminatedUnion("status", [
 var DraftPrimitiveMappingSchema = z26.strictObject({
   schema: z26.literal("felspar.primitive-mapping.draft/v0"),
   caseId: id,
-  rows: z26.array(row).length(authorityPrimitives.length)
+  rows: z26.array(row).min(requiredAuthorityPrimitives.length).max(authorityPrimitives.length)
 }).superRefine((mapping, context3) => {
+  if (!coversAuthorityPrimitives(mapping.rows.map((entry2) => entry2.primitive))) {
+    context3.addIssue({ code: "custom", path: ["rows"], message: "Every category is explicit" });
+  }
   const seen = /* @__PURE__ */ new Set();
   for (const [index, entry2] of mapping.rows.entries()) {
     const path3 = ["rows", index];
@@ -2717,39 +2729,342 @@ var DraftContextInputSchema = z27.strictObject({
   expectedPlanDigest: reference6.shape.contentDigest
 });
 
+// ../schemas/src/draft-pack-subjects.ts
+import { z as z30 } from "zod";
+
+// ../schemas/src/draft-pack-draft-typed.ts
+import { z as z29 } from "zod";
+
+// ../schemas/src/draft-exact-reader.ts
+import { z as z28 } from "zod";
+var exactNumberReaderVersion = "felspar.exact-number/v2";
+var exactDateReaderVersion = "felspar.exact-date/v2";
+var numberStyles = ["1,234.56", "1.234,56", "1 234,56", "1'234.56"];
+var dateOrders = ["unstated", "month-first", "day-first"];
+var knownCurrencies = [
+  "AED",
+  "ARS",
+  "AUD",
+  "BRL",
+  "CAD",
+  "CHF",
+  "CLP",
+  "CNY",
+  "COP",
+  "CZK",
+  "DKK",
+  "EGP",
+  "EUR",
+  "GBP",
+  "HKD",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "ISK",
+  "JPY",
+  "KES",
+  "KRW",
+  "MXN",
+  "MYR",
+  "NGN",
+  "NOK",
+  "NZD",
+  "PEN",
+  "PHP",
+  "PKR",
+  "PLN",
+  "RON",
+  "RUB",
+  "SAR",
+  "SEK",
+  "SGD",
+  "THB",
+  "TRY",
+  "TWD",
+  "UAH",
+  "USD",
+  "VND",
+  "ZAR"
+];
+var knownCurrencySet = new Set(knownCurrencies);
+function isKnownCurrency(code) {
+  return knownCurrencySet.has(code);
+}
+var UnitWordSchema = z28.string().min(1).max(64).regex(/^\p{L}[\p{L}\p{N}'’ -]*\p{L}$|^\p{L}$/u, "Use a word or short phrase");
+var ExactNumberUnitSchema = z28.discriminatedUnion("kind", [
+  z28.strictObject({
+    kind: z28.literal("currency"),
+    code: z28.string().regex(/^[A-Z]{3}$/u).refine(isKnownCurrency, "Not a currency code the reader recognises")
+  }),
+  z28.strictObject({ kind: z28.literal("percent") }),
+  z28.strictObject({
+    kind: z28.literal("count"),
+    words: z28.array(UnitWordSchema).min(1).max(16).refine((words) => hasUniqueValues(words.map((word) => word.toLowerCase())), "Duplicate unit word")
+  })
+]);
+var ExactReaderSchema = z28.discriminatedUnion("version", [
+  z28.strictObject({
+    version: z28.literal(exactNumberReaderVersion),
+    unit: ExactNumberUnitSchema,
+    numberStyle: z28.enum(numberStyles)
+  }),
+  z28.strictObject({
+    version: z28.literal(exactDateReaderVersion),
+    dateOrder: z28.enum(dateOrders)
+  })
+]);
+
+// ../schemas/src/draft-pack-draft-typed.ts
+var draftIdentifier = z29.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/u, "Use lowercase letters, digits, - and _");
+var draftQuote = z29.string().min(1).max(4e3);
+var draftValue = draftIdentifier;
+var dayOffset = z29.number().int().min(-3660).max(3660);
+var PackDraftBoundSchema = z29.union([
+  z29.number(),
+  CalendarDateSchema,
+  z29.strictObject({ question: draftIdentifier, days: dayOffset }),
+  z29.strictObject({ decisionDate: dayOffset })
+]);
+var PackDraftComparisonSchema = z29.strictObject({
+  lt: PackDraftBoundSchema.optional(),
+  lte: PackDraftBoundSchema.optional(),
+  gt: PackDraftBoundSchema.optional(),
+  gte: PackDraftBoundSchema.optional(),
+  eq: PackDraftBoundSchema.optional(),
+  quote: draftQuote
+}).superRefine((value, context3) => {
+  const lower = Number(value.gt !== void 0) + Number(value.gte !== void 0);
+  const upper = Number(value.lt !== void 0) + Number(value.lte !== void 0);
+  const hasEquality = value.eq !== void 0;
+  if (lower + upper + Number(hasEquality) === 0) {
+    context3.addIssue({ code: "custom", message: "Give a bound: lt, lte, gt, gte or eq" });
+  } else if (lower > 1 || upper > 1) {
+    context3.addIssue({ code: "custom", message: "At most one lower and one upper bound" });
+  } else if (hasEquality && lower + upper > 0) {
+    context3.addIssue({ code: "custom", message: "eq stands alone" });
+  }
+});
+var PackDraftConditionSchema = z29.union([
+  draftValue,
+  z29.array(draftValue).min(2).max(64),
+  PackDraftComparisonSchema
+]);
+var PackDraftConditionsSchema = z29.record(draftIdentifier, PackDraftConditionSchema);
+var questionTypes = ["number", "date"];
+var typedQuestionFields = {
+  type: z29.enum(questionTypes).optional(),
+  unit: z29.string().min(1).max(64).optional(),
+  unitWords: z29.array(UnitWordSchema).min(1).max(16).optional(),
+  integer: z29.boolean().optional(),
+  minimum: z29.number().optional(),
+  maximum: z29.number().optional()
+};
+var declaredDateOrders = [
+  "month-first",
+  "day-first"
+];
+var packConventionFields = {
+  numberStyle: z29.enum(numberStyles).optional(),
+  dateOrder: z29.enum(declaredDateOrders).optional(),
+  timeZone: z29.string().min(1).max(64).regex(/^[A-Za-z][A-Za-z0-9_+/-]*$/u, "Use an IANA time zone name, such as Europe/Paris").refine(isTimeZone, "Unknown IANA time zone").optional()
+};
+var caseFactSchema = z29.union([draftValue, z29.number()]);
+var caseDecisionDate = CalendarDateSchema.optional();
+
+// ../schemas/src/draft-pack-subjects.ts
+var subjectMatchRules = ["exact", "case-insensitive"];
+var subjectIdPattern = /^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u;
+var SubjectIdSchema = z30.string().min(1).max(200).regex(subjectIdPattern);
+var packSubjectLimits = {
+  maxSubjects: 16,
+  maxRelationships: 16,
+  maxEscalations: 16,
+  maxRelatedIds: 16
+};
+var relationshipCardinalities = ["one", "many"];
+var identifierText = z30.string().trim().min(1).max(200);
+var relationships = z30.array(z30.strictObject({
+  name: draftIdentifier,
+  subject: draftIdentifier,
+  cardinality: z30.enum(relationshipCardinalities),
+  required: z30.boolean().optional(),
+  definition: draftQuote
+})).max(packSubjectLimits.maxRelationships).refine((rows) => hasUniqueValues(rows.map((row2) => row2.name)), "Duplicate relationship");
+var identityModes = ["provided", "fields", "content", "issued"];
+var identityField = z30.strictObject({
+  name: draftIdentifier,
+  identifier: identifierText,
+  example: SubjectIdSchema,
+  match: z30.enum(subjectMatchRules).optional()
+});
+var PackDraftIdentitySchema = z30.discriminatedUnion("mode", [
+  z30.strictObject({ mode: z30.literal("provided") }),
+  z30.strictObject({
+    mode: z30.literal("fields"),
+    fields: z30.array(identityField).min(1).max(8).refine((rows) => hasUniqueValues(rows.map((row2) => row2.name)), "Duplicate field")
+  }),
+  z30.strictObject({ mode: z30.literal("content"), question: draftIdentifier }),
+  z30.strictObject({ mode: z30.literal("issued") })
+]);
+var PackDraftSubjectSchema = z30.strictObject({
+  id: draftIdentifier,
+  definition: draftQuote,
+  identifier: identifierText.optional(),
+  example: SubjectIdSchema.optional(),
+  identity: PackDraftIdentitySchema.optional(),
+  match: z30.enum(subjectMatchRules).optional(),
+  relationships: relationships.optional()
+});
+var PackDraftSubjectsSchema = z30.array(PackDraftSubjectSchema).min(1).max(packSubjectLimits.maxSubjects).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate subject");
+var PackDraftEscalationsSchema = z30.array(z30.strictObject({ id: draftIdentifier, quote: draftQuote })).min(1).max(packSubjectLimits.maxEscalations).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate escalation");
+var id2 = z30.string().min(1).max(256).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
+var ReleasedSubjectsSchema = z30.strictObject({
+  job: id2,
+  types: z30.array(z30.strictObject({
+    id: id2,
+    entryId: id2,
+    identifier: identifierText.optional(),
+    example: SubjectIdSchema.optional(),
+    match: z30.enum(subjectMatchRules),
+    relationships: z30.array(z30.strictObject({
+      name: id2,
+      subject: id2,
+      cardinality: z30.enum(relationshipCardinalities),
+      required: z30.boolean(),
+      entryId: id2
+    })).max(packSubjectLimits.maxRelationships)
+  })).min(1).max(packSubjectLimits.maxSubjects),
+  about: z30.array(z30.strictObject({ key: id2, relationship: id2 })).max(64)
+});
+var ReleasedEscalationsSchema = z30.strictObject({
+  routes: z30.array(z30.strictObject({ id: id2, entryId: id2 })).min(1).max(packSubjectLimits.maxEscalations),
+  outcomes: z30.array(z30.strictObject({ outcome: id2, escalation: id2 })).max(64),
+  unresolved: id2.nullable(),
+  attemptLimit: id2.nullable()
+});
+var ReleasedJobGuideSchema = z30.strictObject({
+  purpose: id2.nullable(),
+  useWhen: z30.array(id2).max(8),
+  notFor: z30.array(id2).max(8),
+  owner: id2.nullable()
+});
+var ReleasedIdentitySchema = z30.discriminatedUnion("mode", [
+  z30.strictObject({ mode: z30.literal("provided") }),
+  z30.strictObject({
+    mode: z30.literal("fields"),
+    fields: z30.array(z30.strictObject({
+      name: id2,
+      identifier: identifierText,
+      example: SubjectIdSchema,
+      match: z30.enum(subjectMatchRules)
+    })).min(1).max(8)
+  }),
+  z30.strictObject({ mode: z30.literal("content"), question: id2 }),
+  z30.strictObject({ mode: z30.literal("issued") })
+]);
+var relatedId = z30.string().min(1).max(200);
+var HostedRelatedSubjectsSchema = z30.record(z30.string().min(1).max(128), z30.union([relatedId, z30.array(relatedId).min(1).max(packSubjectLimits.maxRelatedIds)])).refine((related) => Object.keys(related).length <= packSubjectLimits.maxRelationships, {
+  message: "too_many_related"
+});
+var escalationTriggers = ["outcome", "unresolved", "attempt_limit"];
+
 // ../schemas/src/draft-context-selection.ts
 var base2 = DraftContextPlanSchema.shape;
 var identifier15 = base2.job;
 var draftOutputPreparationContract = "felspar.structured-output-preparation/v1";
 var draftRequiredEvaluationContract = "felspar.required-evaluations/v1";
-var evaluationValidation = z28.strictObject({
-  contract: z28.literal(draftRequiredEvaluationContract),
-  recipes: z28.array(z28.strictObject({ entryId: identifier15, expectedRecipeDigest: base2.artifactDigest })).min(1).max(8).refine((items) => hasUniqueValues(items.map((item) => item.entryId)), "Duplicate required recipe"),
-  maxRequests: z28.number().int().min(1).max(128),
-  maxTotalBytes: z28.number().int().min(1).max(65536)
+var evaluationValidation = z31.strictObject({
+  contract: z31.literal(draftRequiredEvaluationContract),
+  recipes: z31.array(z31.strictObject({ entryId: identifier15, expectedRecipeDigest: base2.artifactDigest })).min(1).max(8).refine((items) => hasUniqueValues(items.map((item) => item.entryId)), "Duplicate required recipe"),
+  maxRequests: z31.number().int().min(1).max(128),
+  maxTotalBytes: z31.number().int().min(1).max(65536)
 });
 var hasUniqueIds = (values) => hasUniqueValues(values);
-var candidate = z28.strictObject({
+var candidate = z31.strictObject({
   entryId: identifier15,
-  outcomes: z28.array(identifier15).min(1).max(64).refine(hasUniqueIds, "Duplicate outcome"),
-  when: z28.array(z28.strictObject({ key: identifier15, equals: identifier15 })).max(16).refine((clauses2) => hasUniqueIds(clauses2.map((clause) => clause.key)), "Duplicate condition key"),
-  priority: z28.number().int().min(0).max(65535)
+  outcomes: z31.array(identifier15).min(1).max(64).refine(hasUniqueIds, "Duplicate outcome"),
+  when: z31.array(z31.strictObject({ key: identifier15, equals: identifier15 })).max(16).refine((clauses2) => hasUniqueIds(clauses2.map((clause) => clause.key)), "Duplicate condition key"),
+  priority: z31.number().int().min(0).max(65535)
 });
-var group = z28.strictObject({
+var group = z31.strictObject({
   id: identifier15,
-  min: z28.number().int().min(0).max(64),
-  max: z28.number().int().min(0).max(64),
-  candidates: z28.array(candidate).max(64)
+  min: z31.number().int().min(0).max(64),
+  max: z31.number().int().min(0).max(64),
+  candidates: z31.array(candidate).max(64)
 }).refine((value) => value.min <= value.max, "Group minimum exceeds maximum");
-var DraftContextSelectionPlanSchema = z28.strictObject({
-  schema: z28.enum([
+function areSubjectsValid(subjects, isIsolated) {
+  const types = new Set(subjects.types.map((row2) => row2.id));
+  const job = subjects.types.find((row2) => row2.id === subjects.job);
+  const relationships2 = new Set(job?.relationships.map((row2) => row2.name));
+  const isTypeValid = (row2) => {
+    const names = row2.relationships.map((item) => item.name);
+    const isLinked = row2.relationships.every((item) => types.has(item.subject) && isIsolated(item.entryId, "subjects"));
+    return isIsolated(row2.entryId, "subjects") && hasUniqueValues(names) && isLinked;
+  };
+  return [
+    subjects.types.length === types.size,
+    job !== void 0,
+    subjects.types.every((row2) => isTypeValid(row2)),
+    hasUniqueValues(subjects.about.map((row2) => row2.key)),
+    subjects.about.every((row2) => relationships2.has(row2.relationship))
+  ].every(Boolean);
+}
+function areEscalationsValid(escalations, context3) {
+  const { isIsolated, outcomes } = context3;
+  const ids3 = new Set(escalations.routes.map((row2) => row2.id));
+  const named = [escalations.unresolved, escalations.attemptLimit].filter((id12) => id12 !== null);
+  return [
+    ids3.size === escalations.routes.length,
+    escalations.routes.every((row2) => isIsolated(row2.entryId, "routing_jobs")),
+    hasUniqueValues(escalations.outcomes.map((row2) => row2.outcome)),
+    escalations.outcomes.every((row2) => ids3.has(row2.escalation) && outcomes.has(row2.outcome)),
+    named.every((id12) => ids3.has(id12))
+  ].every(Boolean);
+}
+function isGuideValid(guide, isIsolated) {
+  const listed = [
+    ...guide.purpose === null ? [] : [[guide.purpose, "routing_jobs"]],
+    ...guide.useWhen.map((entryId) => [entryId, "boundaries"]),
+    ...guide.notFor.map((entryId) => [entryId, "boundaries"]),
+    ...guide.owner === null ? [] : [[guide.owner, "actors"]]
+  ];
+  return listed.every(([entryId, primitive]) => isIsolated(entryId, primitive));
+}
+function subjectPlanIssues(plan) {
+  const issues = [];
+  const candidates = plan.groups.flatMap((item) => item.candidates);
+  const isIsolated = (entryId, primitive) => {
+    const entry2 = plan.entries.find((row2) => row2.id === entryId);
+    return [
+      entry2?.primitive === primitive,
+      entry2?.dependencies.length === 0,
+      !plan.requiredIds.includes(entryId),
+      candidates.every((row2) => row2.entryId !== entryId),
+      plan.entries.every((row2) => !row2.dependencies.includes(entryId))
+    ].every(Boolean);
+  };
+  const outcomes = new Set(candidates.flatMap((row2) => row2.outcomes));
+  if (plan.subjects !== void 0 && !areSubjectsValid(plan.subjects, isIsolated)) {
+    issues.push("Subjects must be isolated subject entries whose references resolve");
+  }
+  if (plan.escalations !== void 0 && !areEscalationsValid(plan.escalations, { isIsolated, outcomes })) {
+    issues.push("Escalations must be isolated routing entries whose references resolve");
+  }
+  if (plan.guide !== void 0 && !isGuideValid(plan.guide, isIsolated)) {
+    issues.push("The job guide must be isolated entries of its kind");
+  }
+  return issues;
+}
+var DraftContextSelectionPlanSchema = z31.strictObject({
+  schema: z31.enum([
     "felspar.context-selection.draft/v0",
     "felspar.context-selection.draft/v1",
     "felspar.context-selection.draft/v2"
   ]),
   evaluationValidation: evaluationValidation.optional(),
-  outputValidation: z28.strictObject({
-    contract: z28.literal(draftOutputPreparationContract),
+  outputValidation: z31.strictObject({
+    contract: z31.literal(draftOutputPreparationContract),
     entryId: identifier15,
     expectedContractDigest: base2.artifactDigest
   }).optional(),
@@ -2759,18 +3074,25 @@ var DraftContextSelectionPlanSchema = z28.strictObject({
   trustDomain: base2.trustDomain,
   outputSurface: identifier15,
   unresolvedGuidanceEntryId: identifier15.optional(),
-  attempts: z28.strictObject({
-    max: z28.number().int().min(1).max(10),
-    withProgress: z28.number().int().min(1).max(10)
+  attempts: z31.strictObject({
+    max: z31.number().int().min(1).max(10),
+    withProgress: z31.number().int().min(1).max(10)
   }).refine((value) => value.withProgress >= value.max, "withProgress below max").optional(),
   entries: base2.entries,
   requiredIds: base2.requiredIds,
   budget: base2.budget,
-  groups: z28.array(group).min(1).max(8)
+  groups: z31.array(group).min(1).max(8),
+  subjects: ReleasedSubjectsSchema.optional(),
+  escalations: ReleasedEscalationsSchema.optional(),
+  guide: ReleasedJobGuideSchema.optional(),
+  caseIdentity: ReleasedIdentitySchema.optional()
 }).superRefine((plan, context3) => {
   if (context3.issues.length > 0) {
     return;
   }
+  for (const message of subjectPlanIssues(plan)) {
+    context3.addIssue({ code: "custom", message });
+  }
   if (plan.schema !== "felspar.context-selection.draft/v0" !== Boolean(plan.outputValidation)) {
     context3.addIssue({
       code: "custom",
@@ -2787,7 +3109,7 @@ var DraftContextSelectionPlanSchema = z28.strictObject({
   if (candidateIds.length > 64 || !hasUniqueIds(candidateIds) || !hasUniqueIds(plan.groups.map((item) => item.id)) || !hasUniqueIds(plan.entries.map((item) => item.id))) {
     context3.addIssue({ code: "custom", message: "Duplicate identities or too many candidates" });
   }
-  if (plan.requiredIds.some((id11) => candidateIds.includes(id11))) {
+  if (plan.requiredIds.some((id12) => candidateIds.includes(id12))) {
     context3.addIssue({ code: "custom", message: "Global required root cannot be a candidate" });
   }
   const guidanceId = plan.unresolvedGuidanceEntryId;
@@ -2810,7 +3132,7 @@ var DraftContextSelectionPlanSchema = z28.strictObject({
     });
   }
 });
-var DraftContextSelectionInputSchema = z28.strictObject({
+var DraftContextSelectionInputSchema = z31.strictObject({
   artifact: DraftContextInputSchema.shape.artifact,
   decision: DraftContextInputSchema.shape.decision,
   plan: DraftContextSelectionPlanSchema,
@@ -2819,22 +3141,22 @@ var DraftContextSelectionInputSchema = z28.strictObject({
 });
 
 // ../schemas/src/draft-origin-gates.ts
-import { z as z30 } from "zod";
+import { z as z33 } from "zod";
 
 // ../schemas/src/draft-normalized-context.ts
-import { z as z29 } from "zod";
+import { z as z32 } from "zod";
 var request = DraftCompiledRequestSchema.shape;
 var context = DraftContextSelectionInputSchema.shape;
 var compilation = DraftCandidateCompilationVerificationSchema.shape;
 var draftNormalizedContextContract = "felspar.normalized-context-run/v1";
-var DraftNormalizedContextInputSchema = z29.strictObject({
+var DraftNormalizedContextInputSchema = z32.strictObject({
   normalization: DraftNormalizedEvidenceSchema,
-  compilation: z29.strictObject({
+  compilation: z32.strictObject({
     artifact: compilation.artifact,
     binding: compilation.binding,
     fixtures: compilation.fixtures
   }),
-  request: z29.strictObject({
+  request: z32.strictObject({
     expectedArtifactDigest: request.expectedArtifactDigest,
     job: request.job,
     trustDomain: request.trustDomain,
@@ -2845,10 +3167,10 @@ var DraftNormalizedContextInputSchema = z29.strictObject({
   requestedSurface: context.requestedSurface
 });
 var digest11 = context.expectedPlanDigest;
-var DraftNormalizedContextReceiptBodySchema = z29.strictObject({
-  schema: z29.literal("felspar.normalized-context-receipt.draft/v0"),
-  authority: z29.literal("unapproved"),
-  runtimeContract: z29.literal(draftNormalizedContextContract),
+var DraftNormalizedContextReceiptBodySchema = z32.strictObject({
+  schema: z32.literal("felspar.normalized-context-receipt.draft/v0"),
+  authority: z32.literal("unapproved"),
+  runtimeContract: z32.literal(draftNormalizedContextContract),
   inputDigest: digest11,
   resultDigest: digest11,
   artifactDigest: digest11,
@@ -2856,7 +3178,7 @@ var DraftNormalizedContextReceiptBodySchema = z29.strictObject({
   decisionRunDigest: digest11.nullable(),
   selectionPlanDigest: digest11,
   capsuleDigest: digest11.nullable(),
-  status: z29.enum(["ready", "blocked"])
+  status: z32.enum(["ready", "blocked"])
 });
 var DraftNormalizedContextReceiptSchema = DraftNormalizedContextReceiptBodySchema.extend({
   receiptDigest: digest11
@@ -2866,25 +3188,25 @@ var DraftNormalizedContextReceiptSchema = DraftNormalizedContextReceiptBodySchem
 var DraftOriginBoundCompilationSchema = DraftSourceBoundCompilationSchema.extend({
   origins: DraftCandidateOriginsSchema
 });
-var DraftContextOriginsSchema = z30.strictObject({
-  schema: z30.literal("felspar.context-origins.draft/v0"),
+var DraftContextOriginsSchema = z33.strictObject({
+  schema: z33.literal("felspar.context-origins.draft/v0"),
   planDigest: DraftContextSelectionPlanSchema.shape.artifactDigest,
-  entries: z30.array(z30.strictObject({
+  entries: z33.array(z33.strictObject({
     entryId: DraftContextSelectionPlanSchema.shape.job,
     origin: DraftAuthorityOriginSchema
   })).max(64)
 });
-var DraftContextOriginInputSchema = z30.strictObject({
+var DraftContextOriginInputSchema = z33.strictObject({
   plan: DraftContextSelectionPlanSchema,
   origins: DraftContextOriginsSchema,
   bundle: DraftSourceTextBundleSchema,
   compositions: DraftSourceCompositionsSchema
 });
-var DraftOriginBoundContextInputSchema = z30.strictObject({
-  schema: z30.literal("felspar.origin-bound-context.draft/v0"),
+var DraftOriginBoundContextInputSchema = z33.strictObject({
+  schema: z33.literal("felspar.origin-bound-context.draft/v0"),
   input: DraftNormalizedContextInputSchema,
   origins: DraftCandidateOriginsSchema,
-  context: z30.strictObject({
+  context: z33.strictObject({
     origins: DraftContextOriginsSchema,
     bundle: DraftSourceTextBundleSchema
   })
@@ -2893,9 +3215,9 @@ var DraftOriginBoundContextInputSchema = z30.strictObject({
 // ../schemas/src/draft-required-context.ts
 var context2 = DraftContextSelectionInputSchema.shape;
 var draftRequiredContextContract = "felspar.required-context-run/v1";
-var DraftRequiredContextInputSchema = z31.strictObject({
+var DraftRequiredContextInputSchema = z34.strictObject({
   normalization: DraftRequiredNormalizationSchema,
-  compilation: z31.strictObject({
+  compilation: z34.strictObject({
     artifact: DraftCompiledArtifactSchema,
     fixtures: DraftAnyCompilationSchema.shape.fixtures
   }),
@@ -2906,8 +3228,8 @@ var DraftRequiredContextInputSchema = z31.strictObject({
   contextOrigins: DraftContextOriginInputSchema.omit({ plan: true })
 });
 var DraftRequiredContextReceiptBodySchema = DraftNormalizedContextReceiptBodySchema.extend({
-  schema: z31.literal("felspar.required-context-receipt.draft/v0"),
-  runtimeContract: z31.literal(draftRequiredContextContract),
+  schema: z34.literal("felspar.required-context-receipt.draft/v0"),
+  runtimeContract: z34.literal(draftRequiredContextContract),
   compilationDigest: context2.expectedPlanDigest,
   contextOriginsDigest: context2.expectedPlanDigest
 });
@@ -2919,12 +3241,12 @@ var DraftRequiredContextReceiptSchema = DraftRequiredContextReceiptBodySchema.ex
 var normalization = DraftRequiredNormalizationSchema.shape;
 var packet = DraftNormalizedEvidenceSchema.shape;
 var digest12 = packet.expectedSemanticBundleDigest;
-var path2 = z32.string().max(512).regex(/^\/authority\//u);
-var DraftRequiredAuthoritySchema = z32.strictObject({
+var path2 = z35.string().max(512).regex(/^\/authority\//u);
+var DraftRequiredAuthoritySchema = z35.strictObject({
   proposal: normalization.proposal,
-  normalizationContract: z32.literal(conditionalNormalizationContract).optional(),
+  normalizationContract: z35.literal(conditionalNormalizationContract).optional(),
   bindings: normalization.bindings,
-  materials: z32.array(z32.strictObject({
+  materials: z35.array(z35.strictObject({
     key: normalization.bindings.element.shape.key,
     semantics: packet.semantics,
     evaluatorContract: packet.evaluatorContract
@@ -2951,12 +3273,12 @@ var DraftRequiredAuthoritySchema = z32.strictObject({
     });
   }
 });
-var DraftRequiredOriginsSchema = z32.strictObject({
-  schema: z32.literal("felspar.required-origins.draft/v0"),
+var DraftRequiredOriginsSchema = z35.strictObject({
+  schema: z35.literal("felspar.required-origins.draft/v0"),
   authorityDigest: digest12,
-  entries: z32.array(z32.strictObject({ path: path2, origin: DraftAuthorityOriginSchema })).max(1024)
+  entries: z35.array(z35.strictObject({ path: path2, origin: DraftAuthorityOriginSchema })).max(1024)
 });
-var DraftRequiredOriginInputSchema = z32.strictObject({
+var DraftRequiredOriginInputSchema = z35.strictObject({
   catalog: DraftRequiredAuthoritySchema,
   origins: DraftRequiredOriginsSchema,
   expectedAuthorityDigest: digest12,
@@ -2964,19 +3286,19 @@ var DraftRequiredOriginInputSchema = z32.strictObject({
   bundle: DraftSourceTextBundleSchema,
   compositions: DraftSourceCompositionsSchema
 });
-var DraftCoveredRequiredContextSchema = z32.strictObject({
+var DraftCoveredRequiredContextSchema = z35.strictObject({
   authority: DraftRequiredOriginInputSchema,
   input: DraftRequiredContextInputSchema
 });
-var DraftCoveredRequiredReceiptBodySchema = z32.strictObject({
-  schema: z32.literal("felspar.covered-required-receipt.draft/v0"),
-  authority: z32.literal("unapproved"),
+var DraftCoveredRequiredReceiptBodySchema = z35.strictObject({
+  schema: z35.literal("felspar.covered-required-receipt.draft/v0"),
+  authority: z35.literal("unapproved"),
   inputDigest: digest12,
   resultDigest: digest12,
   authorityDigest: digest12,
   originsDigest: digest12,
   capsuleDigest: digest12.nullable(),
-  status: z32.enum(["ready", "blocked"])
+  status: z35.enum(["ready", "blocked"])
 });
 var DraftCoveredRequiredReceiptSchema = DraftCoveredRequiredReceiptBodySchema.extend({
   receiptDigest: digest12
@@ -2988,20 +3310,20 @@ var DraftRequiredPreparationSchema = DraftRequiredContextInputSchema.omit({
   authority: DraftRequiredOriginInputSchema,
   expectedArtifactDigest: digest12
 });
-var DraftPreparedRequiredReadSchema = z32.strictObject({
+var DraftPreparedRequiredReadSchema = z35.strictObject({
   request: DraftRequiredContextInputSchema.shape.request,
   normalizations: normalization.normalizations
 });
 
 // ../schemas/src/draft-supplied-context.ts
-import { z as z33 } from "zod";
+import { z as z36 } from "zod";
 var draftSuppliedContextContract = "felspar.supplied-context-run/v1";
 var draftSuppliedContextPartsContract = "felspar.supplied-context-run/v2";
-var DraftSuppliedAuthoritySchema = z33.strictObject({
+var DraftSuppliedAuthoritySchema = z36.strictObject({
   proposal: DraftRequiredProposalSchema,
-  route: z33.strictObject({
-    kind: z33.literal("supplied_values"),
-    contract: z33.literal("felspar.declared-scalar-observations/v1")
+  route: z36.strictObject({
+    kind: z36.literal("supplied_values"),
+    contract: z36.literal("felspar.declared-scalar-observations/v1")
   })
 });
 var DraftSuppliedOriginInputSchema = DraftRequiredOriginInputSchema.extend({
@@ -3010,7 +3332,7 @@ var DraftSuppliedOriginInputSchema = DraftRequiredOriginInputSchema.extend({
 var DraftSuppliedContextSchema = DraftRequiredContextInputSchema.omit({
   normalization: true
 }).extend({
-  schema: z33.literal("felspar.supplied-context.draft/v0"),
+  schema: z36.literal("felspar.supplied-context.draft/v0"),
   authority: DraftSuppliedOriginInputSchema,
   evidence: DraftRequiredDecisionSchema.shape.evidence
 });
@@ -3018,7 +3340,7 @@ var DraftSuppliedPreparationSchema = DraftSuppliedContextSchema.omit({
   request: true,
   evidence: true
 }).extend({
-  schema: z33.literal("felspar.supplied-preparation.draft/v0"),
+  schema: z36.literal("felspar.supplied-preparation.draft/v0"),
   expectedArtifactDigest: DraftSuppliedContextSchema.shape.request.shape.expectedArtifactDigest
 });
 var DraftPreparedSuppliedRequestSchema = DraftSuppliedContextSchema.pick({
@@ -3026,186 +3348,106 @@ var DraftPreparedSuppliedRequestSchema = DraftSuppliedContextSchema.pick({
   evidence: true
 });
 var DraftSuppliedReceiptBodySchema = DraftCoveredRequiredReceiptBodySchema.extend({
-  schema: z33.literal("felspar.supplied-context-receipt.draft/v0"),
-  runtimeContract: z33.enum([draftSuppliedContextContract, draftSuppliedContextPartsContract])
+  schema: z36.literal("felspar.supplied-context-receipt.draft/v0"),
+  runtimeContract: z36.enum([draftSuppliedContextContract, draftSuppliedContextPartsContract])
 });
 var DraftSuppliedReceiptSchema = DraftSuppliedReceiptBodySchema.extend({
   receiptDigest: DraftCoveredRequiredReceiptBodySchema.shape.inputDigest
 }).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only ready delivery has a capsule digest");
 
 // ../schemas/src/draft-requirements.ts
-var request2 = z34.strictObject({
-  schema: z34.literal("felspar.requirements-request.draft/v0"),
+var request2 = z37.strictObject({
+  schema: z37.literal("felspar.requirements-request.draft/v0"),
   job: DraftRequiredProposalSchema.shape.job,
   trustDomain: DraftRequiredProposalSchema.shape.trustDomain,
-  maxResponseBytes: z34.number().int().min(1).max(1048576)
+  maxResponseBytes: z37.number().int().min(1).max(1048576)
 });
-var DraftRequirementsRequestSchema = z34.discriminatedUnion("route", [
+var DraftRequirementsRequestSchema = z37.discriminatedUnion("route", [
   request2.extend({
-    route: z34.literal("normalized"),
+    route: z37.literal("normalized"),
     authority: DraftRequiredOriginInputSchema
   }),
   request2.extend({
-    route: z34.literal("supplied"),
+    route: z37.literal("supplied"),
     authority: DraftSuppliedOriginInputSchema
   })
 ]);
 
 // ../schemas/src/draft-typed-normalization.ts
-import { z as z37 } from "zod";
-
-// ../schemas/src/draft-exact-reader.ts
-import { z as z35 } from "zod";
-var exactNumberReaderVersion = "felspar.exact-number/v2";
-var exactDateReaderVersion = "felspar.exact-date/v2";
-var numberStyles = ["1,234.56", "1.234,56", "1 234,56", "1'234.56"];
-var dateOrders = ["unstated", "month-first", "day-first"];
-var knownCurrencies = [
-  "AED",
-  "ARS",
-  "AUD",
-  "BRL",
-  "CAD",
-  "CHF",
-  "CLP",
-  "CNY",
-  "COP",
-  "CZK",
-  "DKK",
-  "EGP",
-  "EUR",
-  "GBP",
-  "HKD",
-  "HUF",
-  "IDR",
-  "ILS",
-  "INR",
-  "ISK",
-  "JPY",
-  "KES",
-  "KRW",
-  "MXN",
-  "MYR",
-  "NGN",
-  "NOK",
-  "NZD",
-  "PEN",
-  "PHP",
-  "PKR",
-  "PLN",
-  "RON",
-  "RUB",
-  "SAR",
-  "SEK",
-  "SGD",
-  "THB",
-  "TRY",
-  "TWD",
-  "UAH",
-  "USD",
-  "VND",
-  "ZAR"
-];
-var knownCurrencySet = new Set(knownCurrencies);
-function isKnownCurrency(code) {
-  return knownCurrencySet.has(code);
-}
-var UnitWordSchema = z35.string().min(1).max(64).regex(/^\p{L}[\p{L}\p{N}'’ -]*\p{L}$|^\p{L}$/u, "Use a word or short phrase");
-var ExactNumberUnitSchema = z35.discriminatedUnion("kind", [
-  z35.strictObject({
-    kind: z35.literal("currency"),
-    code: z35.string().regex(/^[A-Z]{3}$/u).refine(isKnownCurrency, "Not a currency code the reader recognises")
-  }),
-  z35.strictObject({ kind: z35.literal("percent") }),
-  z35.strictObject({
-    kind: z35.literal("count"),
-    words: z35.array(UnitWordSchema).min(1).max(16).refine((words) => hasUniqueValues(words.map((word) => word.toLowerCase())), "Duplicate unit word")
-  })
-]);
-var ExactReaderSchema = z35.discriminatedUnion("version", [
-  z35.strictObject({
-    version: z35.literal(exactNumberReaderVersion),
-    unit: ExactNumberUnitSchema,
-    numberStyle: z35.enum(numberStyles)
-  }),
-  z35.strictObject({
-    version: z35.literal(exactDateReaderVersion),
-    dateOrder: z35.enum(dateOrders)
-  })
-]);
+import { z as z39 } from "zod";
 
 // ../schemas/src/draft-scalar-selection.ts
-import { z as z36 } from "zod";
+import { z as z38 } from "zod";
 var scalarSelectionConfidence = "candidate-selected-probability/v1";
-var DraftScalarParserSchema = z36.discriminatedUnion("version", [
-  z36.strictObject({
-    version: z36.literal("iso-currency-decimal/v1"),
-    currency: z36.string().regex(/^[A-Z]{3}$/u)
+var DraftScalarParserSchema = z38.discriminatedUnion("version", [
+  z38.strictObject({
+    version: z38.literal("iso-currency-decimal/v1"),
+    currency: z38.string().regex(/^[A-Z]{3}$/u)
   }),
-  z36.strictObject({ version: z36.literal("iso-calendar-date/v1") })
+  z38.strictObject({ version: z38.literal("iso-calendar-date/v1") })
 ]);
-var digest13 = z36.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var candidateId = z36.string().regex(/^candidate_(?:\d|[1-5]\d|6[0-3])$/u);
-var DraftScalarSelectionSchema = z36.strictObject({
-  schema: z36.literal("felspar.scalar-candidate-selection.draft/v0"),
+var digest13 = z38.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var candidateId = z38.string().regex(/^candidate_(?:\d|[1-5]\d|6[0-3])$/u);
+var DraftScalarSelectionSchema = z38.strictObject({
+  schema: z38.literal("felspar.scalar-candidate-selection.draft/v0"),
   requestDigest: digest13,
   parser: DraftScalarParserSchema,
-  sourceText: z36.string().min(1).max(262144),
+  sourceText: z38.string().min(1).max(262144),
   candidatesDigest: digest13,
   selectedCandidateId: candidateId.nullable(),
-  probabilities: z36.array(z36.strictObject({ value: candidateId, probability: z36.number().min(0).max(1) })).min(1).max(64),
-  abstentionProbability: z36.number().min(0).max(1),
-  providerConfidence: z36.number().min(0).max(1)
+  probabilities: z38.array(z38.strictObject({ value: candidateId, probability: z38.number().min(0).max(1) })).min(1).max(64),
+  abstentionProbability: z38.number().min(0).max(1),
+  providerConfidence: z38.number().min(0).max(1)
 });
 
 // ../schemas/src/draft-typed-normalization.ts
-var identifier16 = z37.string().min(1).max(200).regex(/\S/u);
+var identifier16 = z39.string().min(1).max(200).regex(/\S/u);
 var digest14 = DraftNormalizedEvidenceSchema.shape.expectedSemanticBundleDigest;
 var { evaluator: evaluator2 } = DraftNormalizedEvidenceSchema.shape.evaluatorContract.shape;
 var reference7 = DraftEvidenceValidationSchema.shape.observationChecks.shape.scope.shape.observations.element.shape.evidence;
 var key2 = { key: identifier16 };
-var scalarRecipe = z37.strictObject({
+var scalarRecipe = z39.strictObject({
   ...key2,
-  kind: z37.literal("scalar"),
+  kind: z39.literal("scalar"),
   definitionDigest: digest14,
   id: identifier16,
   version: identifier16,
-  instructions: z37.string().min(1).max(16384).regex(/\S/u),
+  instructions: z39.string().min(1).max(16384).regex(/\S/u),
   evaluator: evaluator2,
   calibration: DraftNormalizedEvidenceSchema.shape.evaluatorContract.shape.calibration,
-  confidenceContract: z37.enum(["declared-scalar-confidence/v1", scalarSelectionConfidence]),
+  confidenceContract: z39.enum(["declared-scalar-confidence/v1", scalarSelectionConfidence]),
   parser: DraftScalarParserSchema.optional(),
-  minimumConfidence: z37.number().gt(0).max(1),
+  minimumConfidence: z39.number().gt(0).max(1),
   reader: ExactReaderSchema.optional()
 }).refine((recipe2) => recipe2.confidenceContract === scalarSelectionConfidence === Boolean(recipe2.parser), "A candidate-selection recipe requires its parser; legacy recipes cannot carry a parser");
-var DraftInterpretationManifestSchema = z37.strictObject({
-  schema: z37.literal("felspar.typed-interpretation-manifest.draft/v0"),
-  authority: z37.literal("unapproved"),
+var DraftInterpretationManifestSchema = z39.strictObject({
+  schema: z39.literal("felspar.typed-interpretation-manifest.draft/v0"),
+  authority: z39.literal("unapproved"),
   authorityDigest: digest14,
-  recipes: z37.array(z37.discriminatedUnion("kind", [
+  recipes: z39.array(z39.discriminatedUnion("kind", [
     scalarRecipe,
-    z37.strictObject({
+    z39.strictObject({
       ...key2,
-      kind: z37.literal("enum"),
+      kind: z39.literal("enum"),
       semanticBundleDigest: digest14,
       evaluatorContractDigest: digest14
     })
   ])).min(1).max(64).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate recipe key")
 });
-var judgment2 = z37.discriminatedUnion("status", [
-  z37.strictObject({
-    status: z37.literal("evaluated"),
+var judgment2 = z39.discriminatedUnion("status", [
+  z39.strictObject({
+    status: z39.literal("evaluated"),
     value: DraftEvidenceValueSchema,
     unit: identifier16.optional(),
-    confidence: z37.number().min(0).max(1)
+    confidence: z39.number().min(0).max(1)
   }),
-  z37.strictObject({ status: z37.enum(["abstained", "timeout", "malformed", "review_required"]) })
+  z39.strictObject({ status: z39.enum(["abstained", "timeout", "malformed", "review_required"]) })
 ]);
-var scalarPacket = z37.strictObject({
+var scalarPacket = z39.strictObject({
   ...key2,
-  kind: z37.literal("scalar"),
-  evidence: z37.strictObject(DraftEvidenceValidationSchema.shape).omit({ results: true }),
-  records: z37.array(z37.strictObject({
+  kind: z39.literal("scalar"),
+  evidence: z39.strictObject(DraftEvidenceValidationSchema.shape).omit({ results: true }),
+  records: z39.array(z39.strictObject({
     observationId: identifier16,
     evidence: reference7,
     recipeDigest: digest14,
@@ -3215,31 +3457,31 @@ var scalarPacket = z37.strictObject({
     selection: DraftScalarSelectionSchema.optional()
   })).max(64)
 });
-var DraftTypedNormalizationSchema = z37.strictObject({
-  schema: z37.literal("felspar.typed-normalization.draft/v0"),
+var DraftTypedNormalizationSchema = z39.strictObject({
+  schema: z39.literal("felspar.typed-normalization.draft/v0"),
   invocation: DraftSuppliedContextSchema.omit({ evidence: true }),
   manifest: DraftInterpretationManifestSchema,
   expectedManifestDigest: digest14,
-  packets: z37.array(z37.discriminatedUnion("kind", [
+  packets: z39.array(z39.discriminatedUnion("kind", [
     scalarPacket,
-    z37.strictObject({ ...key2, kind: z37.literal("enum"), input: DraftNormalizedEvidenceSchema })
+    z39.strictObject({ ...key2, kind: z39.literal("enum"), input: DraftNormalizedEvidenceSchema })
   ])).max(64).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate packet key")
 });
 var DraftLayeredNormalizationSchema = DraftTypedNormalizationSchema.extend({
-  schema: z37.literal("felspar.typed-normalization.draft/v1")
+  schema: z39.literal("felspar.typed-normalization.draft/v1")
 });
 
 // ../schemas/src/draft-context-receipt.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 var digest15 = DraftContextSelectionInputSchema.shape.expectedPlanDigest;
 var { evaluationTime } = DraftContextSelectionInputSchema.shape.decision.shape.scope.shape;
 var draftContextRuntimeContract = "felspar.context-selection-run/v1";
-var DraftContextReceiptBodySchema = z38.strictObject({
-  schema: z38.literal("felspar.context-receipt.draft/v0"),
-  authority: z38.literal("unapproved"),
-  stage: z38.literal("draft-context-selection"),
-  runtimeContract: z38.literal(draftContextRuntimeContract),
-  identityFormat: z38.literal("felspar.json-content-identity/v1"),
+var DraftContextReceiptBodySchema = z40.strictObject({
+  schema: z40.literal("felspar.context-receipt.draft/v0"),
+  authority: z40.literal("unapproved"),
+  stage: z40.literal("draft-context-selection"),
+  runtimeContract: z40.literal(draftContextRuntimeContract),
+  identityFormat: z40.literal("felspar.json-content-identity/v1"),
   evaluationTime,
   inputDigest: digest15,
   artifactDigest: digest15,
@@ -3247,143 +3489,143 @@ var DraftContextReceiptBodySchema = z38.strictObject({
   decisionRunDigest: digest15,
   resultDigest: digest15,
   capsuleDigest: digest15.nullable(),
-  status: z38.enum(["ready", "blocked"])
+  status: z40.enum(["ready", "blocked"])
 });
 var DraftContextReceiptSchema = DraftContextReceiptBodySchema.extend({
   receiptDigest: digest15
 }).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only a ready context receipt has a capsule digest");
-var DraftContextVerificationOptionsSchema = z38.strictObject({
+var DraftContextVerificationOptionsSchema = z40.strictObject({
   expectedReceiptDigest: digest15,
-  deliveredCapsule: z38.record(z38.string(), z38.unknown()).nullable()
+  deliveredCapsule: z40.record(z40.string(), z40.unknown()).nullable()
 });
 
 // ../schemas/src/draft-evaluation-requests.ts
-import { z as z39 } from "zod";
-var identifier17 = z39.string().min(1).max(200).regex(/\S/u);
+import { z as z41 } from "zod";
+var identifier17 = z41.string().min(1).max(200).regex(/\S/u);
 var digest16 = DraftTypedNormalizationSchema.shape.expectedManifestDigest;
 var [scalar2] = DraftTypedNormalizationSchema.shape.packets.element.options;
 var { reference: reference8 } = DraftEvidenceMetadataSchema.shape.sources.element.shape;
-var DraftEvaluationRequestsSchema = z39.strictObject({
-  schema: z39.literal("felspar.evaluation-requests.draft/v0"),
+var DraftEvaluationRequestsSchema = z41.strictObject({
+  schema: z41.literal("felspar.evaluation-requests.draft/v0"),
   invocation: DraftTypedNormalizationSchema.shape.invocation,
   manifest: DraftTypedNormalizationSchema.shape.manifest,
   expectedManifestDigest: digest16,
-  limits: z39.strictObject({
-    maxQuestions: z39.number().int().min(1).max(64),
-    maxRequestBytes: z39.number().int().min(1).max(1048576),
-    maxResponseBytes: z39.number().int().min(1).max(1048576)
+  limits: z41.strictObject({
+    maxQuestions: z41.number().int().min(1).max(64),
+    maxRequestBytes: z41.number().int().min(1).max(1048576),
+    maxResponseBytes: z41.number().int().min(1).max(1048576)
   }),
-  packets: z39.array(z39.discriminatedUnion("kind", [
-    z39.strictObject({
+  packets: z41.array(z41.discriminatedUnion("kind", [
+    z41.strictObject({
       key: identifier17,
-      kind: z39.literal("scalar"),
+      kind: z41.literal("scalar"),
       evidence: DraftEvidenceMetadataSchema
     }),
-    z39.strictObject({
+    z41.strictObject({
       key: identifier17,
-      kind: z39.literal("enum"),
+      kind: z41.literal("enum"),
       input: DraftNormalizedEvidenceSchema.omit({ normalizations: true, attemptStatus: true })
     })
   ])).max(64).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate preparation key"),
-  passages: z39.array(z39.strictObject({ reference: reference8, text: z39.string().min(1).max(262144) })).max(1024)
+  passages: z41.array(z41.strictObject({ reference: reference8, text: z41.string().min(1).max(262144) })).max(1024)
 });
-var DraftEvaluationResponseSchema = z39.strictObject({
-  schema: z39.literal("felspar.evaluation-response.draft/v0"),
+var DraftEvaluationResponseSchema = z41.strictObject({
+  schema: z41.literal("felspar.evaluation-response.draft/v0"),
   requestDigest: digest16,
-  answers: z39.array(z39.discriminatedUnion("kind", [
-    z39.strictObject({
+  answers: z41.array(z41.discriminatedUnion("kind", [
+    z41.strictObject({
       key: identifier17,
-      kind: z39.literal("scalar"),
+      kind: z41.literal("scalar"),
       records: scalar2.shape.records
     }),
-    z39.strictObject({
+    z41.strictObject({
       key: identifier17,
-      kind: z39.literal("enum"),
+      kind: z41.literal("enum"),
       records: DraftNormalizedEvidenceSchema.shape.normalizations
     })
   ])).max(16).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate answer key")
 });
-var DraftEvaluationResponsesSchema = z39.array(DraftEvaluationResponseSchema).max(2);
+var DraftEvaluationResponsesSchema = z41.array(DraftEvaluationResponseSchema).max(2);
 var DraftLayeredEvaluationSchema = DraftEvaluationRequestsSchema.extend({
-  schema: z39.literal("felspar.evaluation-requests.draft/v1"),
+  schema: z41.literal("felspar.evaluation-requests.draft/v1"),
   limits: DraftEvaluationRequestsSchema.shape.limits.extend({
-    maxRounds: z39.number().int().min(1).max(16),
-    maxTotalQuestions: z39.number().int().min(1).max(64),
-    maxTotalRequestBytes: z39.number().int().min(1).max(1048576),
-    maxTotalResponseBytes: z39.number().int().min(1).max(1048576)
+    maxRounds: z41.number().int().min(1).max(16),
+    maxTotalQuestions: z41.number().int().min(1).max(64),
+    maxTotalRequestBytes: z41.number().int().min(1).max(1048576),
+    maxTotalResponseBytes: z41.number().int().min(1).max(1048576)
   })
 });
-var DraftLayeredResponsesSchema = z39.array(DraftEvaluationResponseSchema).max(16);
+var DraftLayeredResponsesSchema = z41.array(DraftEvaluationResponseSchema).max(16);
 
 // ../schemas/src/draft-job-handoff.ts
 var digest17 = DraftContextVerificationOptionsSchema.shape.expectedReceiptDigest;
 var draftJobHandoffContract = "felspar.job-handoff/v1";
-var DraftJobDiscoverySchema = z40.strictObject({
-  schema: z40.literal("felspar.job-discovery.draft/v0"),
+var DraftJobDiscoverySchema = z42.strictObject({
+  schema: z42.literal("felspar.job-discovery.draft/v0"),
   requirements: DraftRequirementsRequestSchema,
   compilation: DraftRequiredContextInputSchema.shape.compilation,
   expectedArtifactDigest: digest17
 });
 var executionVersion0 = "felspar.job-execution.draft/v0";
-var DraftJobExecutionSchema = z40.strictObject({
-  schema: z40.literal(executionVersion0),
+var DraftJobExecutionSchema = z42.strictObject({
+  schema: z42.literal(executionVersion0),
   discovery: DraftJobDiscoverySchema,
   expectedHandoffDigest: digest17,
-  invocation: z40.discriminatedUnion("route", [
-    z40.strictObject({ route: z40.literal("normalized"), input: DraftCoveredRequiredContextSchema }),
-    z40.strictObject({ route: z40.literal("supplied"), input: DraftSuppliedContextSchema }),
-    z40.strictObject({ route: z40.literal("typed"), input: DraftTypedNormalizationSchema }),
-    z40.strictObject({ route: z40.literal("layered"), input: DraftLayeredNormalizationSchema }),
-    z40.strictObject({
-      route: z40.literal("evaluated"),
+  invocation: z42.discriminatedUnion("route", [
+    z42.strictObject({ route: z42.literal("normalized"), input: DraftCoveredRequiredContextSchema }),
+    z42.strictObject({ route: z42.literal("supplied"), input: DraftSuppliedContextSchema }),
+    z42.strictObject({ route: z42.literal("typed"), input: DraftTypedNormalizationSchema }),
+    z42.strictObject({ route: z42.literal("layered"), input: DraftLayeredNormalizationSchema }),
+    z42.strictObject({
+      route: z42.literal("evaluated"),
       input: DraftLayeredEvaluationSchema,
       responses: DraftLayeredResponsesSchema
     })
   ])
 });
-var DraftJobDiscoveryReferenceSchema = z40.strictObject({
-  schema: z40.literal("felspar.job-discovery-reference.draft/v1"),
-  route: z40.enum(["normalized", "supplied"]),
+var DraftJobDiscoveryReferenceSchema = z42.strictObject({
+  schema: z42.literal("felspar.job-discovery-reference.draft/v1"),
+  route: z42.enum(["normalized", "supplied"]),
   job: DraftRequirementsRequestSchema.options[0].shape.job,
   trustDomain: DraftRequirementsRequestSchema.options[0].shape.trustDomain,
   maxResponseBytes: DraftRequirementsRequestSchema.options[0].shape.maxResponseBytes,
   expectedArtifactDigest: digest17
 });
-var DraftJobExecutionV1Schema = z40.strictObject({
-  schema: z40.literal("felspar.job-execution.draft/v1"),
+var DraftJobExecutionV1Schema = z42.strictObject({
+  schema: z42.literal("felspar.job-execution.draft/v1"),
   discovery: DraftJobDiscoveryReferenceSchema,
   expectedHandoffDigest: digest17,
   invocation: DraftJobExecutionSchema.shape.invocation
 });
-var DraftAnyJobExecutionSchema = z40.discriminatedUnion("schema", [
+var DraftAnyJobExecutionSchema = z42.discriminatedUnion("schema", [
   DraftJobExecutionSchema,
   DraftJobExecutionV1Schema
 ]);
-var DraftJobReceiptBodySchema = z40.strictObject({
-  schema: z40.literal("felspar.job-handoff-receipt.draft/v0"),
-  authority: z40.literal("unapproved"),
-  runtimeContract: z40.literal(draftJobHandoffContract),
-  route: z40.enum(["normalized", "supplied", "typed", "layered", "evaluated"]),
+var DraftJobReceiptBodySchema = z42.strictObject({
+  schema: z42.literal("felspar.job-handoff-receipt.draft/v0"),
+  authority: z42.literal("unapproved"),
+  runtimeContract: z42.literal(draftJobHandoffContract),
+  route: z42.enum(["normalized", "supplied", "typed", "layered", "evaluated"]),
   inputDigest: digest17,
   handoffDigest: digest17,
   artifactDigest: digest17,
   downstreamRunDigest: digest17,
   capsuleDigest: digest17.nullable(),
-  status: z40.enum(["ready", "blocked"])
+  status: z42.enum(["ready", "blocked"])
 });
 var DraftJobReceiptSchema = DraftJobReceiptBodySchema.extend({
   receiptDigest: digest17
 }).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only ready delivery has a capsule digest");
-var DraftJobVerificationSchema = z40.strictObject({
+var DraftJobVerificationSchema = z42.strictObject({
   receipt: DraftJobReceiptSchema,
   retained: DraftAnyJobExecutionSchema,
   options: DraftContextVerificationOptionsSchema
 });
 
 // ../schemas/src/draft-application-access.ts
-var identifier18 = z41.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
+var identifier18 = z43.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
 var digest18 = DraftJobExecutionSchema.shape.expectedHandoffDigest;
-var instant = z41.iso.datetime({ offset: true });
+var instant = z43.iso.datetime({ offset: true });
 var applicationActions = [
   "submit_source",
   "submit_proposal",
@@ -3392,8 +3634,8 @@ var applicationActions = [
   "execute_job",
   "inspect_run"
 ];
-var action = z41.enum(applicationActions);
-var DraftApplicationScopeSchema = z41.strictObject({
+var action = z43.enum(applicationActions);
+var DraftApplicationScopeSchema = z43.strictObject({
   organizationId: identifier18,
   environmentId: identifier18,
   authorityId: identifier18
@@ -3403,40 +3645,40 @@ var DraftApplicationTargetSchema = DraftApplicationScopeSchema.extend({
   resourceId: identifier18,
   jobId: identifier18.nullable()
 }).refine((target) => target.action === "execute_job" === (target.jobId !== null), "Only job execution carries a job ID");
-var DraftApplicationActorSchema = z41.strictObject({
+var DraftApplicationActorSchema = z43.strictObject({
   principalId: identifier18,
   organizationId: identifier18,
-  principalType: z41.enum(["user", "delegated_agent", "autonomous_agent"]),
+  principalType: z43.enum(["user", "delegated_agent", "autonomous_agent"]),
   actingUserId: identifier18.nullable(),
   authenticatedAt: instant,
   expiresAt: instant,
-  permissionCeiling: z41.array(action).max(applicationActions.length)
+  permissionCeiling: z43.array(action).max(applicationActions.length)
 }).refine((actor) => actor.principalType === "delegated_agent" === (actor.actingUserId !== null), "Delegated agents preserve the acting user");
-var DraftApplicationPermissionSchema = z41.strictObject({
+var DraftApplicationPermissionSchema = z43.strictObject({
   target: DraftApplicationTargetSchema,
   principalId: identifier18,
   actingUserId: identifier18.nullable(),
-  allowed: z41.boolean(),
+  allowed: z43.boolean(),
   checkedAt: instant,
   expiresAt: instant
 });
-var DraftApplicationJobMaterialSchema = z41.strictObject({
+var DraftApplicationJobMaterialSchema = z43.strictObject({
   discovery: DraftJobExecutionSchema.shape.discovery,
   expectedHandoffDigest: digest18,
   input: DraftLayeredEvaluationSchema
 });
-var DraftApplicationJobMaterialV2Schema = z41.strictObject({
-  schema: z41.literal("felspar.application-job-material.draft/v2"),
+var DraftApplicationJobMaterialV2Schema = z43.strictObject({
+  schema: z43.literal("felspar.application-job-material.draft/v2"),
   discovery: DraftJobDiscoveryReferenceSchema,
   expectedHandoffDigest: digest18,
   input: DraftLayeredEvaluationSchema
 });
-var DraftAnyApplicationJobMaterialSchema = z41.union([
+var DraftAnyApplicationJobMaterialSchema = z43.union([
   DraftApplicationJobMaterialV2Schema,
   DraftApplicationJobMaterialSchema
 ]);
-var DraftApplicationJobRequestSchema = z41.strictObject({
-  schema: z41.literal("felspar.application-job-request.draft/v0"),
+var DraftApplicationJobRequestSchema = z43.strictObject({
+  schema: z43.literal("felspar.application-job-request.draft/v0"),
   scope: DraftApplicationScopeSchema,
   releaseId: identifier18,
   expectedReleaseDigest: digest18,
@@ -3444,8 +3686,8 @@ var DraftApplicationJobRequestSchema = z41.strictObject({
   executionId: identifier18,
   material: DraftAnyApplicationJobMaterialSchema
 });
-var DraftApplicationReleaseSchema = z41.strictObject({
-  schema: z41.literal("felspar.application-release.draft/v0"),
+var DraftApplicationReleaseSchema = z43.strictObject({
+  schema: z43.literal("felspar.application-release.draft/v0"),
   scope: DraftApplicationScopeSchema,
   releaseId: identifier18,
   jobId: identifier18,
@@ -3454,50 +3696,50 @@ var DraftApplicationReleaseSchema = z41.strictObject({
   approvalId: identifier18,
   approvedMaterialDigest: digest18,
   releaseDigest: digest18,
-  status: z41.enum(["draft", "released", "revoked"])
+  status: z43.enum(["draft", "released", "revoked"])
 });
 
 // ../schemas/src/draft-hosted-application.ts
-import { z as z48 } from "zod";
+import { z as z50 } from "zod";
 
 // ../schemas/src/draft-hosted-output-checks.ts
-import { z as z47 } from "zod";
+import { z as z49 } from "zod";
 
 // ../schemas/src/draft-artifact-check-manifest.ts
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 
 // ../schemas/src/draft-artifact-lint-semantic.ts
-import { z as z44 } from "zod";
+import { z as z46 } from "zod";
 
 // ../schemas/src/draft-claim-evaluation-recipe.ts
-import { z as z43 } from "zod";
+import { z as z45 } from "zod";
 
 // ../schemas/src/draft-output-check.ts
-import { z as z42 } from "zod";
+import { z as z44 } from "zod";
 var identifier19 = DraftContextPlanSchema.shape.job;
 var digest19 = DraftJobReceiptBodySchema.shape.inputDigest;
-var byteLimit = z42.number().int().min(1).max(65536);
-var text5 = z42.string().max(16384);
-var sectionRule = z42.discriminatedUnion("check", [
-  z42.strictObject({ id: identifier19, check: z42.literal("text"), maxBytes: byteLimit }),
-  z42.strictObject({
+var byteLimit = z44.number().int().min(1).max(65536);
+var text5 = z44.string().max(16384);
+var sectionRule = z44.discriminatedUnion("check", [
+  z44.strictObject({ id: identifier19, check: z44.literal("text"), maxBytes: byteLimit }),
+  z44.strictObject({
     id: identifier19,
-    check: z42.literal("exact"),
+    check: z44.literal("exact"),
     maxBytes: byteLimit,
-    alternatives: z42.array(text5.min(1).regex(/\S/u)).min(1).max(8).refine(hasUniqueValues)
+    alternatives: z44.array(text5.min(1).regex(/\S/u)).min(1).max(8).refine(hasUniqueValues)
   })
 ]);
 var draftOutputCheckerContract = "felspar.structured-output-check/v1";
-var DraftOutputContractSchema = z42.strictObject({
-  schema: z42.literal("felspar.output-contract.draft/v0"),
+var DraftOutputContractSchema = z44.strictObject({
+  schema: z44.literal("felspar.output-contract.draft/v0"),
   id: identifier19,
-  version: z42.number().int().min(1).max(65535),
+  version: z44.number().int().min(1).max(65535),
   compiledArtifactDigest: digest19,
   job: identifier19,
   trustDomain: identifier19,
   outputSurface: identifier19,
   maxBytes: byteLimit,
-  sections: z42.array(sectionRule).min(1).max(16)
+  sections: z44.array(sectionRule).min(1).max(16)
 }).superRefine((contract, context3) => {
   if (!hasUniqueValues(contract.sections.map((section) => section.id))) {
     context3.addIssue({ code: "custom", message: "Duplicate output section rule" });
@@ -3509,14 +3751,14 @@ var DraftOutputContractSchema = z42.strictObject({
     }
   }
 });
-var DraftStructuredOutputSchema = z42.strictObject({
-  schema: z42.literal("felspar.structured-output.draft/v0"),
+var DraftStructuredOutputSchema = z44.strictObject({
+  schema: z44.literal("felspar.structured-output.draft/v0"),
   id: identifier19,
   revision: identifier19,
-  sections: z42.array(z42.strictObject({ id: identifier19, text: text5 })).max(32).refine((sections) => hasUniqueValues(sections.map((section) => section.id)))
+  sections: z44.array(z44.strictObject({ id: identifier19, text: text5 })).max(32).refine((sections) => hasUniqueValues(sections.map((section) => section.id)))
 });
-var DraftOutputCheckSchema = z42.strictObject({
-  schema: z42.literal("felspar.output-check.draft/v0"),
+var DraftOutputCheckSchema = z44.strictObject({
+  schema: z44.literal("felspar.output-check.draft/v0"),
   execution: DraftJobExecutionSchema,
   expectedJobReceiptDigest: digest19,
   contractEntryId: identifier19,
@@ -3524,8 +3766,8 @@ var DraftOutputCheckSchema = z42.strictObject({
   output: DraftStructuredOutputSchema,
   expectedOutputDigest: digest19
 });
-var DraftOutputDiagnosticSchema = z42.strictObject({
-  code: z42.enum([
+var DraftOutputDiagnosticSchema = z44.strictObject({
+  code: z44.enum([
     "upstream_blocked",
     "contract_coverage_incomplete",
     "contract_invalid",
@@ -3538,13 +3780,13 @@ var DraftOutputDiagnosticSchema = z42.strictObject({
   ]),
   sectionId: identifier19.nullable()
 });
-var DraftOutputReceiptBodySchema = z42.strictObject({
-  schema: z42.literal("felspar.output-receipt.draft/v0"),
-  authority: z42.literal("unapproved"),
-  checkerContract: z42.literal(draftOutputCheckerContract),
-  coverage: z42.literal("declared_structure_and_exact_text"),
-  semanticEvaluation: z42.literal("not_performed"),
-  actionAuthorized: z42.literal(false),
+var DraftOutputReceiptBodySchema = z44.strictObject({
+  schema: z44.literal("felspar.output-receipt.draft/v0"),
+  authority: z44.literal("unapproved"),
+  checkerContract: z44.literal(draftOutputCheckerContract),
+  coverage: z44.literal("declared_structure_and_exact_text"),
+  semanticEvaluation: z44.literal("not_performed"),
+  actionAuthorized: z44.literal(false),
   inputDigest: digest19,
   jobReceiptDigest: digest19,
   compiledArtifactDigest: digest19,
@@ -3553,39 +3795,39 @@ var DraftOutputReceiptBodySchema = z42.strictObject({
   outputDigest: digest19,
   outputId: identifier19,
   outputRevision: identifier19,
-  status: z42.enum(["checks_passed", "invalid", "blocked"]),
-  structuralOnlySectionIds: z42.array(identifier19).max(16),
-  diagnostics: z42.array(DraftOutputDiagnosticSchema).max(81)
+  status: z44.enum(["checks_passed", "invalid", "blocked"]),
+  structuralOnlySectionIds: z44.array(identifier19).max(16),
+  diagnostics: z44.array(DraftOutputDiagnosticSchema).max(81)
 });
 var DraftOutputReceiptSchema = DraftOutputReceiptBodySchema.extend({
   receiptDigest: digest19
 });
-var DraftOutputVerificationOptionsSchema = z42.strictObject({
+var DraftOutputVerificationOptionsSchema = z44.strictObject({
   expectedReceiptDigest: digest19
 });
 
 // ../schemas/src/draft-claim-evaluation-recipe.ts
 var scope = DraftOutputContractSchema.shape;
 var identifier20 = scope.id;
-var text6 = z43.string().min(1).max(2048).regex(/\S/u);
-var ids2 = z43.array(identifier20).max(8).refine(hasUniqueValues, "Duplicate identifier");
+var text6 = z45.string().min(1).max(2048).regex(/\S/u);
+var ids2 = z45.array(identifier20).max(8).refine(hasUniqueValues, "Duplicate identifier");
 var { judgment: judgment3 } = DraftNormalizedEvidenceSchema.shape.normalizations.element.shape;
-var option = z43.strictObject({
+var option = z45.strictObject({
   value: judgment3.options[0].shape.probabilities.element.shape.value,
   meaning: text6,
-  effect: z43.enum(["satisfied", "violated", "unresolved"])
+  effect: z45.enum(["satisfied", "violated", "unresolved"])
 });
-var question = z43.strictObject({
+var question = z45.strictObject({
   id: identifier20,
   sectionIds: ids2.min(1),
   instructions: text6,
   authorityEntryIds: ids2.min(1),
   evidenceKeys: ids2,
-  options: z43.array(option).min(2).max(8).refine((items) => hasUniqueValues(items.map((item) => item.value)), "Duplicate option").refine((items) => items.some((item) => item.effect === "unresolved"), "Explicit unresolved option required"),
-  minimumSelectedProbability: z43.number().gt(0).max(1)
+  options: z45.array(option).min(2).max(8).refine((items) => hasUniqueValues(items.map((item) => item.value)), "Duplicate option").refine((items) => items.some((item) => item.effect === "unresolved"), "Explicit unresolved option required"),
+  minimumSelectedProbability: z45.number().gt(0).max(1)
 });
-var DraftClaimEvaluationRecipeSchema = z43.strictObject({
-  schema: z43.literal("felspar.claim-evaluation-recipe.draft/v0"),
+var DraftClaimEvaluationRecipeSchema = z45.strictObject({
+  schema: z45.literal("felspar.claim-evaluation-recipe.draft/v0"),
   id: identifier20,
   version: identifier20,
   compiledArtifactDigest: scope.compiledArtifactDigest,
@@ -3595,16 +3837,16 @@ var DraftClaimEvaluationRecipeSchema = z43.strictObject({
   evaluator: DraftEvaluatorContractSchema.shape.evaluator,
   calibration: DraftEvaluatorContractSchema.shape.calibration,
   probabilityContract: DraftEvaluatorContractSchema.shape.probabilityContract,
-  questions: z43.array(question).min(1).max(8).refine((items) => hasUniqueValues(items.map((item) => item.id)), "Duplicate question"),
-  limits: z43.strictObject({
-    maxRequests: z43.number().int().min(1).max(128),
-    maxRequestBytes: z43.number().int().min(1).max(16384),
-    maxTotalBytes: z43.number().int().min(1).max(65536)
+  questions: z45.array(question).min(1).max(8).refine((items) => hasUniqueValues(items.map((item) => item.id)), "Duplicate question"),
+  limits: z45.strictObject({
+    maxRequests: z45.number().int().min(1).max(128),
+    maxRequestBytes: z45.number().int().min(1).max(16384),
+    maxTotalBytes: z45.number().int().min(1).max(65536)
   })
 });
 
 // ../schemas/src/draft-artifact-lint-semantic.ts
-var id2 = DraftApplicationScopeSchema.shape.authorityId;
+var id3 = DraftApplicationScopeSchema.shape.authorityId;
 var digest20 = DraftJobReceiptSchema.shape.receiptDigest;
 var recipe = DraftClaimEvaluationRecipeSchema.shape;
 var recipeQuestion = recipe.questions.element.shape;
@@ -3616,82 +3858,82 @@ var artifactSemanticLimits = {
   maxRequestBytes: 32768,
   maxTotalBytes: 1048576
 };
-var ArtifactSemanticQuestionSchema = z44.strictObject({
-  id: id2,
+var ArtifactSemanticQuestionSchema = z46.strictObject({
+  id: id3,
   instructions: recipeQuestion.instructions,
   options: recipeQuestion.options,
   minimumSelectedProbability: recipeQuestion.minimumSelectedProbability,
-  aggregation: z44.enum(["prohibit", "require", "match"])
+  aggregation: z46.enum(["prohibit", "require", "match"])
 });
-var ArtifactSemanticRecipeSchema = z44.strictObject({
+var ArtifactSemanticRecipeSchema = z46.strictObject({
   evaluator: recipe.evaluator,
   calibration: recipe.calibration,
   probabilityContract: recipe.probabilityContract,
-  questions: z44.array(ArtifactSemanticQuestionSchema).min(1).max(artifactSemanticLimits.maxQuestions),
-  limits: z44.strictObject({
-    maxEvaluations: z44.number().int().min(1).max(artifactSemanticLimits.maxEvaluations),
-    maxRequestBytes: z44.number().int().min(1).max(artifactSemanticLimits.maxRequestBytes),
-    maxTotalBytes: z44.number().int().min(1).max(artifactSemanticLimits.maxTotalBytes)
+  questions: z46.array(ArtifactSemanticQuestionSchema).min(1).max(artifactSemanticLimits.maxQuestions),
+  limits: z46.strictObject({
+    maxEvaluations: z46.number().int().min(1).max(artifactSemanticLimits.maxEvaluations),
+    maxRequestBytes: z46.number().int().min(1).max(artifactSemanticLimits.maxRequestBytes),
+    maxTotalBytes: z46.number().int().min(1).max(artifactSemanticLimits.maxTotalBytes)
   })
 });
-var ArtifactSemanticRequestSchema = z44.strictObject({
-  schema: z44.literal("felspar.artifact-question.draft/v1"),
+var ArtifactSemanticRequestSchema = z46.strictObject({
+  schema: z46.literal("felspar.artifact-question.draft/v1"),
   preparationDigest: digest20,
-  unitId: id2,
-  sectionId: id2,
-  start: z44.number().int().min(0),
-  end: z44.number().int().min(1),
+  unitId: id3,
+  sectionId: id3,
+  start: z46.number().int().min(0),
+  end: z46.number().int().min(1),
   textDigest: digest20,
-  text: z44.string().min(1),
-  questionId: id2,
+  text: z46.string().min(1),
+  questionId: id3,
   instructions: recipeQuestion.instructions,
-  options: z44.array(z44.strictObject({ value: z44.string(), meaning: z44.string() })).min(2).max(8),
-  policy: z44.array(z44.strictObject({ sourceLocator: z44.string(), text: z44.string() })).min(1),
+  options: z46.array(z46.strictObject({ value: z46.string(), meaning: z46.string() })).min(2).max(8),
+  policy: z46.array(z46.strictObject({ sourceLocator: z46.string(), text: z46.string() })).min(1),
   evaluator: recipe.evaluator,
   calibration: recipe.calibration,
   requestDigest: digest20
 });
-var ArtifactSemanticResponseSchema = z44.strictObject({
-  schema: z44.literal("felspar.artifact-question-response.draft/v1"),
+var ArtifactSemanticResponseSchema = z46.strictObject({
+  schema: z46.literal("felspar.artifact-question-response.draft/v1"),
   preparationDigest: digest20,
   evaluator: recipe.evaluator,
   calibrationDigest: digest20,
-  answers: z44.array(z44.strictObject({ unitId: id2, questionId: id2, requestDigest: digest20, judgment: judgment4 })).max(artifactSemanticLimits.maxEvaluations)
+  answers: z46.array(z46.strictObject({ unitId: id3, questionId: id3, requestDigest: digest20, judgment: judgment4 })).max(artifactSemanticLimits.maxEvaluations)
 });
-var ArtifactSemanticJudgmentSchema = z44.strictObject({
-  unitId: id2,
-  sectionId: id2,
-  start: z44.number().int().min(0),
-  end: z44.number().int().min(1),
+var ArtifactSemanticJudgmentSchema = z46.strictObject({
+  unitId: id3,
+  sectionId: id3,
+  start: z46.number().int().min(0),
+  end: z46.number().int().min(1),
   textDigest: digest20,
-  questionId: id2,
+  questionId: id3,
   requestDigest: digest20,
   judgment: judgment4.nullable(),
-  value: z44.string().nullable(),
-  effect: z44.enum(["satisfied", "violated", "unresolved", "unavailable", "not_stated"]),
-  reasons: z44.array(z44.string().max(128)).max(8)
+  value: z46.string().nullable(),
+  effect: z46.enum(["satisfied", "violated", "unresolved", "unavailable", "not_stated"]),
+  reasons: z46.array(z46.string().max(128)).max(8)
 });
-var ArtifactSemanticRecordSchema = z44.strictObject({
-  state: z44.enum(["ready", "skipped", "over_budget", "not_evaluated"]),
+var ArtifactSemanticRecordSchema = z46.strictObject({
+  state: z46.enum(["ready", "skipped", "over_budget", "not_evaluated"]),
   preparationDigest: digest20,
   evaluator: ArtifactSemanticRecipeSchema.shape.evaluator,
   calibrationDigest: digest20,
   probabilityContract: ArtifactSemanticRecipeSchema.shape.probabilityContract,
-  questions: z44.array(ArtifactSemanticQuestionSchema.pick({
+  questions: z46.array(ArtifactSemanticQuestionSchema.pick({
     id: true,
     minimumSelectedProbability: true,
     aggregation: true
   }).extend({
-    checkId: id2,
-    anchorSectionId: id2,
-    sectionsAvailable: z44.boolean(),
-    units: z44.number().int().min(0).max(artifactSemanticLimits.maxEvaluations),
-    options: z44.array(z44.strictObject({
+    checkId: id3,
+    anchorSectionId: id3,
+    sectionsAvailable: z46.boolean(),
+    units: z46.number().int().min(0).max(artifactSemanticLimits.maxEvaluations),
+    options: z46.array(z46.strictObject({
       value: ArtifactSemanticQuestionSchema.shape.options.element.shape.value,
-      effect: z44.enum(["satisfied", "violated", "unresolved", "not_stated"])
+      effect: z46.enum(["satisfied", "violated", "unresolved", "not_stated"])
     })).min(2).max(8)
   })).max(artifactSemanticLimits.maxQuestions),
-  judgments: z44.array(ArtifactSemanticJudgmentSchema).max(artifactSemanticLimits.maxEvaluations)
+  judgments: z46.array(ArtifactSemanticJudgmentSchema).max(artifactSemanticLimits.maxEvaluations)
 });
 var caseNotStated = "not_stated";
 var abstain = "cannot_determine";
@@ -3734,7 +3976,7 @@ function inspectSemantic(manifest2, issue) {
 }
 
 // ../schemas/src/draft-artifact-check-manifest.ts
-var id3 = DraftApplicationScopeSchema.shape.authorityId;
+var id4 = DraftApplicationScopeSchema.shape.authorityId;
 var digest21 = DraftJobReceiptSchema.shape.receiptDigest;
 var artifactLintLimits = {
   maxTotalBytes: 65536,
@@ -3749,12 +3991,12 @@ var artifactLintLimits = {
 function isWellFormedText(value) {
   return !/\p{Cs}/u.test(value);
 }
-var literal = z45.string().min(1).max(artifactLintLimits.maxLiteralUnits).regex(/\S/u).refine(isWellFormedText);
-var passage = z45.strictObject({
-  sourceLocator: z45.string().min(1).max(4096).regex(/\S/u),
+var literal = z47.string().min(1).max(artifactLintLimits.maxLiteralUnits).regex(/\S/u).refine(isWellFormedText);
+var passage = z47.strictObject({
+  sourceLocator: z47.string().min(1).max(4096).regex(/\S/u),
   contentDigest: digest21
 });
-var common = { id: id3, required: z45.boolean(), specification: passage };
+var common = { id: id4, required: z47.boolean(), specification: passage };
 var artifactCheckKinds = [
   "section",
   "required_wording",
@@ -3767,64 +4009,64 @@ var artifactLintMediaTypes = [
   "text/plain",
   "application/vnd.felspar.structured-output+json"
 ];
-var sectionTargets = z45.array(id3).min(1).max(artifactLintLimits.maxSections);
-var ArtifactCheckSchema = z45.discriminatedUnion("kind", [
-  z45.strictObject({ ...common, kind: z45.literal("section"), sectionId: id3 }),
-  z45.strictObject({
+var sectionTargets = z47.array(id4).min(1).max(artifactLintLimits.maxSections);
+var ArtifactCheckSchema = z47.discriminatedUnion("kind", [
+  z47.strictObject({ ...common, kind: z47.literal("section"), sectionId: id4 }),
+  z47.strictObject({
     ...common,
-    kind: z45.literal("required_wording"),
-    sectionId: id3,
-    alternatives: z45.array(literal).min(1).max(artifactLintLimits.maxAlternatives)
+    kind: z47.literal("required_wording"),
+    sectionId: id4,
+    alternatives: z47.array(literal).min(1).max(artifactLintLimits.maxAlternatives)
   }),
-  z45.strictObject({
+  z47.strictObject({
     ...common,
-    kind: z45.literal("prohibited_literal"),
+    kind: z47.literal("prohibited_literal"),
     sectionIds: sectionTargets,
-    literals: z45.array(literal).min(1).max(artifactLintLimits.maxLiterals)
+    literals: z47.array(literal).min(1).max(artifactLintLimits.maxLiterals)
   }),
-  z45.strictObject({
+  z47.strictObject({
     ...common,
-    kind: z45.literal("field_value"),
-    sectionId: id3,
-    label: z45.string().min(1).max(128).regex(/^[^\s:](?:[^\n\r:]*[^\s:])?$/u).refine(isWellFormedText),
-    unit: z45.string().min(1).max(32).regex(/^\S+$/u).refine(isWellFormedText).nullable(),
-    evidenceKey: id3,
-    comparator: z45.enum(["eq", "lte", "gte"])
+    kind: z47.literal("field_value"),
+    sectionId: id4,
+    label: z47.string().min(1).max(128).regex(/^[^\s:](?:[^\n\r:]*[^\s:])?$/u).refine(isWellFormedText),
+    unit: z47.string().min(1).max(32).regex(/^\S+$/u).refine(isWellFormedText).nullable(),
+    evidenceKey: id4,
+    comparator: z47.enum(["eq", "lte", "gte"])
   }),
-  z45.strictObject({
+  z47.strictObject({
     ...common,
-    kind: z45.literal("case_answer"),
+    kind: z47.literal("case_answer"),
     sectionIds: sectionTargets,
-    fact: z45.discriminatedUnion("comparison", [
-      z45.strictObject({ key: id3, comparison: z45.literal("choice") }),
-      z45.strictObject({
-        key: id3,
-        comparison: z45.literal("number"),
+    fact: z47.discriminatedUnion("comparison", [
+      z47.strictObject({ key: id4, comparison: z47.literal("choice") }),
+      z47.strictObject({
+        key: id4,
+        comparison: z47.literal("number"),
         reader: ExactReaderSchema.options[0]
       }),
-      z45.strictObject({
-        key: id3,
-        comparison: z45.literal("date"),
+      z47.strictObject({
+        key: id4,
+        comparison: z47.literal("date"),
         reader: ExactReaderSchema.options[1]
       })
     ]),
-    answers: z45.array(z45.strictObject({
-      value: id3,
-      wording: z45.array(literal).max(artifactLintLimits.maxAlternatives)
+    answers: z47.array(z47.strictObject({
+      value: id4,
+      wording: z47.array(literal).max(artifactLintLimits.maxAlternatives)
     })).max(artifactLintLimits.maxLiterals),
-    questionId: id3.nullable()
+    questionId: id4.nullable()
   }),
-  z45.strictObject({
+  z47.strictObject({
     ...common,
-    kind: z45.literal("semantic_question"),
+    kind: z47.literal("semantic_question"),
     sectionIds: sectionTargets,
-    questionId: id3
+    questionId: id4
   })
 ]);
-var sectionDeclaration = z45.strictObject({
-  id: id3,
-  heading: z45.string().min(1).max(256).regex(/\S/u).refine((value) => !/[\n\r]/u.test(value) && isWellFormedText(value)).nullable(),
-  maxUnits: z45.number().int().min(1).max(artifactLintLimits.maxSectionUnits)
+var sectionDeclaration = z47.strictObject({
+  id: id4,
+  heading: z47.string().min(1).max(256).regex(/\S/u).refine((value) => !/[\n\r]/u.test(value) && isWellFormedText(value)).nullable(),
+  maxUnits: z47.number().int().min(1).max(artifactLintLimits.maxSectionUnits)
 });
 function caseAnswerIssues(checks) {
   const issues = [];
@@ -3844,18 +4086,18 @@ function caseAnswerIssues(checks) {
   }
   return issues;
 }
-var ArtifactCheckManifestSchema = z45.strictObject({
-  schema: z45.literal("felspar.artifact-check-manifest.draft/v1"),
-  id: id3,
-  version: z45.number().int().min(1).max(65535),
-  jobId: id3,
-  trustDomain: id3,
-  contract: z45.strictObject({ id: id3, digest: digest21 }),
-  parser: z45.enum(["body", "headings"]),
-  maxBytes: z45.number().int().min(1).max(artifactLintLimits.maxTotalBytes),
-  sections: z45.array(sectionDeclaration).min(1).max(artifactLintLimits.maxSections),
-  caseContext: z45.enum(["required", "not_required"]),
-  checks: z45.array(ArtifactCheckSchema).min(1).max(artifactLintLimits.maxChecks),
+var ArtifactCheckManifestSchema = z47.strictObject({
+  schema: z47.literal("felspar.artifact-check-manifest.draft/v1"),
+  id: id4,
+  version: z47.number().int().min(1).max(65535),
+  jobId: id4,
+  trustDomain: id4,
+  contract: z47.strictObject({ id: id4, digest: digest21 }),
+  parser: z47.enum(["body", "headings"]),
+  maxBytes: z47.number().int().min(1).max(artifactLintLimits.maxTotalBytes),
+  sections: z47.array(sectionDeclaration).min(1).max(artifactLintLimits.maxSections),
+  caseContext: z47.enum(["required", "not_required"]),
+  checks: z47.array(ArtifactCheckSchema).min(1).max(artifactLintLimits.maxChecks),
   semantic: ArtifactSemanticRecipeSchema.nullable()
 }).superRefine((manifest2, context3) => {
   const issue = (message) => {
@@ -3900,11 +4142,11 @@ var ArtifactCheckManifestSchema = z45.strictObject({
 var ArtifactSpecificationSchema = passage;
 
 // ../schemas/src/draft-job-obligations-manifest.ts
-import { z as z46 } from "zod";
-var id4 = DraftApplicationScopeSchema.shape.authorityId;
+import { z as z48 } from "zod";
+var id5 = DraftApplicationScopeSchema.shape.authorityId;
 var digest22 = DraftJobReceiptSchema.shape.receiptDigest;
 var passage2 = {
-  sourceLocator: z46.string().min(1).max(4096).regex(/\S/u),
+  sourceLocator: z48.string().min(1).max(4096).regex(/\S/u),
   contentDigest: digest22
 };
 var jobObligationsLimits = {
@@ -3915,41 +4157,41 @@ var jobObligationsLimits = {
   maxApprovalTargets: 16,
   maxManifestBytes: 65536
 };
-var DraftJobObligationsScopeSchema = z46.strictObject({
-  purposeRef: id4,
-  useRef: id4.nullable()
+var DraftJobObligationsScopeSchema = z48.strictObject({
+  purposeRef: id5,
+  useRef: id5.nullable()
 });
-var artifact = z46.strictObject({
-  id: id4,
-  role: id4,
-  contract: z46.strictObject({ id: id4, digest: digest22 }),
+var artifact = z48.strictObject({
+  id: id5,
+  role: id5,
+  contract: z48.strictObject({ id: id5, digest: digest22 }),
   ...passage2
 });
-var approval = z46.strictObject({
-  id: id4,
-  policy: z46.strictObject({ id: id4, ...passage2 }),
-  phase: z46.enum(["before_decision", "before_generation", "before_use"]),
-  appliesTo: z46.array(z46.discriminatedUnion("kind", [
-    z46.strictObject({ kind: z46.literal("decision") }),
-    z46.strictObject({ kind: z46.literal("artifact"), id: id4 }),
-    z46.strictObject({ kind: z46.literal("use") })
+var approval = z48.strictObject({
+  id: id5,
+  policy: z48.strictObject({ id: id5, ...passage2 }),
+  phase: z48.enum(["before_decision", "before_generation", "before_use"]),
+  appliesTo: z48.array(z48.discriminatedUnion("kind", [
+    z48.strictObject({ kind: z48.literal("decision") }),
+    z48.strictObject({ kind: z48.literal("artifact"), id: id5 }),
+    z48.strictObject({ kind: z48.literal("use") })
   ])).min(1).max(jobObligationsLimits.maxApprovalTargets)
 });
-var outcome = z46.strictObject({
-  outcomeId: id4,
+var outcome = z48.strictObject({
+  outcomeId: id5,
   ...passage2,
-  contextRequired: z46.boolean(),
-  artifacts: z46.array(artifact).max(jobObligationsLimits.maxArtifacts),
-  approvals: z46.array(approval).max(jobObligationsLimits.maxApprovals)
+  contextRequired: z48.boolean(),
+  artifacts: z48.array(artifact).max(jobObligationsLimits.maxArtifacts),
+  approvals: z48.array(approval).max(jobObligationsLimits.maxApprovals)
 });
-var manifest = z46.strictObject({
-  schema: z46.literal("felspar.job-obligations.draft/v0"),
-  jobId: id4,
-  trustDomain: id4,
+var manifest = z48.strictObject({
+  schema: z48.literal("felspar.job-obligations.draft/v0"),
+  jobId: id5,
+  trustDomain: id5,
   scope: DraftJobObligationsScopeSchema,
   source: DraftSourceReferenceSchema,
-  contracts: z46.array(z46.strictObject({ id: id4, ...passage2 })).max(jobObligationsLimits.maxContracts),
-  outcomes: z46.array(outcome).min(1).max(jobObligationsLimits.maxOutcomes)
+  contracts: z48.array(z48.strictObject({ id: id5, ...passage2 })).max(jobObligationsLimits.maxContracts),
+  outcomes: z48.array(outcome).min(1).max(jobObligationsLimits.maxOutcomes)
 });
 function unique3(values, context3, path3) {
   const distinct = new Set(values);
@@ -4020,10 +4262,10 @@ var DraftJobObligationsOutcomeSchema = outcome;
 
 // ../schemas/src/draft-hosted-output-checks.ts
 var hostedOutputCheckLimits = { maxOutputs: 8 };
-var HostedOutputChecksSchema = z47.strictObject({
-  schema: z47.literal("felspar.output-checks.draft/v0"),
+var HostedOutputChecksSchema = z49.strictObject({
+  schema: z49.literal("felspar.output-checks.draft/v0"),
   obligations: DraftJobObligationsSchema,
-  manifests: z47.array(ArtifactCheckManifestSchema).min(1).max(hostedOutputCheckLimits.maxOutputs)
+  manifests: z49.array(ArtifactCheckManifestSchema).min(1).max(hostedOutputCheckLimits.maxOutputs)
 }).superRefine((value, context3) => {
   if (context3.issues.length > 0) {
     return;
@@ -4050,59 +4292,59 @@ var HostedOutputChecksSchema = z47.strictObject({
 });
 
 // ../schemas/src/draft-hosted-application.ts
-var id5 = z48.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+var id6 = z50.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
 var digest23 = DraftApplicationReleaseSchema.shape.releaseDigest;
-var HostedSourceInputSchema = z48.strictObject({
-  sourceId: id5,
-  revision: id5,
-  title: z48.string().min(1).max(200),
-  text: z48.string().min(1).max(1048576)
-});
-var HostedProposalInputV0Schema = z48.strictObject({
-  sourceObjectId: id5,
+var HostedSourceInputSchema = z50.strictObject({
+  sourceId: id6,
+  revision: id6,
+  title: z50.string().min(1).max(200),
+  text: z50.string().min(1).max(1048576)
+});
+var HostedProposalInputV0Schema = z50.strictObject({
+  sourceObjectId: id6,
   expectedSourceDigest: digest23,
   material: DraftApplicationJobMaterialSchema,
   compilation: DraftCompilationSchema
 });
-var HostedProposalInputV2Schema = z48.strictObject({
-  schema: z48.literal("felspar.hosted-proposal.draft/v2"),
-  sourceObjectId: id5,
+var HostedProposalInputV2Schema = z50.strictObject({
+  schema: z50.literal("felspar.hosted-proposal.draft/v2"),
+  sourceObjectId: id6,
   expectedSourceDigest: digest23,
   material: DraftApplicationJobMaterialV2Schema,
   outputChecks: HostedOutputChecksSchema.optional()
 });
-var HostedProposalInputSchema = z48.union([
+var HostedProposalInputSchema = z50.union([
   HostedProposalInputV2Schema,
   HostedProposalInputV0Schema
 ]);
-var HostedApprovalInputSchema = z48.strictObject({
+var HostedApprovalInputSchema = z50.strictObject({
   expectedProposalDigest: digest23,
-  reviewedMeaning: z48.literal(true),
-  reviewedFixtures: z48.literal(true),
-  reviewNote: z48.string().min(1).max(2e3)
+  reviewedMeaning: z50.literal(true),
+  reviewedFixtures: z50.literal(true),
+  reviewNote: z50.string().min(1).max(2e3)
 });
-var HostedReleaseInputSchema = z48.strictObject({ expectedApprovalDigest: digest23 });
-var HostedReleaseBundleSchema = z48.strictObject({
+var HostedReleaseInputSchema = z50.strictObject({ expectedApprovalDigest: digest23 });
+var HostedReleaseBundleSchema = z50.strictObject({
   release: DraftApplicationReleaseSchema,
   material: DraftAnyApplicationJobMaterialSchema,
-  approvalObjectId: id5,
+  approvalObjectId: id6,
   approvalDigest: digest23,
   proposalDigest: digest23,
   sourceDigest: digest23,
   verifiedCompilation: DraftVerifiedCompilationSchema.optional()
 });
-var HostedJobInputSchema = z48.strictObject({
-  executionId: id5,
+var HostedJobInputSchema = z50.strictObject({
+  executionId: id6,
   expectedReleaseDigest: digest23,
   material: DraftAnyApplicationJobMaterialSchema
 });
-var HostedSuppliedJobInputSchema = z48.strictObject({
-  mode: z48.literal("supplied"),
-  executionId: id5,
+var HostedSuppliedJobInputSchema = z50.strictObject({
+  mode: z50.literal("supplied"),
+  executionId: id6,
   expectedReleaseDigest: digest23,
   expectedAuthorityDigest: digest23,
-  jobId: id5,
-  entityId: id5,
+  jobId: id6,
+  entityId: id6,
   evidence: DraftRequiredDecisionSchema.shape.evidence,
   passages: DraftLayeredEvaluationSchema.shape.passages.max(256)
 });
@@ -4112,88 +4354,95 @@ var hostedFactsLimits = {
   maxFactsBytes: 524288,
   maxQuestions: 64
 };
-var factSource = z48.strictObject({
-  class: id5,
+var factSource = z50.strictObject({
+  class: id6,
   id: DraftSourceReferenceSchema.shape.sourceId,
-  revision: id5.optional(),
-  locator: z48.string().min(1).max(4096).optional(),
+  revision: id6.optional(),
+  locator: z50.string().min(1).max(4096).optional(),
   observedAt: DraftObservationChecksSchema.shape.evaluationTime,
-  sensitivity: id5.optional()
+  sensitivity: id6.optional()
 });
-var excerptText = z48.string().min(1).refine((text7) => text7.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
-var HostedExcerptSchema = z48.strictObject({ text: excerptText, source: factSource });
-var HostedValueFactSchema = z48.strictObject({
-  value: z48.union([z48.string().min(1).max(200), z48.number(), z48.boolean()]),
-  source: factSource.extend({ excerpt: excerptText.optional() })
+var excerptText = z50.string().min(1).refine((text7) => text7.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
+var about = z50.string().min(1).max(200).optional();
+var HostedExcerptSchema = z50.strictObject({ text: excerptText, source: factSource, about });
+var HostedValueFactSchema = z50.strictObject({
+  value: z50.union([z50.string().min(1).max(200), z50.number(), z50.boolean()]),
+  source: factSource.extend({ excerpt: excerptText.optional() }),
+  about
 });
-var HostedFactSchema = z48.union([
+var HostedFactSchema = z50.union([
   HostedValueFactSchema,
   HostedExcerptSchema,
-  z48.array(HostedExcerptSchema).min(1).refine((excerpts2) => excerpts2.length <= hostedFactsLimits.maxExcerptsPerQuestion, "too_many_excerpts")
+  z50.array(HostedExcerptSchema).min(1).refine((excerpts2) => excerpts2.length <= hostedFactsLimits.maxExcerptsPerQuestion, "too_many_excerpts")
 ]);
 function factsBytes(facts) {
   const encoder2 = new TextEncoder();
   return encoder2.encode(JSON.stringify(facts)).length;
 }
-var HostedFactsJobInputSchema = z48.strictObject({
-  mode: z48.literal("facts"),
-  executionId: id5,
+var HostedFactsJobInputSchema = z50.strictObject({
+  mode: z50.literal("facts"),
+  executionId: id6,
   expectedReleaseDigest: digest23,
-  jobId: id5,
-  entityId: id5,
-  facts: z48.record(id5, HostedFactSchema).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions").refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large")
+  jobId: id6,
+  entityId: id6,
+  related: HostedRelatedSubjectsSchema.optional(),
+  identity: z50.record(z50.string().min(1).max(128), z50.string().min(1).max(200)).optional(),
+  facts: z50.record(id6, HostedFactSchema).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions").refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large")
+});
+var HostedFactsRequestSchema = HostedFactsJobInputSchema.extend({
+  entityId: id6.optional()
 });
-var HostedJobRequestSchema = z48.union([
+var HostedJobRequestSchema = z50.union([
   HostedJobInputSchema,
   HostedSuppliedJobInputSchema,
   HostedFactsJobInputSchema
 ]);
-var HostedClassificationResultSchema = z48.strictObject({
-  key: id5,
-  observationId: id5,
+var HostedClassificationResultSchema = z50.strictObject({
+  key: id6,
+  observationId: id6,
   record: DraftNormalizedEvidenceSchema.shape.normalizations.element,
-  reason: z48.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
-  cached: z48.boolean()
+  reason: z50.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
+  cached: z50.boolean()
 });
 function retainsFactsExactly(record) {
   const hasFacts = record.facts !== void 0 && record.judgments !== void 0 && record.judgmentsDigest !== void 0;
   return record.schema === "felspar.hosted-supplied-execution/v3" === hasFacts;
 }
-var HostedSuppliedExecutionRecordSchema = z48.strictObject({
-  schema: z48.enum([
+var HostedSuppliedExecutionRecordSchema = z50.strictObject({
+  schema: z50.enum([
     "felspar.hosted-supplied-execution/v1",
     "felspar.hosted-supplied-execution/v2",
     "felspar.hosted-supplied-execution/v3"
   ]),
-  release: z48.strictObject({ releaseId: id5, releaseDigest: digest23, materialDigest: digest23 }),
-  evaluationTime: z48.iso.datetime(),
+  release: z50.strictObject({ releaseId: id6, releaseDigest: digest23, materialDigest: digest23 }),
+  evaluationTime: z50.iso.datetime(),
   input: HostedSuppliedJobInputSchema,
   facts: HostedFactsJobInputSchema.optional(),
-  judgments: z48.array(HostedClassificationResultSchema).max(192).optional(),
+  judgments: z50.array(HostedClassificationResultSchema).max(192).optional(),
   judgmentsDigest: digest23.optional(),
-  expansion: z48.literal("agreeing-excerpts").optional(),
-  job: z48.record(z48.string(), z48.unknown())
+  expansion: z50.literal("agreeing-excerpts").optional(),
+  job: z50.record(z50.string(), z50.unknown())
 }).refine(retainsFactsExactly, "Version 3 records, and only they, retain facts with their judgments");
-var HostedObjectSchema = z48.strictObject({
-  id: id5,
-  kind: z48.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
+var HostedObjectSchema = z50.strictObject({
+  id: id6,
+  kind: z50.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
   payloadDigest: digest23,
-  objectKey: z48.string().min(1).max(1e3),
-  parentId: id5.nullable(),
-  status: z48.enum(["active", "released", "revoked"]),
-  metadata: z48.record(z48.string(), z48.unknown())
-});
-var HostedJobResultSchema = z48.object({
-  status: z48.string(),
-  reason: z48.string().nullable(),
-  result: z48.object({
-    executionId: z48.string(),
-    releaseId: id5,
+  objectKey: z50.string().min(1).max(1e3),
+  parentId: id6.nullable(),
+  status: z50.enum(["active", "released", "revoked"]),
+  metadata: z50.record(z50.string(), z50.unknown())
+});
+var HostedJobResultSchema = z50.object({
+  status: z50.string(),
+  reason: z50.string().nullable(),
+  result: z50.object({
+    executionId: z50.string(),
+    releaseId: id6,
     releaseDigest: digest23,
-    outcome: z48.string().nullable(),
-    scoring: z48.unknown(),
-    context: z48.unknown(),
-    receipt: z48.unknown()
+    outcome: z50.string().nullable(),
+    scoring: z50.unknown(),
+    context: z50.unknown(),
+    receipt: z50.unknown()
   }).loose().nullable()
 });
 
@@ -4215,7 +4464,22 @@ var fixes = {
   request_too_large: `The facts in one request are at most ${limits.maxFactsBytes} bytes. Send shorter excerpts.`,
   release_changed: "The release changed. Describe the job again and resend with the current release digest.",
   job_mismatch: "This release serves a different job. Use the job and release from describe.",
-  attempt_limit_reached: "This case has used its decision attempts. Don't ask again: escalate it with the next step from your last result.",
+  attempt_limit_reached: "This case has used its decision attempts. Don't ask again: escalate it with the escalation this refusal names (report its id exactly), or with the next step from your last result.",
+  subject_id_invalid: "Send the case's ID as the job's subject describes it (its identifier and example in the job requirements): letters, digits and . _ : @ - only.",
+  unknown_relationship: "This job's subject has no relationship of this name. Use a relationship listed under subject.related in the job requirements, or leave related out.",
+  related_subject_required: "A question you answered is about a related record. Send that record's ID under related.<relationship>, and quote that record for the question.",
+  too_many_related: "Send at most 16 related record IDs.",
+  entity_id_required: "This job identifies each case by the record's own ID: send it as entityId (entity_id over MCP), as the job requirements' identity says.",
+  case_id_derived: "This job derives each case's ID from its fields or text. Leave entityId out, or send the case.id from an earlier result unchanged.",
+  unknown_case_id: "This case ID was not issued to you for this job. Leave entityId out on a first decision; afterwards send exactly the case.id Felspar returned.",
+  issued_case_limit: "You opened as many new cases on this job as one caller may in 24 hours. Reuse the case.id of the case you are working on instead of starting a new one.",
+  identity_field_required: "This job identifies each case by fields: send every field the job requirements' identity lists, under identity.",
+  identity_field_unknown: "This field is not one of the job's identity fields. Use the names its identity lists.",
+  identity_field_invalid: "An identity field value uses letters, digits and . _ : @ - only, as its example shows.",
+  content_required: "This job identifies each case by its text: send the text being judged under the question the identity names.",
+  one_related_id: "This relationship is one record: send its ID as a single string under related.<relationship>, not a list.",
+  related_id_required: "Several records were sent for this relationship: name the one this excerpt comes from in its about field.",
+  unknown_related_id: "This excerpt's about names a record not sent under related for its relationship. Send that record's ID there, or correct about.",
   rate_limited: "This caller or workspace sent more decision requests in the last minute than its plan allows. Wait retryAfterSeconds, then resend the same request with the same execution ID. Send every question you have evidence for in one facts request per entity instead of one request per question, and spread a large run over time; for runs of thousands of entities, ask Felspar about batch scoring.",
   execution_id_reused: "This execution ID was already used for a different request. Use a new execution ID, or resend the original request unchanged.",
   invalid_body: "The body must be JSON or content parts within the size limit.",
@@ -4241,173 +4505,226 @@ function hostedRefusalFix(code) {
 }
 
 // ../schemas/src/draft-hosted-job-description.ts
-import { z as z50 } from "zod";
+import { z as z52 } from "zod";
 
 // ../schemas/src/draft-hosted-output-guides.ts
-import { z as z49 } from "zod";
-var id6 = z49.string().min(1).max(200);
-var located = z49.strictObject({
-  text: z49.string().min(1).max(262144),
-  locator: z49.string().min(1).max(4096)
+import { z as z51 } from "zod";
+var id7 = z51.string().min(1).max(200);
+var located = z51.strictObject({
+  text: z51.string().min(1).max(262144),
+  locator: z51.string().min(1).max(4096)
 });
 var hostedOutputGuideLimits = { maxOutputs: 8, maxContext: 8, maxChecks: 64 };
-var HostedOutputGuideSchema = z49.strictObject({
-  id: id6,
+var HostedOutputGuideSchema = z51.strictObject({
+  id: id7,
   what: located,
-  maxCharacters: z49.number().int().min(1),
-  context: z49.array(located.extend({ id: id6 })).max(hostedOutputGuideLimits.maxContext).optional(),
-  checks: z49.array(z49.strictObject({
-    check: id6,
-    rule: z49.string().nullable(),
-    must: z49.string().min(1).max(8e3)
+  maxCharacters: z51.number().int().min(1),
+  context: z51.array(located.extend({ id: id7 })).max(hostedOutputGuideLimits.maxContext).optional(),
+  checks: z51.array(z51.strictObject({
+    check: id7,
+    rule: z51.string().nullable(),
+    must: z51.string().min(1).max(8e3)
   })).max(hostedOutputGuideLimits.maxChecks)
 });
-var HostedOutputGuidesSchema = z49.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
+var HostedOutputGuidesSchema = z51.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
 
 // ../schemas/src/draft-hosted-job-description.ts
-var id7 = z50.string().min(1).max(200);
+var id8 = z52.string().min(1).max(200);
 var digest24 = DraftApplicationReleaseSchema.shape.releaseDigest;
 var { requirements, rules } = DraftRequiredProposalSchema.shape;
-var quotedText = z50.strictObject({
-  text: z50.string().min(1).max(262144),
+var quotedText = z52.strictObject({
+  text: z52.string().min(1).max(262144),
   source: DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
-    locator: z50.string().min(1).max(4096),
+    locator: z52.string().min(1).max(4096),
     contentDigest: digest24
   }),
-  parts: z50.array(z50.strictObject({ locator: z50.string().min(1).max(4096), text: z50.string() })).max(16)
-});
-var HostedJobDescriptionSchema = z50.strictObject({
-  schema: z50.literal("felspar.hosted-job-description.draft/v0"),
-  job: id7,
-  trustDomain: id7,
-  release: z50.strictObject({
-    releaseId: id7,
+  parts: z52.array(z52.strictObject({ locator: z52.string().min(1).max(4096), text: z52.string() })).max(16)
+});
+var subjectShape = {
+  identifier: z52.string().min(1).max(200),
+  example: z52.string().min(1).max(200),
+  match: z52.enum(subjectMatchRules)
+};
+var HostedJobSubjectSchema = z52.strictObject({
+  type: id8,
+  definition: quotedText,
+  identifier: subjectShape.identifier.optional(),
+  example: subjectShape.example.optional(),
+  match: subjectShape.match,
+  related: z52.array(z52.strictObject({
+    relationship: id8,
+    meaning: quotedText,
+    cardinality: z52.enum(relationshipCardinalities),
+    required: z52.boolean(),
+    subject: id8,
+    definition: quotedText,
+    ...subjectShape
+  })).max(16),
+  send: z52.string().min(1).max(2e4)
+});
+var HostedJobEscalationsSchema = z52.strictObject({
+  routes: z52.array(z52.strictObject({ id: id8, quote: quotedText })).min(1).max(16),
+  unresolved: id8.nullable(),
+  attemptLimit: id8.nullable(),
+  rule: z52.string().min(1).max(1e3)
+});
+var HostedEscalationSchema = z52.strictObject({
+  id: id8,
+  trigger: z52.enum(escalationTriggers),
+  why: quotedText
+});
+var HostedJobDescriptionSchema = z52.strictObject({
+  schema: z52.literal("felspar.hosted-job-description.draft/v0"),
+  job: id8,
+  purpose: quotedText.optional(),
+  useWhen: z52.array(quotedText).max(8).optional(),
+  notFor: z52.array(quotedText).max(8).optional(),
+  owner: quotedText.optional(),
+  subject: HostedJobSubjectSchema.optional(),
+  identity: z52.strictObject({
+    mode: z52.enum(identityModes),
+    send: z52.string().min(1).max(4e3),
+    fields: z52.array(z52.strictObject({ name: id8, ...subjectShape })).max(8).optional(),
+    question: id8.optional()
+  }).optional(),
+  trustDomain: id8,
+  release: z52.strictObject({
+    releaseId: id8,
     releaseDigest: digest24,
     materialDigest: digest24,
     expectedAuthorityDigest: digest24
   }),
   resolutionPolicy: DraftRequiredProposalSchema.shape.resolutionPolicy,
-  questions: z50.array(requirements.element.extend({
-    key: id7,
-    type: z50.enum(["enum", "boolean", "number", "date"]),
+  questions: z52.array(requirements.element.extend({
+    key: id8,
+    type: z52.enum(["enum", "boolean", "number", "date"]),
     meaning: quotedText,
-    answer: z50.strictObject({
-      send: z50.enum(["text", "text_or_value"]),
-      valueFormat: z50.enum(["number", "calendar-date"]).nullable(),
-      interpretation: z50.enum(["classified", "exact_read", "unsupported"]),
-      threshold: z50.number().gt(0).max(1).nullable(),
-      applies: z50.enum(["always", "conditional"]),
-      dependsOn: z50.array(id7).max(32),
-      appliesWhen: z50.string().min(1).max(2e3).nullable(),
+    answer: z52.strictObject({
+      send: z52.enum(["text", "text_or_value"]),
+      valueFormat: z52.enum(["number", "calendar-date"]).nullable(),
+      interpretation: z52.enum(["classified", "exact_read", "unsupported"]),
+      threshold: z52.number().gt(0).max(1).nullable(),
+      applies: z52.enum(["always", "conditional"]),
+      dependsOn: z52.array(id8).max(32),
+      appliesWhen: z52.string().min(1).max(2e3).nullable(),
       reading: ExactReaderSchema.optional()
     }),
-    answers: z50.array(z50.strictObject({
-      value: id7,
-      meaning: z50.string().nullable(),
-      inclusions: z50.array(z50.string()).max(8),
-      exclusions: z50.array(z50.string()).max(8),
-      examples: z50.array(z50.string()).max(8),
-      edgeCases: z50.array(z50.string()).max(8)
+    answers: z52.array(z52.strictObject({
+      value: id8,
+      meaning: z52.string().nullable(),
+      inclusions: z52.array(z52.string()).max(8),
+      exclusions: z52.array(z52.string()).max(8),
+      examples: z52.array(z52.string()).max(8),
+      edgeCases: z52.array(z52.string()).max(8)
     })).max(64).optional(),
-    whereToLook: z50.array(quotedText).max(8).optional()
+    whereToLook: z52.array(quotedText).max(8).optional(),
+    about: z52.strictObject({ relationship: id8, subject: id8 }).optional()
   })).max(64),
-  rules: z50.array(rules.element.extend({ text: quotedText })).max(256),
-  outcomes: z50.array(z50.strictObject({
-    id: id7,
+  rules: z52.array(rules.element.extend({ text: quotedText })).max(256),
+  outcomes: z52.array(z52.strictObject({
+    id: id8,
     meaning: quotedText.nullable(),
     nextStep: quotedText.nullable().optional(),
-    outputs: HostedOutputGuidesSchema.optional()
+    outputs: HostedOutputGuidesSchema.optional(),
+    escalate: id8.optional()
   })).max(64),
+  escalations: HostedJobEscalationsSchema.optional(),
   whenUnresolved: quotedText.nullable().optional(),
-  attempts: z50.strictObject({
-    max: z50.number().int().min(1).max(10),
-    withProgress: z50.number().int().min(1).max(10),
-    rule: z50.string().min(1).max(1e3)
+  attempts: z52.strictObject({
+    max: z52.number().int().min(1).max(10),
+    withProgress: z52.number().int().min(1).max(10),
+    rule: z52.string().min(1).max(1e3)
   }).optional(),
-  guidance: z50.strictObject({ gather: z50.string().min(1).max(2e3) }),
-  input: z50.strictObject({
-    jsonSchema: z50.record(z50.string(), z50.unknown()),
+  guidance: z52.strictObject({ gather: z52.string().min(1).max(2e3) }),
+  input: z52.strictObject({
+    jsonSchema: z52.record(z52.string(), z52.unknown()),
     example: HostedFactsJobInputSchema.nullable(),
-    exampleNote: z50.string().max(1e3)
+    exampleNote: z52.string().max(1e3)
   }),
-  limits: z50.strictObject({
-    maxEvidenceItems: z50.number().int().positive(),
-    maxPassages: z50.number().int().positive(),
-    facts: z50.strictObject({
-      maxExcerptCharacters: z50.literal(hostedFactsLimits.maxExcerptCharacters),
-      maxExcerptsPerQuestion: z50.literal(hostedFactsLimits.maxExcerptsPerQuestion),
-      maxFactsBytes: z50.literal(hostedFactsLimits.maxFactsBytes),
-      maxQuestions: z50.literal(hostedFactsLimits.maxQuestions)
+  limits: z52.strictObject({
+    maxEvidenceItems: z52.number().int().positive(),
+    maxPassages: z52.number().int().positive(),
+    facts: z52.strictObject({
+      maxExcerptCharacters: z52.literal(hostedFactsLimits.maxExcerptCharacters),
+      maxExcerptsPerQuestion: z52.literal(hostedFactsLimits.maxExcerptsPerQuestion),
+      maxFactsBytes: z52.literal(hostedFactsLimits.maxFactsBytes),
+      maxQuestions: z52.literal(hostedFactsLimits.maxQuestions)
     })
   })
 });
-var interpretedExcerpt = z50.strictObject({
-  id: id7,
-  method: z50.enum(["value", "exact_read", "classified"]),
-  status: z50.enum(["accepted", "needs_evidence", "not_needed"]),
-  value: z50.union([z50.string(), z50.number(), z50.boolean()]).optional(),
-  reasons: z50.array(z50.string()),
-  classification: z50.strictObject({
-    candidate: z50.string().nullable(),
-    probability: z50.number().min(0).max(1).nullable(),
-    abstention: z50.number().min(0).max(1).nullable(),
-    threshold: z50.number().min(0).max(1),
-    alternatives: z50.array(z50.strictObject({ value: z50.string(), probability: z50.number() }))
+var interpretedExcerpt = z52.strictObject({
+  id: id8,
+  method: z52.enum(["value", "exact_read", "classified"]),
+  status: z52.enum(["accepted", "needs_evidence", "not_needed"]),
+  value: z52.union([z52.string(), z52.number(), z52.boolean()]).optional(),
+  reasons: z52.array(z52.string()),
+  classification: z52.strictObject({
+    candidate: z52.string().nullable(),
+    probability: z52.number().min(0).max(1).nullable(),
+    abstention: z52.number().min(0).max(1).nullable(),
+    threshold: z52.number().min(0).max(1),
+    alternatives: z52.array(z52.strictObject({ value: z52.string(), probability: z52.number() }))
   }).optional()
 });
-var ruleSummary = z50.strictObject({ id: id7, outcome: id7, text: quotedText });
-var HostedJobExplanationSchema = z50.strictObject({
-  schema: z50.literal("felspar.hosted-job-explanation.draft/v0"),
-  decision: z50.strictObject({ status: z50.string().nullable(), reasons: z50.array(z50.string()) }),
-  needs: z50.array(z50.strictObject({
-    key: id7,
-    status: z50.string(),
-    reasons: z50.array(z50.string()),
-    acceptedSourceClasses: z50.array(z50.string()),
-    maxAgeMs: z50.number().int().nonnegative(),
+var ruleSummary = z52.strictObject({ id: id8, outcome: id8, text: quotedText });
+var HostedJobExplanationSchema = z52.strictObject({
+  schema: z52.literal("felspar.hosted-job-explanation.draft/v0"),
+  decision: z52.strictObject({ status: z52.string().nullable(), reasons: z52.array(z52.string()) }),
+  needs: z52.array(z52.strictObject({
+    key: id8,
+    status: z52.string(),
+    reasons: z52.array(z52.string()),
+    acceptedSourceClasses: z52.array(z52.string()),
+    maxAgeMs: z52.number().int().nonnegative(),
     requiredWhen: HostedJobDescriptionSchema.shape.questions.element.shape.requiredWhen,
-    excerpts: z50.array(interpretedExcerpt).optional()
+    excerpts: z52.array(interpretedExcerpt).optional()
   })),
-  why: z50.strictObject({
-    rules: z50.array(ruleSummary),
-    overrides: z50.array(z50.strictObject({ by: id7, target: id7 })),
-    suppressedRuleIds: z50.array(id7),
-    evidence: z50.array(z50.record(z50.string(), z50.unknown()))
+  why: z52.strictObject({
+    rules: z52.array(ruleSummary),
+    overrides: z52.array(z52.strictObject({ by: id8, target: id8 })),
+    suppressedRuleIds: z52.array(id8),
+    evidence: z52.array(z52.record(z52.string(), z52.unknown()))
   }).nullable(),
-  context: z50.strictObject({ status: z50.string(), reason: z50.string().nullable() }).nullable(),
-  reviewNeeds: z50.array(z50.string()),
-  evidenceFreshUntil: z50.iso.datetime().nullable()
+  context: z52.strictObject({ status: z52.string(), reason: z52.string().nullable() }).nullable(),
+  reviewNeeds: z52.array(z52.string()),
+  evidenceFreshUntil: z52.iso.datetime().nullable()
 });
-var HostedReceiptVerificationInputSchema = z50.strictObject({
+var HostedReceiptVerificationInputSchema = z52.strictObject({
   receipt: DraftJobReceiptSchema,
   expectedReceiptDigest: digest24,
   deliveredCapsule: DraftContextVerificationOptionsSchema.shape.deliveredCapsule
 });
-var HostedReceiptVerificationSchema = z50.strictObject({
-  authority: z50.literal("unapproved"),
-  status: z50.enum(["reproduced", "mismatch"]),
-  mismatches: z50.array(z50.string()),
-  decided: z50.strictObject({
-    jobId: id7,
-    entityId: id7,
-    releaseId: id7,
-    outcome: id7.nullable()
+var HostedReceiptVerificationSchema = z52.strictObject({
+  authority: z52.literal("unapproved"),
+  status: z52.enum(["reproduced", "mismatch"]),
+  mismatches: z52.array(z52.string()),
+  decided: z52.strictObject({
+    jobId: id8,
+    entityId: id8,
+    releaseId: id8,
+    outcome: id8.nullable(),
+    case: z52.strictObject({ id: id8, mode: z52.enum(identityModes) }).optional(),
+    subject: z52.strictObject({
+      type: id8,
+      related: z52.array(z52.strictObject({ relationship: id8, subject: id8, id: id8, questions: z52.array(id8).max(64) })).max(256)
+    }).optional(),
+    escalation: HostedEscalationSchema.omit({ why: true }).optional()
   }).optional()
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-import { z as z53 } from "zod";
+import { z as z55 } from "zod";
 
 // ../schemas/src/draft-artifact-lint.ts
-import { z as z52 } from "zod";
+import { z as z54 } from "zod";
 
 // ../schemas/src/draft-job-obligations.ts
-import { z as z51 } from "zod";
-var id8 = DraftApplicationScopeSchema.shape.authorityId;
+import { z as z53 } from "zod";
+var id9 = DraftApplicationScopeSchema.shape.authorityId;
 var digest25 = DraftJobReceiptSchema.shape.receiptDigest;
 var outcome2 = DraftJobObligationsOutcomeSchema;
 var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.extend({
-  schema: z51.literal("felspar.application-job-material.draft/v3"),
+  schema: z53.literal("felspar.application-job-material.draft/v3"),
   obligations: DraftJobObligationsSchema
 }).superRefine((value, context3) => {
   if (context3.issues.length > 0) {
@@ -4435,57 +4752,57 @@ var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.ex
   }
 });
 var HostedProposalInputV3Schema = HostedProposalInputV2Schema.extend({
-  schema: z51.literal("felspar.hosted-proposal.draft/v3"),
+  schema: z53.literal("felspar.hosted-proposal.draft/v3"),
   material: DraftApplicationJobMaterialV3Schema
 });
 var jobObligationsReplayRoutes = ["supplied", "evaluated"];
 var replayRoutes = new Set(jobObligationsReplayRoutes);
 var DraftJobObligationsExecutionSchema = DraftAnyJobExecutionSchema.refine((execution) => replayRoutes.has(execution.invocation.route), "Obligations assessments support supplied and evaluated native executions");
-var DraftJobObligationsNativeResultSchema = z51.strictObject({
-  authority: z51.literal("unapproved"),
-  discovery: z51.record(z51.string(), z51.unknown()),
-  executed: z51.record(z51.string(), z51.unknown()),
+var DraftJobObligationsNativeResultSchema = z53.strictObject({
+  authority: z53.literal("unapproved"),
+  discovery: z53.record(z53.string(), z53.unknown()),
+  executed: z53.record(z53.string(), z53.unknown()),
   receipt: DraftJobReceiptSchema
 });
-var DraftJobObligationsInputSchema = z51.strictObject({
+var DraftJobObligationsInputSchema = z53.strictObject({
   release: DraftApplicationReleaseSchema,
-  material: z51.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
+  material: z53.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
   execution: DraftJobObligationsExecutionSchema,
   expectedReceiptDigest: digest25,
   job: DraftJobObligationsNativeResultSchema,
   explanation: HostedJobExplanationSchema,
-  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id8 })
+  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id9 })
 });
-var requirements2 = z51.strictObject({
-  status: z51.enum(["established", "unresolved"]),
+var requirements2 = z53.strictObject({
+  status: z53.enum(["established", "unresolved"]),
   scope: DraftJobObligationsScopeSchema,
   artifacts: outcome2.shape.artifacts,
   approvals: outcome2.shape.approvals,
-  unresolved: z51.array(z51.strictObject({ scopeRef: id8, reasonCodes: z51.array(id8).min(1).max(64) })).max(64)
+  unresolved: z53.array(z53.strictObject({ scopeRef: id9, reasonCodes: z53.array(id9).min(1).max(64) })).max(64)
 });
-var nextReference = z51.discriminatedUnion("kind", [
-  z51.strictObject({ kind: z51.literal("evidence_need"), id: id8 }),
-  z51.strictObject({ kind: z51.literal("artifact_requirement"), id: id8 }),
-  z51.strictObject({ kind: z51.literal("approval_requirement"), id: id8 }),
-  z51.strictObject({ kind: z51.literal("unresolved_scope"), scopeRef: id8 })
+var nextReference = z53.discriminatedUnion("kind", [
+  z53.strictObject({ kind: z53.literal("evidence_need"), id: id9 }),
+  z53.strictObject({ kind: z53.literal("artifact_requirement"), id: id9 }),
+  z53.strictObject({ kind: z53.literal("approval_requirement"), id: id9 }),
+  z53.strictObject({ kind: z53.literal("unresolved_scope"), scopeRef: id9 })
 ]);
-var DraftJobObligationsAssessmentBodySchema = z51.strictObject({
-  schema: z51.literal("felspar.job-obligations-assessment.draft/v0"),
-  binding: z51.strictObject({
+var DraftJobObligationsAssessmentBodySchema = z53.strictObject({
+  schema: z53.literal("felspar.job-obligations-assessment.draft/v0"),
+  binding: z53.strictObject({
     releaseDigest: digest25,
     materialDigest: digest25,
     nativeReceiptDigest: digest25,
-    jobId: id8,
+    jobId: id9,
     applicationScope: DraftApplicationScopeSchema,
-    caseId: id8,
-    entityId: id8,
-    evaluationTime: z51.iso.datetime({ offset: true }),
-    purposeRef: id8,
-    useRef: id8.nullable()
+    caseId: id9,
+    entityId: id9,
+    evaluationTime: z53.iso.datetime({ offset: true }),
+    purposeRef: id9,
+    useRef: id9.nullable()
   }),
   requirements: requirements2,
-  next: z51.strictObject({
-    kind: z51.enum([
+  next: z53.strictObject({
+    kind: z53.enum([
       "stop",
       "review_required",
       "gather_evidence",
@@ -4493,8 +4810,8 @@ var DraftJobObligationsAssessmentBodySchema = z51.strictObject({
       "verify_before_action",
       "return_result"
     ]),
-    reasonCodes: z51.array(id8).max(64),
-    refs: z51.array(nextReference).max(64)
+    reasonCodes: z53.array(id9).max(64),
+    refs: z53.array(nextReference).max(64)
   })
 });
 function isNextRefDeclared(ref, required) {
@@ -4531,48 +4848,48 @@ var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchem
 });
 
 // ../schemas/src/draft-artifact-lint.ts
-var id9 = DraftApplicationScopeSchema.shape.authorityId;
+var id10 = DraftApplicationScopeSchema.shape.authorityId;
 var digest26 = DraftJobReceiptSchema.shape.receiptDigest;
 var passage3 = ArtifactSpecificationSchema;
-var plainArtifact = z52.strictObject({
-  id: id9,
-  revision: id9,
-  mediaType: z52.literal("text/plain"),
-  exportProfile: id9.nullable(),
-  content: z52.string().max(artifactLintLimits.maxTotalBytes),
+var plainArtifact = z54.strictObject({
+  id: id10,
+  revision: id10,
+  mediaType: z54.literal("text/plain"),
+  exportProfile: id10.nullable(),
+  content: z54.string().max(artifactLintLimits.maxTotalBytes),
   expectedContentDigest: digest26
 });
-var structuredArtifact = z52.strictObject({
-  id: id9,
-  revision: id9,
-  mediaType: z52.literal("application/vnd.felspar.structured-output+json"),
-  exportProfile: id9.nullable(),
+var structuredArtifact = z54.strictObject({
+  id: id10,
+  revision: id10,
+  mediaType: z54.literal("application/vnd.felspar.structured-output+json"),
+  exportProfile: id10.nullable(),
   content: DraftStructuredOutputSchema,
   expectedContentDigest: digest26
 });
-var ArtifactLintArtifactSchema = z52.discriminatedUnion("mediaType", [
+var ArtifactLintArtifactSchema = z54.discriminatedUnion("mediaType", [
   plainArtifact,
   structuredArtifact
 ]);
-var ArtifactLintDecisionSchema = z52.strictObject({
+var ArtifactLintDecisionSchema = z54.strictObject({
   inputs: DraftJobObligationsInputSchema,
   assessment: DraftJobObligationsAssessmentSchema,
   expectedAssessmentDigest: digest26
 });
-var ArtifactLintInputSchema = z52.strictObject({
-  schema: z52.literal("felspar.lint.draft/v1"),
-  requestId: id9,
+var ArtifactLintInputSchema = z54.strictObject({
+  schema: z54.literal("felspar.lint.draft/v1"),
+  requestId: id10,
   release: DraftApplicationReleaseSchema,
   material: DraftApplicationJobMaterialV3Schema,
   manifest: ArtifactCheckManifestSchema,
   expectedManifestDigest: digest26,
-  attachedObligations: z52.strictObject({ expectedObligationsDigest: digest26 }).optional(),
-  attachedCase: z52.strictObject({
+  attachedObligations: z54.strictObject({ expectedObligationsDigest: digest26 }).optional(),
+  attachedCase: z54.strictObject({
     decisionReceiptDigest: digest26,
-    answers: z52.array(z52.strictObject({ key: id9, value: z52.union([z52.string().min(1).max(200), z52.null()]) })).max(256)
+    answers: z54.array(z54.strictObject({ key: id10, value: z54.union([z54.string().min(1).max(200), z54.null()]) })).max(256)
   }).optional(),
-  case: z52.strictObject({ caseId: id9, purposeRef: id9, useRef: id9.nullable() }),
-  artifactRequirementId: id9.nullable(),
+  case: z54.strictObject({ caseId: id10, purposeRef: id10, useRef: id10.nullable() }),
+  artifactRequirementId: id10.nullable(),
   decision: ArtifactLintDecisionSchema.nullable(),
   artifact: ArtifactLintArtifactSchema
 });
@@ -4585,11 +4902,11 @@ var artifactCheckStatuses = [
   "not_applicable",
   "skipped"
 ];
-var range = z52.strictObject({
-  sectionId: id9,
-  start: z52.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
-  end: z52.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
-  offsetUnit: z52.literal("utf16_code_units")
+var range = z54.strictObject({
+  sectionId: id10,
+  start: z54.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
+  end: z54.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
+  offsetUnit: z54.literal("utf16_code_units")
 });
 var findingCodes = [
   "section_missing",
@@ -4617,131 +4934,131 @@ var findingCodes = [
   "evaluation_budget_exceeded",
   "evaluation_skipped"
 ];
-var ArtifactFindingSchema = z52.strictObject({
-  code: z52.enum(findingCodes),
-  checkId: id9.nullable(),
-  severity: z52.enum(["error", "warning"]),
+var ArtifactFindingSchema = z54.strictObject({
+  code: z54.enum(findingCodes),
+  checkId: id10.nullable(),
+  severity: z54.enum(["error", "warning"]),
   specification: passage3.nullable(),
   location: range.nullable(),
-  insertionAnchor: z52.strictObject({ sectionId: id9.nullable(), at: z52.number().int().min(0) }).nullable(),
-  literalIndex: z52.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
-});
-var ArtifactCheckObservationSchema = z52.strictObject({
-  checkId: id9,
-  kind: z52.enum(artifactCheckKinds),
-  required: z52.boolean(),
-  method: z52.enum(["deterministic", "semantic"]),
-  status: z52.enum(artifactCheckStatuses),
-  occurrences: z52.number().int().min(0),
-  parsedValue: z52.number().nullable(),
-  caseValue: z52.number().nullable()
-});
-var ArtifactLintRecordBodySchema = z52.strictObject({
-  schema: z52.literal("felspar.lint-record.draft/v1"),
-  requestId: id9,
-  status: z52.enum(["pass", "revise", "unavailable", "review_required"]),
-  caseContext: z52.enum(["bound", "not_required"]),
-  binding: z52.strictObject({
+  insertionAnchor: z54.strictObject({ sectionId: id10.nullable(), at: z54.number().int().min(0) }).nullable(),
+  literalIndex: z54.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
+});
+var ArtifactCheckObservationSchema = z54.strictObject({
+  checkId: id10,
+  kind: z54.enum(artifactCheckKinds),
+  required: z54.boolean(),
+  method: z54.enum(["deterministic", "semantic"]),
+  status: z54.enum(artifactCheckStatuses),
+  occurrences: z54.number().int().min(0),
+  parsedValue: z54.number().nullable(),
+  caseValue: z54.number().nullable()
+});
+var ArtifactLintRecordBodySchema = z54.strictObject({
+  schema: z54.literal("felspar.lint-record.draft/v1"),
+  requestId: id10,
+  status: z54.enum(["pass", "revise", "unavailable", "review_required"]),
+  caseContext: z54.enum(["bound", "not_required"]),
+  binding: z54.strictObject({
     scope: DraftApplicationScopeSchema,
-    releaseId: id9,
+    releaseId: id10,
     releaseDigest: digest26,
     materialDigest: digest26,
     obligationsDigest: digest26.optional(),
     caseFactsDigest: digest26.optional(),
-    jobId: id9,
-    manifestId: id9,
+    jobId: id10,
+    manifestId: id10,
     manifestDigest: digest26,
-    contract: z52.strictObject({ id: id9, digest: digest26 }),
-    caseId: id9,
-    purposeRef: id9,
-    useRef: id9.nullable(),
-    artifactRequirementId: id9.nullable(),
+    contract: z54.strictObject({ id: id10, digest: digest26 }),
+    caseId: id10,
+    purposeRef: id10,
+    useRef: id10.nullable(),
+    artifactRequirementId: id10.nullable(),
     decisionReceiptDigest: digest26.nullable(),
     obligationsAssessmentDigest: digest26.nullable()
   }),
-  artifact: z52.strictObject({
-    id: id9,
-    revision: id9,
-    mediaType: z52.enum(artifactLintMediaTypes),
-    exportProfile: id9.nullable(),
+  artifact: z54.strictObject({
+    id: id10,
+    revision: id10,
+    mediaType: z54.enum(artifactLintMediaTypes),
+    exportProfile: id10.nullable(),
     contentDigest: digest26,
-    sections: z52.array(z52.strictObject({
-      id: id9,
-      units: z52.number().int().min(0),
+    sections: z54.array(z54.strictObject({
+      id: id10,
+      units: z54.number().int().min(0),
       contentDigest: digest26.nullable()
     })).max(artifactLintLimits.maxSections)
   }),
-  checks: z52.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
-  findings: z52.array(ArtifactFindingSchema).max(2048),
+  checks: z54.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
+  findings: z54.array(ArtifactFindingSchema).max(2048),
   semantic: ArtifactSemanticRecordSchema.nullable(),
-  coverage: z52.strictObject({
-    scope: z52.literal("declared_checks_only"),
-    declared: z52.number().int().min(0),
-    applicable: z52.number().int().min(0),
-    completed: z52.number().int().min(0),
-    required: z52.number().int().min(0),
-    requiredCompleted: z52.number().int().min(0),
-    textAssigned: z52.enum(["complete", "incomplete"]),
-    semantic: z52.enum(["not_declared", "complete", "incomplete"]),
-    nativeDocumentLayout: z52.literal("not_checked")
+  coverage: z54.strictObject({
+    scope: z54.literal("declared_checks_only"),
+    declared: z54.number().int().min(0),
+    applicable: z54.number().int().min(0),
+    completed: z54.number().int().min(0),
+    required: z54.number().int().min(0),
+    requiredCompleted: z54.number().int().min(0),
+    textAssigned: z54.enum(["complete", "incomplete"]),
+    semantic: z54.enum(["not_declared", "complete", "incomplete"]),
+    nativeDocumentLayout: z54.literal("not_checked")
   }),
-  actionAuthorized: z52.literal(false)
+  actionAuthorized: z54.literal(false)
 });
 var ArtifactLintRecordSchema = ArtifactLintRecordBodySchema.extend({
   recordDigest: digest26
 });
-var ArtifactLintReceiptSchema = z52.strictObject({
-  schema: z52.literal("felspar.lint-receipt.draft/v1"),
+var ArtifactLintReceiptSchema = z54.strictObject({
+  schema: z54.literal("felspar.lint-receipt.draft/v1"),
   recordDigest: digest26,
   releaseDigest: digest26,
   manifestDigest: digest26,
   contractDigest: digest26,
-  caseId: id9,
-  caseContext: z52.enum(["bound", "not_required"]),
+  caseId: id10,
+  caseContext: z54.enum(["bound", "not_required"]),
   decisionReceiptDigest: digest26.nullable(),
   obligationsAssessmentDigest: digest26.nullable(),
-  artifactId: id9,
-  artifactRevision: id9,
+  artifactId: id10,
+  artifactRevision: id10,
   artifactDigest: digest26,
-  actionAuthorized: z52.literal(false),
+  actionAuthorized: z54.literal(false),
   receiptDigest: digest26
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-var id10 = DraftApplicationScopeSchema.shape.authorityId;
+var id11 = DraftApplicationScopeSchema.shape.authorityId;
 var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
-var HostedOutputCheckInputSchema = z53.strictObject({
-  executionId: id10,
-  output: id10.optional(),
-  text: z53.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
-  revision: id10.optional()
-});
-var HostedOutputCheckRecordSchema = z53.strictObject({
-  schema: z53.literal("felspar.hosted-output-check/v0"),
-  checkId: id10,
-  jobId: id10,
-  output: id10,
-  decision: z53.strictObject({ executionId: id10, outcome: id10, receiptDigest: digest27 }),
-  release: z53.strictObject({ releaseId: id10, releaseDigest: digest27 }),
+var HostedOutputCheckInputSchema = z55.strictObject({
+  executionId: id11,
+  output: id11.optional(),
+  text: z55.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
+  revision: id11.optional()
+});
+var HostedOutputCheckRecordSchema = z55.strictObject({
+  schema: z55.literal("felspar.hosted-output-check/v0"),
+  checkId: id11,
+  jobId: id11,
+  output: id11,
+  decision: z55.strictObject({ executionId: id11, outcome: id11, receiptDigest: digest27 }),
+  release: z55.strictObject({ releaseId: id11, releaseDigest: digest27 }),
   record: ArtifactLintRecordSchema,
   receipt: ArtifactLintReceiptSchema.nullable(),
-  evaluation: z53.strictObject({
-    modelCalls: z53.number().int().min(0),
-    reason: z53.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
+  evaluation: z55.strictObject({
+    modelCalls: z55.number().int().min(0),
+    reason: z55.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
   })
 });
 
 // src/draft-hosted-client.ts
-import { z as z54 } from "zod";
-var digestText = z54.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var HostedOutputCheckReplySchema = z54.object({
-  status: z54.enum(["pass", "revise", "review_required", "unavailable"]),
-  checkId: z54.string(),
-  output: z54.string(),
-  findings: z54.array(z54.record(z54.string(), z54.unknown())),
-  receipt: z54.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
-  decision: z54.object({ executionId: z54.string(), receiptDigest: digestText }),
-  actionAuthorized: z54.literal(false)
+import { z as z56 } from "zod";
+var digestText = z56.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var HostedOutputCheckReplySchema = z56.object({
+  status: z56.enum(["pass", "revise", "review_required", "unavailable"]),
+  checkId: z56.string(),
+  output: z56.string(),
+  findings: z56.array(z56.record(z56.string(), z56.unknown())),
+  receipt: z56.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
+  decision: z56.object({ executionId: z56.string(), receiptDigest: digestText }),
+  actionAuthorized: z56.literal(false)
 }).loose();
 var hostedPartsContentType = "application/x.felspar-content-parts";
 async function partsBody(value) {
@@ -4793,14 +5110,14 @@ ${jobId}`;
     return result;
   };
 }
-var refusalCode = z54.string().regex(/^[a-z][a-z_]{2,63}$/u);
-var fieldPath = z54.array(z54.string().max(256)).max(32);
-var refusalSchema = z54.object({
+var refusalCode = z56.string().regex(/^[a-z][a-z_]{2,63}$/u);
+var fieldPath = z56.array(z56.string().max(256)).max(32);
+var refusalSchema = z56.object({
   error: refusalCode,
   path: fieldPath.optional(),
-  currentReleaseDigest: z54.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
-  retryAfterSeconds: z54.number().int().min(1).max(3600).optional(),
-  issues: z54.array(z54.object({ code: refusalCode, path: fieldPath })).max(64).optional()
+  currentReleaseDigest: z56.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
+  retryAfterSeconds: z56.number().int().min(1).max(3600).optional(),
+  issues: z56.array(z56.object({ code: refusalCode, path: fieldPath })).max(64).optional()
 }).transform((value) => {
   const fix = hostedRefusalFix(value.error);
   return {
@@ -4894,22 +5211,22 @@ function createHostedFelsparClient(configuration) {
   return {
     submitSource: async (value) => await call("/v0/sources", HostedObjectSchema, HostedSourceInputSchema.parse(value)),
     submitProposal: async (value) => await call("/v0/proposals", HostedObjectSchema, HostedProposalInputSchema.parse(value)),
-    approveProposal: async (id11, value) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id11))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value)),
-    releasePack: async (id11, value) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id11))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value)),
-    loadRelease: async (id11) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id11))}`, HostedReleaseBundleSchema),
-    describeJob: async (id11, job) => await describe(objectId.parse(id11), objectId.parse(job)),
+    approveProposal: async (id12, value) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id12))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value)),
+    releasePack: async (id12, value) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id12))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value)),
+    loadRelease: async (id12) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id12))}`, HostedReleaseBundleSchema),
+    describeJob: async (id12, job) => await describe(objectId.parse(id12), objectId.parse(job)),
     verifyReceipt: async (executionObjectId, value) => await call(`/v0/executions/${encodeURIComponent(objectId.parse(executionObjectId))}/verify`, HostedReceiptVerificationSchema, HostedReceiptVerificationInputSchema.parse(value)),
     ...outputCheckCalls(call),
-    executeJob: async (id11, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id11))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
-    resolveFacts: async (id11, value) => {
-      const releaseId = objectId.parse(id11);
+    executeJob: async (id12, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id12))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
+    resolveFacts: async (id12, value) => {
+      const releaseId = objectId.parse(id12);
       const input = await factsRequest(value, async (jobId) => await describe(releaseId, jobId));
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
       return pinnedResult(await call(path3, HostedJobResultSchema, input), releaseId, input);
     },
-    resolveJob: async (id11, value) => {
+    resolveJob: async (id12, value) => {
       const input = HostedSuppliedJobInputSchema.parse(value);
-      const releaseId = objectId.parse(id11);
+      const releaseId = objectId.parse(id12);
       const response = await call(`/v0/releases/${encodeURIComponent(releaseId)}/jobs`, HostedJobResultSchema, input);
       return pinnedResult(response, releaseId, input);
     }