@felspar/sdk 0.4.1 → 0.4.2

package/dist/chunks/{chunk-PYLLH47S.js → chunk-4E64YLWE.js}

@@ -316,8 +316,8 @@ async function sha256(text8) {
   const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(text8)));
   return `sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
-function reference(digest29) {
-  return { [draftContentPartReferenceKey]: digest29 };
+function reference(digest31) {
+  return { [draftContentPartReferenceKey]: digest31 };
 }
 var referenceBytes = utf8(canonicalizeJson(reference(`sha256:${"0".repeat(64)}`)));
 var logicalLimit = "Content parts exceed the logical byte, node or depth limit";
@@ -419,9 +419,9 @@ function storedForm(input, state) {
   if (known) {
     return known.value;
   }
-  const digest29 = state.digests.get(input);
-  if (digest29 !== void 0) {
-    return reference(digest29);
+  const digest31 = state.digests.get(input);
+  if (digest31 !== void 0) {
+    return reference(digest31);
   }
   const node = state.measured.get(input);
   if (!node) {
@@ -460,10 +460,10 @@ async function splitRoot(value2, isCollecting, isFreezing = false) {
   }
   for (const node of state.order) {
     const token = canonicalizeJson(storedForm(node.input, state));
-    const digest30 = await sha256(token);
-    state.digests.set(node.input, digest30);
-    state.parts.set(digest30, token);
-    remember(node, reference(digest30), referenceBytes);
+    const digest32 = await sha256(token);
+    state.digests.set(node.input, digest32);
+    state.parts.set(digest32, token);
+    remember(node, reference(digest32), referenceBytes);
   }
   const stored = storedForm(value2, state);
   if (value2 !== null && typeof value2 === "object") {
@@ -472,8 +472,8 @@ async function splitRoot(value2, isCollecting, isFreezing = false) {
       remember(node, stored, node.tokenBytes);
     }
   }
-  const digest29 = await sha256(canonicalizeJson(stored));
-  return { state, root: { ...root, value: stored }, digest: digest29 };
+  const digest31 = await sha256(canonicalizeJson(stored));
+  return { state, root: { ...root, value: stored }, digest: digest31 };
 }
 function byDigest(left, right) {
   return left < right ? -1 : 1;
@@ -484,7 +484,7 @@ function admitStored(parts, bytes) {
   }
 }
 async function packContentParts(value2) {
-  const { state, root, digest: digest29 } = await splitRoot(value2, true);
+  const { state, root, digest: digest31 } = await splitRoot(value2, true);
   const parts = [];
   for (const part of state.parts.keys()) {
     parts.push(part);
@@ -495,7 +495,7 @@ async function packContentParts(value2) {
   const storedBytes = utf8(text8);
   admitStored(parts.length, storedBytes);
   return {
-    digest: digest29,
+    digest: digest31,
     text: text8,
     parts: parts.length,
     storedBytes,
@@ -1534,7 +1534,7 @@ function inspectScoredPolicy(proposal, context3) {
   }
   inspectScoringReferences(scoring, proposal.requirements, context3);
   const ids3 = new Set(rules2.map((rule3) => rule3.id));
-  if (gates.some((id14) => !ids3.has(id14))) {
+  if (gates.some((id15) => !ids3.has(id15))) {
     fail("Unknown mandatory gate rule");
   }
   if (rules2.every((rule3) => gates.includes(rule3.id))) {
@@ -1547,7 +1547,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((id14) => gates.includes(id14) !== isGate)) {
+    if (rule3.overrides.some((id15) => gates.includes(id15) !== isGate)) {
       fail("Explicit overrides cannot cross mandatory-gate and score-band classes");
     }
     const range2 = rule3.scoreRange;
@@ -1570,6 +1570,7 @@ function areScoredRulesDisjoint(proposal, left, right) {
 // ../schemas/src/draft-required-decision.ts
 var typedResolutionPolicy = "strict-required-types/direct-overrides/v2";
 var valueAgreementOutcomeRegions = "outcome-regions";
+var freshnessStaleBeforeReview = "stale-before-review";
 var identifier8 = DraftEvidenceScopeSchema.shape.entityId;
 var duplicateIdentity = "Duplicate identity";
 var uniqueIds = z15.array(identifier8).max(64).refine(hasUniqueValues, duplicateIdentity);
@@ -1613,7 +1614,8 @@ var shape = z15.strictObject({
   scope: z15.strictObject({
     entityId: identifier8,
     evaluationTime: DraftObservationChecksSchema.shape.evaluationTime,
-    valueAgreement: z15.literal(valueAgreementOutcomeRegions).optional()
+    valueAgreement: z15.literal(valueAgreementOutcomeRegions).optional(),
+    freshness: z15.literal(freshnessStaleBeforeReview).optional()
   }),
   evidence: z15.array(DraftEvidenceValidationSchema).max(64)
 });
@@ -1658,19 +1660,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 = (id14) => {
-    if (visiting.has(id14)) {
+  const hasPathCycle = (id15) => {
+    if (visiting.has(id15)) {
       return true;
     }
-    if (visited.has(id14)) {
+    if (visited.has(id15)) {
       return false;
     }
-    visiting.add(id14);
-    if ((graph.get(id14) ?? []).some(hasPathCycle)) {
+    visiting.add(id15);
+    if ((graph.get(id15) ?? []).some(hasPathCycle)) {
       return true;
     }
-    visiting.delete(id14);
-    visited.add(id14);
+    visiting.delete(id15);
+    visited.add(id15);
     return false;
   };
   return rules2.some((item) => hasPathCycle(item.id));
@@ -1699,11 +1701,11 @@ function inspectRules(proposal, context3) {
         fail("Undeclared condition key or value");
       }
     }
-    if (item.overrides.some((id14) => id14 === item.id || !ids3.has(id14))) {
+    if (item.overrides.some((id15) => id15 === item.id || !ids3.has(id15))) {
       fail("Unknown or self override");
     }
-    if (item.overrides.some((id14) => {
-      const target2 = byId.get(id14);
+    if (item.overrides.some((id15) => {
+      const target2 = byId.get(id15);
       return target2 !== void 0 && draftRulePriority(target2) > draftRulePriority(item);
     })) {
       fail("Override points to a higher priority tier");
@@ -1876,8 +1878,8 @@ function checkExpected(candidate2, context3) {
   }
   unique2(result.observationIds, context3, ["expected", "observationIds"]);
   const observationIds = new Set(candidate2.observations.map((entry3) => entry3.id));
-  for (const [index, id14] of result.observationIds.entries()) {
-    requireBinding2(observationIds.has(id14), context3, {
+  for (const [index, id15] of result.observationIds.entries()) {
+    requireBinding2(observationIds.has(id15), context3, {
       path: ["expected", "observationIds", index],
       message: "Unknown observation"
     });
@@ -2261,11 +2263,11 @@ var sourceBundle = z21.strictObject({
   const identities = /* @__PURE__ */ new Set();
   for (const [sourceIndex, source3] of bundle.sources.entries()) {
     const at = ["sources", sourceIndex];
-    const identity = sourceKey(source3);
-    if (identities.has(identity)) {
+    const identity2 = sourceKey(source3);
+    if (identities.has(identity2)) {
       context3.addIssue({ code: "custom", path: at, message: "Duplicate source/revision" });
     }
-    identities.add(identity);
+    identities.add(identity2);
     const locators2 = /* @__PURE__ */ new Set();
     for (const [index, passage4] of source3.passages.entries()) {
       const path3 = [...at, "passages", index];
@@ -2414,10 +2416,11 @@ var DraftEvaluatorContractSchema = z24.strictObject({
   evaluator,
   calibration: z24.strictObject({ id: identifier13, version: identifier13, contentDigest: digest9 }),
   minimumSelectedProbability: z24.number().gt(0).max(1),
-  inputContextContract: z24.enum(["job-entity-time/v1", "job-only/v2"]).optional(),
+  inputContextContract: z24.enum(["job-entity-time/v1", "job-only/v2", "job-only/v3", "job-only/v4"]).optional(),
   probabilityContract: z24.enum([
     "closed-distribution-unique-maximum/v1",
-    "closed-distribution-with-abstention/v1"
+    "closed-distribution-with-abstention/v1",
+    "independent-option-support/v1"
   ])
 });
 var judgment = z24.discriminatedUnion("status", [
@@ -2425,11 +2428,25 @@ var judgment = z24.discriminatedUnion("status", [
     status: z24.literal("evaluated"),
     abstentionProbability: z24.number().min(0).max(1).optional(),
     promptInjectionProbability: z24.number().min(0).max(1).optional(),
+    applicabilityProbability: z24.number().min(0).max(1).optional(),
+    irrelevanceProbability: z24.number().min(0).max(1).optional(),
+    independentOptions: z24.array(z24.strictObject({
+      value: z24.string().min(1).max(200),
+      supported: z24.number().min(0).max(1),
+      ruledOut: z24.number().min(0).max(1),
+      unresolved: z24.number().min(0).max(1)
+    })).min(1).max(64).optional(),
     probabilities: z24.array(z24.strictObject({
       value: z24.string().min(1).max(200),
       probability: z24.number().min(0).max(1)
-    })).min(1).max(64)
-  }),
+    })).max(64)
+  }).refine((row2) => {
+    if (row2.independentOptions === void 0) {
+      return row2.probabilities.length > 0 && row2.applicabilityProbability === void 0 && row2.irrelevanceProbability === void 0;
+    }
+    const hasSignals = row2.applicabilityProbability !== void 0 && row2.promptInjectionProbability !== void 0 && row2.irrelevanceProbability !== void 0;
+    return row2.probabilities.length === 0 && row2.abstentionProbability === void 0 && hasSignals;
+  }, "Judgment score contracts must not be mixed"),
   z24.strictObject({ status: z24.enum(["abstained", "timeout", "malformed", "review_required"]) })
 ]);
 var DraftNormalizedEvidenceSchema = z24.strictObject({
@@ -3183,13 +3200,13 @@ function areSubjectsValid(subjects, isIsolated) {
 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((id14) => id14 !== null);
+  const named = [escalations.unresolved, escalations.attemptLimit].filter((id15) => id15 !== 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((id14) => ids3.has(id14))
+    named.every((id15) => ids3.has(id15))
   ].every(Boolean);
 }
 function isGuideValid(guide, isIsolated) {
@@ -3279,7 +3296,7 @@ var DraftContextSelectionPlanSchema = z31.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((id14) => candidateIds.includes(id14))) {
+  if (plan.requiredIds.some((id15) => candidateIds.includes(id15))) {
     context3.addIssue({ code: "custom", message: "Global required root cannot be a candidate" });
   }
   const guidanceId = plan.unresolvedGuidanceEntryId;
@@ -3870,7 +3887,20 @@ var DraftApplicationReleaseSchema = z43.strictObject({
 });
 
 // ../schemas/src/draft-hosted-application.ts
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
+
+// ../schemas/src/draft-decision-attempt.ts
+import { z as z44 } from "zod";
+var DecisionGraphAttemptSchema = z44.strictObject({
+  schema: z44.literal("felspar.decision-attempt/v1"),
+  executionId: z44.string().min(1).max(200),
+  releaseId: z44.string().min(1).max(200),
+  receiptDigest: z44.string().regex(/^sha256:[a-f0-9]{64}$/u),
+  ordinal: z44.number().int().min(1).max(12),
+  next: z44.enum(["decided", "retry", "escalate"]),
+  remaining: z44.number().int().min(0).max(10),
+  escalationId: z44.string().min(1).max(200).nullable()
+});
 
 // ../schemas/src/draft-source-instant.ts
 var localPattern = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?([^.\d].*)$/u;
@@ -3940,43 +3970,43 @@ function normalizedSourceInstant(value2) {
 }
 
 // ../schemas/src/draft-hosted-output-checks.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 
 // ../schemas/src/draft-artifact-check-manifest.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 
 // ../schemas/src/draft-artifact-lint-semantic.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 
 // ../schemas/src/draft-claim-evaluation-recipe.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 
 // ../schemas/src/draft-output-check.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var identifier19 = DraftContextPlanSchema.shape.job;
 var digest19 = DraftJobReceiptBodySchema.shape.inputDigest;
-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({
+var byteLimit = z45.number().int().min(1).max(65536);
+var text5 = z45.string().max(16384);
+var sectionRule = z45.discriminatedUnion("check", [
+  z45.strictObject({ id: identifier19, check: z45.literal("text"), maxBytes: byteLimit }),
+  z45.strictObject({
     id: identifier19,
-    check: z44.literal("exact"),
+    check: z45.literal("exact"),
     maxBytes: byteLimit,
-    alternatives: z44.array(text5.min(1).regex(/\S/u)).min(1).max(8).refine(hasUniqueValues)
+    alternatives: z45.array(text5.min(1).regex(/\S/u)).min(1).max(8).refine(hasUniqueValues)
   })
 ]);
 var draftOutputCheckerContract = "felspar.structured-output-check/v1";
-var DraftOutputContractSchema = z44.strictObject({
-  schema: z44.literal("felspar.output-contract.draft/v0"),
+var DraftOutputContractSchema = z45.strictObject({
+  schema: z45.literal("felspar.output-contract.draft/v0"),
   id: identifier19,
-  version: z44.number().int().min(1).max(65535),
+  version: z45.number().int().min(1).max(65535),
   compiledArtifactDigest: digest19,
   job: identifier19,
   trustDomain: identifier19,
   outputSurface: identifier19,
   maxBytes: byteLimit,
-  sections: z44.array(sectionRule).min(1).max(16)
+  sections: z45.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" });
@@ -3988,14 +4018,14 @@ var DraftOutputContractSchema = z44.strictObject({
     }
   }
 });
-var DraftStructuredOutputSchema = z44.strictObject({
-  schema: z44.literal("felspar.structured-output.draft/v0"),
+var DraftStructuredOutputSchema = z45.strictObject({
+  schema: z45.literal("felspar.structured-output.draft/v0"),
   id: identifier19,
   revision: identifier19,
-  sections: z44.array(z44.strictObject({ id: identifier19, text: text5 })).max(32).refine((sections) => hasUniqueValues(sections.map((section) => section.id)))
+  sections: z45.array(z45.strictObject({ id: identifier19, text: text5 })).max(32).refine((sections) => hasUniqueValues(sections.map((section) => section.id)))
 });
-var DraftOutputCheckSchema = z44.strictObject({
-  schema: z44.literal("felspar.output-check.draft/v0"),
+var DraftOutputCheckSchema = z45.strictObject({
+  schema: z45.literal("felspar.output-check.draft/v0"),
   execution: DraftJobExecutionSchema,
   expectedJobReceiptDigest: digest19,
   contractEntryId: identifier19,
@@ -4003,8 +4033,8 @@ var DraftOutputCheckSchema = z44.strictObject({
   output: DraftStructuredOutputSchema,
   expectedOutputDigest: digest19
 });
-var DraftOutputDiagnosticSchema = z44.strictObject({
-  code: z44.enum([
+var DraftOutputDiagnosticSchema = z45.strictObject({
+  code: z45.enum([
     "upstream_blocked",
     "contract_coverage_incomplete",
     "contract_invalid",
@@ -4017,13 +4047,13 @@ var DraftOutputDiagnosticSchema = z44.strictObject({
   ]),
   sectionId: identifier19.nullable()
 });
-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),
+var DraftOutputReceiptBodySchema = z45.strictObject({
+  schema: z45.literal("felspar.output-receipt.draft/v0"),
+  authority: z45.literal("unapproved"),
+  checkerContract: z45.literal(draftOutputCheckerContract),
+  coverage: z45.literal("declared_structure_and_exact_text"),
+  semanticEvaluation: z45.literal("not_performed"),
+  actionAuthorized: z45.literal(false),
   inputDigest: digest19,
   jobReceiptDigest: digest19,
   compiledArtifactDigest: digest19,
@@ -4032,39 +4062,39 @@ var DraftOutputReceiptBodySchema = z44.strictObject({
   outputDigest: digest19,
   outputId: identifier19,
   outputRevision: identifier19,
-  status: z44.enum(["checks_passed", "invalid", "blocked"]),
-  structuralOnlySectionIds: z44.array(identifier19).max(16),
-  diagnostics: z44.array(DraftOutputDiagnosticSchema).max(81)
+  status: z45.enum(["checks_passed", "invalid", "blocked"]),
+  structuralOnlySectionIds: z45.array(identifier19).max(16),
+  diagnostics: z45.array(DraftOutputDiagnosticSchema).max(81)
 });
 var DraftOutputReceiptSchema = DraftOutputReceiptBodySchema.extend({
   receiptDigest: digest19
 });
-var DraftOutputVerificationOptionsSchema = z44.strictObject({
+var DraftOutputVerificationOptionsSchema = z45.strictObject({
   expectedReceiptDigest: digest19
 });
 
 // ../schemas/src/draft-claim-evaluation-recipe.ts
 var scope = DraftOutputContractSchema.shape;
 var identifier20 = scope.id;
-var text6 = z45.string().min(1).max(2048).regex(/\S/u);
-var ids2 = z45.array(identifier20).max(8).refine(hasUniqueValues, "Duplicate identifier");
+var text6 = z46.string().min(1).max(2048).regex(/\S/u);
+var ids2 = z46.array(identifier20).max(8).refine(hasUniqueValues, "Duplicate identifier");
 var { judgment: judgment3 } = DraftNormalizedEvidenceSchema.shape.normalizations.element.shape;
-var option = z45.strictObject({
+var option = z46.strictObject({
   value: judgment3.options[0].shape.probabilities.element.shape.value,
   meaning: text6,
-  effect: z45.enum(["satisfied", "violated", "unresolved"])
+  effect: z46.enum(["satisfied", "violated", "unresolved"])
 });
-var question = z45.strictObject({
+var question = z46.strictObject({
   id: identifier20,
   sectionIds: ids2.min(1),
   instructions: text6,
   authorityEntryIds: ids2.min(1),
   evidenceKeys: ids2,
-  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)
+  options: z46.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: z46.number().gt(0).max(1)
 });
-var DraftClaimEvaluationRecipeSchema = z45.strictObject({
-  schema: z45.literal("felspar.claim-evaluation-recipe.draft/v0"),
+var DraftClaimEvaluationRecipeSchema = z46.strictObject({
+  schema: z46.literal("felspar.claim-evaluation-recipe.draft/v0"),
   id: identifier20,
   version: identifier20,
   compiledArtifactDigest: scope.compiledArtifactDigest,
@@ -4074,11 +4104,11 @@ var DraftClaimEvaluationRecipeSchema = z45.strictObject({
   evaluator: DraftEvaluatorContractSchema.shape.evaluator,
   calibration: DraftEvaluatorContractSchema.shape.calibration,
   probabilityContract: DraftEvaluatorContractSchema.shape.probabilityContract,
-  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)
+  questions: z46.array(question).min(1).max(8).refine((items) => hasUniqueValues(items.map((item) => item.id)), "Duplicate question"),
+  limits: z46.strictObject({
+    maxRequests: z46.number().int().min(1).max(128),
+    maxRequestBytes: z46.number().int().min(1).max(16384),
+    maxTotalBytes: z46.number().int().min(1).max(65536)
   })
 });
 
@@ -4095,85 +4125,85 @@ var artifactSemanticLimits = {
   maxRequestBytes: 32768,
   maxTotalBytes: 16777216
 };
-var ArtifactSemanticQuestionSchema = z46.strictObject({
+var ArtifactSemanticQuestionSchema = z47.strictObject({
   id: id3,
   instructions: recipeQuestion.instructions,
   options: recipeQuestion.options,
   minimumSelectedProbability: recipeQuestion.minimumSelectedProbability,
-  aggregation: z46.enum(["prohibit", "require", "match"])
+  aggregation: z47.enum(["prohibit", "require", "match"])
 });
-var ArtifactSemanticRecipeSchema = z46.strictObject({
+var ArtifactSemanticRecipeSchema = z47.strictObject({
   evaluator: recipe.evaluator,
   calibration: recipe.calibration,
   probabilityContract: recipe.probabilityContract,
-  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)
+  questions: z47.array(ArtifactSemanticQuestionSchema).min(1).max(artifactSemanticLimits.maxQuestions),
+  limits: z47.strictObject({
+    maxEvaluations: z47.number().int().min(1).max(artifactSemanticLimits.maxEvaluations),
+    maxRequestBytes: z47.number().int().min(1).max(artifactSemanticLimits.maxRequestBytes),
+    maxTotalBytes: z47.number().int().min(1).max(artifactSemanticLimits.maxTotalBytes)
   })
 });
-var ArtifactSemanticRequestSchema = z46.strictObject({
-  schema: z46.literal("felspar.artifact-question.draft/v1"),
+var ArtifactSemanticRequestSchema = z47.strictObject({
+  schema: z47.literal("felspar.artifact-question.draft/v1"),
   preparationDigest: digest20,
   unitId: id3,
   sectionId: id3,
-  start: z46.number().int().min(0),
-  end: z46.number().int().min(1),
+  start: z47.number().int().min(0),
+  end: z47.number().int().min(1),
   textDigest: digest20,
-  text: z46.string().min(1),
+  text: z47.string().min(1),
   questionId: id3,
   instructions: recipeQuestion.instructions,
-  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),
+  options: z47.array(z47.strictObject({ value: z47.string(), meaning: z47.string() })).min(2).max(8),
+  policy: z47.array(z47.strictObject({ sourceLocator: z47.string(), text: z47.string() })).min(1),
   evaluator: recipe.evaluator,
   calibration: recipe.calibration,
   requestDigest: digest20
 });
-var artifactInjectionScreen = z46.literal("paragraph-injection/v1");
-var ArtifactSemanticResponseSchema = z46.strictObject({
-  schema: z46.literal("felspar.artifact-question-response.draft/v1"),
+var artifactInjectionScreen = z47.literal("paragraph-injection/v1");
+var ArtifactSemanticResponseSchema = z47.strictObject({
+  schema: z47.literal("felspar.artifact-question-response.draft/v1"),
   screen: artifactInjectionScreen.optional(),
   preparationDigest: digest20,
   evaluator: recipe.evaluator,
   calibrationDigest: digest20,
-  answers: z46.array(z46.strictObject({ unitId: id3, questionId: id3, requestDigest: digest20, judgment: judgment4 })).max(artifactSemanticLimits.maxEvaluations)
+  answers: z47.array(z47.strictObject({ unitId: id3, questionId: id3, requestDigest: digest20, judgment: judgment4 })).max(artifactSemanticLimits.maxEvaluations)
 });
-var ArtifactSemanticJudgmentSchema = z46.strictObject({
+var ArtifactSemanticJudgmentSchema = z47.strictObject({
   unitId: id3,
   sectionId: id3,
-  start: z46.number().int().min(0),
-  end: z46.number().int().min(1),
+  start: z47.number().int().min(0),
+  end: z47.number().int().min(1),
   textDigest: digest20,
   questionId: id3,
   requestDigest: digest20,
   judgment: judgment4.nullable(),
-  value: z46.string().nullable(),
-  effect: z46.enum(["satisfied", "violated", "unresolved", "unavailable", "not_stated"]),
-  reasons: z46.array(z46.string().max(128)).max(8)
+  value: z47.string().nullable(),
+  effect: z47.enum(["satisfied", "violated", "unresolved", "unavailable", "not_stated"]),
+  reasons: z47.array(z47.string().max(128)).max(8)
 });
-var ArtifactSemanticRecordSchema = z46.strictObject({
-  state: z46.enum(["ready", "skipped", "over_budget", "not_evaluated"]),
+var ArtifactSemanticRecordSchema = z47.strictObject({
+  state: z47.enum(["ready", "skipped", "over_budget", "not_evaluated"]),
   screen: artifactInjectionScreen.optional(),
   preparationDigest: digest20,
   evaluator: ArtifactSemanticRecipeSchema.shape.evaluator,
   calibrationDigest: digest20,
   probabilityContract: ArtifactSemanticRecipeSchema.shape.probabilityContract,
-  questions: z46.array(ArtifactSemanticQuestionSchema.pick({
+  questions: z47.array(ArtifactSemanticQuestionSchema.pick({
     id: true,
     minimumSelectedProbability: true,
     aggregation: true
   }).extend({
     checkId: id3,
     anchorSectionId: id3,
-    sectionsAvailable: z46.boolean(),
-    units: z46.number().int().min(0).max(artifactSemanticLimits.maxEvaluations),
-    options: z46.array(z46.strictObject({
+    sectionsAvailable: z47.boolean(),
+    units: z47.number().int().min(0).max(artifactSemanticLimits.maxEvaluations),
+    options: z47.array(z47.strictObject({
       value: ArtifactSemanticQuestionSchema.shape.options.element.shape.value,
-      effect: z46.enum(["satisfied", "violated", "unresolved", "not_stated"])
+      effect: z47.enum(["satisfied", "violated", "unresolved", "not_stated"])
     })).min(2).max(8)
   })).max(artifactSemanticLimits.maxQuestions),
-  judgments: z46.array(ArtifactSemanticJudgmentSchema).max(artifactSemanticLimits.maxEvaluations)
+  judgments: z47.array(ArtifactSemanticJudgmentSchema).max(artifactSemanticLimits.maxEvaluations)
 });
 var caseNotStated = "not_stated";
 var abstain = "cannot_determine";
@@ -4231,12 +4261,12 @@ var artifactLintLimits = {
 function isWellFormedText(value2) {
   return !/\p{Cs}/u.test(value2);
 }
-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),
+var literal = z48.string().min(1).max(artifactLintLimits.maxLiteralUnits).regex(/\S/u).refine(isWellFormedText);
+var passage = z48.strictObject({
+  sourceLocator: z48.string().min(1).max(4096).regex(/\S/u),
   contentDigest: digest21
 });
-var common = { id: id4, required: z47.boolean(), specification: passage };
+var common = { id: id4, required: z48.boolean(), specification: passage };
 var artifactCheckKinds = [
   "section",
   "required_wording",
@@ -4249,64 +4279,64 @@ var artifactLintMediaTypes = [
   "text/plain",
   "application/vnd.felspar.structured-output+json"
 ];
-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({
+var sectionTargets = z48.array(id4).min(1).max(artifactLintLimits.maxSections);
+var ArtifactCheckSchema = z48.discriminatedUnion("kind", [
+  z48.strictObject({ ...common, kind: z48.literal("section"), sectionId: id4 }),
+  z48.strictObject({
     ...common,
-    kind: z47.literal("required_wording"),
+    kind: z48.literal("required_wording"),
     sectionId: id4,
-    alternatives: z47.array(literal).min(1).max(artifactLintLimits.maxAlternatives)
+    alternatives: z48.array(literal).min(1).max(artifactLintLimits.maxAlternatives)
   }),
-  z47.strictObject({
+  z48.strictObject({
     ...common,
-    kind: z47.literal("prohibited_literal"),
+    kind: z48.literal("prohibited_literal"),
     sectionIds: sectionTargets,
-    literals: z47.array(literal).min(1).max(artifactLintLimits.maxLiterals)
+    literals: z48.array(literal).min(1).max(artifactLintLimits.maxLiterals)
   }),
-  z47.strictObject({
+  z48.strictObject({
     ...common,
-    kind: z47.literal("field_value"),
+    kind: z48.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(),
+    label: z48.string().min(1).max(128).regex(/^[^\s:](?:[^\n\r:]*[^\s:])?$/u).refine(isWellFormedText),
+    unit: z48.string().min(1).max(32).regex(/^\S+$/u).refine(isWellFormedText).nullable(),
     evidenceKey: id4,
-    comparator: z47.enum(["eq", "lte", "gte"])
+    comparator: z48.enum(["eq", "lte", "gte"])
   }),
-  z47.strictObject({
+  z48.strictObject({
     ...common,
-    kind: z47.literal("case_answer"),
+    kind: z48.literal("case_answer"),
     sectionIds: sectionTargets,
-    fact: z47.discriminatedUnion("comparison", [
-      z47.strictObject({ key: id4, comparison: z47.literal("choice") }),
-      z47.strictObject({
+    fact: z48.discriminatedUnion("comparison", [
+      z48.strictObject({ key: id4, comparison: z48.literal("choice") }),
+      z48.strictObject({
         key: id4,
-        comparison: z47.literal("number"),
+        comparison: z48.literal("number"),
         reader: ExactReaderSchema.options[0]
       }),
-      z47.strictObject({
+      z48.strictObject({
         key: id4,
-        comparison: z47.literal("date"),
+        comparison: z48.literal("date"),
         reader: ExactReaderSchema.options[1]
       })
     ]),
-    answers: z47.array(z47.strictObject({
+    answers: z48.array(z48.strictObject({
       value: id4,
-      wording: z47.array(literal).max(artifactLintLimits.maxAlternatives)
+      wording: z48.array(literal).max(artifactLintLimits.maxAlternatives)
     })).max(artifactLintLimits.maxLiterals),
     questionId: id4.nullable()
   }),
-  z47.strictObject({
+  z48.strictObject({
     ...common,
-    kind: z47.literal("semantic_question"),
+    kind: z48.literal("semantic_question"),
     sectionIds: sectionTargets,
     questionId: id4
   })
 ]);
-var sectionDeclaration = z47.strictObject({
+var sectionDeclaration = z48.strictObject({
   id: id4,
-  heading: z47.string().min(1).max(256).regex(/\S/u).refine((value2) => !/[\n\r]/u.test(value2) && isWellFormedText(value2)).nullable(),
-  maxUnits: z47.number().int().min(1).max(artifactLintLimits.maxSectionUnits)
+  heading: z48.string().min(1).max(256).regex(/\S/u).refine((value2) => !/[\n\r]/u.test(value2) && isWellFormedText(value2)).nullable(),
+  maxUnits: z48.number().int().min(1).max(artifactLintLimits.maxSectionUnits)
 });
 function caseAnswerIssues(checks) {
   const issues = [];
@@ -4326,18 +4356,18 @@ function caseAnswerIssues(checks) {
   }
   return issues;
 }
-var ArtifactCheckManifestSchema = z47.strictObject({
-  schema: z47.literal("felspar.artifact-check-manifest.draft/v1"),
+var ArtifactCheckManifestSchema = z48.strictObject({
+  schema: z48.literal("felspar.artifact-check-manifest.draft/v1"),
   id: id4,
-  version: z47.number().int().min(1).max(65535),
+  version: z48.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),
+  contract: z48.strictObject({ id: id4, digest: digest21 }),
+  parser: z48.enum(["body", "headings"]),
+  maxBytes: z48.number().int().min(1).max(artifactLintLimits.maxTotalBytes),
+  sections: z48.array(sectionDeclaration).min(1).max(artifactLintLimits.maxSections),
+  caseContext: z48.enum(["required", "not_required"]),
+  checks: z48.array(ArtifactCheckSchema).min(1).max(artifactLintLimits.maxChecks),
   semantic: ArtifactSemanticRecipeSchema.nullable()
 }).superRefine((manifest2, context3) => {
   const issue = (message) => {
@@ -4382,11 +4412,11 @@ var ArtifactCheckManifestSchema = z47.strictObject({
 var ArtifactSpecificationSchema = passage;
 
 // ../schemas/src/draft-job-obligations-manifest.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 var id5 = DraftApplicationScopeSchema.shape.authorityId;
 var digest22 = DraftJobReceiptSchema.shape.receiptDigest;
 var passage2 = {
-  sourceLocator: z48.string().min(1).max(4096).regex(/\S/u),
+  sourceLocator: z49.string().min(1).max(4096).regex(/\S/u),
   contentDigest: digest22
 };
 var jobObligationsLimits = {
@@ -4397,41 +4427,41 @@ var jobObligationsLimits = {
   maxApprovalTargets: 16,
   maxManifestBytes: 65536
 };
-var DraftJobObligationsScopeSchema = z48.strictObject({
+var DraftJobObligationsScopeSchema = z49.strictObject({
   purposeRef: id5,
   useRef: id5.nullable()
 });
-var artifact = z48.strictObject({
+var artifact = z49.strictObject({
   id: id5,
   role: id5,
-  contract: z48.strictObject({ id: id5, digest: digest22 }),
+  contract: z49.strictObject({ id: id5, digest: digest22 }),
   ...passage2
 });
-var approval = z48.strictObject({
+var approval = z49.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") })
+  policy: z49.strictObject({ id: id5, ...passage2 }),
+  phase: z49.enum(["before_decision", "before_generation", "before_use"]),
+  appliesTo: z49.array(z49.discriminatedUnion("kind", [
+    z49.strictObject({ kind: z49.literal("decision") }),
+    z49.strictObject({ kind: z49.literal("artifact"), id: id5 }),
+    z49.strictObject({ kind: z49.literal("use") })
   ])).min(1).max(jobObligationsLimits.maxApprovalTargets)
 });
-var outcome = z48.strictObject({
+var outcome = z49.strictObject({
   outcomeId: id5,
   ...passage2,
-  contextRequired: z48.boolean(),
-  artifacts: z48.array(artifact).max(jobObligationsLimits.maxArtifacts),
-  approvals: z48.array(approval).max(jobObligationsLimits.maxApprovals)
+  contextRequired: z49.boolean(),
+  artifacts: z49.array(artifact).max(jobObligationsLimits.maxArtifacts),
+  approvals: z49.array(approval).max(jobObligationsLimits.maxApprovals)
 });
-var manifest = z48.strictObject({
-  schema: z48.literal("felspar.job-obligations.draft/v0"),
+var manifest = z49.strictObject({
+  schema: z49.literal("felspar.job-obligations.draft/v0"),
   jobId: id5,
   trustDomain: id5,
   scope: DraftJobObligationsScopeSchema,
   source: DraftSourceReferenceSchema,
-  contracts: z48.array(z48.strictObject({ id: id5, ...passage2 })).max(jobObligationsLimits.maxContracts),
-  outcomes: z48.array(outcome).min(1).max(jobObligationsLimits.maxOutcomes)
+  contracts: z49.array(z49.strictObject({ id: id5, ...passage2 })).max(jobObligationsLimits.maxContracts),
+  outcomes: z49.array(outcome).min(1).max(jobObligationsLimits.maxOutcomes)
 });
 function unique3(values, context3, path3) {
   const distinct = new Set(values);
@@ -4502,10 +4532,10 @@ var DraftJobObligationsOutcomeSchema = outcome;
 
 // ../schemas/src/draft-hosted-output-checks.ts
 var hostedOutputCheckLimits = { maxOutputs: 8 };
-var HostedOutputChecksSchema = z49.strictObject({
-  schema: z49.literal("felspar.output-checks.draft/v0"),
+var HostedOutputChecksSchema = z50.strictObject({
+  schema: z50.literal("felspar.output-checks.draft/v0"),
   obligations: DraftJobObligationsSchema,
-  manifests: z49.array(ArtifactCheckManifestSchema).min(1).max(hostedOutputCheckLimits.maxOutputs)
+  manifests: z50.array(ArtifactCheckManifestSchema).min(1).max(hostedOutputCheckLimits.maxOutputs)
 }).superRefine((value2, context3) => {
   if (context3.issues.length > 0) {
     return;
@@ -4532,13 +4562,13 @@ var HostedOutputChecksSchema = z49.strictObject({
 });
 
 // ../schemas/src/draft-pack-revision.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 
 // ../schemas/src/draft-pack-draft-outputs.ts
-import { z as z50 } from "zod";
-var identifier21 = z50.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/u, "Use lowercase letters, digits, - and _");
-var quote = z50.string().min(1).max(4e3);
-var wording = z50.string().min(1).max(artifactLintLimits.maxLiteralUnits).regex(/\S/u, "Wording needs a visible character").refine(isWellFormedText, "Wording has a broken character");
+import { z as z51 } from "zod";
+var identifier21 = z51.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/u, "Use lowercase letters, digits, - and _");
+var quote = z51.string().min(1).max(4e3);
+var wording = z51.string().min(1).max(artifactLintLimits.maxLiteralUnits).regex(/\S/u, "Wording needs a visible character").refine(isWellFormedText, "Wording has a broken character");
 var packDraftOutputLimits = {
   maxOutputs: 8,
   maxChecks: 16,
@@ -4547,26 +4577,26 @@ var packDraftOutputLimits = {
   defaultCharacters: 8e3,
   maxCharacters: artifactLintLimits.maxSectionUnits
 };
-var wordingCheck = (max) => z50.strictObject({ id: identifier21, quote, wording: z50.array(wording).min(1).max(max) });
-var PackDraftOutputSchema = z50.strictObject({
+var wordingCheck = (max) => z51.strictObject({ id: identifier21, quote, wording: z51.array(wording).min(1).max(max) });
+var PackDraftOutputSchema = z51.strictObject({
   id: identifier21,
   what: quote,
-  outcomes: z50.array(identifier21).min(1).max(64).refine(hasUniqueValues, "Duplicate outcome"),
-  maxCharacters: z50.number().int().min(1).max(packDraftOutputLimits.maxCharacters).optional(),
-  context: z50.array(z50.strictObject({ id: identifier21, quote })).min(1).max(packDraftOutputLimits.maxContext).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate context id").optional(),
-  require: z50.array(wordingCheck(artifactLintLimits.maxAlternatives)).max(packDraftOutputLimits.maxChecks).optional(),
-  prohibit: z50.array(wordingCheck(artifactLintLimits.maxLiterals)).max(packDraftOutputLimits.maxChecks).optional(),
-  ask: z50.array(z50.strictObject({
+  outcomes: z51.array(identifier21).min(1).max(64).refine(hasUniqueValues, "Duplicate outcome"),
+  maxCharacters: z51.number().int().min(1).max(packDraftOutputLimits.maxCharacters).optional(),
+  context: z51.array(z51.strictObject({ id: identifier21, quote })).min(1).max(packDraftOutputLimits.maxContext).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate context id").optional(),
+  require: z51.array(wordingCheck(artifactLintLimits.maxAlternatives)).max(packDraftOutputLimits.maxChecks).optional(),
+  prohibit: z51.array(wordingCheck(artifactLintLimits.maxLiterals)).max(packDraftOutputLimits.maxChecks).optional(),
+  ask: z51.array(z51.strictObject({
     id: identifier21,
     quote,
-    kind: z50.enum(["require", "prohibit"]),
-    question: z50.string().min(1).max(2e3).regex(/\S/u)
+    kind: z51.enum(["require", "prohibit"]),
+    question: z51.string().min(1).max(2e3).regex(/\S/u)
   })).max(packDraftOutputLimits.maxQuestions).optional(),
-  states: z50.array(z50.strictObject({
+  states: z51.array(z51.strictObject({
     id: identifier21,
     quote,
     question: identifier21,
-    wording: z50.record(identifier21, z50.array(wording).min(1).max(8)).optional()
+    wording: z51.record(identifier21, z51.array(wording).min(1).max(8)).optional()
   })).max(packDraftOutputLimits.maxQuestions).optional()
 }).refine((output) => {
   const ids3 = [
@@ -4581,12 +4611,12 @@ var PackDraftOutputSchema = z50.strictObject({
 }, `At most ${packDraftOutputLimits.maxQuestions} asked questions and stated answers together`).refine((output) => {
   return (output.require?.length ?? 0) + (output.prohibit?.length ?? 0) + (output.ask?.length ?? 0) + (output.states?.length ?? 0) > 0;
 }, "An output needs at least one check");
-var PackDraftOutputsSchema = z50.array(PackDraftOutputSchema).min(1).max(packDraftOutputLimits.maxOutputs).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate output");
+var PackDraftOutputsSchema = z51.array(PackDraftOutputSchema).min(1).max(packDraftOutputLimits.maxOutputs).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate output");
 
 // ../schemas/src/draft-pack-draft-scoring.ts
-import { z as z51 } from "zod";
-var points = z51.number().min(0).max(1e6);
-var PackDraftScoreSchema = z51.strictObject({
+import { z as z52 } from "zod";
+var points = z52.number().min(0).max(1e6);
+var PackDraftScoreSchema = z52.strictObject({
   lt: points.optional(),
   lte: points.optional(),
   gt: points.optional(),
@@ -4605,33 +4635,33 @@ var PackDraftScoreSchema = z51.strictObject({
     context3.addIssue({ code: "custom", message: "eq stands alone" });
   }
 });
-var contribution2 = z51.strictObject({
+var contribution2 = z52.strictObject({
   id: draftIdentifier,
   points,
   quote: draftQuote,
   when: PackDraftConditionsSchema
 });
-var criterion2 = z51.strictObject({
+var criterion2 = z52.strictObject({
   id: draftIdentifier,
   meaning: draftQuote,
   activeWhen: PackDraftConditionsSchema.optional(),
-  points: z51.array(contribution2).min(1).max(16).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate points id"),
-  otherwise: z51.strictObject({ points, quote: draftQuote }).optional()
+  points: z52.array(contribution2).min(1).max(16).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate points id"),
+  otherwise: z52.strictObject({ points, quote: draftQuote }).optional()
 });
-var PackDraftScoringSchema = z51.strictObject({
-  scale: z51.union([z51.literal(1), z51.literal(100)]).optional(),
-  criteria: z51.array(criterion2).min(1).max(16).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate criterion")
+var PackDraftScoringSchema = z52.strictObject({
+  scale: z52.union([z52.literal(1), z52.literal(100)]).optional(),
+  criteria: z52.array(criterion2).min(1).max(16).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate criterion")
 });
 var packDraftScoreExpectation = {
-  score: z51.number().min(0).optional(),
-  points: z51.record(draftIdentifier, z51.number().min(0).nullable()).optional()
+  score: z52.number().min(0).optional(),
+  points: z52.record(draftIdentifier, z52.number().min(0).nullable()).optional()
 };
 
 // ../schemas/src/draft-pack-draft.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 
 // ../schemas/src/draft-pack-draft-coverage.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 var coverageDispositions = ["represented", "needs_review", "unsupported"];
 var coverageTargetKinds = [
   "question",
@@ -4655,16 +4685,16 @@ var coverageFields = [
   "outputChecks",
   "subject"
 ];
-var target = z52.union([
-  ...coverageTargetKinds.map((kind) => z52.strictObject({ [kind]: draftIdentifier })),
-  z52.strictObject({ field: z52.enum(coverageFields) })
+var target = z53.union([
+  ...coverageTargetKinds.map((kind) => z53.strictObject({ [kind]: draftIdentifier })),
+  z53.strictObject({ field: z53.enum(coverageFields) })
 ]);
-var entry2 = z52.strictObject({
+var entry2 = z53.strictObject({
   quote: draftQuote,
-  categories: z52.array(z52.enum(authorityPrimitives)).min(1).max(authorityPrimitives.length).refine(hasUniqueValues, "Duplicate category"),
-  disposition: z52.enum(coverageDispositions),
-  carriedBy: z52.array(target).min(1).max(16).optional(),
-  why: z52.string().min(1).max(600).optional()
+  categories: z53.array(z53.enum(authorityPrimitives)).min(1).max(authorityPrimitives.length).refine(hasUniqueValues, "Duplicate category"),
+  disposition: z53.enum(coverageDispositions),
+  carriedBy: z53.array(target).min(1).max(16).optional(),
+  why: z53.string().min(1).max(600).optional()
 }).superRefine((row2, context3) => {
   const isRepresented = row2.disposition === "represented";
   if (isRepresented && row2.carriedBy === void 0) {
@@ -4689,10 +4719,10 @@ var entry2 = z52.strictObject({
     });
   }
 });
-var PackDraftCoverageSchema = z52.array(entry2).min(1).max(128);
+var PackDraftCoverageSchema = z53.array(entry2).min(1).max(128);
 
 // ../schemas/src/draft-pack-draft-readings.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 var readingCheckLimits = {
   maxPerAnswer: 8,
   maxPerCheck: 96,
@@ -4700,13 +4730,13 @@ var readingCheckLimits = {
   maxCharacters: 2e3,
   maxLabelCharacters: 120
 };
-var PackDraftReadingTestSchema = z53.strictObject({
+var PackDraftReadingTestSchema = z54.strictObject({
   id: draftIdentifier,
   question: draftIdentifier,
-  text: z53.string().trim().min(1).max(readingCheckLimits.maxCharacters),
+  text: z54.string().trim().min(1).max(readingCheckLimits.maxCharacters),
   expect: draftValue
 });
-var PackDraftReadingTestsSchema = z53.array(PackDraftReadingTestSchema).min(1).max(readingCheckLimits.maxKept).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate reading test");
+var PackDraftReadingTestsSchema = z54.array(PackDraftReadingTestSchema).min(1).max(readingCheckLimits.maxKept).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate reading test");
 function readingTestIssue(row2, questions, path3) {
   const question3 = questions.find((item) => item.key === row2.question);
   if (question3 === void 0 || question3.type !== void 0 || question3.derive !== void 0) {
@@ -4742,18 +4772,18 @@ function readingTestIssues(tests, questions) {
   }
   return issues;
 }
-var variant = z53.strictObject({
+var variant = z54.strictObject({
   id: draftIdentifier.optional(),
   question: draftIdentifier,
-  text: z53.string().trim().min(1).max(readingCheckLimits.maxCharacters),
+  text: z54.string().trim().min(1).max(readingCheckLimits.maxCharacters),
   expect: draftValue.optional(),
-  label: z53.string().trim().min(1).max(readingCheckLimits.maxLabelCharacters).optional()
+  label: z54.string().trim().min(1).max(readingCheckLimits.maxLabelCharacters).optional()
 });
-var ReadingCheckRequestSchema = z53.strictObject({
-  sourceObjectId: z53.string().min(1).max(200),
-  draft: z53.unknown(),
-  variants: z53.array(variant).max(readingCheckLimits.maxPerCheck).optional(),
-  includeTests: z53.boolean().default(true)
+var ReadingCheckRequestSchema = z54.strictObject({
+  sourceObjectId: z54.string().min(1).max(200),
+  draft: z54.unknown(),
+  variants: z54.array(variant).max(readingCheckLimits.maxPerCheck).optional(),
+  includeTests: z54.boolean().default(true)
 });
 var readingResults = ["as_expected", "different", "held", "read", "not_read"];
 var readingReasons = [
@@ -4765,36 +4795,36 @@ var readingReasons = [
   "limit_reached",
   "not_answered"
 ];
-var probability = z53.number().min(0).max(1);
-var ReadingOutcomeSchema = z53.strictObject({
-  id: z53.string().min(1).max(200),
-  origin: z53.enum(["test", "sent"]),
-  question: z53.string().min(1).max(200),
-  label: z53.string().optional(),
-  expect: z53.string().nullable(),
-  result: z53.enum(readingResults),
-  picked: z53.string().nullable(),
-  leaning: z53.string().nullable(),
+var probability = z54.number().min(0).max(1);
+var ReadingOutcomeSchema = z54.strictObject({
+  id: z54.string().min(1).max(200),
+  origin: z54.enum(["test", "sent"]),
+  question: z54.string().min(1).max(200),
+  label: z54.string().optional(),
+  expect: z54.string().nullable(),
+  result: z54.enum(readingResults),
+  picked: z54.string().nullable(),
+  leaning: z54.string().nullable(),
   confidence: probability.nullable(),
   bar: probability,
-  reason: z53.enum(readingReasons).nullable()
+  reason: z54.enum(readingReasons).nullable()
 });
-var count = z53.number().int().min(0);
-var counts = z53.strictObject({
+var count = z54.number().int().min(0);
+var counts = z54.strictObject({
   as_expected: count,
   different: count,
   held: count,
   read: count,
   not_read: count
 });
-var ReadingCheckSchema = z53.strictObject({
-  schema: z53.literal("felspar.reading-check/v0"),
-  authority: z53.literal("unapproved"),
-  jobId: z53.string(),
-  status: z53.enum(["clean", "misses", "incomplete"]),
+var ReadingCheckSchema = z54.strictObject({
+  schema: z54.literal("felspar.reading-check/v0"),
+  authority: z54.literal("unapproved"),
+  jobId: z54.string(),
+  status: z54.enum(["clean", "misses", "incomplete"]),
   counts,
-  questions: z53.array(z53.strictObject({ question: z53.string(), bar: probability, counts })),
-  readings: z53.array(ReadingOutcomeSchema)
+  questions: z54.array(z54.strictObject({ question: z54.string(), bar: probability, counts })),
+  readings: z54.array(ReadingOutcomeSchema)
 });
 
 // ../schemas/src/draft-pack-draft.ts
@@ -4808,18 +4838,18 @@ var packDraftVersions = [
   "felspar.pack-draft/v1",
   "felspar.pack-draft/v2"
 ];
-var answers = z54.array(z54.strictObject({
+var answers = z55.array(z55.strictObject({
   value,
   meaning: quote2,
-  inclusions: z54.array(quote2).max(8).optional(),
-  exclusions: z54.array(quote2).max(8).optional(),
-  examples: z54.array(quote2).max(8).optional(),
-  edgeCases: z54.array(quote2).max(8).optional(),
-  noneOfThese: z54.literal(true).optional()
+  inclusions: z55.array(quote2).max(8).optional(),
+  exclusions: z55.array(quote2).max(8).optional(),
+  examples: z55.array(quote2).max(8).optional(),
+  edgeCases: z55.array(quote2).max(8).optional(),
+  noneOfThese: z55.literal(true).optional()
 })).min(2).max(64).refine((rows) => hasUniqueValues(rows.map((row2) => row2.value)), "Duplicate answer").refine((rows) => rows.filter((row2) => row2.noneOfThese === true).length <= 1, "Only one answer may be noneOfThese");
-var derive = z54.strictObject({
+var derive = z55.strictObject({
   from: identifier22,
-  when: z54.record(value, z54.union([value, z54.array(value).min(2).max(64)])),
+  when: z55.record(value, z55.union([value, z55.array(value).min(2).max(64)])),
   otherwise: value.optional()
 });
 var notDerived = [
@@ -4864,26 +4894,26 @@ function deriveIssues(row2) {
   }
   return issues;
 }
-var evidenceKinds = z54.array(identifier22).min(1).max(8).refine(hasUniqueValues, "Duplicate kind");
-var evidenceAge = z54.number().int().min(1).max(3650);
-var questionEvidence = z54.strictObject({
+var evidenceKinds = z55.array(identifier22).min(1).max(8).refine(hasUniqueValues, "Duplicate kind");
+var evidenceAge = z55.number().int().min(1).max(3650);
+var questionEvidence = z55.strictObject({
   evidenceKinds: evidenceKinds.optional(),
   maxEvidenceAgeDays: evidenceAge.optional(),
   quote: quote2
 }).refine((row2) => row2.evidenceKinds !== void 0 || row2.maxEvidenceAgeDays !== void 0, "Give evidenceKinds, maxEvidenceAgeDays or both");
-var minimumConfidence = z54.number().min(0.5).max(0.99);
-var question2 = z54.strictObject({
+var minimumConfidence = z55.number().min(0.5).max(0.99);
+var question2 = z55.strictObject({
   key: identifier22,
   meaning: quote2,
   answers: answers.optional(),
   ...typedQuestionFields,
   askOnlyWhen: conditions.optional(),
-  whereToLook: z54.array(quote2).max(8).optional(),
+  whereToLook: z55.array(quote2).max(8).optional(),
   about: identifier22.optional(),
   derive: derive.optional(),
   evidence: questionEvidence.optional(),
   minimumConfidence: minimumConfidence.optional(),
-  highConsequence: z54.literal(true).optional()
+  highConsequence: z55.literal(true).optional()
 }).superRefine((row2, context3) => {
   if (row2.type !== void 0 && row2.highConsequence !== void 0) {
     context3.addIssue({
@@ -4906,57 +4936,57 @@ var question2 = z54.strictObject({
     context3.addIssue({ code: "custom", ...issue });
   }
 });
-var shape3 = z54.strictObject({
-  schema: z54.enum(packDraftVersions),
+var shape3 = z55.strictObject({
+  schema: z55.enum(packDraftVersions),
   job: identifier22,
   purpose: quote2.optional(),
-  useWhen: z54.array(quote2).min(1).max(8).optional(),
-  notFor: z54.array(quote2).min(1).max(8).optional(),
+  useWhen: z55.array(quote2).min(1).max(8).optional(),
+  notFor: z55.array(quote2).min(1).max(8).optional(),
   owner: quote2.optional(),
   evidenceKinds,
   maxEvidenceAgeDays: evidenceAge,
-  manualFacts: z54.strictObject({ allowed: z54.literal(false), quote: quote2 }).optional(),
+  manualFacts: z55.strictObject({ allowed: z55.literal(false), quote: quote2 }).optional(),
   ...packConventionFields,
   businessDays: PackDraftBusinessDaysSchema.optional(),
-  questions: z54.array(question2).min(1).max(64).refine((rows) => hasUniqueValues(rows.map((row2) => row2.key)), "Duplicate question"),
+  questions: z55.array(question2).min(1).max(64).refine((rows) => hasUniqueValues(rows.map((row2) => row2.key)), "Duplicate question"),
   subjects: PackDraftSubjectsSchema.optional(),
   subject: identifier22.optional(),
   escalations: PackDraftEscalationsSchema.optional(),
-  outcomes: z54.array(z54.strictObject({
+  outcomes: z55.array(z55.strictObject({
     id: identifier22,
     nextStep: quote2,
     escalate: identifier22.optional()
   })).min(1).max(64).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate outcome"),
-  whenUnresolved: z54.union([quote2, z54.strictObject({ quote: quote2, escalate: identifier22 })]),
-  attempts: z54.strictObject({
-    max: z54.number().int().min(1).max(10).optional(),
+  whenUnresolved: z55.union([quote2, z55.strictObject({ quote: quote2, escalate: identifier22 })]),
+  attempts: z55.strictObject({
+    max: z55.number().int().min(1).max(10).optional(),
     escalate: identifier22.optional()
   }).optional(),
   scoring: PackDraftScoringSchema.optional(),
-  ruleOrder: z54.enum(ruleOrders).optional(),
-  rules: z54.array(z54.strictObject({
+  ruleOrder: z55.enum(ruleOrders).optional(),
+  rules: z55.array(z55.strictObject({
     id: identifier22,
     meaning: quote2,
     when: conditions.optional(),
     score: PackDraftScoreSchema.optional(),
-    gate: z54.literal(true).optional(),
+    gate: z55.literal(true).optional(),
     outcome: identifier22,
-    except: z54.array(identifier22).min(1).max(16).refine(hasUniqueValues, "Duplicate rule").optional()
+    except: z55.array(identifier22).min(1).max(16).refine(hasUniqueValues, "Duplicate rule").optional()
   })).min(1).max(256).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate rule"),
-  cases: z54.array(z54.strictObject({
+  cases: z55.array(z55.strictObject({
     id: identifier22,
-    why: z54.string().min(1).max(2e3),
-    facts: z54.record(identifier22, caseFactSchema),
+    why: z55.string().min(1).max(2e3),
+    facts: z55.record(identifier22, caseFactSchema),
     decisionDate: caseDecisionDate,
-    subject: z54.strictObject({ id: SubjectIdSchema }).optional(),
-    expect: z54.union([
-      z54.strictObject({
+    subject: z55.strictObject({ id: SubjectIdSchema }).optional(),
+    expect: z55.union([
+      z55.strictObject({
         outcome: identifier22,
         rule: identifier22,
         escalation: identifier22.optional(),
         ...packDraftScoreExpectation
       }),
-      z54.strictObject({ held: z54.enum(heldStates), ...packDraftScoreExpectation })
+      z55.strictObject({ held: z55.enum(heldStates), ...packDraftScoreExpectation })
     ])
   })).min(1).max(200).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate case"),
   outputChecks: PackDraftOutputsSchema.optional(),
@@ -5019,107 +5049,107 @@ var PackDraftSchema = shape3.superRefine((draft, context3) => {
 });
 
 // ../schemas/src/draft-pack-revision.ts
-var KeptPackDraftSchema = z55.looseObject({
-  schema: z55.string().regex(/^felspar\.pack-draft\/v\d{1,3}$/u),
-  job: z55.string().min(1).max(200)
+var KeptPackDraftSchema = z56.looseObject({
+  schema: z56.string().regex(/^felspar\.pack-draft\/v\d{1,3}$/u),
+  job: z56.string().min(1).max(200)
 });
-var id6 = z55.string().min(1).max(200);
-var text7 = z55.string().min(1).max(262144);
-var texts = z55.array(z55.string()).max(8);
+var id6 = z56.string().min(1).max(200);
+var text7 = z56.string().min(1).max(262144);
+var texts = z56.array(z56.string()).max(8);
 var when = PackDraftConditionsSchema;
 var conventions = packConventionFields;
-var PackOutlineSchema = z55.strictObject({
-  schema: z55.literal("felspar.pack-outline/v0"),
+var PackOutlineSchema = z56.strictObject({
+  schema: z56.literal("felspar.pack-outline/v0"),
   job: id6,
   purpose: text7.nullable(),
   useWhen: texts,
   notFor: texts,
   owner: text7.nullable(),
-  evidenceKinds: z55.array(id6).max(8),
-  maxEvidenceAgeDays: z55.number().int().min(1).nullable(),
-  numberStyle: z55.enum(numberStyles).nullable(),
+  evidenceKinds: z56.array(id6).max(8),
+  maxEvidenceAgeDays: z56.number().int().min(1).nullable(),
+  numberStyle: z56.enum(numberStyles).nullable(),
   dateOrder: conventions.dateOrder.unwrap().nullable(),
-  timeZone: z55.string().min(1).max(64).nullable(),
+  timeZone: z56.string().min(1).max(64).nullable(),
   businessDays: PackDraftBusinessDaysSchema.nullable(),
   subject: id6.nullable(),
-  subjects: z55.array(z55.strictObject({
+  subjects: z56.array(z56.strictObject({
     id: id6,
     definition: text7,
-    identifier: z55.string().nullable(),
-    example: z55.string().nullable(),
-    match: z55.string(),
-    relationships: z55.array(z55.strictObject({
+    identifier: z56.string().nullable(),
+    example: z56.string().nullable(),
+    match: z56.string(),
+    relationships: z56.array(z56.strictObject({
       name: id6,
       subject: id6,
-      cardinality: z55.enum(["one", "many"]),
-      required: z55.boolean(),
+      cardinality: z56.enum(["one", "many"]),
+      required: z56.boolean(),
       definition: text7
     })).max(16),
     identity: PackDraftIdentitySchema.nullable()
   })).max(16),
-  escalations: z55.array(z55.strictObject({ id: id6, quote: text7 })).max(16),
-  questions: z55.array(z55.strictObject({
+  escalations: z56.array(z56.strictObject({ id: id6, quote: text7 })).max(16),
+  questions: z56.array(z56.strictObject({
     key: id6,
-    type: z55.enum(["enum", "boolean", "number", "date"]),
+    type: z56.enum(["enum", "boolean", "number", "date"]),
     meaning: text7,
     about: id6.nullable(),
-    askOnlyWhen: z55.string().nullable(),
+    askOnlyWhen: z56.string().nullable(),
     when: when.nullable(),
-    unit: z55.string().nullable(),
-    unitWords: z55.array(z55.string()).max(16).nullable(),
-    integer: z55.boolean().nullable(),
-    minimum: z55.number().nullable(),
-    maximum: z55.number().nullable(),
-    answers: z55.array(z55.strictObject({
+    unit: z56.string().nullable(),
+    unitWords: z56.array(z56.string()).max(16).nullable(),
+    integer: z56.boolean().nullable(),
+    minimum: z56.number().nullable(),
+    maximum: z56.number().nullable(),
+    answers: z56.array(z56.strictObject({
       value: id6,
-      meaning: z55.string().nullable(),
+      meaning: z56.string().nullable(),
       inclusions: texts,
       exclusions: texts,
       examples: texts,
       edgeCases: texts
     })).max(64),
     whereToLook: texts,
-    evidence: z55.strictObject({
-      evidenceKinds: z55.array(id6).max(8).nullable(),
-      maxEvidenceAgeDays: z55.number().int().min(1).nullable(),
+    evidence: z56.strictObject({
+      evidenceKinds: z56.array(id6).max(8).nullable(),
+      maxEvidenceAgeDays: z56.number().int().min(1).nullable(),
       quote: text7
     }).nullable(),
-    minimumConfidence: z55.number().nullable()
+    minimumConfidence: z56.number().nullable()
   })).max(64),
-  outcomes: z55.array(z55.strictObject({ id: id6, nextStep: text7.nullable(), escalate: id6.nullable() })).max(64),
-  whenUnresolved: z55.strictObject({ quote: text7, escalate: id6.nullable() }).nullable(),
-  attempts: z55.strictObject({ max: z55.number().int(), escalate: id6.nullable() }).nullable(),
-  rules: z55.array(z55.strictObject({
+  outcomes: z56.array(z56.strictObject({ id: id6, nextStep: text7.nullable(), escalate: id6.nullable() })).max(64),
+  whenUnresolved: z56.strictObject({ quote: text7, escalate: id6.nullable() }).nullable(),
+  attempts: z56.strictObject({ max: z56.number().int(), escalate: id6.nullable() }).nullable(),
+  rules: z56.array(z56.strictObject({
     id: id6,
     meaning: text7,
     outcome: id6,
     when: when.nullable(),
-    conditions: z55.string().nullable(),
-    scoreRange: z55.record(z55.string(), z55.unknown()).nullable(),
+    conditions: z56.string().nullable(),
+    scoreRange: z56.record(z56.string(), z56.unknown()).nullable(),
     score: PackDraftScoreSchema.nullable(),
-    gate: z55.boolean(),
-    except: z55.array(id6).max(16).nullable()
+    gate: z56.boolean(),
+    except: z56.array(id6).max(16).nullable()
   })).max(256),
-  ruleOrder: z55.enum(ruleOrders).nullable(),
+  ruleOrder: z56.enum(ruleOrders).nullable(),
   scoring: PackDraftScoringSchema.nullable(),
-  cases: z55.array(z55.strictObject({
+  cases: z56.array(z56.strictObject({
     id: id6,
-    why: z55.string().nullable(),
-    facts: z55.record(id6, caseFactSchema),
+    why: z56.string().nullable(),
+    facts: z56.record(id6, caseFactSchema),
     decisionDate: CalendarDateSchema.nullable(),
-    subject: z55.strictObject({ id: id6 }).nullable(),
-    expect: z55.union([
-      z55.strictObject({ outcome: id6, rule: id6, score: z55.number().nullable() }),
-      z55.strictObject({ held: z55.enum(heldStates), score: z55.number().nullable() })
+    subject: z56.strictObject({ id: id6 }).nullable(),
+    expect: z56.union([
+      z56.strictObject({ outcome: id6, rule: id6, score: z56.number().nullable() }),
+      z56.strictObject({ held: z56.enum(heldStates), score: z56.number().nullable() })
     ])
   })).max(200),
   outputChecks: PackDraftOutputsSchema.nullable(),
-  manualFacts: z55.strictObject({ allowed: z55.literal(false), quote: z55.string().min(1) }).nullable(),
-  notKept: z55.array(z55.strictObject({ path: z55.string().min(1), reason: z55.string().min(1) })).max(64)
+  manualFacts: z56.strictObject({ allowed: z56.literal(false), quote: z56.string().min(1) }).nullable(),
+  notKept: z56.array(z56.strictObject({ path: z56.string().min(1), reason: z56.string().min(1) })).max(64)
 });
 
 // ../schemas/src/draft-bar-calibration.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 var barCalibrationPolicy = {
   lowestBar: 0.8,
   highestBar: 0.99,
@@ -5130,32 +5160,32 @@ var barCalibrationPolicy = {
 };
 var barCalibrationId = "felspar-backtest-bar";
 var barCalibrationVersion = "v1";
-var id7 = z56.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
-var digest23 = z56.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var share = z56.number().min(0).max(1);
-var bar = z56.number().min(barCalibrationPolicy.lowestBar).max(barCalibrationPolicy.highestBar);
-var BacktestLabelSchema = z56.strictObject({
+var id7 = z57.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+var digest23 = z57.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var share = z57.number().min(0).max(1);
+var bar = z57.number().min(barCalibrationPolicy.lowestBar).max(barCalibrationPolicy.highestBar);
+var BacktestLabelSchema = z57.strictObject({
   executionObjectId: id7,
   question: draftValue,
   answer: draftValue.nullable()
 });
-var BacktestLabelsSchema = z56.array(BacktestLabelSchema).min(1).max(barCalibrationPolicy.maxLabels).refine((rows) => {
+var BacktestLabelsSchema = z57.array(BacktestLabelSchema).min(1).max(barCalibrationPolicy.maxLabels).refine((rows) => {
   const seen = new Set(rows.map((row2) => JSON.stringify([row2.executionObjectId, row2.question])));
   return seen.size === rows.length;
 }, "Label each question of a case once");
 var calibrationReadings = ["right", "wrong", "held"];
-var caseRow = z56.strictObject({
+var caseRow = z57.strictObject({
   executionObjectId: id7,
   label: draftValue.nullable(),
   leaning: draftValue.nullable(),
   confidence: share.nullable(),
-  atCurrentBar: z56.enum(calibrationReadings),
-  atSuggestedBar: z56.enum(calibrationReadings).nullable()
+  atCurrentBar: z57.enum(calibrationReadings),
+  atSuggestedBar: z57.enum(calibrationReadings).nullable()
 });
-var barRow = z56.strictObject({
+var barRow = z57.strictObject({
   bar,
-  decided: z56.number().int().min(0),
-  right: z56.number().int().min(0),
+  decided: z57.number().int().min(0),
+  right: z57.number().int().min(0),
   precision: share.nullable(),
   coverage: share
 });
@@ -5165,113 +5195,163 @@ var calibrationStatuses = [
   "coverage_gap",
   "needs_more_evidence_or_rewrite"
 ];
-var QuestionCalibrationSchema = z56.strictObject({
+var QuestionCalibrationSchema = z57.strictObject({
   question: id7,
-  status: z56.enum(calibrationStatuses),
-  consequence: z56.enum(["ordinary", "strict"]),
+  status: z57.enum(calibrationStatuses),
+  consequence: z57.enum(["ordinary", "strict"]),
   target: share,
   currentBar: share,
-  labeled: z56.number().int().min(0),
-  insufficient: z56.number().int().min(0),
-  otherAnswers: z56.number().int().min(0),
-  notRead: z56.number().int().min(0),
-  suggestion: z56.strictObject({
+  labeled: z57.number().int().min(0),
+  insufficient: z57.number().int().min(0),
+  otherAnswers: z57.number().int().min(0),
+  notRead: z57.number().int().min(0),
+  suggestion: z57.strictObject({
     bar,
     precision: share,
     coverage: share,
-    calibration: z56.strictObject({
-      id: z56.literal(barCalibrationId),
-      version: z56.literal(barCalibrationVersion),
+    calibration: z57.strictObject({
+      id: z57.literal(barCalibrationId),
+      version: z57.literal(barCalibrationVersion),
       contentDigest: digest23
     })
   }).optional(),
-  bars: z56.array(barRow).max(20),
-  cases: z56.array(caseRow).max(50)
+  bars: z57.array(barRow).max(20),
+  cases: z57.array(caseRow).max(50)
 });
-var BacktestCalibrationSchema = z56.strictObject({
-  schema: z56.literal("felspar.bar-calibration/v1"),
+var BacktestCalibrationSchema = z57.strictObject({
+  schema: z57.literal("felspar.bar-calibration/v1"),
   calibrationDigest: digest23,
-  minimumCases: z56.number().int().min(1),
-  questions: z56.array(QuestionCalibrationSchema).max(64),
-  ignoredLabels: z56.number().int().min(0)
+  minimumCases: z57.number().int().min(1),
+  questions: z57.array(QuestionCalibrationSchema).max(64),
+  ignoredLabels: z57.number().int().min(0)
 });
-var AcceptedBarsSchema = z56.strictObject({
-  savedResultId: z56.string().regex(/^backtest-[a-f0-9]{32}$/u),
+var AcceptedBarsSchema = z57.strictObject({
+  savedResultId: z57.string().regex(/^backtest-[a-f0-9]{32}$/u),
   calibrationDigest: digest23,
-  questions: z56.array(id7).min(1).max(64)
+  questions: z57.array(id7).min(1).max(64)
 });
 var ReleaseCalibrationSchema = AcceptedBarsSchema.extend({
-  acceptedBy: z56.string().min(1).max(200),
+  acceptedBy: z57.string().min(1).max(200),
   approvedMaterialDigest: digest23,
-  bars: z56.array(z56.strictObject({ question: id7, bar, calibrationDigest: digest23 })).min(1).max(64)
+  bars: z57.array(z57.strictObject({ question: id7, bar, calibrationDigest: digest23 })).min(1).max(64)
+});
+
+// ../schemas/src/draft-pack-environments.ts
+import { z as z58 } from "zod";
+var packEnvironments = ["staging", "production"];
+var PackEnvironmentSchema = z58.enum(packEnvironments);
+var packEnvironmentMoves = ["release", "stage", "promote", "rollback"];
+var PackEnvironmentMoveActionSchema = z58.enum(packEnvironmentMoves);
+var id8 = z58.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+var digest24 = z58.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var CandidateBindingSchema = z58.strictObject({
+  candidateSourceObjectId: id8,
+  capturedSourceObjectId: id8,
+  providerRevision: id8,
+  textDigest: digest24
+});
+var PackEnvironmentServedSchema = z58.strictObject({
+  environment: PackEnvironmentSchema,
+  releaseId: id8.nullable(),
+  releaseDigest: digest24.nullable(),
+  candidate: z58.boolean(),
+  movedBy: z58.string().nullable(),
+  movedAt: z58.string().nullable()
+});
+var PackEnvironmentMoveSchema = z58.strictObject({
+  environment: PackEnvironmentSchema,
+  action: PackEnvironmentMoveActionSchema,
+  fromReleaseId: id8.nullable(),
+  releaseId: id8,
+  principalId: z58.string(),
+  movedAt: z58.string(),
+  binding: CandidateBindingSchema.nullable()
+});
+var PackEnvironmentsSchema = z58.strictObject({
+  jobId: id8,
+  staging: PackEnvironmentServedSchema,
+  production: PackEnvironmentServedSchema,
+  moves: z58.array(PackEnvironmentMoveSchema).max(50)
+});
+var PromoteInputSchema = z58.strictObject({
+  expectedReleaseId: id8,
+  writeBack: z58.literal(true).optional()
+});
+var RollbackInputSchema = z58.strictObject({ releaseId: id8, expectedReleaseId: id8 });
+var StageReleaseInputSchema = z58.strictObject({ releaseId: id8 });
+var StageCandidateInputSchema = z58.strictObject({
+  reviewedMeaning: z58.literal(true),
+  reviewedFixtures: z58.literal(true),
+  reviewNote: z58.string().min(1).max(2e3)
 });
 
 // ../schemas/src/draft-hosted-application.ts
-var id8 = z57.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
-var digest24 = DraftApplicationReleaseSchema.shape.releaseDigest;
-var HostedSourceInputSchema = z57.strictObject({
-  sourceId: id8,
-  revision: id8,
-  title: z57.string().min(1).max(200),
-  text: z57.string().min(1).max(1048576)
-});
-var HostedProposalInputV0Schema = z57.strictObject({
-  sourceObjectId: id8,
-  expectedSourceDigest: digest24,
+var id9 = z59.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+var digest25 = DraftApplicationReleaseSchema.shape.releaseDigest;
+var HostedSourceInputSchema = z59.strictObject({
+  sourceId: id9,
+  revision: id9,
+  title: z59.string().min(1).max(200),
+  text: z59.string().min(1).max(1048576)
+});
+var HostedProposalInputV0Schema = z59.strictObject({
+  sourceObjectId: id9,
+  expectedSourceDigest: digest25,
   material: DraftApplicationJobMaterialSchema,
   compilation: DraftCompilationSchema
 });
-var HostedManualFactsRuleSchema = z57.strictObject({
-  allowed: z57.literal(false),
-  text: z57.string().min(1).max(4e3),
-  sourceLocator: z57.string().min(1).max(4096),
-  contentDigest: digest24
+var HostedManualFactsRuleSchema = z59.strictObject({
+  allowed: z59.literal(false),
+  text: z59.string().min(1).max(4e3),
+  sourceLocator: z59.string().min(1).max(4096),
+  contentDigest: digest25
 });
-var HostedProposalInputV2Schema = z57.strictObject({
-  schema: z57.literal("felspar.hosted-proposal.draft/v2"),
-  sourceObjectId: id8,
-  expectedSourceDigest: digest24,
+var HostedProposalInputV2Schema = z59.strictObject({
+  schema: z59.literal("felspar.hosted-proposal.draft/v2"),
+  sourceObjectId: id9,
+  expectedSourceDigest: digest25,
   material: DraftApplicationJobMaterialV2Schema,
   outputChecks: HostedOutputChecksSchema.optional(),
   manualFacts: HostedManualFactsRuleSchema.optional(),
   draft: KeptPackDraftSchema.optional()
 });
-var HostedProposalInputSchema = z57.union([
+var HostedProposalInputSchema = z59.union([
   HostedProposalInputV2Schema,
   HostedProposalInputV0Schema
 ]);
-var HostedApprovalInputSchema = z57.strictObject({
-  expectedProposalDigest: digest24,
-  reviewedMeaning: z57.literal(true),
-  reviewedFixtures: z57.literal(true),
-  reviewNote: z57.string().min(1).max(2e3)
-});
-var HostedReleaseInputSchema = z57.strictObject({
-  expectedApprovalDigest: digest24,
-  acceptBars: AcceptedBarsSchema.optional()
-});
-var HostedReleaseBundleSchema = z57.strictObject({
+var HostedApprovalInputSchema = z59.strictObject({
+  expectedProposalDigest: digest25,
+  reviewedMeaning: z59.literal(true),
+  reviewedFixtures: z59.literal(true),
+  reviewNote: z59.string().min(1).max(2e3)
+});
+var HostedReleaseInputSchema = z59.strictObject({
+  expectedApprovalDigest: digest25,
+  acceptBars: AcceptedBarsSchema.optional(),
+  environment: PackEnvironmentSchema.optional()
+});
+var HostedReleaseBundleSchema = z59.strictObject({
   release: DraftApplicationReleaseSchema,
   material: DraftAnyApplicationJobMaterialSchema,
-  approvalObjectId: id8,
-  approvalDigest: digest24,
-  proposalDigest: digest24,
-  sourceDigest: digest24,
+  approvalObjectId: id9,
+  approvalDigest: digest25,
+  proposalDigest: digest25,
+  sourceDigest: digest25,
   verifiedCompilation: DraftVerifiedCompilationSchema.optional(),
   calibration: ReleaseCalibrationSchema.optional()
 });
-var HostedJobInputSchema = z57.strictObject({
-  executionId: id8,
-  expectedReleaseDigest: digest24,
+var HostedJobInputSchema = z59.strictObject({
+  executionId: id9,
+  expectedReleaseDigest: digest25,
   material: DraftAnyApplicationJobMaterialSchema
 });
-var HostedSuppliedJobInputSchema = z57.strictObject({
-  mode: z57.literal("supplied"),
-  executionId: id8,
-  expectedReleaseDigest: digest24,
-  expectedAuthorityDigest: digest24,
-  jobId: id8,
-  entityId: id8,
+var HostedSuppliedJobInputSchema = z59.strictObject({
+  mode: z59.literal("supplied"),
+  executionId: id9,
+  expectedReleaseDigest: digest25,
+  expectedAuthorityDigest: digest25,
+  jobId: id9,
+  entityId: id9,
   evidence: DraftRequiredDecisionSchema.shape.evidence,
   passages: DraftLayeredEvaluationSchema.shape.passages.max(256)
 });
@@ -5281,18 +5361,18 @@ var hostedFactsLimits = {
   maxFactsBytes: 524288,
   maxQuestions: 64
 };
-var factSourceId = z57.string().refine(isDraftSourceId, "source_id_invalid").describe(`The source's own ID or address, such as its page URL with any query: RFC 3986 characters, starting with a letter or digit, at most ${draftSourceIdLimit} characters.`);
-var observedAt = z57.string().refine((value2) => normalizedSourceInstant(value2) !== null, "observed_at_invalid").transform((value2) => normalizedSourceInstant(value2) ?? value2).describe(`When the source was read: an RFC 3339 date and time with Z or an offset, such as 2026-10-21T10:00:00Z or 2026-10-21T12:00+02:00, at most ${sourceInstantMaxLength} characters. Stored in UTC.`);
+var factSourceId = z59.string().refine(isDraftSourceId, "source_id_invalid").describe(`The source's own ID or address, such as its page URL with any query: RFC 3986 characters, starting with a letter or digit, at most ${draftSourceIdLimit} characters.`);
+var observedAt = z59.string().refine((value2) => normalizedSourceInstant(value2) !== null, "observed_at_invalid").transform((value2) => normalizedSourceInstant(value2) ?? value2).describe(`When the source was read: an RFC 3339 date and time with Z or an offset, such as 2026-10-21T10:00:00Z or 2026-10-21T12:00+02:00, at most ${sourceInstantMaxLength} characters. Stored in UTC.`);
 var sourceFields = {
-  class: id8,
+  class: id9,
   id: factSourceId,
-  revision: id8.optional(),
-  locator: z57.string().min(1).max(4096).optional(),
+  revision: id9.optional(),
+  locator: z59.string().min(1).max(4096).optional(),
   observedAt,
-  sensitivity: id8.optional()
+  sensitivity: id9.optional()
 };
 var manualSourcePrefix = "felspar:";
