@felspar/sdk 0.4.0 → 0.4.2

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

@@ -51,26 +51,26 @@ function append(token, state, bytes = utf8Bytes(token)) {
   state.parts.push(state.buffer);
   state.buffer = "";
 }
-function quoted(value) {
-  if (value.length > canonicalJsonLimits.maxBytes) {
+function quoted(value2) {
+  if (value2.length > canonicalJsonLimits.maxBytes) {
     throw new RangeError("Canonical JSON string exceeds the byte limit");
   }
-  if (/[\uD800-\uDFFF]/u.test(value)) {
+  if (/[\uD800-\uDFFF]/u.test(value2)) {
     throw new TypeError("Canonical JSON requires valid Unicode strings");
   }
-  return JSON.stringify(value);
+  return JSON.stringify(value2);
 }
-function appendQuoted(value, state) {
-  let entry2 = state.strings.get(value);
-  if (!entry2) {
-    const token = quoted(value);
-    entry2 = { token, bytes: utf8Bytes(token) };
-    if (state.strings.size < 256 && state.stringBytes + entry2.bytes <= 65536) {
-      state.strings.set(value, entry2);
-      state.stringBytes += entry2.bytes;
+function appendQuoted(value2, state) {
+  let entry3 = state.strings.get(value2);
+  if (!entry3) {
+    const token = quoted(value2);
+    entry3 = { token, bytes: utf8Bytes(token) };
+    if (state.strings.size < 256 && state.stringBytes + entry3.bytes <= 65536) {
+      state.strings.set(value2, entry3);
+      state.stringBytes += entry3.bytes;
     }
   }
-  append(entry2.token, state, entry2.bytes);
+  append(entry3.token, state, entry3.bytes);
 }
 function dataValue(input, key3) {
   const descriptor = Object.getOwnPropertyDescriptor(input, key3);
@@ -131,13 +131,13 @@ function writeObject(input, state, depth) {
   }
   append("}", state);
 }
-function writeSealed(entry2, state, depth) {
-  state.nodes += entry2.nodes - 1;
-  if (depth + entry2.height > canonicalJsonLimits.maxDepth || state.nodes > canonicalJsonLimits.maxNodes) {
+function writeSealed(entry3, state, depth) {
+  state.nodes += entry3.nodes - 1;
+  if (depth + entry3.height > canonicalJsonLimits.maxDepth || state.nodes > canonicalJsonLimits.maxNodes) {
     throw new RangeError("Canonical JSON exceeds the depth or node limit");
   }
-  state.height = Math.max(state.height, depth + entry2.height);
-  append(entry2.json, state, entry2.bytes);
+  state.height = Math.max(state.height, depth + entry3.height);
+  append(entry3.json, state, entry3.bytes);
 }
 function writeContainer(input, state, depth) {
   const sealed = sealedEntries.get(input);
@@ -266,12 +266,12 @@ function sealValue(input, depth, state) {
     throw new RangeError("Canonical JSON exceeds the depth, node or byte limit");
   }
   Object.freeze(input);
-  const entry2 = { json, bytes, nodes, height };
+  const entry3 = { json, bytes, nodes, height };
   sealedContainers.add(input);
   if (bytes >= sealedEntryMinimumBytes) {
-    sealedEntries.set(input, entry2);
+    sealedEntries.set(input, entry3);
   }
-  return entry2;
+  return entry3;
 }
 function sealCanonicalJson(input) {
   sealValue(input, 0, { ancestors: /* @__PURE__ */ new Set() });
@@ -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(digest28) {
-  return { [draftContentPartReferenceKey]: digest28 };
+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";
@@ -326,12 +326,12 @@ function admit(logical, depth) {
     throw new RangeError(logicalLimit);
   }
 }
-function scalar(value) {
-  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
+function scalar(value2) {
+  if (value2 === void 0 || typeof value2 === "function" || typeof value2 === "symbol") {
     throw new TypeError("Content parts require JSON values");
   }
-  const bytes = utf8(JSON.stringify(value));
-  return { value, tokenBytes: bytes, logical: { bytes, nodes: 1, height: 0 } };
+  const bytes = utf8(JSON.stringify(value2));
+  return { value: value2, tokenBytes: bytes, logical: { bytes, nodes: 1, height: 0 } };
 }
 function combine(keys, children) {
   let tokenBytes = 2 + Math.max(children.length - 1, 0);
@@ -350,8 +350,8 @@ function combine(keys, children) {
 }
 var hydratedValues = /* @__PURE__ */ new WeakSet();
 var knownSplits = /* @__PURE__ */ new WeakMap();
-function isImmutable(value) {
-  return hydratedValues.has(value) || isCanonicalJsonSealed(value);
+function isImmutable(value2) {
+  return hydratedValues.has(value2) || isCanonicalJsonSealed(value2);
 }
 function entriesOf(input) {
   const isArray = Array.isArray(input);
@@ -397,7 +397,7 @@ function measure(input, state, depth) {
       throw new RangeError(logicalLimit);
     }
     const entries2 = entriesOf(input);
-    const children = entries2.map(([, value]) => measure(value, state, depth + 1));
+    const children = entries2.map(([, value2]) => measure(value2, state, depth + 1));
     const keys = Array.isArray(input) ? null : entries2.map(([key3]) => key3);
     const { tokenBytes: tokenBytes2, logical } = combine(keys, children);
     const isPart = tokenBytes2 >= contentPartsLimits.minPartBytes;
@@ -419,19 +419,19 @@ function storedForm(input, state) {
   if (known) {
     return known.value;
   }
-  const digest28 = state.digests.get(input);
-  if (digest28 !== void 0) {
-    return reference(digest28);
+  const digest31 = state.digests.get(input);
+  if (digest31 !== void 0) {
+    return reference(digest31);
   }
   const node = state.measured.get(input);
   if (!node) {
     throw new Error("Content parts lost a measured container");
   }
-  return rebuild(input, node.entries, node.entries.map(([, value]) => storedForm(value, state)));
+  return rebuild(input, node.entries, node.entries.map(([, value2]) => storedForm(value2, state)));
 }
-function remember(node, value, tokenBytes) {
+function remember(node, value2, tokenBytes) {
   if (isImmutable(node.input)) {
-    knownSplits.set(node.input, { value, tokenBytes, logical: node.logical });
+    knownSplits.set(node.input, { value: value2, tokenBytes, logical: node.logical });
   }
 }
 function isCanonicalDocumentSized(logical) {
@@ -446,7 +446,7 @@ function freezeMeasured(state) {
     hydratedValues.add(node.input);
   }
 }
-async function splitRoot(value, isCollecting, isFreezing = false) {
+async function splitRoot(value2, isCollecting, isFreezing = false) {
   const state = {
     isCollecting,
     measured: /* @__PURE__ */ new Map(),
@@ -454,26 +454,26 @@ async function splitRoot(value, isCollecting, isFreezing = false) {
     digests: /* @__PURE__ */ new Map(),
     parts: /* @__PURE__ */ new Map()
   };
-  const root = measure(value, state, 0);
+  const root = measure(value2, state, 0);
   if (isFreezing) {
     freezeMeasured(state);
   }
   for (const node of state.order) {
     const token = canonicalizeJson(storedForm(node.input, state));
-    const digest29 = await sha256(token);
-    state.digests.set(node.input, digest29);
-    state.parts.set(digest29, token);
-    remember(node, reference(digest29), referenceBytes);
-  }
-  const stored = storedForm(value, state);
-  if (value !== null && typeof value === "object") {
-    const node = state.measured.get(value);
+    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") {
+    const node = state.measured.get(value2);
     if (node && !node.isPart) {
       remember(node, stored, node.tokenBytes);
     }
   }
-  const digest28 = await sha256(canonicalizeJson(stored));
-  return { state, root: { ...root, value: stored }, digest: digest28 };
+  const digest31 = await sha256(canonicalizeJson(stored));
+  return { state, root: { ...root, value: stored }, digest: digest31 };
 }
 function byDigest(left, right) {
   return left < right ? -1 : 1;
@@ -483,8 +483,8 @@ function admitStored(parts, bytes) {
     throw new RangeError("Content parts exceed the stored part or byte limit");
   }
 }
-async function packContentParts(value) {
-  const { state, root, digest: digest28 } = await splitRoot(value, true);
+async function packContentParts(value2) {
+  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(value) {
   const storedBytes = utf8(text8);
   admitStored(parts.length, storedBytes);
   return {
-    digest: digest28,
+    digest: digest31,
     text: text8,
     parts: parts.length,
     storedBytes,
@@ -524,12 +524,12 @@ import { z as z5 } from "zod";
 
 // ../schemas/src/draft-calendar-date.ts
 import { z as z2 } from "zod";
-var CalendarDateSchema = z2.string().regex(/^(?!0000)\d{4}-\d{2}-\d{2}$/u).refine((value) => {
-  const instant2 = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
-  return Number.isFinite(instant2.getTime()) && instant2.toISOString().slice(0, 10) === value;
+var CalendarDateSchema = z2.string().regex(/^(?!0000)\d{4}-\d{2}-\d{2}$/u).refine((value2) => {
+  const instant2 = /* @__PURE__ */ new Date(`${value2}T00:00:00.000Z`);
+  return Number.isFinite(instant2.getTime()) && instant2.toISOString().slice(0, 10) === value2;
 }, "Expected a real Gregorian calendar date in years 0001\u20139999");
-function calendarDay(value) {
-  return Date.parse(`${value}T00:00:00.000Z`) / 864e5;
+function calendarDay(value2) {
+  return Date.parse(`${value2}T00:00:00.000Z`) / 864e5;
 }
 
 // ../schemas/src/draft-evidence-scope.ts
@@ -537,8 +537,8 @@ import { z as z3 } from "zod";
 var identifier = z3.string().min(1).max(256).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
 var draftSourceIdLimit = 2048;
 var draftSourceIdPattern = /^[a-zA-Z0-9](?:[a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=]|%[0-9a-fA-F]{2})*$/u;
-function isDraftSourceId(value) {
-  return value.length <= draftSourceIdLimit && draftSourceIdPattern.test(value);
+function isDraftSourceId(value2) {
+  return value2.length <= draftSourceIdLimit && draftSourceIdPattern.test(value2);
 }
 var sourceId = z3.string().min(1).max(draftSourceIdLimit).regex(draftSourceIdPattern);
 var reference2 = z3.strictObject({
@@ -630,8 +630,8 @@ var businessCalendar = z5.strictObject({
     });
   }
   if (calendar.holidays.some((day) => {
-    const value = calendarDay(day);
-    return value < calendarDay(calendar.validFrom) || value > calendarDay(calendar.validThrough);
+    const value2 = calendarDay(day);
+    return value2 < calendarDay(calendar.validFrom) || value2 > calendarDay(calendar.validThrough);
   })) {
     context3.addIssue({ code: "custom", message: "Holiday outside declared calendar coverage" });
   }
@@ -691,20 +691,20 @@ function unique(values, context3, path3) {
 function checkAuthority(authority, context3) {
   unique(authority.definition.allowedValues, context3, ["definition", "allowedValues"]);
   unique(authority.allowedOutcomes, context3, ["allowedOutcomes"]);
-  unique(authority.rules.map((entry2) => entry2.id), context3, ["rules"]);
+  unique(authority.rules.map((entry3) => entry3.id), context3, ["rules"]);
   const values = new Set(authority.definition.allowedValues);
   const outcomes = new Set(authority.allowedOutcomes);
-  for (const [index, entry2] of authority.rules.entries()) {
+  for (const [index, entry3] of authority.rules.entries()) {
     const at = ["rules", index];
-    requireBinding(entry2.when.key === authority.definition.key, context3, {
+    requireBinding(entry3.when.key === authority.definition.key, context3, {
       path: [...at, "when", "key"],
       message: unknownDefinition
     });
-    requireBinding(values.has(entry2.when.equals), context3, {
+    requireBinding(values.has(entry3.when.equals), context3, {
       path: [...at, "when", "equals"],
       message: "Unknown definition value"
     });
-    requireBinding(outcomes.has(entry2.outcome), context3, {
+    requireBinding(outcomes.has(entry3.outcome), context3, {
       path: [...at, "outcome"],
       message: "Unknown outcome"
     });
@@ -769,15 +769,15 @@ var admission = z8.strictObject({
   trustDomain: identifier5,
   status: z8.enum(["approved", "revoked"])
 });
-function draftEvidenceReferenceKey(value) {
-  return JSON.stringify([draftPassageKey(value), value.contentDigest]);
+function draftEvidenceReferenceKey(value2) {
+  return JSON.stringify([draftPassageKey(value2), value2.contentDigest]);
 }
-function draftAdmissionKey(value) {
+function draftAdmissionKey(value2) {
   return JSON.stringify([
-    draftEvidenceReferenceKey(value.reference),
-    value.purpose,
-    value.sensitivity,
-    value.trustDomain
+    draftEvidenceReferenceKey(value2.reference),
+    value2.purpose,
+    value2.sensitivity,
+    value2.trustDomain
   ]);
 }
 function requireCoverage({ expected: expected2, actual, path: path3 }, context3) {
@@ -909,9 +909,9 @@ import { z as z12 } from "zod";
 
 // ../schemas/src/draft-decision-date.ts
 import { z as z11 } from "zod";
-function isTimeZone(value) {
+function isTimeZone(value2) {
   try {
-    const format = new Intl.DateTimeFormat("en-US", { timeZone: value });
+    const format = new Intl.DateTimeFormat("en-US", { timeZone: value2 });
     const options = format.resolvedOptions();
     return options.timeZone.length > 0;
   } catch {
@@ -992,22 +992,22 @@ function interval(clause, definition3) {
   if (!bounds) {
     return null;
   }
-  const { minimum, maximum, operator, value } = bounds;
+  const { minimum, maximum, operator, value: value2 } = bounds;
   return {
-    low: operator === "lt" || operator === "lte" ? minimum : Math.max(minimum, value),
-    high: operator === "gt" || operator === "gte" ? maximum : Math.min(maximum, value),
-    lowClosed: operator !== "gt" || minimum > value,
-    highClosed: operator !== "lt" || maximum < value
+    low: operator === "lt" || operator === "lte" ? minimum : Math.max(minimum, value2),
+    high: operator === "gt" || operator === "gte" ? maximum : Math.min(maximum, value2),
+    lowClosed: operator !== "gt" || minimum > value2,
+    highClosed: operator !== "lt" || maximum < value2
   };
 }
-function nextNumber(value) {
-  if (value === 0) {
+function nextNumber(value2) {
+  if (value2 === 0) {
     return Number.MIN_VALUE;
   }
   const view = new DataView(new ArrayBuffer(8));
-  view.setFloat64(0, value);
+  view.setFloat64(0, value2);
   const bits = view.getBigUint64(0);
-  view.setBigUint64(0, value > 0 ? bits + 1n : bits - 1n);
+  view.setBigUint64(0, value2 > 0 ? bits + 1n : bits - 1n);
   return view.getFloat64(0);
 }
 function isNonempty(range2, isInteger) {
@@ -1046,7 +1046,7 @@ function isConditionSupported(clause, definition3, definitions) {
     return clause.key !== clause.compareFact.key && areCompatibleFacts(definition3, definitions?.get(clause.compareFact.key));
   }
   if ("allowedValues" in definition3) {
-    return "oneOf" in clause ? clause.oneOf.every((value) => definition3.allowedValues.includes(value)) : "equals" in clause && typeof clause.equals === "string" && definition3.allowedValues.includes(clause.equals);
+    return "oneOf" in clause ? clause.oneOf.every((value2) => definition3.allowedValues.includes(value2)) : "equals" in clause && typeof clause.equals === "string" && definition3.allowedValues.includes(clause.equals);
   }
   if (definition3.valueRule.type === "boolean") {
     return "equals" in clause && typeof clause.equals === "boolean";
@@ -1066,7 +1066,7 @@ function relativeConditionsOverlap(left, right) {
     const { operator: b, ...rightOffset } = right.relativeDate;
     if (JSON.stringify(leftOffset) === JSON.stringify(rightOffset)) {
       const signs = { eq: [0], lt: [-1], lte: [-1, 0], gt: [1], gte: [0, 1] };
-      return signs[a].some((value) => signs[b].includes(value));
+      return signs[a].some((value2) => signs[b].includes(value2));
     }
   }
   return null;
@@ -1127,12 +1127,12 @@ function areConditionsOverlapping(left, right, definition3) {
   }
   if ("compareFact" in left && "compareFact" in right && left.compareFact.key === right.compareFact.key) {
     const signs = { eq: [0], lt: [-1], lte: [-1, 0], gt: [1], gte: [0, 1] };
-    return signs[left.compareFact.operator].some((value) => signs[right.compareFact.operator].includes(value));
+    return signs[left.compareFact.operator].some((value2) => signs[right.compareFact.operator].includes(value2));
   }
   const leftValues = optionsOf(left);
   const rightValues = optionsOf(right);
   if (leftValues && rightValues) {
-    return leftValues.some((value) => rightValues.includes(value));
+    return leftValues.some((value2) => rightValues.includes(value2));
   }
   const a = interval(left, definition3);
   const b = interval(right, definition3);
@@ -1286,7 +1286,7 @@ function isGuardImplied(guard, clause) {
   const allowed = choiceValues(guard);
   const values = choiceValues(clause);
   const isSameKey = clause.key === guard.key;
-  return isSameKey && values.length > 0 && values.every((value) => allowed.includes(value));
+  return isSameKey && values.length > 0 && values.every((value2) => allowed.includes(value2));
 }
 function isPolicyValid(proposal, context3) {
   const clauses2 = [
@@ -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((id13) => !ids3.has(id13))) {
+  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((id13) => gates.includes(id13) !== 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;
@@ -1569,6 +1569,8 @@ 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);
@@ -1611,7 +1613,9 @@ var shape = z15.strictObject({
   }),
   scope: z15.strictObject({
     entityId: identifier8,
-    evaluationTime: DraftObservationChecksSchema.shape.evaluationTime
+    evaluationTime: DraftObservationChecksSchema.shape.evaluationTime,
+    valueAgreement: z15.literal(valueAgreementOutcomeRegions).optional(),
+    freshness: z15.literal(freshnessStaleBeforeReview).optional()
   }),
   evidence: z15.array(DraftEvidenceValidationSchema).max(64)
 });
@@ -1631,23 +1635,44 @@ function draftRulePriority(ranked) {
 function hasDraftRulePrecedence(winner, other) {
   return winner.overrides.includes(other.id) || draftRulePriority(winner) > draftRulePriority(other);
 }
+function overlappingRulePairs(proposal) {
+  const { rules: rules2, requirements: requirements3 } = proposal;
+  const definitions = new Map(requirements3.map((item) => [item.definition.key, item.definition]));
+  const pairs = [];
+  for (const [index, item] of rules2.entries()) {
+    const later = rules2.slice(index + 1);
+    for (const [offset, other] of later.entries()) {
+      if (item.outcome !== other.outcome && !areScoredRulesDisjoint(proposal, item, other) && hasOverlap(item, other, definitions)) {
+        pairs.push([index, index + offset + 1]);
+      }
+    }
+  }
+  return pairs;
+}
+function contradictoryRulePairs(proposal) {
+  const { rules: rules2 } = proposal;
+  return overlappingRulePairs(proposal).filter(([left, right]) => {
+    const [item, other] = [rules2[left], rules2[right]];
+    return item !== void 0 && other !== void 0 && !hasDraftRulePrecedence(item, other) && !hasDraftRulePrecedence(other, item);
+  });
+}
 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 = (id13) => {
-    if (visiting.has(id13)) {
+  const hasPathCycle = (id15) => {
+    if (visiting.has(id15)) {
       return true;
     }
-    if (visited.has(id13)) {
+    if (visited.has(id15)) {
       return false;
     }
-    visiting.add(id13);
-    if ((graph.get(id13) ?? []).some(hasPathCycle)) {
+    visiting.add(id15);
+    if ((graph.get(id15) ?? []).some(hasPathCycle)) {
       return true;
     }
-    visiting.delete(id13);
-    visited.add(id13);
+    visiting.delete(id15);
+    visited.add(id15);
     return false;
   };
   return rules2.some((item) => hasPathCycle(item.id));
@@ -1656,7 +1681,7 @@ function inspectRules(proposal, context3) {
   const { rules: rules2, requirements: requirements3, allowedOutcomes } = proposal;
   const definitions = new Map(requirements3.map((item) => [item.definition.key, item.definition]));
   const ids3 = new Set(rules2.map((item) => item.id));
-  const byId = new Map(rules2.map((entry2) => [entry2.id, entry2]));
+  const byId = new Map(rules2.map((entry3) => [entry3.id, entry3]));
   for (const [index, item] of rules2.entries()) {
     const fail = (message) => {
       context3.addIssue({
@@ -1676,22 +1701,22 @@ function inspectRules(proposal, context3) {
         fail("Undeclared condition key or value");
       }
     }
-    if (item.overrides.some((id13) => id13 === item.id || !ids3.has(id13))) {
+    if (item.overrides.some((id15) => id15 === item.id || !ids3.has(id15))) {
       fail("Unknown or self override");
     }
-    if (item.overrides.some((id13) => {
-      const target = byId.get(id13);
-      return target !== void 0 && draftRulePriority(target) > draftRulePriority(item);
+    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");
     }
-    const laterRules = rules2.slice(index + 1);
-    for (const other of laterRules) {
-      const isContradictory = item.outcome !== other.outcome && !areScoredRulesDisjoint(proposal, item, other) && hasOverlap(item, other, definitions);
-      if (isContradictory && !hasDraftRulePrecedence(item, other) && !hasDraftRulePrecedence(other, item)) {
-        fail("Overlapping contradictory rules require a direct override");
-      }
-    }
+  }
+  for (const [index] of contradictoryRulePairs(proposal)) {
+    context3.addIssue({
+      code: "custom",
+      path: ["rules", index],
+      message: "Overlapping contradictory rules require a direct override"
+    });
   }
   if (hasCycle(rules2)) {
     context3.addIssue({ code: "custom", path: ["rules"], message: "Override cycle" });
@@ -1817,26 +1842,26 @@ function unique2(values, context3, path3) {
 }
 function checkObservations(candidate2, context3) {
   const { authority, observations } = candidate2;
-  unique2(observations.map((entry2) => entry2.id), context3, ["observations"]);
-  for (const [index, entry2] of observations.entries()) {
+  unique2(observations.map((entry3) => entry3.id), context3, ["observations"]);
+  for (const [index, entry3] of observations.entries()) {
     const at = ["observations", index];
-    requireBinding2(entry2.key === authority.definition.key, context3, {
+    requireBinding2(entry3.key === authority.definition.key, context3, {
       path: [...at, "key"],
       message: unknownDefinition2
     });
-    requireBinding2(authority.definition.allowedValues.includes(entry2.value), context3, {
+    requireBinding2(authority.definition.allowedValues.includes(entry3.value), context3, {
       path: [...at, "value"],
       message: "Unknown definition value"
     });
-    requireBinding2(entry2.definitionDigest === authority.definition.contentDigest, context3, {
+    requireBinding2(entry3.definitionDigest === authority.definition.contentDigest, context3, {
       path: [...at, "definitionDigest"],
       message: "Definition fingerprint mismatch"
     });
-    requireBinding2(entry2.evidence.entityId === candidate2.entityId, context3, {
+    requireBinding2(entry3.evidence.entityId === candidate2.entityId, context3, {
       path: [...at, "evidence", "entityId"],
       message: "Evidence belongs to a different entity"
     });
-    requireBinding2(Date.parse(entry2.observedAt) <= Date.parse(candidate2.evaluatedAt), context3, {
+    requireBinding2(Date.parse(entry3.observedAt) <= Date.parse(candidate2.evaluatedAt), context3, {
       path: [...at, "observedAt"],
       message: "Observation is later than evaluation"
     });
@@ -1852,9 +1877,9 @@ function checkExpected(candidate2, context3) {
     return;
   }
   unique2(result.observationIds, context3, ["expected", "observationIds"]);
-  const observationIds = new Set(candidate2.observations.map((entry2) => entry2.id));
-  for (const [index, id13] of result.observationIds.entries()) {
-    requireBinding2(observationIds.has(id13), context3, {
+  const observationIds = new Set(candidate2.observations.map((entry3) => entry3.id));
+  for (const [index, id15] of result.observationIds.entries()) {
+    requireBinding2(observationIds.has(id15), context3, {
       path: ["expected", "observationIds", index],
       message: "Unknown observation"
     });
@@ -1866,7 +1891,7 @@ function checkExpected(candidate2, context3) {
     path: ["expected", "outcome"],
     message: "Unknown outcome"
   });
-  requireBinding2(candidate2.authority.rules.some((entry2) => entry2.id === result.ruleId), context3, { path: ["expected", "ruleId"], message: "Unknown rule" });
+  requireBinding2(candidate2.authority.rules.some((entry3) => entry3.id === result.ruleId), context3, { path: ["expected", "ruleId"], message: "Unknown rule" });
 }
 var DraftDecisionCaseSchema = shape2.superRefine((candidate2, context3) => {
   checkObservations(candidate2, context3);
@@ -1994,10 +2019,10 @@ var expectation = z19.strictObject({
   status: z19.enum(["ready", "blocked", "review_required", "stale", "conflict", "gap"]),
   outcome: identifier11.nullable(),
   selectedRuleIds: z19.array(identifier11).max(256).refine(hasUniqueValues, "Duplicate rule identity")
-}).superRefine((value, context3) => {
-  const hasOutcome = value.outcome !== null;
-  const hasRules = value.selectedRuleIds.length > 0;
-  const isReady = value.status === "ready";
+}).superRefine((value2, context3) => {
+  const hasOutcome = value2.outcome !== null;
+  const hasRules = value2.selectedRuleIds.length > 0;
+  const isReady = value2.status === "ready";
   if (isReady ? !hasOutcome || !hasRules : hasOutcome || hasRules) {
     context3.addIssue({
       code: "custom",
@@ -2014,9 +2039,22 @@ var DraftEvidenceFixtureSchema = z19.strictObject({
   ...fixtureIdentity,
   evidence: DraftRequiredDecisionSchema.shape.evidence
 });
+var fixtureFact = z19.strictObject({
+  key: identifier11,
+  value: DraftEvidenceValueSchema,
+  held: z19.enum(["stale", "review"]).optional(),
+  conflictsWith: DraftEvidenceValueSchema.optional()
+}).superRefine((fact, context3) => {
+  if (fact.held !== void 0 && fact.conflictsWith !== void 0) {
+    context3.addIssue({ code: "custom", message: "A fact is stale, flagged or conflicting" });
+  }
+  if (fact.conflictsWith === fact.value) {
+    context3.addIssue({ code: "custom", message: "Conflicting values must differ" });
+  }
+});
 var DraftFactFixtureSchema = z19.strictObject({
   ...fixtureIdentity,
-  facts: z19.array(z19.strictObject({ key: identifier11, value: DraftEvidenceValueSchema })).max(64).refine((facts) => hasUniqueValues(facts.map((fact) => fact.key)), "Duplicate fact key")
+  facts: z19.array(fixtureFact).max(64).refine((facts) => hasUniqueValues(facts.map((fact) => fact.key)), "Duplicate fact key")
 });
 var DraftAnyCompilationFixtureSchema = z19.union([
   DraftEvidenceFixtureSchema,
@@ -2148,40 +2186,40 @@ function boundedDraftInput(limits2) {
     let nodes = 0;
     let text8 = 0;
     const budgetError = new Error("Draft input budget exceeded or non-data input");
-    function copy(value, depth) {
+    function copy(value2, depth) {
       nodes += 1;
       if (nodes > limits2.nodes || depth > maxDepth) {
         throw budgetError;
       }
-      if (typeof value === "string") {
-        text8 += value.length;
-        if (value.length > limits2.stringLength || text8 > limits2.totalText) {
+      if (typeof value2 === "string") {
+        text8 += value2.length;
+        if (value2.length > limits2.stringLength || text8 > limits2.totalText) {
           throw budgetError;
         }
-        return value;
+        return value2;
       }
-      if (value === null || typeof value !== "object") {
-        return value;
+      if (value2 === null || typeof value2 !== "object") {
+        return value2;
       }
-      const isArray = Array.isArray(value);
-      const prototype = Object.getPrototypeOf(value);
+      const isArray = Array.isArray(value2);
+      const prototype = Object.getPrototypeOf(value2);
       if (prototype !== null && prototype !== (isArray ? Array.prototype : Object.prototype)) {
         throw budgetError;
       }
-      if (isArray && value.length > limits2.arrayLength) {
+      if (isArray && value2.length > limits2.arrayLength) {
         throw budgetError;
       }
-      const output = isArray ? Array.from({ length: value.length }) : {};
+      const output = isArray ? Array.from({ length: value2.length }) : {};
       let properties = 0;
-      for (const key3 in value) {
-        if (!Object.hasOwn(value, key3)) {
+      for (const key3 in value2) {
+        if (!Object.hasOwn(value2, key3)) {
           continue;
         }
         properties += 1;
         if (properties > (isArray ? limits2.arrayLength : 32)) {
           throw budgetError;
         }
-        const descriptor = Object.getOwnPropertyDescriptor(value, key3);
+        const descriptor = Object.getOwnPropertyDescriptor(value2, key3);
         if (!descriptor || !("value" in descriptor)) {
           throw budgetError;
         }
@@ -2206,7 +2244,7 @@ function boundedDraftInput(limits2) {
     }
   });
 }
-var isUnicodeText = (value) => !/[\uD800-\uDFFF]/u.test(value);
+var isUnicodeText = (value2) => !/[\uD800-\uDFFF]/u.test(value2);
 var isSplitCharacter = (text8, offset) => offset > 0 && offset < text8.length && /[\uDC00-\uDFFF]/u.test(text8.charAt(offset));
 var sourceText = DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
   text: z21.string().min(1).max(1048576).refine(isUnicodeText, "Lone Unicode surrogate"),
@@ -2225,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];
@@ -2378,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", [
@@ -2389,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({
@@ -2571,22 +2624,22 @@ var DraftPrimitiveMappingSchema = z26.strictObject({
   caseId: id,
   rows: z26.array(row).min(requiredAuthorityPrimitives.length).max(authorityPrimitives.length)
 }).superRefine((mapping, context3) => {
-  if (!coversAuthorityPrimitives(mapping.rows.map((entry2) => entry2.primitive))) {
+  if (!coversAuthorityPrimitives(mapping.rows.map((entry3) => entry3.primitive))) {
     context3.addIssue({ code: "custom", path: ["rows"], message: "Every category is explicit" });
   }
   const seen = /* @__PURE__ */ new Set();
-  for (const [index, entry2] of mapping.rows.entries()) {
+  for (const [index, entry3] of mapping.rows.entries()) {
     const path3 = ["rows", index];
-    if (seen.has(entry2.primitive)) {
+    if (seen.has(entry3.primitive)) {
       context3.addIssue({ code: "custom", path: path3, message: "Duplicate primitive" });
     }
-    seen.add(entry2.primitive);
-    if (entry2.status !== "mapped") {
+    seen.add(entry3.primitive);
+    if (entry3.status !== "mapped") {
       continue;
     }
     const references = /* @__PURE__ */ new Set();
-    for (const [at, ref] of entry2.references.entries()) {
-      if (!kinds[entry2.primitive].includes(ref.kind)) {
+    for (const [at, ref] of entry3.references.entries()) {
+      if (!kinds[entry3.primitive].includes(ref.kind)) {
         context3.addIssue({
           code: "custom",
           path: [...path3, "references", at],
@@ -2606,7 +2659,7 @@ var DraftPrimitiveMappingSchema = z26.strictObject({
   }
 });
 function readObservation(input, ref) {
-  const index = input.observations.findIndex((entry2) => entry2.id === ref.observationId);
+  const index = input.observations.findIndex((entry3) => entry3.id === ref.observationId);
   const observation2 = input.observations[index];
   if (!observation2) {
     return void 0;
@@ -2642,7 +2695,7 @@ function readReference(input, ref) {
       return { path: "expected", value: input.expected };
     }
     case "rule": {
-      const index = authority.rules.findIndex((entry2) => entry2.id === ref.ruleId);
+      const index = authority.rules.findIndex((entry3) => entry3.id === ref.ruleId);
       const rule3 = authority.rules[index];
       return rule3 ? {
         path: `authority.rules.${index}`,
@@ -2671,18 +2724,18 @@ var DraftMappedCaseSchema = z26.strictObject({
       message: "Mapping belongs to a different case"
     });
   }
-  for (const [index, entry2] of mapping.rows.entries()) {
-    if (entry2.status !== "mapped") {
+  for (const [index, entry3] of mapping.rows.entries()) {
+    if (entry3.status !== "mapped") {
       continue;
     }
-    if (entry2.primitive === "gaps" && input.expected.state === "ready") {
+    if (entry3.primitive === "gaps" && input.expected.state === "ready") {
       context3.addIssue({
         code: "custom",
         path: ["mapping", "rows", index],
         message: "Ready expectation cannot demonstrate an unresolved gap or conflict"
       });
     }
-    for (const [at, ref] of entry2.references.entries()) {
+    for (const [at, ref] of entry3.references.entries()) {
       if (!readReference(input, ref)) {
         context3.addIssue({
           code: "custom",
@@ -2849,6 +2902,8 @@ var PackDraftBoundSchema = z29.union([
   z29.number(),
   CalendarDateSchema,
   z29.strictObject({ question: draftIdentifier, days: dayOffset }),
+  z29.strictObject({ question: draftIdentifier, businessDays: dayOffset }),
+  z29.strictObject({ question: draftIdentifier }),
   z29.strictObject({ decisionDate: dayOffset })
 ]);
 var PackDraftComparisonSchema = z29.strictObject({
@@ -2858,10 +2913,10 @@ var PackDraftComparisonSchema = z29.strictObject({
   gte: PackDraftBoundSchema.optional(),
   eq: PackDraftBoundSchema.optional(),
   quote: draftQuote
-}).superRefine((value, context3) => {
-  const lower = Number(value.gt !== void 0) + Number(value.gte !== void 0);
-  const upper = Number(value.lt !== void 0) + Number(value.lte !== void 0);
-  const hasEquality = value.eq !== void 0;
+}).superRefine((value2, context3) => {
+  const lower = Number(value2.gt !== void 0) + Number(value2.gte !== void 0);
+  const upper = Number(value2.lt !== void 0) + Number(value2.lte !== void 0);
+  const hasEquality = value2.eq !== void 0;
   if (lower + upper + Number(hasEquality) === 0) {
     context3.addIssue({ code: "custom", message: "Give a bound: lt, lte, gt, gte or eq" });
   } else if (lower > 1 || upper > 1) {
@@ -2876,6 +2931,9 @@ var PackDraftConditionSchema = z29.union([
   PackDraftComparisonSchema
 ]);
 var PackDraftConditionsSchema = z29.record(draftIdentifier, PackDraftConditionSchema);
+function isComparison(condition) {
+  return typeof condition === "object" && !Array.isArray(condition);
+}
 var questionTypes = ["number", "date"];
 var typedQuestionFields = {
   type: z29.enum(questionTypes).optional(),
@@ -2885,6 +2943,66 @@ var typedQuestionFields = {
   minimum: z29.number().optional(),
   maximum: z29.number().optional()
 };
+function unitKindOf(unit) {
+  if (unit === "percent") {
+    return "percent";
+  }
+  return isKnownCurrency(unit) ? "currency" : "count";
+}
+function fieldIssue(question3, field) {
+  return { path: [field], message: `A ${question3.type ?? "choice"} question has no ${field}` };
+}
+function fieldIssues(question3, allowed) {
+  const fields = ["answers", "unit", "unitWords", "integer", "minimum", "maximum"];
+  const present = fields.filter((field) => question3[field] !== void 0);
+  return present.filter((field) => !allowed.includes(field)).map((field) => fieldIssue(question3, field));
+}
+function numberIssues(question3) {
+  const issues = [];
+  const { unit } = question3;
+  if (unit === void 0) {
+    return [
+      {
+        path: ["unit"],
+        message: 'Give the unit: a currency code such as "USD", "percent", or a count noun'
+      }
+    ];
+  }
+  const kind = unitKindOf(unit);
+  if (kind === "count" && !/^[a-z][a-z0-9_-]*$/u.test(unit)) {
+    issues.push({
+      path: ["unit"],
+      message: 'Use a currency code such as "USD", "percent", or a lowercase count noun'
+    });
+  }
+  if (kind === "count" && question3.unitWords === void 0) {
+    issues.push({
+      path: ["unitWords"],
+      message: 'A count needs the words that name its unit next to its number, such as "claims"'
+    });
+  }
+  if (kind !== "count" && question3.unitWords !== void 0) {
+    issues.push({ path: ["unitWords"], message: "Only a count has unit words" });
+  }
+  const { minimum, maximum } = question3;
+  if (minimum !== void 0 && maximum !== void 0 && minimum > maximum) {
+    issues.push({ path: ["maximum"], message: "maximum is below minimum" });
+  }
+  return issues;
+}
+function questionIssues(question3) {
+  if (question3.type === "number") {
+    return [
+      ...fieldIssues(question3, ["unit", "unitWords", "integer", "minimum", "maximum"]),
+      ...numberIssues(question3)
+    ];
+  }
+  if (question3.type === "date") {
+    return fieldIssues(question3, []);
+  }
+  const missing = question3.answers === void 0 ? [{ path: ["answers"], message: "A choice question needs answers" }] : [];
+  return [...fieldIssues(question3, ["answers"]), ...missing];
+}
 var declaredDateOrders = [
   "month-first",
   "day-first"
@@ -2894,7 +3012,51 @@ var packConventionFields = {
   dateOrder: z29.enum(declaredDateOrders).optional(),
   timeZone: z29.string().min(1).max(64).regex(/^[A-Za-z][A-Za-z0-9_+/-]*$/u, "Use an IANA time zone name, such as Europe/Paris").refine(isTimeZone, "Unknown IANA time zone").optional()
 };
-var caseFactSchema = z29.union([draftValue, z29.number()]);
+var plainFact = z29.union([draftValue, z29.number()]);
+var heldFactSchema = z29.union([
+  z29.strictObject({ missing: z29.literal(true) }),
+  z29.strictObject({ stale: plainFact }),
+  z29.strictObject({ review: plainFact }),
+  z29.strictObject({ conflict: z29.tuple([plainFact, plainFact]) }).refine((fact) => fact.conflict[0] !== fact.conflict[1], "Conflicting readings must differ")
+]);
+var caseFactSchema = z29.union([plainFact, heldFactSchema]);
+var heldStates = ["missing", "stale", "conflict", "review"];
+var weekdayNames = [
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday"
+];
+var calendarYear = z29.number().int().min(1900).max(2200);
+var PackDraftBusinessDaysSchema = z29.strictObject({
+  workingDays: z29.array(z29.enum(weekdayNames)).min(1).max(7).refine(hasUniqueValues, "Duplicate working day"),
+  quote: draftQuote,
+  years: z29.strictObject({ from: calendarYear, through: calendarYear }),
+  holidays: z29.array(z29.strictObject({ date: CalendarDateSchema, quote: draftQuote })).max(400).refine((rows) => hasUniqueValues(rows.map((row2) => row2.date)), "Duplicate holiday").optional()
+}).superRefine((calendar, context3) => {
+  const { from, through } = calendar.years;
+  if (through < from || through - from > 99) {
+    context3.addIssue({
+      code: "custom",
+      path: ["years"],
+      message: "years.through must be on or after years.from, within 100 years"
+    });
+  }
+  const holidays = calendar.holidays ?? [];
+  for (const [index, holiday] of holidays.entries()) {
+    const year = Number(holiday.date.slice(0, 4));
+    if (year < from || year > through) {
+      context3.addIssue({
+        code: "custom",
+        path: ["holidays", index, "date"],
+        message: "This holiday is outside the calendar's years"
+      });
+    }
+  }
+});
 var caseDecisionDate = CalendarDateSchema.optional();
 
 // ../schemas/src/draft-pack-subjects.ts
@@ -3017,7 +3179,7 @@ var group = z31.strictObject({
   min: z31.number().int().min(0).max(64),
   max: z31.number().int().min(0).max(64),
   candidates: z31.array(candidate).max(64)
-}).refine((value) => value.min <= value.max, "Group minimum exceeds maximum");
+}).refine((value2) => value2.min <= value2.max, "Group minimum exceeds maximum");
 function areSubjectsValid(subjects, isIsolated) {
   const types = new Set(subjects.types.map((row2) => row2.id));
   const job = subjects.types.find((row2) => row2.id === subjects.job);
@@ -3038,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((id13) => id13 !== 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((id13) => ids3.has(id13))
+    named.every((id15) => ids3.has(id15))
   ].every(Boolean);
 }
 function isGuideValid(guide, isIsolated) {
@@ -3060,10 +3222,10 @@ function subjectPlanIssues(plan) {
   const issues = [];
   const candidates = plan.groups.flatMap((item) => item.candidates);
   const isIsolated = (entryId, primitive) => {
-    const entry2 = plan.entries.find((row2) => row2.id === entryId);
+    const entry3 = plan.entries.find((row2) => row2.id === entryId);
     return [
-      entry2?.primitive === primitive,
-      entry2?.dependencies.length === 0,
+      entry3?.primitive === primitive,
+      entry3?.dependencies.length === 0,
       !plan.requiredIds.includes(entryId),
       candidates.every((row2) => row2.entryId !== entryId),
       plan.entries.every((row2) => !row2.dependencies.includes(entryId))
@@ -3102,7 +3264,7 @@ var DraftContextSelectionPlanSchema = z31.strictObject({
   attempts: z31.strictObject({
     max: z31.number().int().min(1).max(10),
     withProgress: z31.number().int().min(1).max(10)
-  }).refine((value) => value.withProgress >= value.max, "withProgress below max").optional(),
+  }).refine((value2) => value2.withProgress >= value2.max, "withProgress below max").optional(),
   entries: base2.entries,
   requiredIds: base2.requiredIds,
   budget: base2.budget,
@@ -3134,19 +3296,19 @@ 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((id13) => candidateIds.includes(id13))) {
+  if (plan.requiredIds.some((id15) => candidateIds.includes(id15))) {
     context3.addIssue({ code: "custom", message: "Global required root cannot be a candidate" });
   }
   const guidanceId = plan.unresolvedGuidanceEntryId;
   if (guidanceId === void 0) {
     return;
   }
-  const entry2 = plan.entries.find((row2) => row2.id === guidanceId);
+  const entry3 = plan.entries.find((row2) => row2.id === guidanceId);
   if ([
-    !entry2,
-    entry2?.primitive !== "gaps",
-    entry2?.dependencies.length,
-    entry2?.conflictsWith.length,
+    !entry3,
+    entry3?.primitive !== "gaps",
+    entry3?.dependencies.length,
+    entry3?.conflictsWith.length,
     plan.requiredIds.includes(guidanceId),
     candidateIds.includes(guidanceId),
     plan.entries.some((row2) => row2.dependencies.includes(guidanceId))
@@ -3669,7 +3831,7 @@ var DraftApplicationTargetSchema = DraftApplicationScopeSchema.extend({
   action,
   resourceId: identifier18,
   jobId: identifier18.nullable()
-}).refine((target) => target.action === "execute_job" === (target.jobId !== null), "Only job execution carries a job ID");
+}).refine((target2) => target2.action === "execute_job" === (target2.jobId !== null), "Only job execution carries a job ID");
 var DraftApplicationActorSchema = z43.strictObject({
   principalId: identifier18,
   organizationId: identifier18,
@@ -3725,7 +3887,20 @@ var DraftApplicationReleaseSchema = z43.strictObject({
 });
 
 // ../schemas/src/draft-hosted-application.ts
-import { z as z53 } 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;
@@ -3765,11 +3940,11 @@ function utcOf(local, offset) {
   const utc = date.toISOString();
   return utcYear.test(utc) ? utc.slice(0, 19) : null;
 }
-function normalizedSourceInstant(value) {
-  if (value.length > sourceInstantMaxLength) {
+function normalizedSourceInstant(value2) {
+  if (value2.length > sourceInstantMaxLength) {
     return null;
   }
-  const match = localPattern.exec(value);
+  const match = localPattern.exec(value2);
   if (match === null) {
     return null;
   }
@@ -3795,62 +3970,62 @@ function normalizedSourceInstant(value) {
 }
 
 // ../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" });
   }
   const encoder2 = new TextEncoder();
   for (const section of contract.sections) {
-    if (section.check === "exact" && section.alternatives.some((value) => encoder2.encode(value).byteLength > section.maxBytes)) {
+    if (section.check === "exact" && section.alternatives.some((value2) => encoder2.encode(value2).byteLength > section.maxBytes)) {
       context3.addIssue({ code: "custom", message: "Exact alternative exceeds section budget" });
     }
   }
 });
-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,
@@ -3858,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",
@@ -3872,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,
@@ -3887,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,
@@ -3929,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)
   })
 });
 
@@ -3950,92 +4125,95 @@ 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 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";
-function isMatchOf(question2, check) {
-  if (check?.kind !== "case_answer" || question2.aggregation !== "match") {
-    return check?.kind === "semantic_question" && question2.aggregation !== "match";
+function isMatchOf(question3, check) {
+  if (check?.kind !== "case_answer" || question3.aggregation !== "match") {
+    return check?.kind === "semantic_question" && question3.aggregation !== "match";
   }
-  const offered = new Set(question2.options.map((option2) => option2.value));
+  const offered = new Set(question3.options.map((option2) => option2.value));
   const expected2 = [...(check.answers ?? []).map((row2) => row2.value), caseNotStated, abstain];
-  return offered.size === question2.options.length && offered.size === expected2.length && expected2.every((value) => offered.has(value));
+  return offered.size === question3.options.length && offered.size === expected2.length && expected2.every((value2) => offered.has(value2));
 }
 function isAsking(check) {
   const isAsker = check.kind === "semantic_question" || check.kind === "case_answer";
@@ -4045,22 +4223,22 @@ function inspectSemantic(manifest2, issue) {
   const askers = manifest2.checks.filter(isAsking);
   const asked = askers.map((check) => check.questionId ?? "");
   const questions = manifest2.semantic?.questions ?? [];
-  for (const question2 of questions) {
-    const asker = askers.find((check) => check.questionId === question2.id);
-    if (!isMatchOf(question2, asker)) {
+  for (const question3 of questions) {
+    const asker = askers.find((check) => check.questionId === question3.id);
+    if (!isMatchOf(question3, asker)) {
       issue("A semantic question's aggregation differs from the check that asks it");
     }
   }
   const distinctAsked = new Set(asked);
-  if (distinctAsked.size !== asked.length || asked.length !== questions.length || questions.some((question2) => !distinctAsked.has(question2.id))) {
+  if (distinctAsked.size !== asked.length || asked.length !== questions.length || questions.some((question3) => !distinctAsked.has(question3.id))) {
     issue("Every released semantic question is asked by exactly one check");
   }
-  for (const question2 of questions) {
-    if (question2.aggregation === "match") {
+  for (const question3 of questions) {
+    if (question3.aggregation === "match") {
       continue;
     }
-    const effects = new Set(question2.options.map((option2) => option2.effect));
-    const needed = question2.aggregation === "prohibit" ? "violated" : "satisfied";
+    const effects = new Set(question3.options.map((option2) => option2.effect));
+    const needed = question3.aggregation === "prohibit" ? "violated" : "satisfied";
     if (!effects.has(needed)) {
       issue("A semantic question needs an option that can decide its aggregation");
     }
@@ -4080,15 +4258,15 @@ var artifactLintLimits = {
   maxLiteralUnits: 512,
   maxOccurrencesPerCheck: 16
 };
-function isWellFormedText(value) {
-  return !/\p{Cs}/u.test(value);
+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",
@@ -4101,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((value) => !/[\n\r]/u.test(value) && isWellFormedText(value)).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 = [];
@@ -4178,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) => {
@@ -4234,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 = {
@@ -4249,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);
@@ -4291,16 +4469,16 @@ function unique3(values, context3, path3) {
     context3.addIssue({ code: "custom", path: path3, message: "Duplicate obligation identity or target" });
   }
 }
-function isApprovalTargetValid(item, target, useRef) {
+function isApprovalTargetValid(item, target2, useRef) {
   switch (item.phase) {
     case "before_decision": {
-      return target.kind === "decision";
+      return target2.kind === "decision";
     }
     case "before_generation": {
-      return target.kind === "artifact";
+      return target2.kind === "artifact";
     }
     case "before_use": {
-      return target.kind === "artifact" || target.kind === "use" && useRef !== null;
+      return target2.kind === "artifact" || target2.kind === "use" && useRef !== null;
     }
     default: {
       return false;
@@ -4308,11 +4486,11 @@ function isApprovalTargetValid(item, target, useRef) {
   }
 }
 function inspectApproval(item, binding, context3) {
-  unique3(item.appliesTo.map((target) => JSON.stringify(target)), context3, ["approvals", item.id]);
-  const artifacts = new Set(binding.selected.artifacts.map((entry2) => entry2.id));
-  for (const target of item.appliesTo) {
-    const isKnown = target.kind !== "artifact" || artifacts.has(target.id);
-    const isValid = isApprovalTargetValid(item, target, binding.scope.useRef);
+  unique3(item.appliesTo.map((target2) => JSON.stringify(target2)), context3, ["approvals", item.id]);
+  const artifacts = new Set(binding.selected.artifacts.map((entry3) => entry3.id));
+  for (const target2 of item.appliesTo) {
+    const isKnown = target2.kind !== "artifact" || artifacts.has(target2.id);
+    const isValid = isApprovalTargetValid(item, target2, binding.scope.useRef);
     if (!isKnown || !isValid) {
       context3.addIssue({
         code: "custom",
@@ -4322,18 +4500,18 @@ function inspectApproval(item, binding, context3) {
     }
   }
 }
-function inspectManifest(value, context3) {
+function inspectManifest(value2, context3) {
   if (context3.issues.length > 0) {
     return;
   }
-  unique3(value.contracts.map((entry2) => entry2.id), context3, ["contracts"]);
-  unique3(value.outcomes.map((entry2) => entry2.outcomeId), context3, ["outcomes"]);
-  const contracts = new Map(value.contracts.map((entry2) => [entry2.id, entry2.contentDigest]));
-  for (const selected of value.outcomes) {
-    unique3(selected.artifacts.map((entry2) => entry2.id), context3, ["outcomes", selected.outcomeId, "artifacts"]);
-    unique3(selected.approvals.map((entry2) => entry2.id), context3, ["outcomes", selected.outcomeId, "approvals"]);
-    for (const entry2 of selected.artifacts) {
-      if (contracts.get(entry2.contract.id) !== entry2.contract.digest) {
+  unique3(value2.contracts.map((entry3) => entry3.id), context3, ["contracts"]);
+  unique3(value2.outcomes.map((entry3) => entry3.outcomeId), context3, ["outcomes"]);
+  const contracts = new Map(value2.contracts.map((entry3) => [entry3.id, entry3.contentDigest]));
+  for (const selected of value2.outcomes) {
+    unique3(selected.artifacts.map((entry3) => entry3.id), context3, ["outcomes", selected.outcomeId, "artifacts"]);
+    unique3(selected.approvals.map((entry3) => entry3.id), context3, ["outcomes", selected.outcomeId, "approvals"]);
+    for (const entry3 of selected.artifacts) {
+      if (contracts.get(entry3.contract.id) !== entry3.contract.digest) {
         context3.addIssue({
           code: "custom",
           message: "Dangling or mismatched specification reference"
@@ -4341,11 +4519,11 @@ function inspectManifest(value, context3) {
       }
     }
     for (const item of selected.approvals) {
-      inspectApproval(item, { selected, scope: value.scope }, context3);
+      inspectApproval(item, { selected, scope: value2.scope }, context3);
     }
   }
   const encoder2 = new TextEncoder();
-  if (encoder2.encode(JSON.stringify(value)).length > jobObligationsLimits.maxManifestBytes) {
+  if (encoder2.encode(JSON.stringify(value2)).length > jobObligationsLimits.maxManifestBytes) {
     context3.addIssue({ code: "custom", message: "Obligations manifest byte limit exceeded" });
   }
 }
@@ -4354,19 +4532,19 @@ 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)
-}).superRefine((value, context3) => {
+  manifests: z50.array(ArtifactCheckManifestSchema).min(1).max(hostedOutputCheckLimits.maxOutputs)
+}).superRefine((value2, context3) => {
   if (context3.issues.length > 0) {
     return;
   }
   const issue = (message) => {
     context3.addIssue({ code: "custom", message });
   };
-  const { obligations, manifests } = value;
-  const contracts = new Map(obligations.contracts.map((entry2) => [entry2.id, entry2]));
+  const { obligations, manifests } = value2;
+  const contracts = new Map(obligations.contracts.map((entry3) => [entry3.id, entry3]));
   const checked = new Set(manifests.map((manifest2) => manifest2.contract.id));
   if (checked.size !== manifests.length) {
     issue("One manifest per output contract");
@@ -4377,20 +4555,20 @@ var HostedOutputChecksSchema = z49.strictObject({
       issue("A manifest differs from its job or contract");
     }
   }
-  const required = obligations.outcomes.flatMap((entry2) => entry2.artifacts.map((artifact2) => artifact2.contract.id));
+  const required = obligations.outcomes.flatMap((entry3) => entry3.artifacts.map((artifact2) => artifact2.contract.id));
   if (required.some((contractId) => !checked.has(contractId)) || checked.size > contracts.size) {
     issue("Every required output needs exactly one manifest");
   }
 });
 
 // ../schemas/src/draft-pack-revision.ts
-import { z as z52 } 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,
@@ -4399,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 = [
@@ -4433,22 +4611,22 @@ 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(),
   gte: points.optional(),
   eq: points.optional(),
   quote: draftQuote
-}).superRefine((value, context3) => {
-  const lower = Number(value.gt !== void 0) + Number(value.gte !== void 0);
-  const upper = Number(value.lt !== void 0) + Number(value.lte !== void 0);
-  const hasEquality = value.eq !== void 0;
+}).superRefine((value2, context3) => {
+  const lower = Number(value2.gt !== void 0) + Number(value2.gte !== void 0);
+  const upper = Number(value2.lt !== void 0) + Number(value2.lte !== void 0);
+  const hasEquality = value2.eq !== void 0;
   if (lower + upper + Number(hasEquality) === 0) {
     context3.addIssue({ code: "custom", message: "Give a bound: lt, lte, gt, gte or eq" });
   } else if (lower > 1 || upper > 1) {
@@ -4457,170 +4635,723 @@ 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 z55 } from "zod";
+
+// ../schemas/src/draft-pack-draft-coverage.ts
+import { z as z53 } from "zod";
+var coverageDispositions = ["represented", "needs_review", "unsupported"];
+var coverageTargetKinds = [
+  "question",
+  "rule",
+  "outcome",
+  "escalation",
+  "subject"
+];
+var coverageFields = [
+  "purpose",
+  "useWhen",
+  "notFor",
+  "owner",
+  "evidenceKinds",
+  "maxEvidenceAgeDays",
+  "manualFacts",
+  "businessDays",
+  "whenUnresolved",
+  "attempts",
+  "scoring",
+  "outputChecks",
+  "subject"
+];
+var target = z53.union([
+  ...coverageTargetKinds.map((kind) => z53.strictObject({ [kind]: draftIdentifier })),
+  z53.strictObject({ field: z53.enum(coverageFields) })
+]);
+var entry2 = z53.strictObject({
+  quote: draftQuote,
+  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) {
+    context3.addIssue({
+      code: "custom",
+      path: ["carriedBy"],
+      message: "Name what carries a represented passage: a question, rule, outcome, escalation or subject"
+    });
+  }
+  if (!isRepresented && row2.why === void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["why"],
+      message: "Say why it is open or left out, for the owner"
+    });
+  }
+  if (!isRepresented && row2.carriedBy !== void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["carriedBy"],
+      message: "Only a represented passage is carried by the pack"
+    });
+  }
+});
+var PackDraftCoverageSchema = z53.array(entry2).min(1).max(128);
+
+// ../schemas/src/draft-pack-draft-readings.ts
+import { z as z54 } from "zod";
+var readingCheckLimits = {
+  maxPerAnswer: 8,
+  maxPerCheck: 96,
+  maxKept: 200,
+  maxCharacters: 2e3,
+  maxLabelCharacters: 120
+};
+var PackDraftReadingTestSchema = z54.strictObject({
+  id: draftIdentifier,
+  question: draftIdentifier,
+  text: z54.string().trim().min(1).max(readingCheckLimits.maxCharacters),
+  expect: draftValue
+});
+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) {
+    return {
+      path: [...path3, "question"],
+      message: `"${row2.question}" is not a choice question Felspar reads from text`
+    };
+  }
+  const answers2 = question3.answers ?? [];
+  return answers2.every((answer) => answer.value !== row2.expect) ? {
+    path: [...path3, "expect"],
+    message: `"${row2.expect}" is not one of the answers of "${row2.question}"`
+  } : null;
+}
+function readingTestIssues(tests, questions) {
+  const issues = [];
+  const perAnswer = /* @__PURE__ */ new Map();
+  const rows = tests ?? [];
+  for (const [index, row2] of rows.entries()) {
+    const path3 = ["readingTests", index];
+    const issue = readingTestIssue(row2, questions, path3);
+    const at = JSON.stringify([row2.question, row2.expect]);
+    const count2 = (perAnswer.get(at) ?? 0) + 1;
+    perAnswer.set(at, count2);
+    if (issue !== null) {
+      issues.push(issue);
+    } else if (count2 > readingCheckLimits.maxPerAnswer) {
+      issues.push({
+        path: path3,
+        message: `At most ${readingCheckLimits.maxPerAnswer} reading tests per answer`
+      });
+    }
+  }
+  return issues;
+}
+var variant = z54.strictObject({
+  id: draftIdentifier.optional(),
+  question: draftIdentifier,
+  text: z54.string().trim().min(1).max(readingCheckLimits.maxCharacters),
+  expect: draftValue.optional(),
+  label: z54.string().trim().min(1).max(readingCheckLimits.maxLabelCharacters).optional()
+});
+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 = [
+  "below_bar",
+  "cannot_tell",
+  "tie",
+  "looks_like_instructions",
+  "evaluation_off",
+  "limit_reached",
+  "not_answered"
+];
+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: z54.enum(readingReasons).nullable()
+});
+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 = z54.strictObject({
+  schema: z54.literal("felspar.reading-check/v0"),
+  authority: z54.literal("unapproved"),
+  jobId: z54.string(),
+  status: z54.enum(["clean", "misses", "incomplete"]),
+  counts,
+  questions: z54.array(z54.strictObject({ question: z54.string(), bar: probability, counts })),
+  readings: z54.array(ReadingOutcomeSchema)
+});
+
+// ../schemas/src/draft-pack-draft.ts
+var identifier22 = draftIdentifier;
+var quote2 = draftQuote;
+var value = draftValue;
+var conditions = PackDraftConditionsSchema;
+var ruleOrders = ["first-match", "unordered"];
+var packDraftVersions = [
+  "felspar.pack-draft/v0",
+  "felspar.pack-draft/v1",
+  "felspar.pack-draft/v2"
+];
+var answers = z55.array(z55.strictObject({
+  value,
+  meaning: quote2,
+  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 = z55.strictObject({
+  from: identifier22,
+  when: z55.record(value, z55.union([value, z55.array(value).min(2).max(64)])),
+  otherwise: value.optional()
+});
+var notDerived = [
+  "type",
+  "askOnlyWhen",
+  "whereToLook",
+  "about",
+  "evidence",
+  "minimumConfidence",
+  "highConsequence"
+];
+function computedIssue(field) {
+  return {
+    path: [field],
+    message: `A derived question is computed, never asked: it has no ${field}`
+  };
+}
+function deriveIssues(row2) {
+  const rule3 = row2.derive;
+  if (rule3 === void 0) {
+    return [];
+  }
+  const present = notDerived.filter((field) => row2[field] !== void 0);
+  const issues = present.map(computedIssue);
+  const values = new Set((row2.answers ?? []).map((answer) => answer.value));
+  const named = [
+    ...Object.keys(rule3.when),
+    ...rule3.otherwise === void 0 ? [] : [rule3.otherwise]
+  ];
+  const unknown = named.filter((item) => !values.has(item));
+  for (const answer of unknown) {
+    issues.push({ path: ["derive"], message: `"${answer}" is not one of this question's answers` });
+  }
+  if (rule3.otherwise !== void 0 && Object.hasOwn(rule3.when, rule3.otherwise)) {
+    issues.push({
+      path: ["derive", "otherwise"],
+      message: "otherwise names an answer already in when"
+    });
+  }
+  if ((row2.answers ?? []).some((answer) => answer.noneOfThese === true)) {
+    issues.push({ path: ["answers"], message: "A derived question has no noneOfThese answer" });
+  }
+  return issues;
+}
+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 = z55.number().min(0.5).max(0.99);
+var question2 = z55.strictObject({
+  key: identifier22,
+  meaning: quote2,
+  answers: answers.optional(),
+  ...typedQuestionFields,
+  askOnlyWhen: conditions.optional(),
+  whereToLook: z55.array(quote2).max(8).optional(),
+  about: identifier22.optional(),
+  derive: derive.optional(),
+  evidence: questionEvidence.optional(),
+  minimumConfidence: minimumConfidence.optional(),
+  highConsequence: z55.literal(true).optional()
+}).superRefine((row2, context3) => {
+  if (row2.type !== void 0 && row2.highConsequence !== void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["highConsequence"],
+      message: "A number or date is read exactly, with no confidence bar to calibrate"
+    });
+  }
+  if (row2.type !== void 0 && row2.minimumConfidence !== void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["minimumConfidence"],
+      message: "A number or date is read exactly, with no confidence bar"
+    });
+  }
+  for (const issue of questionIssues(row2)) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+  for (const issue of deriveIssues(row2)) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+});
+var shape3 = z55.strictObject({
+  schema: z55.enum(packDraftVersions),
+  job: identifier22,
+  purpose: quote2.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: z55.strictObject({ allowed: z55.literal(false), quote: quote2 }).optional(),
+  ...packConventionFields,
+  businessDays: PackDraftBusinessDaysSchema.optional(),
+  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: 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: 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: z55.enum(ruleOrders).optional(),
+  rules: z55.array(z55.strictObject({
+    id: identifier22,
+    meaning: quote2,
+    when: conditions.optional(),
+    score: PackDraftScoreSchema.optional(),
+    gate: z55.literal(true).optional(),
+    outcome: identifier22,
+    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: z55.array(z55.strictObject({
+    id: identifier22,
+    why: z55.string().min(1).max(2e3),
+    facts: z55.record(identifier22, caseFactSchema),
+    decisionDate: caseDecisionDate,
+    subject: z55.strictObject({ id: SubjectIdSchema }).optional(),
+    expect: z55.union([
+      z55.strictObject({
+        outcome: identifier22,
+        rule: identifier22,
+        escalation: identifier22.optional(),
+        ...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(),
+  readingTests: PackDraftReadingTestsSchema.optional(),
+  coverage: PackDraftCoverageSchema.optional()
+});
+function comparisonPaths(when2, at) {
+  const entries2 = Object.entries(when2 ?? {});
+  return entries2.flatMap(([key3, condition]) => isComparison(condition) ? [[...at, key3]] : []);
+}
+function presentPaths(row2, fields, at) {
+  return fields.filter((field) => row2[field] !== void 0).map((field) => [...at, field]);
+}
+function casePaths(row2, at) {
+  const facts = Object.entries(row2.facts);
+  const isTyped = (fact) => typeof fact !== "string";
+  return [
+    ...presentPaths(row2, ["decisionDate"], at),
+    ...presentPaths(row2.expect, ["score", "points"], [...at, "expect"]),
+    ..."held" in row2.expect ? [[...at, "expect", "held"]] : [],
+    ...facts.flatMap(([key3, fact]) => isTyped(fact) ? [[...at, "facts", key3]] : [])
+  ];
+}
+function v1Paths(draft) {
+  const paths = presentPaths(draft, ["numberStyle", "dateOrder", "timeZone", "scoring", "businessDays", "ruleOrder"], []);
+  for (const [index, row2] of draft.questions.entries()) {
+    const at = ["questions", String(index)];
+    paths.push(...presentPaths(row2, ["type", "derive", "evidence", "minimumConfidence", "highConsequence"], at), ...comparisonPaths(row2.askOnlyWhen, [...at, "askOnlyWhen"]));
+  }
+  for (const [index, rule3] of draft.rules.entries()) {
+    const at = ["rules", String(index)];
+    paths.push(...presentPaths(rule3, ["score", "gate", "except"], at), ...comparisonPaths(rule3.when, [...at, "when"]));
+  }
+  for (const [index, row2] of draft.cases.entries()) {
+    paths.push(...casePaths(row2, ["cases", String(index)]));
+  }
+  return paths;
+}
+var PackDraftSchema = shape3.superRefine((draft, context3) => {
+  for (const issue of readingTestIssues(draft.readingTests, draft.questions)) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+  if (draft.schema === "felspar.pack-draft/v2" && draft.purpose === void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["purpose"],
+      message: "Quote the job's purpose: why it exists and what it resolves"
+    });
+  }
+  if (draft.schema !== "felspar.pack-draft/v0") {
+    return;
+  }
+  for (const path3 of v1Paths(draft)) {
+    context3.addIssue({
+      code: "custom",
+      path: path3,
+      message: 'Number and date questions, derived questions, thresholds, conventions, scoring, business days, exceptions, rule order, per-question evidence and held cases need "schema": "felspar.pack-draft/v1"'
+    });
+  }
+});
+
 // ../schemas/src/draft-pack-revision.ts
-var KeptPackDraftSchema = z52.looseObject({
-  schema: z52.string().regex(/^felspar\.pack-draft\/v\d{1,3}$/u),
-  job: z52.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 = z52.string().min(1).max(200);
-var text7 = z52.string().min(1).max(262144);
-var texts = z52.array(z52.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 = z52.strictObject({
-  schema: z52.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: z52.array(id6).max(8),
-  maxEvidenceAgeDays: z52.number().int().min(1).nullable(),
-  numberStyle: z52.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: z52.string().min(1).max(64).nullable(),
+  timeZone: z56.string().min(1).max(64).nullable(),
+  businessDays: PackDraftBusinessDaysSchema.nullable(),
   subject: id6.nullable(),
-  subjects: z52.array(z52.strictObject({
+  subjects: z56.array(z56.strictObject({
     id: id6,
     definition: text7,
-    identifier: z52.string().nullable(),
-    example: z52.string().nullable(),
-    match: z52.string(),
-    relationships: z52.array(z52.strictObject({
+    identifier: z56.string().nullable(),
+    example: z56.string().nullable(),
+    match: z56.string(),
+    relationships: z56.array(z56.strictObject({
       name: id6,
       subject: id6,
-      cardinality: z52.enum(["one", "many"]),
-      required: z52.boolean(),
+      cardinality: z56.enum(["one", "many"]),
+      required: z56.boolean(),
       definition: text7
     })).max(16),
     identity: PackDraftIdentitySchema.nullable()
   })).max(16),
-  escalations: z52.array(z52.strictObject({ id: id6, quote: text7 })).max(16),
-  questions: z52.array(z52.strictObject({
+  escalations: z56.array(z56.strictObject({ id: id6, quote: text7 })).max(16),
+  questions: z56.array(z56.strictObject({
     key: id6,
-    type: z52.enum(["enum", "boolean", "number", "date"]),
+    type: z56.enum(["enum", "boolean", "number", "date"]),
     meaning: text7,
     about: id6.nullable(),
-    askOnlyWhen: z52.string().nullable(),
+    askOnlyWhen: z56.string().nullable(),
     when: when.nullable(),
-    unit: z52.string().nullable(),
-    unitWords: z52.array(z52.string()).max(16).nullable(),
-    integer: z52.boolean().nullable(),
-    minimum: z52.number().nullable(),
-    maximum: z52.number().nullable(),
-    answers: z52.array(z52.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: z52.string().nullable(),
+      meaning: z56.string().nullable(),
       inclusions: texts,
       exclusions: texts,
       examples: texts,
       edgeCases: texts
     })).max(64),
-    whereToLook: texts
+    whereToLook: texts,
+    evidence: z56.strictObject({
+      evidenceKinds: z56.array(id6).max(8).nullable(),
+      maxEvidenceAgeDays: z56.number().int().min(1).nullable(),
+      quote: text7
+    }).nullable(),
+    minimumConfidence: z56.number().nullable()
   })).max(64),
-  outcomes: z52.array(z52.strictObject({ id: id6, nextStep: text7.nullable(), escalate: id6.nullable() })).max(64),
-  whenUnresolved: z52.strictObject({ quote: text7, escalate: id6.nullable() }).nullable(),
-  attempts: z52.strictObject({ max: z52.number().int(), escalate: id6.nullable() }).nullable(),
-  rules: z52.array(z52.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: z52.string().nullable(),
-    scoreRange: z52.record(z52.string(), z52.unknown()).nullable(),
+    conditions: z56.string().nullable(),
+    scoreRange: z56.record(z56.string(), z56.unknown()).nullable(),
     score: PackDraftScoreSchema.nullable(),
-    gate: z52.boolean()
+    gate: z56.boolean(),
+    except: z56.array(id6).max(16).nullable()
   })).max(256),
+  ruleOrder: z56.enum(ruleOrders).nullable(),
   scoring: PackDraftScoringSchema.nullable(),
-  cases: z52.array(z52.strictObject({
+  cases: z56.array(z56.strictObject({
     id: id6,
-    why: z52.string().nullable(),
-    facts: z52.record(id6, caseFactSchema),
+    why: z56.string().nullable(),
+    facts: z56.record(id6, caseFactSchema),
     decisionDate: CalendarDateSchema.nullable(),
-    subject: z52.strictObject({ id: id6 }).nullable(),
-    expect: z52.strictObject({ outcome: id6, rule: id6, score: z52.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(),
-  notKept: z52.array(z52.strictObject({ path: z52.string().min(1), reason: z52.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 z57 } from "zod";
+var barCalibrationPolicy = {
+  lowestBar: 0.8,
+  highestBar: 0.99,
+  targets: { ordinary: 0.9, strict: 0.97 },
+  minimumCases: 10,
+  minimumDecided: 5,
+  maxLabels: 400
+};
+var barCalibrationId = "felspar-backtest-bar";
+var barCalibrationVersion = "v1";
+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 = 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 = z57.strictObject({
+  executionObjectId: id7,
+  label: draftValue.nullable(),
+  leaning: draftValue.nullable(),
+  confidence: share.nullable(),
+  atCurrentBar: z57.enum(calibrationReadings),
+  atSuggestedBar: z57.enum(calibrationReadings).nullable()
+});
+var barRow = z57.strictObject({
+  bar,
+  decided: z57.number().int().min(0),
+  right: z57.number().int().min(0),
+  precision: share.nullable(),
+  coverage: share
+});
+var calibrationStatuses = [
+  "suggested",
+  "too_few_cases",
+  "coverage_gap",
+  "needs_more_evidence_or_rewrite"
+];
+var QuestionCalibrationSchema = z57.strictObject({
+  question: id7,
+  status: z57.enum(calibrationStatuses),
+  consequence: z57.enum(["ordinary", "strict"]),
+  target: share,
+  currentBar: share,
+  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: z57.strictObject({
+      id: z57.literal(barCalibrationId),
+      version: z57.literal(barCalibrationVersion),
+      contentDigest: digest23
+    })
+  }).optional(),
+  bars: z57.array(barRow).max(20),
+  cases: z57.array(caseRow).max(50)
+});
+var BacktestCalibrationSchema = z57.strictObject({
+  schema: z57.literal("felspar.bar-calibration/v1"),
+  calibrationDigest: digest23,
+  minimumCases: z57.number().int().min(1),
+  questions: z57.array(QuestionCalibrationSchema).max(64),
+  ignoredLabels: z57.number().int().min(0)
+});
+var AcceptedBarsSchema = z57.strictObject({
+  savedResultId: z57.string().regex(/^backtest-[a-f0-9]{32}$/u),
+  calibrationDigest: digest23,
+  questions: z57.array(id7).min(1).max(64)
+});
+var ReleaseCalibrationSchema = AcceptedBarsSchema.extend({
+  acceptedBy: z57.string().min(1).max(200),
+  approvedMaterialDigest: digest23,
+  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 id7 = z53.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
-var digest23 = DraftApplicationReleaseSchema.shape.releaseDigest;
-var HostedSourceInputSchema = z53.strictObject({
-  sourceId: id7,
-  revision: id7,
-  title: z53.string().min(1).max(200),
-  text: z53.string().min(1).max(1048576)
-});
-var HostedProposalInputV0Schema = z53.strictObject({
-  sourceObjectId: id7,
-  expectedSourceDigest: digest23,
+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 HostedProposalInputV2Schema = z53.strictObject({
-  schema: z53.literal("felspar.hosted-proposal.draft/v2"),
-  sourceObjectId: id7,
-  expectedSourceDigest: digest23,
+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 = 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 = z53.union([
+var HostedProposalInputSchema = z59.union([
   HostedProposalInputV2Schema,
   HostedProposalInputV0Schema
 ]);
-var HostedApprovalInputSchema = z53.strictObject({
-  expectedProposalDigest: digest23,
-  reviewedMeaning: z53.literal(true),
-  reviewedFixtures: z53.literal(true),
-  reviewNote: z53.string().min(1).max(2e3)
-});
-var HostedReleaseInputSchema = z53.strictObject({ expectedApprovalDigest: digest23 });
-var HostedReleaseBundleSchema = z53.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: id7,
-  approvalDigest: digest23,
-  proposalDigest: digest23,
-  sourceDigest: digest23,
-  verifiedCompilation: DraftVerifiedCompilationSchema.optional()
-});
-var HostedJobInputSchema = z53.strictObject({
-  executionId: id7,
-  expectedReleaseDigest: digest23,
+  approvalObjectId: id9,
+  approvalDigest: digest25,
+  proposalDigest: digest25,
+  sourceDigest: digest25,
+  verifiedCompilation: DraftVerifiedCompilationSchema.optional(),
+  calibration: ReleaseCalibrationSchema.optional()
+});
+var HostedJobInputSchema = z59.strictObject({
+  executionId: id9,
+  expectedReleaseDigest: digest25,
   material: DraftAnyApplicationJobMaterialSchema
 });
-var HostedSuppliedJobInputSchema = z53.strictObject({
-  mode: z53.literal("supplied"),
-  executionId: id7,
-  expectedReleaseDigest: digest23,
-  expectedAuthorityDigest: digest23,
-  jobId: id7,
-  entityId: id7,
+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)
 });
@@ -4630,97 +5361,186 @@ var hostedFactsLimits = {
   maxFactsBytes: 524288,
   maxQuestions: 64
 };
-var factSourceId = z53.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 = z53.string().refine((value) => normalizedSourceInstant(value) !== null, "observed_at_invalid").transform((value) => normalizedSourceInstant(value) ?? value).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 factSource = z53.strictObject({
-  class: id7,
+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: id9,
   id: factSourceId,
-  revision: id7.optional(),
-  locator: z53.string().min(1).max(4096).optional(),
+  revision: id9.optional(),
+  locator: z59.string().min(1).max(4096).optional(),
   observedAt,
-  sensitivity: id7.optional()
-});
-var excerptText = z53.string().min(1).refine((text8) => text8.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
-var about = z53.string().min(1).max(200).optional();
-var HostedExcerptSchema = z53.strictObject({ text: excerptText, source: factSource, about });
-var HostedValueFactSchema = z53.strictObject({
-  value: z53.union([z53.string().min(1).max(200), z53.number(), z53.boolean()]),
-  source: factSource.extend({ excerpt: excerptText.optional() }),
-  about
-});
-var HostedFactSchema = z53.union([
-  HostedValueFactSchema,
-  HostedExcerptSchema,
-  z53.array(HostedExcerptSchema).min(1).refine((excerpts2) => excerpts2.length <= hostedFactsLimits.maxExcerptsPerQuestion, "too_many_excerpts")
-]);
+  sensitivity: id9.optional()
+};
+var manualSourcePrefix = "felspar:";
+var suppliedBy = z59.string().trim().min(1).max(200);
+var isReserved = (sourceId2) => sourceId2?.toLowerCase().startsWith(manualSourcePrefix) === true;
+function sourceIssues(source3) {
+  if (source3.manual === true) {
+    return [
+      ...source3.id === void 0 ? [] : [{ path: ["id"], code: "manual_source_id" }],
+      ...source3.revision === void 0 ? [] : [{ path: ["revision"], code: "manual_source_id" }]
+    ];
+  }
+  return [
+    ...source3.id === void 0 ? [{ path: ["id"], code: "source_id_required" }] : [],
+    ...isReserved(source3.id) ? [{ path: ["id"], code: "source_id_reserved" }] : [],
+    ...source3.observedAt === void 0 ? [{ path: ["observedAt"], code: "observed_at_required" }] : [],
+    ...source3.suppliedBy === void 0 ? [] : [{ path: ["suppliedBy"], code: "supplied_by_needs_manual" }]
+  ];
+}
+function isAdmittedManual(source3) {
+  return source3.by !== void 0 && source3.id === void 0 && source3.revision === void 0;
+}
+function isAdmittedOrdinary(source3) {
+  const isUnmarked = source3.by === void 0 && source3.stamped === void 0 && source3.suppliedBy === void 0;
+  return source3.id !== void 0 && isUnmarked;
+}
+function isAdmitted(source3) {
+  return source3.manual === true ? isAdmittedManual(source3) : isAdmittedOrdinary(source3);
+}
+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: z59.literal(true).optional(),
+  suppliedBy: suppliedBy.optional()
+};
+function refusedSourceIssues(source3, context3) {
+  for (const issue of sourceIssues(source3)) {
+    context3.addIssue({ code: "custom", path: issue.path, message: issue.code });
+  }
+}
+var admittedSourceFields = {
+  ...sourceFields,
+  id: factSourceId.optional(),
+  manual: z59.literal(true).optional(),
+  suppliedBy: suppliedBy.optional(),
+  by: id9.optional(),
+  stamped: z59.literal(true).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 = 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 ? z59.union([excerpt2, valueFact]) : excerpt2;
+  const fact = z59.union([
+    valueFact,
+    excerpt2,
+    z59.array(listed).min(1).refine((excerpts2) => excerpts2.length <= cap, "too_many_excerpts")
+  ]);
+  return { excerpt: excerpt2, valueFact, fact };
+}
+var admittedFacts = factSchemas(admittedSource, admittedValueSource, true);
+var requestFacts = factSchemas(requestSource, requestValueSource, false);
+var HostedExcerptSchema = admittedFacts.excerpt;
+var HostedValueFactSchema = admittedFacts.valueFact;
+var HostedFactSchema = admittedFacts.fact;
 function factsBytes(facts) {
   const encoder2 = new TextEncoder();
   return encoder2.encode(JSON.stringify(facts)).length;
 }
-var HostedFactsJobInputSchema = z53.strictObject({
-  mode: z53.literal("facts"),
-  executionId: id7,
-  expectedReleaseDigest: digest23,
-  jobId: id7,
-  entityId: id7,
+function questionsOf(fact) {
+  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 = z59.strictObject({
+  mode: z59.literal("facts"),
+  executionId: id9,
+  expectedReleaseDigest: digest25,
+  jobId: id9,
+  entityId: id9,
   related: HostedRelatedSubjectsSchema.optional(),
-  identity: z53.record(z53.string().min(1).max(128), z53.string().min(1).max(200)).optional(),
-  facts: z53.record(id7, HostedFactSchema).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions").refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large")
+  identity: z59.record(z59.string().min(1).max(128), z59.string().min(1).max(200)).optional(),
+  facts: questionsOf(HostedFactSchema)
 });
 var HostedFactsRequestSchema = HostedFactsJobInputSchema.extend({
-  entityId: id7.optional()
+  entityId: id9.optional(),
+  facts: factsOf(requestFacts.fact)
 });
-var HostedJobRequestSchema = z53.union([
+var HostedJobRequestSchema = z59.union([
   HostedJobInputSchema,
   HostedSuppliedJobInputSchema,
   HostedFactsJobInputSchema
 ]);
-var HostedClassificationResultSchema = z53.strictObject({
-  key: id7,
-  observationId: id7,
+var HostedClassificationResultSchema = z59.strictObject({
+  key: id9,
+  observationId: id9,
   record: DraftNormalizedEvidenceSchema.shape.normalizations.element,
-  reason: z53.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
-  cached: z53.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 HostedSuppliedExecutionRecordSchema = z53.strictObject({
-  schema: z53.enum([
+var HostedCaseAttemptSchema = z59.strictObject({
+  executionId: id9,
+  added: z59.array(z59.string().min(1).max(draftSourceIdLimit + 4200)).max(192),
+  considered: z59.boolean()
+});
+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 = z59.strictObject({
+  schema: z59.enum([
     "felspar.hosted-supplied-execution/v1",
     "felspar.hosted-supplied-execution/v2",
     "felspar.hosted-supplied-execution/v3"
   ]),
-  release: z53.strictObject({ releaseId: id7, releaseDigest: digest23, materialDigest: digest23 }),
-  evaluationTime: z53.iso.datetime(),
+  release: z59.strictObject({ releaseId: id9, releaseDigest: digest25, materialDigest: digest25 }),
+  evaluationTime: z59.iso.datetime(),
   input: HostedSuppliedJobInputSchema,
   facts: HostedFactsJobInputSchema.optional(),
-  judgments: z53.array(HostedClassificationResultSchema).max(192).optional(),
-  judgmentsDigest: digest23.optional(),
-  expansion: z53.literal("agreeing-excerpts").optional(),
-  job: z53.record(z53.string(), z53.unknown())
-}).refine(retainsFactsExactly, "Version 3 records, and only they, retain facts with their judgments");
-var HostedObjectSchema = z53.strictObject({
-  id: id7,
-  kind: z53.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
-  payloadDigest: digest23,
-  objectKey: z53.string().min(1).max(1e3),
-  parentId: id7.nullable(),
-  status: z53.enum(["active", "released", "revoked"]),
-  metadata: z53.record(z53.string(), z53.unknown())
-});
-var HostedJobResultSchema = z53.object({
-  status: z53.string(),
-  reason: z53.string().nullable(),
-  result: z53.object({
-    executionId: z53.string(),
-    releaseId: id7,
-    releaseDigest: digest23,
-    outcome: z53.string().nullable(),
-    scoring: z53.unknown(),
-    context: z53.unknown(),
-    receipt: z53.unknown()
+  judgments: z59.array(HostedClassificationResultSchema).max(192).optional(),
+  judgmentsDigest: digest25.optional(),
+  expansion: z59.enum(["agreeing-excerpts", "agreeing-excerpts/v2"]).optional(),
+  caseRecord: HostedCaseRecordSchema.optional(),
+  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 = 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()
 });
 
@@ -4730,6 +5550,12 @@ var formatFix = "The request does not match the facts request format at this pat
 var fixes = {
   observed_at_invalid: "Send observedAt as the date and time the source was read, with Z or an offset: for example 2026-10-21T10:00:00Z or 2026-10-21T12:00+02:00. A date alone, a time with no offset or words such as yesterday are not accepted.",
   source_id_invalid: `Send source.id as the source's own ID or address, such as a ticket number or a document URL with its query: at most ${draftSourceIdLimit} characters, starting with a letter or digit, using URL characters only (percent-encode spaces and non-ASCII characters).`,
+  source_id_required: "Send source.id: the source's own ID or address. For words a person gave you, mark the source manual: true instead and leave id out.",
+  observed_at_required: "Send source.observedAt: when the source was read, with Z or an offset. For words a person gave you, mark the source manual: true and Felspar stamps the time it received them.",
+  source_id_reserved: "Source IDs starting with felspar: are Felspar's own. Send the source's own ID, or mark words a person gave you manual: true with no id.",
+  manual_source_id: "A manual source takes no id or revision. Name the source the person gave in locator, such as the record or message it came from.",
+  supplied_by_needs_manual: "suppliedBy is only for words a person gave you: mark that source manual: true, or leave suppliedBy out.",
+  manual_facts_refused: "This job's pack refuses facts supplied by a person (its manualFacts setting). Quote the source record itself, with its source.id and observedAt, or leave the question out.",
   unknown_question: "This question is not in the released job. Use the question keys from describe.",
   source_class_not_accepted: "This question does not accept this source class. Send an excerpt from a source class the question's evidence policy in describe lists.",
   value_not_in_excerpt: "The quoted words do not state this value. Quote the exact words that state it, or send the text without a typed value.",
@@ -4746,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.",
@@ -4784,6 +5611,8 @@ var fixes = {
   proposal_closed: "This proposal was released, rejected, withdrawn or replaced by a newer proposal, so nothing more can be done with it. Call list_jobs for the job's open proposals.",
   not_proposer: "Only the person who made a proposal may withdraw it; an approver may reject it.",
   not_job_approver: "Only this job's owner and named approvers, or a workspace owner, may approve, release or reject its proposals. details.owners names who may; ask one of them to review it on the Felspar web page.",
+  own_proposal: "The person who proposed a change can't approve it while another approver can. details.reason says why; ask one of the job's other approvers to review it on the Felspar web page.",
+  proposal_review_unavailable: "This proposal's review can't be read. Call list_jobs for the job's open proposals.",
   withdraw_on_web_page: "Withdraw a proposal on the Felspar web page, or propose the job again, which replaces your earlier proposal.",
   change_request_needs_release: "This job has no release yet, so there is no document version to propose changes on. Draft its first pack with check_pack and propose_pack.",
   change_request_quote_invalid: "Each change must quote a passage exactly as it is in the release's version of the document (read_source on the source list_jobs names), found exactly once, with changes that don't overlap and a replacement that differs. details.problems names each change by its index: quote_not_found, quote_not_unique (quote more of the passage), edits_overlap or edit_unchanged.",
@@ -4795,9 +5624,27 @@ 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.",
   preview_reinterpret_blocked: "Fix the draft's blocking findings (check_pack lists them) before previewing with reinterpret: true. A preview without reinterpret still runs.",
+  readings_blocked: "Fix the draft's blocking findings (check_pack lists them) before check_readings reads its wording.",
+  nothing_to_read: "Send phrasings in variants, or add readingTests to the draft: there is nothing to read.",
+  too_many_readings: `Read at most ${readingCheckLimits.maxPerCheck} phrasings per check_readings call, the draft's readingTests included. Split them across calls, or send include_tests: false.`,
+  too_many_per_answer: `Send at most ${readingCheckLimits.maxPerAnswer} phrasings per answer (and per question for phrasings with no expected answer), the draft's readingTests included.`,
+  duplicate_reading: "Two phrasings have the same id (a readingTests id counts too). Give each its own id, or leave id out.",
+  question_not_read: "check_readings reads only choice questions Felspar classifies from text: not number, date or derived questions. Use a choice question's key from the draft.",
+  answer_not_in_question: "expect must be one of that question's answer values in the draft.",
   pack_job_mismatch: "That release or proposal belongs to another job. Pass the jobId list_jobs shows with it.",
   decision_not_found: "Check the output against a decision this caller made: send the executionId from your get_job_decision result for this job.",
   decision_not_decided: "This decision has no outcome, so nothing is written for it. Follow its next step instead.",
@@ -4817,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",
@@ -4839,236 +5691,254 @@ function hostedRefusalRecovery(code) {
 }
 
 // ../schemas/src/draft-hosted-job-description.ts
-import { z as z55 } from "zod";
+import { z as z61 } from "zod";
 
 // ../schemas/src/draft-hosted-output-guides.ts
-import { z as z54 } from "zod";
-var id8 = z54.string().min(1).max(200);
-var located = z54.strictObject({
-  text: z54.string().min(1).max(262144),
-  locator: z54.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 = z54.strictObject({
-  id: id8,
+var HostedOutputGuideSchema = z60.strictObject({
+  id: id10,
   what: located,
-  maxCharacters: z54.number().int().min(1),
-  context: z54.array(located.extend({ id: id8 })).max(hostedOutputGuideLimits.maxContext).optional(),
-  checks: z54.array(z54.strictObject({
-    check: id8,
-    rule: z54.string().nullable(),
-    must: z54.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 = z54.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
+var HostedOutputGuidesSchema = z60.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
 
 // ../schemas/src/draft-hosted-job-description.ts
-var id9 = z55.string().min(1).max(200);
-var digest24 = DraftApplicationReleaseSchema.shape.releaseDigest;
+var id11 = z61.string().min(1).max(200);
+var digest26 = DraftApplicationReleaseSchema.shape.releaseDigest;
 var { requirements, rules } = DraftRequiredProposalSchema.shape;
-var quotedText = z55.strictObject({
-  text: z55.string().min(1).max(262144),
+var quotedText = z61.strictObject({
+  text: z61.string().min(1).max(262144),
   source: DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
-    locator: z55.string().min(1).max(4096),
-    contentDigest: digest24
+    locator: z61.string().min(1).max(4096),
+    contentDigest: digest26
   }),
-  parts: z55.array(z55.strictObject({ locator: z55.string().min(1).max(4096), text: z55.string() })).max(16)
+  parts: z61.array(z61.strictObject({ locator: z61.string().min(1).max(4096), text: z61.string() })).max(16)
 });
 var subjectShape = {
-  identifier: z55.string().min(1).max(200),
-  example: z55.string().min(1).max(200),
-  match: z55.enum(subjectMatchRules)
+  identifier: z61.string().min(1).max(200),
+  example: z61.string().min(1).max(200),
+  match: z61.enum(subjectMatchRules)
 };
-var HostedJobSubjectSchema = z55.strictObject({
-  type: id9,
+var HostedJobSubjectSchema = z61.strictObject({
+  type: id11,
   definition: quotedText,
   identifier: subjectShape.identifier.optional(),
   example: subjectShape.example.optional(),
   match: subjectShape.match,
-  related: z55.array(z55.strictObject({
-    relationship: id9,
+  related: z61.array(z61.strictObject({
+    relationship: id11,
     meaning: quotedText,
-    cardinality: z55.enum(relationshipCardinalities),
-    required: z55.boolean(),
-    subject: id9,
+    cardinality: z61.enum(relationshipCardinalities),
+    required: z61.boolean(),
+    subject: id11,
     definition: quotedText,
     ...subjectShape
   })).max(16),
-  send: z55.string().min(1).max(2e4)
+  send: z61.string().min(1).max(2e4)
 });
-var HostedJobEscalationsSchema = z55.strictObject({
-  routes: z55.array(z55.strictObject({ id: id9, quote: quotedText })).min(1).max(16),
-  unresolved: id9.nullable(),
-  attemptLimit: id9.nullable(),
-  rule: z55.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 = z55.strictObject({
-  id: id9,
-  trigger: z55.enum(escalationTriggers),
+var HostedEscalationSchema = z61.strictObject({
+  id: id11,
+  trigger: z61.enum(escalationTriggers),
   why: quotedText
 });
-var HostedJobDescriptionSchema = z55.strictObject({
-  schema: z55.literal("felspar.hosted-job-description.draft/v0"),
-  job: id9,
+var HostedJobDescriptionSchema = z61.strictObject({
+  schema: z61.literal("felspar.hosted-job-description.draft/v0"),
+  job: id11,
   purpose: quotedText.optional(),
-  useWhen: z55.array(quotedText).max(8).optional(),
-  notFor: z55.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: z55.strictObject({
-    mode: z55.enum(identityModes),
-    send: z55.string().min(1).max(4e3),
-    fields: z55.array(z55.strictObject({ name: id9, ...subjectShape })).max(8).optional(),
-    question: id9.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(),
-  trustDomain: id9,
-  release: z55.strictObject({
-    releaseId: id9,
-    releaseDigest: digest24,
-    materialDigest: digest24,
-    expectedAuthorityDigest: digest24
+  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: z55.array(requirements.element.extend({
-    key: id9,
-    type: z55.enum(["enum", "boolean", "number", "date"]),
+  questions: z61.array(requirements.element.extend({
+    key: id11,
+    type: z61.enum(["enum", "boolean", "number", "date"]),
     meaning: quotedText,
-    answer: z55.strictObject({
-      send: z55.enum(["text", "text_or_value"]),
-      valueFormat: z55.enum(["number", "calendar-date"]).nullable(),
-      interpretation: z55.enum(["classified", "exact_read", "unsupported"]),
-      threshold: z55.number().gt(0).max(1).nullable(),
-      applies: z55.enum(["always", "conditional"]),
-      dependsOn: z55.array(id9).max(32),
-      appliesWhen: z55.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: z55.array(z55.strictObject({
-      value: id9,
-      meaning: z55.string().nullable(),
-      inclusions: z55.array(z55.string()).max(8),
-      exclusions: z55.array(z55.string()).max(8),
-      examples: z55.array(z55.string()).max(8),
-      edgeCases: z55.array(z55.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: z55.array(quotedText).max(8).optional(),
-    about: z55.strictObject({ relationship: id9, subject: id9 }).optional()
+    whereToLook: z61.array(quotedText).max(8).optional(),
+    about: z61.strictObject({ relationship: id11, subject: id11 }).optional()
   })).max(64),
-  rules: z55.array(rules.element.extend({ text: quotedText })).max(256),
-  outcomes: z55.array(z55.strictObject({
-    id: id9,
+  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: id9.optional()
+    escalate: id11.optional()
   })).max(64),
   escalations: HostedJobEscalationsSchema.optional(),
   whenUnresolved: quotedText.nullable().optional(),
-  attempts: z55.strictObject({
-    max: z55.number().int().min(1).max(10),
-    withProgress: z55.number().int().min(1).max(10),
-    rule: z55.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: z55.strictObject({ gather: z55.string().min(1).max(2e3) }),
-  input: z55.strictObject({
-    jsonSchema: z55.record(z55.string(), z55.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: z55.string().max(1e3)
+    exampleNote: z61.string().max(1e3)
   }),
-  limits: z55.strictObject({
-    maxEvidenceItems: z55.number().int().positive(),
-    maxPassages: z55.number().int().positive(),
-    facts: z55.strictObject({
-      maxExcerptCharacters: z55.literal(hostedFactsLimits.maxExcerptCharacters),
-      maxExcerptsPerQuestion: z55.literal(hostedFactsLimits.maxExcerptsPerQuestion),
-      maxFactsBytes: z55.literal(hostedFactsLimits.maxFactsBytes),
-      maxQuestions: z55.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 = z55.strictObject({
-  id: id9,
-  method: z55.enum(["value", "exact_read", "classified"]),
-  status: z55.enum(["accepted", "needs_evidence", "not_needed"]),
-  value: z55.union([z55.string(), z55.number(), z55.boolean()]).optional(),
-  reasons: z55.array(z55.string()),
-  classification: z55.strictObject({
-    candidate: z55.string().nullable(),
-    probability: z55.number().min(0).max(1).nullable(),
-    abstention: z55.number().min(0).max(1).nullable(),
-    threshold: z55.number().min(0).max(1),
-    alternatives: z55.array(z55.strictObject({ value: z55.string(), probability: z55.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 = z55.strictObject({ id: id9, outcome: id9, text: quotedText });
-var HostedJobExplanationSchema = z55.strictObject({
-  schema: z55.literal("felspar.hosted-job-explanation.draft/v0"),
-  decision: z55.strictObject({ status: z55.string().nullable(), reasons: z55.array(z55.string()) }),
-  needs: z55.array(z55.strictObject({
-    key: id9,
-    status: z55.string(),
-    reasons: z55.array(z55.string()),
-    acceptedSourceClasses: z55.array(z55.string()),
-    maxAgeMs: z55.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: z55.array(interpretedExcerpt).optional()
+    excerpts: z61.array(interpretedExcerpt).optional()
   })),
-  why: z55.strictObject({
-    rules: z55.array(ruleSummary),
-    overrides: z55.array(z55.strictObject({ by: id9, target: id9 })),
-    suppressedRuleIds: z55.array(id9),
-    evidence: z55.array(z55.record(z55.string(), z55.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: z55.strictObject({ status: z55.string(), reason: z55.string().nullable() }).nullable(),
-  reviewNeeds: z55.array(z55.string()),
-  evidenceFreshUntil: z55.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 = z55.strictObject({
+var HostedReceiptVerificationInputSchema = z61.strictObject({
   receipt: DraftJobReceiptSchema,
-  expectedReceiptDigest: digest24,
+  expectedReceiptDigest: digest26,
   deliveredCapsule: DraftContextVerificationOptionsSchema.shape.deliveredCapsule
 });
-var HostedReceiptVerificationSchema = z55.strictObject({
-  authority: z55.literal("unapproved"),
-  status: z55.enum(["reproduced", "mismatch"]),
-  mismatches: z55.array(z55.string()),
-  decided: z55.strictObject({
-    jobId: id9,
-    entityId: id9,
-    releaseId: id9,
-    outcome: id9.nullable(),
-    case: z55.strictObject({ id: id9, mode: z55.enum(identityModes) }).optional(),
-    subject: z55.strictObject({
-      type: id9,
-      related: z55.array(z55.strictObject({ relationship: id9, subject: id9, id: id9, questions: z55.array(id9).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()
+    escalation: HostedEscalationSchema.omit({ why: true }).optional(),
+    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: z61.string(),
+      stampedByFelspar: z61.boolean(),
+      suppliedBy: z61.strictObject({ text: z61.string(), verified: z61.literal(false) }).optional()
+    })).max(192).optional(),
+    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 z58 } from "zod";
+import { z as z64 } from "zod";
 
 // ../schemas/src/draft-artifact-lint.ts
-import { z as z57 } from "zod";
+import { z as z63 } from "zod";
 
 // ../schemas/src/draft-job-obligations.ts
-import { z as z56 } from "zod";
-var id10 = DraftApplicationScopeSchema.shape.authorityId;
-var digest25 = 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: z56.literal("felspar.application-job-material.draft/v3"),
+  schema: z62.literal("felspar.application-job-material.draft/v3"),
   obligations: DraftJobObligationsSchema
-}).superRefine((value, context3) => {
+}).superRefine((value2, context3) => {
   if (context3.issues.length > 0) {
     return;
   }
-  const { obligations, discovery } = value;
-  const { proposal } = value.input.invocation.authority.catalog;
+  const { obligations, discovery } = value2;
+  const { proposal } = value2.input.invocation.authority.catalog;
   const isSourceMatches = Object.entries(proposal.source).every(([key3, expected2]) => Reflect.get(obligations.source, key3) === expected2);
-  const outcomes = new Set(obligations.outcomes.map((entry2) => entry2.outcomeId));
-  const isComplete = outcomes.size === proposal.allowedOutcomes.length && proposal.allowedOutcomes.every((entry2) => outcomes.has(entry2));
+  const outcomes = new Set(obligations.outcomes.map((entry3) => entry3.outcomeId));
+  const isComplete = outcomes.size === proposal.allowedOutcomes.length && proposal.allowedOutcomes.every((entry3) => outcomes.has(entry3));
   const matches = [
     isSourceMatches,
     isComplete,
@@ -5086,57 +5956,57 @@ var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.ex
   }
 });
 var HostedProposalInputV3Schema = HostedProposalInputV2Schema.extend({
-  schema: z56.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 = z56.strictObject({
-  authority: z56.literal("unapproved"),
-  discovery: z56.record(z56.string(), z56.unknown()),
-  executed: z56.record(z56.string(), z56.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 = z56.strictObject({
+var DraftJobObligationsInputSchema = z62.strictObject({
   release: DraftApplicationReleaseSchema,
-  material: z56.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
+  material: z62.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
   execution: DraftJobObligationsExecutionSchema,
-  expectedReceiptDigest: digest25,
+  expectedReceiptDigest: digest27,
   job: DraftJobObligationsNativeResultSchema,
   explanation: HostedJobExplanationSchema,
-  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id10 })
+  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id12 })
 });
-var requirements2 = z56.strictObject({
-  status: z56.enum(["established", "unresolved"]),
+var requirements2 = z62.strictObject({
+  status: z62.enum(["established", "unresolved"]),
   scope: DraftJobObligationsScopeSchema,
   artifacts: outcome2.shape.artifacts,
   approvals: outcome2.shape.approvals,
-  unresolved: z56.array(z56.strictObject({ scopeRef: id10, reasonCodes: z56.array(id10).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 = z56.discriminatedUnion("kind", [
-  z56.strictObject({ kind: z56.literal("evidence_need"), id: id10 }),
-  z56.strictObject({ kind: z56.literal("artifact_requirement"), id: id10 }),
-  z56.strictObject({ kind: z56.literal("approval_requirement"), id: id10 }),
-  z56.strictObject({ kind: z56.literal("unresolved_scope"), scopeRef: id10 })
+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 = z56.strictObject({
-  schema: z56.literal("felspar.job-obligations-assessment.draft/v0"),
-  binding: z56.strictObject({
-    releaseDigest: digest25,
-    materialDigest: digest25,
-    nativeReceiptDigest: digest25,
-    jobId: id10,
+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: id10,
-    entityId: id10,
-    evaluationTime: z56.iso.datetime({ offset: true }),
-    purposeRef: id10,
-    useRef: id10.nullable()
+    caseId: id12,
+    entityId: id12,
+    evaluationTime: z62.iso.datetime({ offset: true }),
+    purposeRef: id12,
+    useRef: id12.nullable()
   }),
   requirements: requirements2,
-  next: z56.strictObject({
-    kind: z56.enum([
+  next: z62.strictObject({
+    kind: z62.enum([
       "stop",
       "review_required",
       "gather_evidence",
@@ -5144,20 +6014,20 @@ var DraftJobObligationsAssessmentBodySchema = z56.strictObject({
       "verify_before_action",
       "return_result"
     ]),
-    reasonCodes: z56.array(id10).max(64),
-    refs: z56.array(nextReference).max(64)
+    reasonCodes: z62.array(id12).max(64),
+    refs: z62.array(nextReference).max(64)
   })
 });
 function isNextRefDeclared(ref, required) {
   switch (ref.kind) {
     case "artifact_requirement": {
-      return required.artifacts.some((entry2) => entry2.id === ref.id);
+      return required.artifacts.some((entry3) => entry3.id === ref.id);
     }
     case "approval_requirement": {
-      return required.approvals.some((entry2) => entry2.id === ref.id);
+      return required.approvals.some((entry3) => entry3.id === ref.id);
     }
     case "unresolved_scope": {
-      return required.unresolved.some((entry2) => entry2.scopeRef === ref.scopeRef);
+      return required.unresolved.some((entry3) => entry3.scopeRef === ref.scopeRef);
     }
     case "evidence_need": {
       return true;
@@ -5168,13 +6038,13 @@ function isNextRefDeclared(ref, required) {
   }
 }
 var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchema.extend({
-  assessmentDigest: digest25
-}).superRefine((value, context3) => {
-  const { requirements: required } = value;
+  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)) {
     context3.addIssue({ code: "custom", message: "Requirements completeness differs" });
   }
-  for (const ref of value.next.refs) {
+  for (const ref of value2.next.refs) {
     if (!isNextRefDeclared(ref, required)) {
       context3.addIssue({ code: "custom", message: "Dangling next reference" });
     }
@@ -5182,48 +6052,48 @@ var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchem
 });
 
 // ../schemas/src/draft-artifact-lint.ts
-var id11 = DraftApplicationScopeSchema.shape.authorityId;
-var digest26 = DraftJobReceiptSchema.shape.receiptDigest;
+var id13 = DraftApplicationScopeSchema.shape.authorityId;
+var digest28 = DraftJobReceiptSchema.shape.receiptDigest;
 var passage3 = ArtifactSpecificationSchema;
-var plainArtifact = z57.strictObject({
-  id: id11,
-  revision: id11,
-  mediaType: z57.literal("text/plain"),
-  exportProfile: id11.nullable(),
-  content: z57.string().max(artifactLintLimits.maxTotalBytes),
-  expectedContentDigest: digest26
-});
-var structuredArtifact = z57.strictObject({
-  id: id11,
-  revision: id11,
-  mediaType: z57.literal("application/vnd.felspar.structured-output+json"),
-  exportProfile: id11.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: digest26
+  expectedContentDigest: digest28
 });
-var ArtifactLintArtifactSchema = z57.discriminatedUnion("mediaType", [
+var ArtifactLintArtifactSchema = z63.discriminatedUnion("mediaType", [
   plainArtifact,
   structuredArtifact
 ]);
-var ArtifactLintDecisionSchema = z57.strictObject({
+var ArtifactLintDecisionSchema = z63.strictObject({
   inputs: DraftJobObligationsInputSchema,
   assessment: DraftJobObligationsAssessmentSchema,
-  expectedAssessmentDigest: digest26
+  expectedAssessmentDigest: digest28
 });
-var ArtifactLintInputSchema = z57.strictObject({
-  schema: z57.literal("felspar.lint.draft/v1"),
-  requestId: id11,
+var ArtifactLintInputSchema = z63.strictObject({
+  schema: z63.literal("felspar.lint.draft/v1"),
+  requestId: id13,
   release: DraftApplicationReleaseSchema,
   material: DraftApplicationJobMaterialV3Schema,
   manifest: ArtifactCheckManifestSchema,
-  expectedManifestDigest: digest26,
-  attachedObligations: z57.strictObject({ expectedObligationsDigest: digest26 }).optional(),
-  attachedCase: z57.strictObject({
-    decisionReceiptDigest: digest26,
-    answers: z57.array(z57.strictObject({ key: id11, value: z57.union([z57.string().min(1).max(200), z57.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: z57.strictObject({ caseId: id11, purposeRef: id11, useRef: id11.nullable() }),
-  artifactRequirementId: id11.nullable(),
+  case: z63.strictObject({ caseId: id13, purposeRef: id13, useRef: id13.nullable() }),
+  artifactRequirementId: id13.nullable(),
   decision: ArtifactLintDecisionSchema.nullable(),
   artifact: ArtifactLintArtifactSchema
 });
@@ -5236,11 +6106,11 @@ var artifactCheckStatuses = [
   "not_applicable",
   "skipped"
 ];
-var range = z57.strictObject({
-  sectionId: id11,
-  start: z57.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
-  end: z57.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
-  offsetUnit: z57.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",
@@ -5261,6 +6131,7 @@ var findingCodes = [
   "semantic_violation",
   "semantic_missing",
   "semantic_unresolved",
+  "possible_prompt_injection",
   "case_answer_conflict",
   "case_answer_missing",
   "case_answer_unconfirmed",
@@ -5268,174 +6139,331 @@ var findingCodes = [
   "evaluation_budget_exceeded",
   "evaluation_skipped"
 ];
-var ArtifactFindingSchema = z57.strictObject({
-  code: z57.enum(findingCodes),
-  checkId: id11.nullable(),
-  severity: z57.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: z57.strictObject({ sectionId: id11.nullable(), at: z57.number().int().min(0) }).nullable(),
-  literalIndex: z57.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
-});
-var ArtifactCheckObservationSchema = z57.strictObject({
-  checkId: id11,
-  kind: z57.enum(artifactCheckKinds),
-  required: z57.boolean(),
-  method: z57.enum(["deterministic", "semantic"]),
-  status: z57.enum(artifactCheckStatuses),
-  occurrences: z57.number().int().min(0),
-  parsedValue: z57.number().nullable(),
-  caseValue: z57.number().nullable()
-});
-var ArtifactLintRecordBodySchema = z57.strictObject({
-  schema: z57.literal("felspar.lint-record.draft/v1"),
-  requestId: id11,
-  status: z57.enum(["pass", "revise", "unavailable", "review_required"]),
-  caseContext: z57.enum(["bound", "not_required"]),
-  binding: z57.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: id11,
-    releaseDigest: digest26,
-    materialDigest: digest26,
-    obligationsDigest: digest26.optional(),
-    caseFactsDigest: digest26.optional(),
-    jobId: id11,
-    manifestId: id11,
-    manifestDigest: digest26,
-    contract: z57.strictObject({ id: id11, digest: digest26 }),
-    caseId: id11,
-    purposeRef: id11,
-    useRef: id11.nullable(),
-    artifactRequirementId: id11.nullable(),
-    decisionReceiptDigest: digest26.nullable(),
-    obligationsAssessmentDigest: digest26.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: z57.strictObject({
-    id: id11,
-    revision: id11,
-    mediaType: z57.enum(artifactLintMediaTypes),
-    exportProfile: id11.nullable(),
-    contentDigest: digest26,
-    sections: z57.array(z57.strictObject({
-      id: id11,
-      units: z57.number().int().min(0),
-      contentDigest: digest26.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: z57.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
-  findings: z57.array(ArtifactFindingSchema).max(2048),
+  checks: z63.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
+  findings: z63.array(ArtifactFindingSchema).max(2048),
   semantic: ArtifactSemanticRecordSchema.nullable(),
-  coverage: z57.strictObject({
-    scope: z57.literal("declared_checks_only"),
-    declared: z57.number().int().min(0),
-    applicable: z57.number().int().min(0),
-    completed: z57.number().int().min(0),
-    required: z57.number().int().min(0),
-    requiredCompleted: z57.number().int().min(0),
-    textAssigned: z57.enum(["complete", "incomplete"]),
-    semantic: z57.enum(["not_declared", "complete", "incomplete"]),
-    nativeDocumentLayout: z57.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: z57.literal(false)
+  actionAuthorized: z63.literal(false)
 });
 var ArtifactLintRecordSchema = ArtifactLintRecordBodySchema.extend({
-  recordDigest: digest26
-});
-var ArtifactLintReceiptSchema = z57.strictObject({
-  schema: z57.literal("felspar.lint-receipt.draft/v1"),
-  recordDigest: digest26,
-  releaseDigest: digest26,
-  manifestDigest: digest26,
-  contractDigest: digest26,
-  caseId: id11,
-  caseContext: z57.enum(["bound", "not_required"]),
-  decisionReceiptDigest: digest26.nullable(),
-  obligationsAssessmentDigest: digest26.nullable(),
-  artifactId: id11,
-  artifactRevision: id11,
-  artifactDigest: digest26,
-  actionAuthorized: z57.literal(false),
-  receiptDigest: digest26
+  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 id12 = DraftApplicationScopeSchema.shape.authorityId;
-var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
-var HostedOutputCheckInputSchema = z58.strictObject({
-  executionId: id12,
-  output: id12.optional(),
-  text: z58.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
-  revision: id12.optional()
-});
-var HostedOutputCheckRecordSchema = z58.strictObject({
-  schema: z58.literal("felspar.hosted-output-check/v0"),
-  checkId: id12,
-  jobId: id12,
-  output: id12,
-  decision: z58.strictObject({ executionId: id12, outcome: id12, receiptDigest: digest27 }),
-  release: z58.strictObject({ releaseId: id12, releaseDigest: digest27 }),
+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: z58.strictObject({
-    modelCalls: z58.number().int().min(0),
-    reason: z58.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 z59 } from "zod";
-var digestText = z59.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var HostedOutputCheckReplySchema = z59.object({
-  status: z59.enum(["pass", "revise", "review_required", "unavailable"]),
-  checkId: z59.string(),
-  output: z59.string(),
-  findings: z59.array(z59.record(z59.string(), z59.unknown())),
-  receipt: z59.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
-  decision: z59.object({ executionId: z59.string(), receiptDigest: digestText }),
-  actionAuthorized: z59.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 = z59.object({ text: z59.string() }).loose();
-var FelsparCaseSchema = z59.object({ id: z59.string().min(1).max(200), mode: z59.enum(identityModes) });
-var FelsparRelatedSchema = z59.object({
-  relationship: z59.string(),
-  subject: z59.string(),
-  id: z59.string(),
-  questions: z59.array(z59.string())
-});
-var FelsparResultSubjectSchema = z59.object({
-  type: z59.string(),
-  id: z59.string(),
-  related: z59.array(FelsparRelatedSchema)
-});
-var FelsparEscalationSchema = z59.object({
-  id: z59.string().min(1).max(200),
-  trigger: z59.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: z59.array(z59.string()).optional()
+    missing: z65.array(z65.string()).optional()
   }).nullable()
 });
-var FelsparJobListSchema = z59.object({
-  jobs: z59.array(z59.object({ id: z59.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(value) {
-  const packed = await packContentParts(value);
+async function partsBody(value2) {
+  const packed = await packContentParts(value2);
   return packed.text;
 }
-async function factsRequest(value, describeRelease) {
-  if (typeof value.expectedReleaseDigest === "string") {
-    return HostedFactsRequestSchema.parse({ mode: "facts", ...value });
+async function factsRequest(value2, describeRelease) {
+  if (typeof value2.expectedReleaseDigest === "string") {
+    return HostedFactsRequestSchema.parse({ mode: "facts", ...value2 });
   }
-  const described = await describeRelease(HostedObjectSchema.shape.id.parse(value.jobId));
+  const described = await describeRelease(HostedObjectSchema.shape.id.parse(value2.jobId));
   return HostedFactsRequestSchema.parse({
     mode: "facts",
-    ...value,
+    ...value2,
     expectedReleaseDigest: described.release.releaseDigest
   });
 }
@@ -5473,31 +6501,31 @@ ${jobId}`;
     return result;
   };
 }
-var refusalCode = z59.string().regex(/^[a-z][a-z_]{2,63}$/u);
-var fieldPath = z59.array(z59.string().max(256)).max(32);
-var refusalEscalationSchema = z59.object({
-  id: z59.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]{0,199}$/u),
-  trigger: z59.enum(escalationTriggers),
-  why: z59.object({ text: z59.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 = z59.object({
+var refusalSchema = z67.object({
   error: refusalCode,
   path: fieldPath.optional(),
-  currentReleaseDigest: z59.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
-  retryAfterSeconds: z59.number().int().min(1).max(3600).optional(),
-  escalation: z59.unknown().optional(),
-  issues: z59.array(z59.object({ code: refusalCode, path: fieldPath })).max(64).optional()
-}).transform(({ escalation: named, ...value }) => {
-  const fix = hostedRefusalFix(value.error);
-  const recovery = hostedRefusalRecovery(value.error);
+  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);
   const escalation = refusalEscalationSchema.safeParse(named).data;
   return {
-    ...value,
+    ...value2,
     ...escalation !== void 0 && { escalation },
     ...fix !== null && { fix },
     ...recovery !== null && { recovery },
-    ...value.issues && {
-      issues: value.issues.map((issue) => {
+    ...value2.issues && {
+      issues: value2.issues.map((issue) => {
         const issueFix = hostedRefusalFix(issue.code);
         return issueFix === null ? issue : { ...issue, fix: issueFix };
       })
@@ -5541,20 +6569,20 @@ function outputCheckCalls(call) {
   const objectId = HostedObjectSchema.shape.id;
   const checksOf = (job) => `/v0/jobs/${encodeURIComponent(objectId.parse(job))}/output-checks`;
   return {
-    checkOutput: async (job, value) => await call(checksOf(job), HostedOutputCheckReplySchema, HostedOutputCheckInputSchema.parse(value)),
+    checkOutput: async (job, value2) => await call(checksOf(job), HostedOutputCheckReplySchema, HostedOutputCheckInputSchema.parse(value2)),
     readOutputCheck: async (job, checkId) => await call(`${checksOf(job)}/${encodeURIComponent(objectId.parse(checkId))}`, HostedOutputCheckReplySchema)
   };
 }
 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 (id13, value) => {
-      const input = HostedSuppliedJobInputSchema.parse(value);
-      const releaseId = objectId.parse(id13);
+    resolveJob: async (id15, value2) => {
+      const input = HostedSuppliedJobInputSchema.parse(value2);
+      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);
     }
   };
 }
@@ -5573,14 +6601,14 @@ function createHostedFelsparClient(configuration) {
   }
   const authorization = authorizationOf(configuration);
   const fetcher = configuration.fetcher ?? fetch;
-  async function call(path3, schema, value) {
+  async function call(path3, schema, value2) {
     const headers = new Headers(authorization === null ? {} : { Authorization: authorization });
-    const body = value === void 0 ? void 0 : await partsBody(value);
+    const body = value2 === void 0 ? void 0 : await partsBody(value2);
     if (body !== void 0) {
       headers.set("Content-Type", hostedPartsContentType);
     }
     const response = await fetcher(`${origin.origin}${path3}`, {
-      method: value === void 0 ? "GET" : "POST",
+      method: value2 === void 0 ? "GET" : "POST",
       headers,
       credentials: "include",
       redirect: "error",
@@ -5595,21 +6623,22 @@ function createHostedFelsparClient(configuration) {
   const objectId = HostedObjectSchema.shape.id;
   const describe = jobDescriber(async (releaseId, jobId) => await call(describePath(releaseId, jobId), HostedJobDescriptionSchema));
   return {
-    submitSource: async (value) => await call("/v0/sources", HostedObjectSchema, HostedSourceInputSchema.parse(value)),
-    submitProposal: async (value) => await call("/v0/proposals", HostedObjectSchema, HostedProposalInputSchema.parse(value)),
-    approveProposal: async (id13, value) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id13))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value)),
-    releasePack: async (id13, value) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id13))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value)),
-    loadRelease: async (id13) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id13))}`, HostedReleaseBundleSchema),
-    describeJob: async (id13, job) => await describe(objectId.parse(id13), objectId.parse(job)),
-    verifyReceipt: async (executionObjectId, value) => await call(`/v0/executions/${encodeURIComponent(objectId.parse(executionObjectId))}/verify`, HostedReceiptVerificationSchema, HostedReceiptVerificationInputSchema.parse(value)),
+    ...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 (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 (id13, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id13))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
+    executeJob: async (id15, value2) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id15))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value2)),
     ...agentCalls(call),
-    resolveFacts: async (id13, value) => {
-      const releaseId = objectId.parse(id13);
-      const input = await factsRequest(value, async (jobId) => await describe(releaseId, jobId));
+    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);
     }
   };
 }