-var suppliedBy = z57.string().trim().min(1).max(200);
+var suppliedBy = z59.string().trim().min(1).max(200);
 var isReserved = (sourceId2) => sourceId2?.toLowerCase().startsWith(manualSourcePrefix) === true;
 function sourceIssues(source3) {
   if (source3.manual === true) {
@@ -5318,13 +5398,13 @@ function isAdmittedOrdinary(source3) {
 function isAdmitted(source3) {
   return source3.manual === true ? isAdmittedManual(source3) : isAdmittedOrdinary(source3);
 }
-var excerptText = z57.string().min(1).refine((text8) => text8.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
+var excerptText = z59.string().min(1).refine((text8) => text8.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
 var valueSourceFields = { excerpt: excerptText.optional() };
 var requestSourceFields = {
   ...sourceFields,
   id: factSourceId.optional(),
   observedAt: observedAt.optional(),
-  manual: z57.literal(true).optional(),
+  manual: z59.literal(true).optional(),
   suppliedBy: suppliedBy.optional()
 };
 function refusedSourceIssues(source3, context3) {
@@ -5335,34 +5415,34 @@ function refusedSourceIssues(source3, context3) {
 var admittedSourceFields = {
   ...sourceFields,
   id: factSourceId.optional(),
-  manual: z57.literal(true).optional(),
+  manual: z59.literal(true).optional(),
   suppliedBy: suppliedBy.optional(),
-  by: id8.optional(),
-  stamped: z57.literal(true).optional()
+  by: id9.optional(),
+  stamped: z59.literal(true).optional()
 };
-var requestSource = z57.strictObject(requestSourceFields).superRefine(refusedSourceIssues);
-var requestValueSource = z57.strictObject({ ...requestSourceFields, ...valueSourceFields }).superRefine(refusedSourceIssues);
-var admittedSource = z57.strictObject(admittedSourceFields).refine(isAdmitted, "source_not_admitted");
-var admittedValueSource = z57.strictObject({ ...admittedSourceFields, ...valueSourceFields }).refine(isAdmitted, "source_not_admitted");
-var about = z57.string().min(1).max(200).optional();
+var requestSource = z59.strictObject(requestSourceFields).superRefine(refusedSourceIssues);
+var requestValueSource = z59.strictObject({ ...requestSourceFields, ...valueSourceFields }).superRefine(refusedSourceIssues);
+var admittedSource = z59.strictObject(admittedSourceFields).refine(isAdmitted, "source_not_admitted");
+var admittedValueSource = z59.strictObject({ ...admittedSourceFields, ...valueSourceFields }).refine(isAdmitted, "source_not_admitted");
+var about = z59.string().min(1).max(200).optional();
 var hostedCaseRecordLimits = {
   maxExcerptsPerQuestion: 30,
   maxExcerpts: hostedFactsLimits.maxQuestions * hostedFactsLimits.maxExcerptsPerQuestion,
   maxAttempts: 12
 };
 function factSchemas(source3, valueSource, isRecord) {
-  const excerpt2 = z57.strictObject({ text: excerptText, source: source3, about });
-  const valueFact = z57.strictObject({
-    value: z57.union([z57.string().min(1).max(200), z57.number(), z57.boolean()]),
+  const excerpt2 = z59.strictObject({ text: excerptText, source: source3, about });
+  const valueFact = z59.strictObject({
+    value: z59.union([z59.string().min(1).max(200), z59.number(), z59.boolean()]),
     source: valueSource,
     about
   });
   const cap = isRecord ? hostedCaseRecordLimits.maxExcerptsPerQuestion : hostedFactsLimits.maxExcerptsPerQuestion;
-  const listed = isRecord ? z57.union([excerpt2, valueFact]) : excerpt2;
-  const fact = z57.union([
+  const listed = isRecord ? z59.union([excerpt2, valueFact]) : excerpt2;
+  const fact = z59.union([
     valueFact,
     excerpt2,
-    z57.array(listed).min(1).refine((excerpts2) => excerpts2.length <= cap, "too_many_excerpts")
+    z59.array(listed).min(1).refine((excerpts2) => excerpts2.length <= cap, "too_many_excerpts")
   ]);
   return { excerpt: excerpt2, valueFact, fact };
 }
@@ -5376,90 +5456,91 @@ function factsBytes(facts) {
   return encoder2.encode(JSON.stringify(facts)).length;
 }
 function questionsOf(fact) {
-  return z57.record(id8, fact).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions");
+  return z59.record(id9, fact).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions");
 }
 function factsOf(fact) {
   return questionsOf(fact).refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large");
 }
-var HostedFactsJobInputSchema = z57.strictObject({
-  mode: z57.literal("facts"),
-  executionId: id8,
-  expectedReleaseDigest: digest24,
-  jobId: id8,
-  entityId: id8,
+var HostedFactsJobInputSchema = z59.strictObject({
+  mode: z59.literal("facts"),
+  executionId: id9,
+  expectedReleaseDigest: digest25,
+  jobId: id9,
+  entityId: id9,
   related: HostedRelatedSubjectsSchema.optional(),
-  identity: z57.record(z57.string().min(1).max(128), z57.string().min(1).max(200)).optional(),
+  identity: z59.record(z59.string().min(1).max(128), z59.string().min(1).max(200)).optional(),
   facts: questionsOf(HostedFactSchema)
 });
 var HostedFactsRequestSchema = HostedFactsJobInputSchema.extend({
-  entityId: id8.optional(),
+  entityId: id9.optional(),
   facts: factsOf(requestFacts.fact)
 });
-var HostedJobRequestSchema = z57.union([
+var HostedJobRequestSchema = z59.union([
   HostedJobInputSchema,
   HostedSuppliedJobInputSchema,
   HostedFactsJobInputSchema
 ]);
-var HostedClassificationResultSchema = z57.strictObject({
-  key: id8,
-  observationId: id8,
+var HostedClassificationResultSchema = z59.strictObject({
+  key: id9,
+  observationId: id9,
   record: DraftNormalizedEvidenceSchema.shape.normalizations.element,
-  reason: z57.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
-  cached: z57.boolean()
+  reason: z59.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
+  cached: z59.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 HostedCaseAttemptSchema = z57.strictObject({
-  executionId: id8,
-  added: z57.array(z57.string().min(1).max(draftSourceIdLimit + 4200)).max(192),
-  considered: z57.boolean()
+var HostedCaseAttemptSchema = z59.strictObject({
+  executionId: id9,
+  added: z59.array(z59.string().min(1).max(draftSourceIdLimit + 4200)).max(192),
+  considered: z59.boolean()
 });
-var HostedCaseRecordSchema = z57.strictObject({
-  rule: z57.literal("whole-case"),
-  attempt: z57.number().int().min(1).max(hostedCaseRecordLimits.maxAttempts + 1),
-  attempts: z57.array(HostedCaseAttemptSchema).min(1).max(hostedCaseRecordLimits.maxAttempts + 1),
+var HostedCaseRecordSchema = z59.strictObject({
+  rule: z59.literal("whole-case"),
+  attempt: z59.number().int().min(1).max(hostedCaseRecordLimits.maxAttempts + 1),
+  attempts: z59.array(HostedCaseAttemptSchema).min(1).max(hostedCaseRecordLimits.maxAttempts + 1),
   facts: questionsOf(HostedFactSchema).optional()
 });
-var HostedSuppliedExecutionRecordSchema = z57.strictObject({
-  schema: z57.enum([
+var HostedSuppliedExecutionRecordSchema = z59.strictObject({
+  schema: z59.enum([
     "felspar.hosted-supplied-execution/v1",
     "felspar.hosted-supplied-execution/v2",
     "felspar.hosted-supplied-execution/v3"
   ]),
-  release: z57.strictObject({ releaseId: id8, releaseDigest: digest24, materialDigest: digest24 }),
-  evaluationTime: z57.iso.datetime(),
+  release: z59.strictObject({ releaseId: id9, releaseDigest: digest25, materialDigest: digest25 }),
+  evaluationTime: z59.iso.datetime(),
   input: HostedSuppliedJobInputSchema,
   facts: HostedFactsJobInputSchema.optional(),
-  judgments: z57.array(HostedClassificationResultSchema).max(192).optional(),
-  judgmentsDigest: digest24.optional(),
-  expansion: z57.literal("agreeing-excerpts").optional(),
+  judgments: z59.array(HostedClassificationResultSchema).max(192).optional(),
+  judgmentsDigest: digest25.optional(),
+  expansion: z59.enum(["agreeing-excerpts", "agreeing-excerpts/v2"]).optional(),
   caseRecord: HostedCaseRecordSchema.optional(),
-  job: z57.record(z57.string(), z57.unknown())
+  decisionAttempt: DecisionGraphAttemptSchema.optional(),
+  job: z59.record(z59.string(), z59.unknown())
 }).refine(retainsFactsExactly, "Version 3 records, and only they, retain facts with their judgments").refine((record) => record.caseRecord === void 0 || record.facts !== void 0, {
   message: "Only a facts record keeps a case record"
 });
-var HostedObjectSchema = z57.strictObject({
-  id: id8,
-  kind: z57.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
-  payloadDigest: digest24,
-  objectKey: z57.string().min(1).max(1e3),
-  parentId: id8.nullable(),
-  status: z57.enum(["active", "released", "revoked"]),
-  metadata: z57.record(z57.string(), z57.unknown())
-});
-var HostedJobResultSchema = z57.object({
-  status: z57.string(),
-  reason: z57.string().nullable(),
-  result: z57.object({
-    executionId: z57.string(),
-    releaseId: id8,
-    releaseDigest: digest24,
-    outcome: z57.string().nullable(),
-    scoring: z57.unknown(),
-    context: z57.unknown(),
-    receipt: z57.unknown()
+var HostedObjectSchema = z59.strictObject({
+  id: id9,
+  kind: z59.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
+  payloadDigest: digest25,
+  objectKey: z59.string().min(1).max(1e3),
+  parentId: id9.nullable(),
+  status: z59.enum(["active", "released", "revoked"]),
+  metadata: z59.record(z59.string(), z59.unknown())
+});
+var HostedJobResultSchema = z59.object({
+  status: z59.string(),
+  reason: z59.string().nullable(),
+  result: z59.object({
+    executionId: z59.string(),
+    releaseId: id9,
+    releaseDigest: digest25,
+    outcome: z59.string().nullable(),
+    scoring: z59.unknown(),
+    context: z59.unknown(),
+    receipt: z59.unknown()
   }).loose().nullable()
 });
 
@@ -5491,6 +5572,7 @@ var fixes = {
   job_mismatch: "This release serves a different job. Use the job and release from describe.",
   job_retired: "The workspace owner retired this job. Don't call it again: use the job named in replacement (check it with list_jobs), or, if replacement is null, tell the person the job is retired and stop.",
   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.",
+  case_in_progress: "This case is already being decided. Wait for the first attempt's decision, then resend that attempt unchanged with the same executionId to read it. Send new evidence only after it finishes.",
   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.",
@@ -5542,6 +5624,16 @@ var fixes = {
   change_request_comment_limit: "This change request has as many comments as it can hold. Continue the discussion on the Felspar web page.",
   change_request_closed: "This change request is already closed.",
   change_request_close_on_web_page: "Withdraw or reject a change request on the Felspar web page; opening the job's change request again replaces your earlier one.",
+  environments_on_web_page: "Releasing to staging, promoting and rolling back are a person's click on the Felspar web page. Read which release each environment serves with read_environments and tell the person.",
+  staging_agent_pinned: "A staging agent follows its jobs and is never pinned. Register it with its jobs on Latest, or register a production agent to pin a release.",
+  nothing_staged: "Nothing is released to staging for this job. An approver releases a proposal or a change request's candidate to staging on the Felspar web page.",
+  environment_release_unavailable: "Only a live release of this job that production has served can be staged or rolled back to. Pick one from the job's environments.",
+  environment_moved: "The environment moved since the page was read: it no longer serves the release you expected. Reload the job's environments and decide again.",
+  promotion_out_of_date: "Production moved after this staged release was proposed, so promoting it would replace newer production meaning. Propose the change again on production's current release, or roll production back on purpose.",
+  document_not_captured: "Felspar has no captured version of this document to compare with the candidate. Add its current version (add_current_version or the Sources page), then promote again.",
+  document_not_updated: "The document's newest captured version doesn't hold exactly the candidate's text. details.missing names the change request's changes still missing by index: edit the document to match, add its current version and promote again.",
+  candidate_needs_promotion: "This proposal was built on a change request's text that the document may not hold, so it is released to staging, never straight to production. Release it to staging, then promote it once the document holds exactly that text.",
+  change_request_not_stageable: "Only an open, up-to-date change request with a revised pack draft, built on production's current release, can be released to staging. Open the change request again on the current release.",
   proposal_draft_invalid: "A proposal's draft must be a valid felspar.pack-draft for the proposal's own job. Propose with propose_pack, which keeps the draft it checked.",
   preview_too_large: "This draft changes more than one preview can show (2,048 item changes or 64 breaking changes). Preview a smaller revision, or split the pack.",
   backtest_allowance_used: "This proposal has used its whole fresh-read allowance, which all its backtests share. Backtest it again without reinterpret: true: the answers already read are reused and nothing new is read.",
@@ -5572,7 +5664,12 @@ var hostedRefusalCodes = Object.freeze(Object.keys(fixes));
 function hostedRefusalFix(code) {
   return Object.hasOwn(fixes, code) ? fixes[code] ?? null : null;
 }
-var retried = /* @__PURE__ */ new Set(["rate_limited", "history_unavailable", "operation_unavailable"]);
+var retried = /* @__PURE__ */ new Set([
+  "case_in_progress",
+  "rate_limited",
+  "history_unavailable",
+  "operation_unavailable"
+]);
 var escalated = /* @__PURE__ */ new Set([
   "unauthenticated",
   "forbidden",
@@ -5594,243 +5691,244 @@ function hostedRefusalRecovery(code) {
 }
 
 // ../schemas/src/draft-hosted-job-description.ts
-import { z as z59 } from "zod";
+import { z as z61 } from "zod";
 
 // ../schemas/src/draft-hosted-output-guides.ts
-import { z as z58 } from "zod";
-var id9 = z58.string().min(1).max(200);
-var located = z58.strictObject({
-  text: z58.string().min(1).max(262144),
-  locator: z58.string().min(1).max(4096)
+import { z as z60 } from "zod";
+var id10 = z60.string().min(1).max(200);
+var located = z60.strictObject({
+  text: z60.string().min(1).max(262144),
+  locator: z60.string().min(1).max(4096)
 });
 var hostedOutputGuideLimits = { maxOutputs: 8, maxContext: 8, maxChecks: 64 };
-var HostedOutputGuideSchema = z58.strictObject({
-  id: id9,
+var HostedOutputGuideSchema = z60.strictObject({
+  id: id10,
   what: located,
-  maxCharacters: z58.number().int().min(1),
-  context: z58.array(located.extend({ id: id9 })).max(hostedOutputGuideLimits.maxContext).optional(),
-  checks: z58.array(z58.strictObject({
-    check: id9,
-    rule: z58.string().nullable(),
-    must: z58.string().min(1).max(8e3)
+  maxCharacters: z60.number().int().min(1),
+  context: z60.array(located.extend({ id: id10 })).max(hostedOutputGuideLimits.maxContext).optional(),
+  checks: z60.array(z60.strictObject({
+    check: id10,
+    rule: z60.string().nullable(),
+    must: z60.string().min(1).max(8e3)
   })).max(hostedOutputGuideLimits.maxChecks)
 });
-var HostedOutputGuidesSchema = z58.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
+var HostedOutputGuidesSchema = z60.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
 
 // ../schemas/src/draft-hosted-job-description.ts
-var id10 = z59.string().min(1).max(200);
-var digest25 = DraftApplicationReleaseSchema.shape.releaseDigest;
+var id11 = z61.string().min(1).max(200);
+var digest26 = DraftApplicationReleaseSchema.shape.releaseDigest;
 var { requirements, rules } = DraftRequiredProposalSchema.shape;
-var quotedText = z59.strictObject({
-  text: z59.string().min(1).max(262144),
+var quotedText = z61.strictObject({
+  text: z61.string().min(1).max(262144),
   source: DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
-    locator: z59.string().min(1).max(4096),
-    contentDigest: digest25
+    locator: z61.string().min(1).max(4096),
+    contentDigest: digest26
   }),
-  parts: z59.array(z59.strictObject({ locator: z59.string().min(1).max(4096), text: z59.string() })).max(16)
+  parts: z61.array(z61.strictObject({ locator: z61.string().min(1).max(4096), text: z61.string() })).max(16)
 });
 var subjectShape = {
-  identifier: z59.string().min(1).max(200),
-  example: z59.string().min(1).max(200),
-  match: z59.enum(subjectMatchRules)
+  identifier: z61.string().min(1).max(200),
+  example: z61.string().min(1).max(200),
+  match: z61.enum(subjectMatchRules)
 };
-var HostedJobSubjectSchema = z59.strictObject({
-  type: id10,
+var HostedJobSubjectSchema = z61.strictObject({
+  type: id11,
   definition: quotedText,
   identifier: subjectShape.identifier.optional(),
   example: subjectShape.example.optional(),
   match: subjectShape.match,
-  related: z59.array(z59.strictObject({
-    relationship: id10,
+  related: z61.array(z61.strictObject({
+    relationship: id11,
     meaning: quotedText,
-    cardinality: z59.enum(relationshipCardinalities),
-    required: z59.boolean(),
-    subject: id10,
+    cardinality: z61.enum(relationshipCardinalities),
+    required: z61.boolean(),
+    subject: id11,
     definition: quotedText,
     ...subjectShape
   })).max(16),
-  send: z59.string().min(1).max(2e4)
+  send: z61.string().min(1).max(2e4)
 });
-var HostedJobEscalationsSchema = z59.strictObject({
-  routes: z59.array(z59.strictObject({ id: id10, quote: quotedText })).min(1).max(16),
-  unresolved: id10.nullable(),
-  attemptLimit: id10.nullable(),
-  rule: z59.string().min(1).max(1e3)
+var HostedJobEscalationsSchema = z61.strictObject({
+  routes: z61.array(z61.strictObject({ id: id11, quote: quotedText })).min(1).max(16),
+  unresolved: id11.nullable(),
+  attemptLimit: id11.nullable(),
+  rule: z61.string().min(1).max(1e3)
 });
-var HostedEscalationSchema = z59.strictObject({
-  id: id10,
-  trigger: z59.enum(escalationTriggers),
+var HostedEscalationSchema = z61.strictObject({
+  id: id11,
+  trigger: z61.enum(escalationTriggers),
   why: quotedText
 });
-var HostedJobDescriptionSchema = z59.strictObject({
-  schema: z59.literal("felspar.hosted-job-description.draft/v0"),
-  job: id10,
+var HostedJobDescriptionSchema = z61.strictObject({
+  schema: z61.literal("felspar.hosted-job-description.draft/v0"),
+  job: id11,
   purpose: quotedText.optional(),
-  useWhen: z59.array(quotedText).max(8).optional(),
-  notFor: z59.array(quotedText).max(8).optional(),
+  useWhen: z61.array(quotedText).max(8).optional(),
+  notFor: z61.array(quotedText).max(8).optional(),
   owner: quotedText.optional(),
   subject: HostedJobSubjectSchema.optional(),
-  identity: z59.strictObject({
-    mode: z59.enum(identityModes),
-    send: z59.string().min(1).max(4e3),
-    fields: z59.array(z59.strictObject({ name: id10, ...subjectShape })).max(8).optional(),
-    question: id10.optional()
+  identity: z61.strictObject({
+    mode: z61.enum(identityModes),
+    send: z61.string().min(1).max(4e3),
+    fields: z61.array(z61.strictObject({ name: id11, ...subjectShape })).max(8).optional(),
+    question: id11.optional()
   }).optional(),
-  manualFacts: z59.strictObject({ allowed: z59.literal(false), quote: z59.string().min(1).max(4e3) }).optional(),
-  trustDomain: id10,
-  release: z59.strictObject({
-    releaseId: id10,
-    releaseDigest: digest25,
-    materialDigest: digest25,
-    expectedAuthorityDigest: digest25
+  manualFacts: z61.strictObject({ allowed: z61.literal(false), quote: z61.string().min(1).max(4e3) }).optional(),
+  trustDomain: id11,
+  release: z61.strictObject({
+    releaseId: id11,
+    releaseDigest: digest26,
+    materialDigest: digest26,
+    expectedAuthorityDigest: digest26
   }),
   resolutionPolicy: DraftRequiredProposalSchema.shape.resolutionPolicy,
-  questions: z59.array(requirements.element.extend({
-    key: id10,
-    type: z59.enum(["enum", "boolean", "number", "date"]),
+  questions: z61.array(requirements.element.extend({
+    key: id11,
+    type: z61.enum(["enum", "boolean", "number", "date"]),
     meaning: quotedText,
-    answer: z59.strictObject({
-      send: z59.enum(["text", "text_or_value"]),
-      valueFormat: z59.enum(["number", "calendar-date"]).nullable(),
-      interpretation: z59.enum(["classified", "exact_read", "unsupported"]),
-      threshold: z59.number().gt(0).max(1).nullable(),
-      applies: z59.enum(["always", "conditional"]),
-      dependsOn: z59.array(id10).max(32),
-      appliesWhen: z59.string().min(1).max(2e3).nullable(),
+    answer: z61.strictObject({
+      send: z61.enum(["text", "text_or_value"]),
+      valueFormat: z61.enum(["number", "calendar-date"]).nullable(),
+      interpretation: z61.enum(["classified", "exact_read", "unsupported"]),
+      threshold: z61.number().gt(0).max(1).nullable(),
+      applies: z61.enum(["always", "conditional"]),
+      dependsOn: z61.array(id11).max(32),
+      appliesWhen: z61.string().min(1).max(2e3).nullable(),
       reading: ExactReaderSchema.optional()
     }),
-    answers: z59.array(z59.strictObject({
-      value: id10,
-      meaning: z59.string().nullable(),
-      inclusions: z59.array(z59.string()).max(8),
-      exclusions: z59.array(z59.string()).max(8),
-      examples: z59.array(z59.string()).max(8),
-      edgeCases: z59.array(z59.string()).max(8)
+    answers: z61.array(z61.strictObject({
+      value: id11,
+      meaning: z61.string().nullable(),
+      inclusions: z61.array(z61.string()).max(8),
+      exclusions: z61.array(z61.string()).max(8),
+      examples: z61.array(z61.string()).max(8),
+      edgeCases: z61.array(z61.string()).max(8)
     })).max(64).optional(),
-    whereToLook: z59.array(quotedText).max(8).optional(),
-    about: z59.strictObject({ relationship: id10, subject: id10 }).optional()
+    whereToLook: z61.array(quotedText).max(8).optional(),
+    about: z61.strictObject({ relationship: id11, subject: id11 }).optional()
   })).max(64),
-  rules: z59.array(rules.element.extend({ text: quotedText })).max(256),
-  outcomes: z59.array(z59.strictObject({
-    id: id10,
+  rules: z61.array(rules.element.extend({ text: quotedText })).max(256),
+  outcomes: z61.array(z61.strictObject({
+    id: id11,
     meaning: quotedText.nullable(),
     nextStep: quotedText.nullable().optional(),
     outputs: HostedOutputGuidesSchema.optional(),
-    escalate: id10.optional()
+    escalate: id11.optional()
   })).max(64),
   escalations: HostedJobEscalationsSchema.optional(),
   whenUnresolved: quotedText.nullable().optional(),
-  attempts: z59.strictObject({
-    max: z59.number().int().min(1).max(10),
-    withProgress: z59.number().int().min(1).max(10),
-    rule: z59.string().min(1).max(1e3)
+  attempts: z61.strictObject({
+    max: z61.number().int().min(1).max(10),
+    withProgress: z61.number().int().min(1).max(10),
+    rule: z61.string().min(1).max(1e3)
   }).optional(),
-  guidance: z59.strictObject({ gather: z59.string().min(1).max(2e3) }),
-  input: z59.strictObject({
-    jsonSchema: z59.record(z59.string(), z59.unknown()),
+  guidance: z61.strictObject({ gather: z61.string().min(1).max(2e3) }),
+  input: z61.strictObject({
+    jsonSchema: z61.record(z61.string(), z61.unknown()),
     example: HostedFactsJobInputSchema.nullable(),
-    exampleNote: z59.string().max(1e3)
+    exampleNote: z61.string().max(1e3)
   }),
-  limits: z59.strictObject({
-    maxEvidenceItems: z59.number().int().positive(),
-    maxPassages: z59.number().int().positive(),
-    facts: z59.strictObject({
-      maxExcerptCharacters: z59.literal(hostedFactsLimits.maxExcerptCharacters),
-      maxExcerptsPerQuestion: z59.literal(hostedFactsLimits.maxExcerptsPerQuestion),
-      maxFactsBytes: z59.literal(hostedFactsLimits.maxFactsBytes),
-      maxQuestions: z59.literal(hostedFactsLimits.maxQuestions)
+  limits: z61.strictObject({
+    maxEvidenceItems: z61.number().int().positive(),
+    maxPassages: z61.number().int().positive(),
+    facts: z61.strictObject({
+      maxExcerptCharacters: z61.literal(hostedFactsLimits.maxExcerptCharacters),
+      maxExcerptsPerQuestion: z61.literal(hostedFactsLimits.maxExcerptsPerQuestion),
+      maxFactsBytes: z61.literal(hostedFactsLimits.maxFactsBytes),
+      maxQuestions: z61.literal(hostedFactsLimits.maxQuestions)
     })
   })
 });
-var interpretedExcerpt = z59.strictObject({
-  id: id10,
-  method: z59.enum(["value", "exact_read", "classified"]),
-  status: z59.enum(["accepted", "needs_evidence", "not_needed"]),
-  value: z59.union([z59.string(), z59.number(), z59.boolean()]).optional(),
-  reasons: z59.array(z59.string()),
-  classification: z59.strictObject({
-    candidate: z59.string().nullable(),
-    probability: z59.number().min(0).max(1).nullable(),
-    abstention: z59.number().min(0).max(1).nullable(),
-    threshold: z59.number().min(0).max(1),
-    alternatives: z59.array(z59.strictObject({ value: z59.string(), probability: z59.number() }))
+var interpretedExcerpt = z61.strictObject({
+  id: id11,
+  method: z61.enum(["value", "exact_read", "classified"]),
+  status: z61.enum(["accepted", "needs_evidence", "not_needed"]),
+  value: z61.union([z61.string(), z61.number(), z61.boolean()]).optional(),
+  reasons: z61.array(z61.string()),
+  classification: z61.strictObject({
+    candidate: z61.string().nullable(),
+    probability: z61.number().min(0).max(1).nullable(),
+    abstention: z61.number().min(0).max(1).nullable(),
+    threshold: z61.number().min(0).max(1),
+    alternatives: z61.array(z61.strictObject({ value: z61.string(), probability: z61.number() }))
   }).optional()
 });
-var ruleSummary = z59.strictObject({ id: id10, outcome: id10, text: quotedText });
-var HostedJobExplanationSchema = z59.strictObject({
-  schema: z59.literal("felspar.hosted-job-explanation.draft/v0"),
-  decision: z59.strictObject({ status: z59.string().nullable(), reasons: z59.array(z59.string()) }),
-  needs: z59.array(z59.strictObject({
-    key: id10,
-    status: z59.string(),
-    reasons: z59.array(z59.string()),
-    acceptedSourceClasses: z59.array(z59.string()),
-    maxAgeMs: z59.number().int().nonnegative(),
+var ruleSummary = z61.strictObject({ id: id11, outcome: id11, text: quotedText });
+var HostedJobExplanationSchema = z61.strictObject({
+  schema: z61.literal("felspar.hosted-job-explanation.draft/v0"),
+  decision: z61.strictObject({ status: z61.string().nullable(), reasons: z61.array(z61.string()) }),
+  needs: z61.array(z61.strictObject({
+    key: id11,
+    status: z61.string(),
+    reasons: z61.array(z61.string()),
+    acceptedSourceClasses: z61.array(z61.string()),
+    maxAgeMs: z61.number().int().nonnegative(),
     requiredWhen: HostedJobDescriptionSchema.shape.questions.element.shape.requiredWhen,
-    excerpts: z59.array(interpretedExcerpt).optional()
+    excerpts: z61.array(interpretedExcerpt).optional()
   })),
-  why: z59.strictObject({
-    rules: z59.array(ruleSummary),
-    overrides: z59.array(z59.strictObject({ by: id10, target: id10 })),
-    suppressedRuleIds: z59.array(id10),
-    evidence: z59.array(z59.record(z59.string(), z59.unknown()))
+  why: z61.strictObject({
+    rules: z61.array(ruleSummary),
+    overrides: z61.array(z61.strictObject({ by: id11, target: id11 })),
+    suppressedRuleIds: z61.array(id11),
+    evidence: z61.array(z61.record(z61.string(), z61.unknown()))
   }).nullable(),
-  context: z59.strictObject({ status: z59.string(), reason: z59.string().nullable() }).nullable(),
-  reviewNeeds: z59.array(z59.string()),
-  evidenceFreshUntil: z59.iso.datetime().nullable()
+  context: z61.strictObject({ status: z61.string(), reason: z61.string().nullable() }).nullable(),
+  reviewNeeds: z61.array(z61.string()),
+  evidenceFreshUntil: z61.iso.datetime().nullable()
 });
-var HostedReceiptVerificationInputSchema = z59.strictObject({
+var HostedReceiptVerificationInputSchema = z61.strictObject({
   receipt: DraftJobReceiptSchema,
-  expectedReceiptDigest: digest25,
+  expectedReceiptDigest: digest26,
   deliveredCapsule: DraftContextVerificationOptionsSchema.shape.deliveredCapsule
 });
-var HostedReceiptVerificationSchema = z59.strictObject({
-  authority: z59.literal("unapproved"),
-  status: z59.enum(["reproduced", "mismatch"]),
-  mismatches: z59.array(z59.string()),
-  decided: z59.strictObject({
-    jobId: id10,
-    entityId: id10,
-    releaseId: id10,
-    outcome: id10.nullable(),
-    case: z59.strictObject({ id: id10, mode: z59.enum(identityModes) }).optional(),
-    subject: z59.strictObject({
-      type: id10,
-      related: z59.array(z59.strictObject({ relationship: id10, subject: id10, id: id10, questions: z59.array(id10).max(64) })).max(256)
+var HostedReceiptVerificationSchema = z61.strictObject({
+  authority: z61.literal("unapproved"),
+  status: z61.enum(["reproduced", "mismatch"]),
+  mismatches: z61.array(z61.string()),
+  decided: z61.strictObject({
+    jobId: id11,
+    entityId: id11,
+    releaseId: id11,
+    outcome: id11.nullable(),
+    environment: PackEnvironmentSchema.optional(),
+    case: z61.strictObject({ id: id11, mode: z61.enum(identityModes) }).optional(),
+    subject: z61.strictObject({
+      type: id11,
+      related: z61.array(z61.strictObject({ relationship: id11, subject: id11, id: id11, questions: z61.array(id11).max(64) })).max(256)
     }).optional(),
     escalation: HostedEscalationSchema.omit({ why: true }).optional(),
-    manualFacts: z59.array(z59.strictObject({
-      question: id10,
-      excerpt: z59.number().int().min(0).max(hostedCaseRecordLimits.maxExcerptsPerQuestion - 1),
-      via: z59.strictObject({
-        principal: id10,
-        agent: z59.strictObject({ name: z59.string(), accountable: id10 }).nullable()
+    manualFacts: z61.array(z61.strictObject({
+      question: id11,
+      excerpt: z61.number().int().min(0).max(hostedCaseRecordLimits.maxExcerptsPerQuestion - 1),
+      via: z61.strictObject({
+        principal: id11,
+        agent: z61.strictObject({ name: z61.string(), accountable: id11 }).nullable()
       }),
-      observedAt: z59.string(),
-      stampedByFelspar: z59.boolean(),
-      suppliedBy: z59.strictObject({ text: z59.string(), verified: z59.literal(false) }).optional()
+      observedAt: z61.string(),
+      stampedByFelspar: z61.boolean(),
+      suppliedBy: z61.strictObject({ text: z61.string(), verified: z61.literal(false) }).optional()
     })).max(192).optional(),
-    caseRecord: z59.strictObject({
-      rule: z59.literal("whole-case"),
-      attempt: z59.number().int().min(1),
-      attempts: z59.array(HostedCaseAttemptSchema).max(hostedCaseRecordLimits.maxAttempts + 1)
+    caseRecord: z61.strictObject({
+      rule: z61.literal("whole-case"),
+      attempt: z61.number().int().min(1),
+      attempts: z61.array(HostedCaseAttemptSchema).max(hostedCaseRecordLimits.maxAttempts + 1)
     }).optional()
   }).optional()
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 
 // ../schemas/src/draft-artifact-lint.ts
-import { z as z61 } from "zod";
+import { z as z63 } from "zod";
 
 // ../schemas/src/draft-job-obligations.ts
-import { z as z60 } from "zod";
-var id11 = DraftApplicationScopeSchema.shape.authorityId;
-var digest26 = DraftJobReceiptSchema.shape.receiptDigest;
+import { z as z62 } from "zod";
+var id12 = DraftApplicationScopeSchema.shape.authorityId;
+var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
 var outcome2 = DraftJobObligationsOutcomeSchema;
 var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.extend({
-  schema: z60.literal("felspar.application-job-material.draft/v3"),
+  schema: z62.literal("felspar.application-job-material.draft/v3"),
   obligations: DraftJobObligationsSchema
 }).superRefine((value2, context3) => {
   if (context3.issues.length > 0) {
@@ -5858,57 +5956,57 @@ var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.ex
   }
 });
 var HostedProposalInputV3Schema = HostedProposalInputV2Schema.extend({
-  schema: z60.literal("felspar.hosted-proposal.draft/v3"),
+  schema: z62.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 = z60.strictObject({
-  authority: z60.literal("unapproved"),
-  discovery: z60.record(z60.string(), z60.unknown()),
-  executed: z60.record(z60.string(), z60.unknown()),
+var DraftJobObligationsNativeResultSchema = z62.strictObject({
+  authority: z62.literal("unapproved"),
+  discovery: z62.record(z62.string(), z62.unknown()),
+  executed: z62.record(z62.string(), z62.unknown()),
   receipt: DraftJobReceiptSchema
 });
-var DraftJobObligationsInputSchema = z60.strictObject({
+var DraftJobObligationsInputSchema = z62.strictObject({
   release: DraftApplicationReleaseSchema,
-  material: z60.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
+  material: z62.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
   execution: DraftJobObligationsExecutionSchema,
-  expectedReceiptDigest: digest26,
+  expectedReceiptDigest: digest27,
   job: DraftJobObligationsNativeResultSchema,
   explanation: HostedJobExplanationSchema,
-  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id11 })
+  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id12 })
 });
-var requirements2 = z60.strictObject({
-  status: z60.enum(["established", "unresolved"]),
+var requirements2 = z62.strictObject({
+  status: z62.enum(["established", "unresolved"]),
   scope: DraftJobObligationsScopeSchema,
   artifacts: outcome2.shape.artifacts,
   approvals: outcome2.shape.approvals,
-  unresolved: z60.array(z60.strictObject({ scopeRef: id11, reasonCodes: z60.array(id11).min(1).max(64) })).max(64)
+  unresolved: z62.array(z62.strictObject({ scopeRef: id12, reasonCodes: z62.array(id12).min(1).max(64) })).max(64)
 });
-var nextReference = z60.discriminatedUnion("kind", [
-  z60.strictObject({ kind: z60.literal("evidence_need"), id: id11 }),
-  z60.strictObject({ kind: z60.literal("artifact_requirement"), id: id11 }),
-  z60.strictObject({ kind: z60.literal("approval_requirement"), id: id11 }),
-  z60.strictObject({ kind: z60.literal("unresolved_scope"), scopeRef: id11 })
+var nextReference = z62.discriminatedUnion("kind", [
+  z62.strictObject({ kind: z62.literal("evidence_need"), id: id12 }),
+  z62.strictObject({ kind: z62.literal("artifact_requirement"), id: id12 }),
+  z62.strictObject({ kind: z62.literal("approval_requirement"), id: id12 }),
+  z62.strictObject({ kind: z62.literal("unresolved_scope"), scopeRef: id12 })
 ]);
-var DraftJobObligationsAssessmentBodySchema = z60.strictObject({
-  schema: z60.literal("felspar.job-obligations-assessment.draft/v0"),
-  binding: z60.strictObject({
-    releaseDigest: digest26,
-    materialDigest: digest26,
-    nativeReceiptDigest: digest26,
-    jobId: id11,
+var DraftJobObligationsAssessmentBodySchema = z62.strictObject({
+  schema: z62.literal("felspar.job-obligations-assessment.draft/v0"),
+  binding: z62.strictObject({
+    releaseDigest: digest27,
+    materialDigest: digest27,
+    nativeReceiptDigest: digest27,
+    jobId: id12,
     applicationScope: DraftApplicationScopeSchema,
-    caseId: id11,
-    entityId: id11,
-    evaluationTime: z60.iso.datetime({ offset: true }),
-    purposeRef: id11,
-    useRef: id11.nullable()
+    caseId: id12,
+    entityId: id12,
+    evaluationTime: z62.iso.datetime({ offset: true }),
+    purposeRef: id12,
+    useRef: id12.nullable()
   }),
   requirements: requirements2,
-  next: z60.strictObject({
-    kind: z60.enum([
+  next: z62.strictObject({
+    kind: z62.enum([
       "stop",
       "review_required",
       "gather_evidence",
@@ -5916,8 +6014,8 @@ var DraftJobObligationsAssessmentBodySchema = z60.strictObject({
       "verify_before_action",
       "return_result"
     ]),
-    reasonCodes: z60.array(id11).max(64),
-    refs: z60.array(nextReference).max(64)
+    reasonCodes: z62.array(id12).max(64),
+    refs: z62.array(nextReference).max(64)
   })
 });
 function isNextRefDeclared(ref, required) {
@@ -5940,7 +6038,7 @@ function isNextRefDeclared(ref, required) {
   }
 }
 var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchema.extend({
-  assessmentDigest: digest26
+  assessmentDigest: digest27
 }).superRefine((value2, context3) => {
   const { requirements: required } = value2;
   if (required.status === "established" !== (required.unresolved.length === 0) || required.status === "unresolved" && (required.artifacts.length > 0 || required.approvals.length > 0)) {
@@ -5954,48 +6052,48 @@ var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchem
 });
 
 // ../schemas/src/draft-artifact-lint.ts
-var id12 = DraftApplicationScopeSchema.shape.authorityId;
-var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
+var id13 = DraftApplicationScopeSchema.shape.authorityId;
+var digest28 = DraftJobReceiptSchema.shape.receiptDigest;
 var passage3 = ArtifactSpecificationSchema;
-var plainArtifact = z61.strictObject({
-  id: id12,
-  revision: id12,
-  mediaType: z61.literal("text/plain"),
-  exportProfile: id12.nullable(),
-  content: z61.string().max(artifactLintLimits.maxTotalBytes),
-  expectedContentDigest: digest27
-});
-var structuredArtifact = z61.strictObject({
-  id: id12,
-  revision: id12,
-  mediaType: z61.literal("application/vnd.felspar.structured-output+json"),
-  exportProfile: id12.nullable(),
+var plainArtifact = z63.strictObject({
+  id: id13,
+  revision: id13,
+  mediaType: z63.literal("text/plain"),
+  exportProfile: id13.nullable(),
+  content: z63.string().max(artifactLintLimits.maxTotalBytes),
+  expectedContentDigest: digest28
+});
+var structuredArtifact = z63.strictObject({
+  id: id13,
+  revision: id13,
+  mediaType: z63.literal("application/vnd.felspar.structured-output+json"),
+  exportProfile: id13.nullable(),
   content: DraftStructuredOutputSchema,
-  expectedContentDigest: digest27
+  expectedContentDigest: digest28
 });
-var ArtifactLintArtifactSchema = z61.discriminatedUnion("mediaType", [
+var ArtifactLintArtifactSchema = z63.discriminatedUnion("mediaType", [
   plainArtifact,
   structuredArtifact
 ]);
-var ArtifactLintDecisionSchema = z61.strictObject({
+var ArtifactLintDecisionSchema = z63.strictObject({
   inputs: DraftJobObligationsInputSchema,
   assessment: DraftJobObligationsAssessmentSchema,
-  expectedAssessmentDigest: digest27
+  expectedAssessmentDigest: digest28
 });
-var ArtifactLintInputSchema = z61.strictObject({
-  schema: z61.literal("felspar.lint.draft/v1"),
-  requestId: id12,
+var ArtifactLintInputSchema = z63.strictObject({
+  schema: z63.literal("felspar.lint.draft/v1"),
+  requestId: id13,
   release: DraftApplicationReleaseSchema,
   material: DraftApplicationJobMaterialV3Schema,
   manifest: ArtifactCheckManifestSchema,
-  expectedManifestDigest: digest27,
-  attachedObligations: z61.strictObject({ expectedObligationsDigest: digest27 }).optional(),
-  attachedCase: z61.strictObject({
-    decisionReceiptDigest: digest27,
-    answers: z61.array(z61.strictObject({ key: id12, value: z61.union([z61.string().min(1).max(200), z61.null()]) })).max(256)
+  expectedManifestDigest: digest28,
+  attachedObligations: z63.strictObject({ expectedObligationsDigest: digest28 }).optional(),
+  attachedCase: z63.strictObject({
+    decisionReceiptDigest: digest28,
+    answers: z63.array(z63.strictObject({ key: id13, value: z63.union([z63.string().min(1).max(200), z63.null()]) })).max(256)
   }).optional(),
-  case: z61.strictObject({ caseId: id12, purposeRef: id12, useRef: id12.nullable() }),
-  artifactRequirementId: id12.nullable(),
+  case: z63.strictObject({ caseId: id13, purposeRef: id13, useRef: id13.nullable() }),
+  artifactRequirementId: id13.nullable(),
   decision: ArtifactLintDecisionSchema.nullable(),
   artifact: ArtifactLintArtifactSchema
 });
@@ -6008,11 +6106,11 @@ var artifactCheckStatuses = [
   "not_applicable",
   "skipped"
 ];
-var range = z61.strictObject({
-  sectionId: id12,
-  start: z61.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
-  end: z61.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
-  offsetUnit: z61.literal("utf16_code_units")
+var range = z63.strictObject({
+  sectionId: id13,
+  start: z63.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
+  end: z63.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
+  offsetUnit: z63.literal("utf16_code_units")
 });
 var findingCodes = [
   "section_missing",
@@ -6041,161 +6139,318 @@ var findingCodes = [
   "evaluation_budget_exceeded",
   "evaluation_skipped"
 ];
-var ArtifactFindingSchema = z61.strictObject({
-  code: z61.enum(findingCodes),
-  checkId: id12.nullable(),
-  severity: z61.enum(["error", "warning"]),
+var ArtifactFindingSchema = z63.strictObject({
+  code: z63.enum(findingCodes),
+  checkId: id13.nullable(),
+  severity: z63.enum(["error", "warning"]),
   specification: passage3.nullable(),
   location: range.nullable(),
-  insertionAnchor: z61.strictObject({ sectionId: id12.nullable(), at: z61.number().int().min(0) }).nullable(),
-  literalIndex: z61.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
-});
-var ArtifactCheckObservationSchema = z61.strictObject({
-  checkId: id12,
-  kind: z61.enum(artifactCheckKinds),
-  required: z61.boolean(),
-  method: z61.enum(["deterministic", "semantic"]),
-  status: z61.enum(artifactCheckStatuses),
-  occurrences: z61.number().int().min(0),
-  parsedValue: z61.number().nullable(),
-  caseValue: z61.number().nullable()
-});
-var ArtifactLintRecordBodySchema = z61.strictObject({
-  schema: z61.literal("felspar.lint-record.draft/v1"),
-  requestId: id12,
-  status: z61.enum(["pass", "revise", "unavailable", "review_required"]),
-  caseContext: z61.enum(["bound", "not_required"]),
-  binding: z61.strictObject({
+  insertionAnchor: z63.strictObject({ sectionId: id13.nullable(), at: z63.number().int().min(0) }).nullable(),
+  literalIndex: z63.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
+});
+var ArtifactCheckObservationSchema = z63.strictObject({
+  checkId: id13,
+  kind: z63.enum(artifactCheckKinds),
+  required: z63.boolean(),
+  method: z63.enum(["deterministic", "semantic"]),
+  status: z63.enum(artifactCheckStatuses),
+  occurrences: z63.number().int().min(0),
+  parsedValue: z63.number().nullable(),
+  caseValue: z63.number().nullable()
+});
+var ArtifactLintRecordBodySchema = z63.strictObject({
+  schema: z63.literal("felspar.lint-record.draft/v1"),
+  requestId: id13,
+  status: z63.enum(["pass", "revise", "unavailable", "review_required"]),
+  caseContext: z63.enum(["bound", "not_required"]),
+  binding: z63.strictObject({
     scope: DraftApplicationScopeSchema,
-    releaseId: id12,
-    releaseDigest: digest27,
-    materialDigest: digest27,
-    obligationsDigest: digest27.optional(),
-    caseFactsDigest: digest27.optional(),
-    jobId: id12,
-    manifestId: id12,
-    manifestDigest: digest27,
-    contract: z61.strictObject({ id: id12, digest: digest27 }),
-    caseId: id12,
-    purposeRef: id12,
-    useRef: id12.nullable(),
-    artifactRequirementId: id12.nullable(),
-    decisionReceiptDigest: digest27.nullable(),
-    obligationsAssessmentDigest: digest27.nullable()
+    releaseId: id13,
+    releaseDigest: digest28,
+    materialDigest: digest28,
+    obligationsDigest: digest28.optional(),
+    caseFactsDigest: digest28.optional(),
+    jobId: id13,
+    manifestId: id13,
+    manifestDigest: digest28,
+    contract: z63.strictObject({ id: id13, digest: digest28 }),
+    caseId: id13,
+    purposeRef: id13,
+    useRef: id13.nullable(),
+    artifactRequirementId: id13.nullable(),
+    decisionReceiptDigest: digest28.nullable(),
+    obligationsAssessmentDigest: digest28.nullable()
   }),
-  artifact: z61.strictObject({
-    id: id12,
-    revision: id12,
-    mediaType: z61.enum(artifactLintMediaTypes),
-    exportProfile: id12.nullable(),
-    contentDigest: digest27,
-    sections: z61.array(z61.strictObject({
-      id: id12,
-      units: z61.number().int().min(0),
-      contentDigest: digest27.nullable()
+  artifact: z63.strictObject({
+    id: id13,
+    revision: id13,
+    mediaType: z63.enum(artifactLintMediaTypes),
+    exportProfile: id13.nullable(),
+    contentDigest: digest28,
+    sections: z63.array(z63.strictObject({
+      id: id13,
+      units: z63.number().int().min(0),
+      contentDigest: digest28.nullable()
     })).max(artifactLintLimits.maxSections)
   }),
-  checks: z61.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
-  findings: z61.array(ArtifactFindingSchema).max(2048),
+  checks: z63.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
+  findings: z63.array(ArtifactFindingSchema).max(2048),
   semantic: ArtifactSemanticRecordSchema.nullable(),
-  coverage: z61.strictObject({
-    scope: z61.literal("declared_checks_only"),
-    declared: z61.number().int().min(0),
-    applicable: z61.number().int().min(0),
-    completed: z61.number().int().min(0),
-    required: z61.number().int().min(0),
-    requiredCompleted: z61.number().int().min(0),
-    textAssigned: z61.enum(["complete", "incomplete"]),
-    semantic: z61.enum(["not_declared", "complete", "incomplete"]),
-    nativeDocumentLayout: z61.literal("not_checked")
+  coverage: z63.strictObject({
+    scope: z63.literal("declared_checks_only"),
+    declared: z63.number().int().min(0),
+    applicable: z63.number().int().min(0),
+    completed: z63.number().int().min(0),
+    required: z63.number().int().min(0),
+    requiredCompleted: z63.number().int().min(0),
+    textAssigned: z63.enum(["complete", "incomplete"]),
+    semantic: z63.enum(["not_declared", "complete", "incomplete"]),
+    nativeDocumentLayout: z63.literal("not_checked")
   }),
-  actionAuthorized: z61.literal(false)
+  actionAuthorized: z63.literal(false)
 });
 var ArtifactLintRecordSchema = ArtifactLintRecordBodySchema.extend({
-  recordDigest: digest27
-});
-var ArtifactLintReceiptSchema = z61.strictObject({
-  schema: z61.literal("felspar.lint-receipt.draft/v1"),
-  recordDigest: digest27,
-  releaseDigest: digest27,
-  manifestDigest: digest27,
-  contractDigest: digest27,
-  caseId: id12,
-  caseContext: z61.enum(["bound", "not_required"]),
-  decisionReceiptDigest: digest27.nullable(),
-  obligationsAssessmentDigest: digest27.nullable(),
-  artifactId: id12,
-  artifactRevision: id12,
-  artifactDigest: digest27,
-  actionAuthorized: z61.literal(false),
-  receiptDigest: digest27
+  recordDigest: digest28
+});
+var ArtifactLintReceiptSchema = z63.strictObject({
+  schema: z63.literal("felspar.lint-receipt.draft/v1"),
+  recordDigest: digest28,
+  releaseDigest: digest28,
+  manifestDigest: digest28,
+  contractDigest: digest28,
+  caseId: id13,
+  caseContext: z63.enum(["bound", "not_required"]),
+  decisionReceiptDigest: digest28.nullable(),
+  obligationsAssessmentDigest: digest28.nullable(),
+  artifactId: id13,
+  artifactRevision: id13,
+  artifactDigest: digest28,
+  actionAuthorized: z63.literal(false),
+  receiptDigest: digest28
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-var id13 = DraftApplicationScopeSchema.shape.authorityId;
-var digest28 = DraftJobReceiptSchema.shape.receiptDigest;
-var HostedOutputCheckInputSchema = z62.strictObject({
-  executionId: id13,
-  output: id13.optional(),
-  text: z62.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
-  revision: id13.optional()
-});
-var HostedOutputCheckRecordSchema = z62.strictObject({
-  schema: z62.literal("felspar.hosted-output-check/v0"),
-  checkId: id13,
-  jobId: id13,
-  output: id13,
-  decision: z62.strictObject({ executionId: id13, outcome: id13, receiptDigest: digest28 }),
-  release: z62.strictObject({ releaseId: id13, releaseDigest: digest28 }),
+var id14 = DraftApplicationScopeSchema.shape.authorityId;
+var digest29 = DraftJobReceiptSchema.shape.receiptDigest;
+var HostedOutputCheckInputSchema = z64.strictObject({
+  executionId: id14,
+  output: id14.optional(),
+  text: z64.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
+  revision: id14.optional()
+});
+var HostedOutputCheckRecordSchema = z64.strictObject({
+  schema: z64.literal("felspar.hosted-output-check/v0"),
+  checkId: id14,
+  jobId: id14,
+  output: id14,
+  decision: z64.strictObject({ executionId: id14, outcome: id14, receiptDigest: digest29 }),
+  release: z64.strictObject({ releaseId: id14, releaseDigest: digest29 }),
   record: ArtifactLintRecordSchema,
   receipt: ArtifactLintReceiptSchema.nullable(),
-  evaluation: z62.strictObject({
-    modelCalls: z62.number().int().min(0),
-    reason: z62.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
+  evaluation: z64.strictObject({
+    modelCalls: z64.number().int().min(0),
+    reason: z64.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
   })
 });
 
 // src/draft-hosted-client.ts
-import { z as z63 } from "zod";
-var digestText = z63.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var HostedOutputCheckReplySchema = z63.object({
-  status: z63.enum(["pass", "revise", "review_required", "unavailable"]),
-  checkId: z63.string(),
-  output: z63.string(),
-  findings: z63.array(z63.record(z63.string(), z63.unknown())),
-  receipt: z63.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
-  decision: z63.object({ executionId: z63.string(), receiptDigest: digestText }),
-  actionAuthorized: z63.literal(false)
+import { z as z67 } from "zod";
+
+// ../schemas/src/draft-agent-responses.ts
+import { z as z65 } from "zod";
+var digestText = z65.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var HostedOutputCheckReplySchema = z65.object({
+  status: z65.enum(["pass", "revise", "review_required", "unavailable"]),
+  checkId: z65.string(),
+  output: z65.string(),
+  findings: z65.array(z65.record(z65.string(), z65.unknown())),
+  receipt: z65.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
+  decision: z65.object({ executionId: z65.string(), receiptDigest: digestText }),
+  actionAuthorized: z65.literal(false)
 }).loose();
-var quotedWords = z63.object({ text: z63.string() }).loose();
-var FelsparCaseSchema = z63.object({ id: z63.string().min(1).max(200), mode: z63.enum(identityModes) });
-var FelsparRelatedSchema = z63.object({
-  relationship: z63.string(),
-  subject: z63.string(),
-  id: z63.string(),
-  questions: z63.array(z63.string())
-});
-var FelsparResultSubjectSchema = z63.object({
-  type: z63.string(),
-  id: z63.string(),
-  related: z63.array(FelsparRelatedSchema)
-});
-var FelsparEscalationSchema = z63.object({
-  id: z63.string().min(1).max(200),
-  trigger: z63.enum(escalationTriggers),
+var quotedWords = z65.object({ text: z65.string() }).loose();
+var FelsparCaseSchema = z65.object({
+  id: z65.string().min(1).max(200),
+  mode: z65.enum(identityModes)
+});
+var FelsparRelatedSchema = z65.object({
+  relationship: z65.string(),
+  subject: z65.string(),
+  id: z65.string(),
+  questions: z65.array(z65.string())
+});
+var FelsparResultSubjectSchema = z65.object({
+  type: z65.string(),
+  id: z65.string(),
+  related: z65.array(FelsparRelatedSchema)
+});
+var FelsparEscalationSchema = z65.object({
+  id: z65.string().min(1).max(200),
+  trigger: z65.enum(escalationTriggers),
   why: quotedWords
 });
-var FelsparJobResultSchema = HostedJobResultSchema.extend({
+var AgentExecutedResponseSchema = HostedJobResultSchema.extend({
   result: HostedJobResultSchema.shape.result.unwrap().extend({
     case: FelsparCaseSchema.optional(),
     subject: FelsparResultSubjectSchema.optional(),
     escalation: FelsparEscalationSchema.optional(),
-    missing: z63.array(z63.string()).optional()
+    missing: z65.array(z65.string()).optional()
   }).nullable()
 });
-var FelsparJobListSchema = z63.object({
-  jobs: z63.array(z63.object({ id: z63.string().min(1).max(200) })).max(256)
+var AgentMissingRelatedResponseSchema = z65.object({
+  status: z65.literal("gap"),
+  reason: z65.literal("related_subject_missing"),
+  result: AgentExecutedResponseSchema.shape.result.unwrap().pick({
+    executionId: true,
+    releaseId: true,
+    releaseDigest: true,
+    case: true,
+    subject: true,
+    escalation: true
+  }).extend({
+    outcome: z65.null(),
+    receipt: z65.null(),
+    missing: z65.array(z65.string()),
+    explanation: z65.object({
+      needs: z65.array(z65.object({
+        key: z65.string(),
+        status: z65.literal("missing"),
+        reasons: z65.array(z65.string())
+      }))
+    })
+  })
+});
+var FelsparJobResultSchema = z65.union([
+  AgentExecutedResponseSchema,
+  AgentMissingRelatedResponseSchema
+]);
+var FelsparJobListSchema = z65.object({
+  jobs: z65.array(z65.object({ id: z65.string().min(1).max(200) })).max(256)
 });
+
+// ../schemas/src/draft-decision-graph.ts
+import { z as z66 } from "zod";
+
+// ../schemas/src/draft-trace-budget.ts
+var traceGraphLimits = Object.freeze({ nodes: 2048, edges: 4096 });
+
+// ../schemas/src/draft-decision-graph.ts
+var digest30 = DraftJobReceiptSchema.shape.receiptDigest;
+var identity = z66.string().min(1).max(200);
+var nodeId = z66.string().regex(/^n\d+$/u);
+var DecisionGraphStateSchema = z66.enum([
+  "declared",
+  "active",
+  "inactive",
+  "blocked",
+  "suppressed"
+]);
+var DecisionGraphTopologySchema = z66.strictObject({
+  nodes: z66.array(z66.strictObject({
+    id: nodeId,
+    kind: z66.enum([
+      "subject",
+      "question",
+      "rule",
+      "selection",
+      "outcome",
+      "unresolved",
+      "attempts",
+      "retry",
+      "escalation",
+      "scoring",
+      "score_criterion"
+    ]),
+    key: identity,
+    lines: z66.array(z66.string().max(16384)).min(1).max(128),
+    state: DecisionGraphStateSchema
+  })).max(traceGraphLimits.nodes),
+  edges: z66.array(z66.strictObject({
+    from: nodeId,
+    to: nodeId,
+    kind: z66.enum([
+      "asks",
+      "depends_on",
+      "considers",
+      "selects",
+      "overrides",
+      "unresolved",
+      "retry",
+      "escalates",
+      "scores"
+    ]),
+    state: DecisionGraphStateSchema
+  })).max(traceGraphLimits.edges)
+}).superRefine((graph, context3) => {
+  const ids3 = new Set(graph.nodes.map((node) => node.id));
+  const edges = new Set(graph.edges.map(({ from, to, kind }) => JSON.stringify([from, to, kind])));
+  if (ids3.size !== graph.nodes.length || edges.size !== graph.edges.length || graph.edges.some((edge) => !ids3.has(edge.from) || !ids3.has(edge.to))) {
+    context3.addIssue({ code: "custom", message: "Duplicate or dangling graph identity" });
+  }
+});
+var pins = {
+  jobId: identity,
+  releaseId: identity,
+  releaseDigest: digest30,
+  materialDigest: digest30
+};
+var DecisionGraphSchema = z66.discriminatedUnion("status", [
+  z66.strictObject({
+    schema: z66.literal("felspar.decision-graph/v1"),
+    status: z66.literal("ready"),
+    view: z66.enum(["release", "proposal", "run"]),
+    ...pins,
+    topologyDigest: digest30,
+    graph: DecisionGraphTopologySchema,
+    mermaid: z66.string().max(262144),
+    proposalId: identity.optional(),
+    executionObjectId: identity.optional(),
+    receiptDigest: digest30.nullable(),
+    evaluationTime: z66.iso.datetime().nullable(),
+    attempt: DecisionGraphAttemptSchema.nullable(),
+    dashboardUrl: z66.url().optional()
+  }),
+  z66.strictObject({
+    schema: z66.literal("felspar.decision-graph/v1"),
+    status: z66.literal("unavailable"),
+    reason: z66.enum([
+      "graph_limit_exceeded",
+      "unsupported_material",
+      "history_unavailable",
+      "replay_mismatch"
+    ]),
+    dashboardUrl: z66.url().optional()
+  })
+]);
+
+// src/draft-decision-graph-client.ts
+function decisionGraphCalls(call) {
+  async function read(kind, id15) {
+    const value2 = encodeURIComponent(HostedObjectSchema.shape.id.parse(id15));
+    const graph = await call(`/v0/${kind}/${value2}/graph`, DecisionGraphSchema);
+    if (graph.status !== "ready") {
+      return graph;
+    }
+    const pins2 = {
+      releases: graph.releaseId,
+      proposals: graph.proposalId,
+      executions: graph.executionObjectId
+    };
+    if (pins2[kind] !== id15) {
+      throw new Error("Graph identity differs");
+    }
+    return graph;
+  }
+  return {
+    getReleaseGraph: async (id15) => await read("releases", id15),
+    getProposalGraph: async (id15) => await read("proposals", id15),
+    getDecisionGraph: async (executionObjectId) => await read("executions", executionObjectId)
+  };
+}
+
+// src/draft-hosted-client.ts
+var FelsparJobResultSchema2 = FelsparJobResultSchema;
+var FelsparJobListSchema2 = FelsparJobListSchema;
 var hostedPartsContentType = "application/x.felspar-content-parts";
 async function partsBody(value2) {
   const packed = await packContentParts(value2);
@@ -6246,20 +6501,20 @@ ${jobId}`;
     return result;
   };
 }
-var refusalCode = z63.string().regex(/^[a-z][a-z_]{2,63}$/u);
-var fieldPath = z63.array(z63.string().max(256)).max(32);
-var refusalEscalationSchema = z63.object({
-  id: z63.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]{0,199}$/u),
-  trigger: z63.enum(escalationTriggers),
-  why: z63.object({ text: z63.string().max(2e4) })
+var refusalCode = z67.string().regex(/^[a-z][a-z_]{2,63}$/u);
+var fieldPath = z67.array(z67.string().max(256)).max(32);
+var refusalEscalationSchema = z67.object({
+  id: z67.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]{0,199}$/u),
+  trigger: z67.enum(escalationTriggers),
+  why: z67.object({ text: z67.string().max(2e4) })
 });
-var refusalSchema = z63.object({
+var refusalSchema = z67.object({
   error: refusalCode,
   path: fieldPath.optional(),
-  currentReleaseDigest: z63.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
-  retryAfterSeconds: z63.number().int().min(1).max(3600).optional(),
-  escalation: z63.unknown().optional(),
-  issues: z63.array(z63.object({ code: refusalCode, path: fieldPath })).max(64).optional()
+  currentReleaseDigest: z67.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
+  retryAfterSeconds: z67.number().int().min(1).max(3600).optional(),
+  escalation: z67.unknown().optional(),
+  issues: z67.array(z67.object({ code: refusalCode, path: fieldPath })).max(64).optional()
 }).transform(({ escalation: named, ...value2 }) => {
   const fix = hostedRefusalFix(value2.error);
   const recovery = hostedRefusalRecovery(value2.error);
@@ -6321,13 +6576,13 @@ function outputCheckCalls(call) {
 function agentCalls(call) {
   const objectId = HostedObjectSchema.shape.id;
   return {
-    listJobs: async () => await call("/v0/jobs", FelsparJobListSchema),
+    listJobs: async () => await call("/v0/jobs", FelsparJobListSchema2),
     describeCurrentJob: async (job) => await call(`/v0/jobs/${encodeURIComponent(objectId.parse(job))}/brief`, HostedJobDescriptionSchema),
-    resolveJob: async (id14, value2) => {
+    resolveJob: async (id15, value2) => {
       const input = HostedSuppliedJobInputSchema.parse(value2);
-      const releaseId = objectId.parse(id14);
+      const releaseId = objectId.parse(id15);
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
-      return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
+      return pinnedResult(await call(path3, FelsparJobResultSchema2, input), releaseId, input);
     }
   };
 }
@@ -6368,21 +6623,22 @@ function createHostedFelsparClient(configuration) {
   const objectId = HostedObjectSchema.shape.id;
   const describe = jobDescriber(async (releaseId, jobId) => await call(describePath(releaseId, jobId), HostedJobDescriptionSchema));
   return {
+    ...decisionGraphCalls(call),
     submitSource: async (value2) => await call("/v0/sources", HostedObjectSchema, HostedSourceInputSchema.parse(value2)),
     submitProposal: async (value2) => await call("/v0/proposals", HostedObjectSchema, HostedProposalInputSchema.parse(value2)),
-    approveProposal: async (id14, value2) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id14))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value2)),
-    releasePack: async (id14, value2) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id14))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value2)),
-    loadRelease: async (id14) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id14))}`, HostedReleaseBundleSchema),
-    describeJob: async (id14, job) => await describe(objectId.parse(id14), objectId.parse(job)),
+    approveProposal: async (id15, value2) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id15))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value2)),
+    releasePack: async (id15, value2) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id15))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value2)),
+    loadRelease: async (id15) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id15))}`, HostedReleaseBundleSchema),
+    describeJob: async (id15, job) => await describe(objectId.parse(id15), objectId.parse(job)),
     verifyReceipt: async (executionObjectId, value2) => await call(`/v0/executions/${encodeURIComponent(objectId.parse(executionObjectId))}/verify`, HostedReceiptVerificationSchema, HostedReceiptVerificationInputSchema.parse(value2)),
     ...outputCheckCalls(call),
-    executeJob: async (id14, value2) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id14))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value2)),
+    executeJob: async (id15, value2) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id15))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value2)),
     ...agentCalls(call),
-    resolveFacts: async (id14, value2) => {
-      const releaseId = objectId.parse(id14);
+    resolveFacts: async (id15, value2) => {
+      const releaseId = objectId.parse(id15);
       const input = await factsRequest(value2, async (jobId) => await describe(releaseId, jobId));
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
-      return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
+      return pinnedResult(await call(path3, FelsparJobResultSchema2, input), releaseId, input);
     }
   };
 }