@felspar/sdk 0.3.0 → 0.4.0

package/dist/chunks/{chunk-3YVYBD4H.js → chunk-MIPPJBXB.js}

@@ -292,13 +292,13 @@ var contentPartsLimits = Object.freeze({
   maxLogicalDepth: canonicalJsonLimits.maxDepth
 });
 var encoder = new TextEncoder();
-function utf8(text7) {
-  if (text7.length >= 64) {
-    return encoder.encode(text7).byteLength;
+function utf8(text8) {
+  if (text8.length >= 64) {
+    return encoder.encode(text8).byteLength;
   }
   let bytes = 0;
-  for (let index = 0; index < text7.length; index += 1) {
-    const code = text7.codePointAt(index) ?? 0;
+  for (let index = 0; index < text8.length; index += 1) {
+    const code = text8.codePointAt(index) ?? 0;
     if (code < 128) {
       bytes += 1;
     } else if (code < 2048) {
@@ -312,8 +312,8 @@ function utf8(text7) {
   }
   return bytes;
 }
-async function sha256(text7) {
-  const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(text7)));
+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) {
@@ -491,12 +491,12 @@ async function packContentParts(value) {
   }
   parts.sort(byDigest);
   const head = canonicalizeJson({ schema: draftContentPartsFormat, root: root.value, parts });
-  const text7 = [head, ...parts.map((part) => state.parts.get(part) ?? "")].join("\n");
-  const storedBytes = utf8(text7);
+  const text8 = [head, ...parts.map((part) => state.parts.get(part) ?? "")].join("\n");
+  const storedBytes = utf8(text8);
   admitStored(parts.length, storedBytes);
   return {
     digest: digest28,
-    text: text7,
+    text: text8,
     parts: parts.length,
     storedBytes,
     logicalBytes: root.logical.bytes,
@@ -1273,6 +1273,21 @@ function clauseIdentity(clause) {
 function isSameClause(left, right) {
   return clauseIdentity(left) === clauseIdentity(right);
 }
+function choiceValues(clause) {
+  if ("equals" in clause) {
+    return [clause.equals];
+  }
+  return "oneOf" in clause ? clause.oneOf : [];
+}
+function isGuardImplied(guard, clause) {
+  if (isSameClause(guard, clause)) {
+    return true;
+  }
+  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));
+}
 function isPolicyValid(proposal, context3) {
   const clauses2 = [
     ...proposal.rules.flatMap((rule3) => rule3.when),
@@ -1330,11 +1345,11 @@ function inspectRuleGuards(proposal, context3) {
   for (const [index, rule3] of proposal.rules.entries()) {
     for (const clause of rule3.when) {
       const gates = isRelational ? conditionKeys(clause).flatMap((key3) => activationGuards(key3, requirements3)) : requirements3.get(clause.key)?.requiredWhen ?? [];
-      if (gates.some((gate) => rule3.when.every((candidate2) => !isSameClause(gate, candidate2)))) {
+      if (gates.some((gate) => rule3.when.every((candidate2) => !isGuardImplied(gate, candidate2)))) {
         context3.addIssue({
           code: "custom",
           path: ["rules", index],
-          message: "Conditional rule must include every exact activation predicate"
+          message: "Conditional rule must include every activation predicate, or an answer condition on its key within its answers"
         });
       }
     }
@@ -1438,7 +1453,7 @@ import { z as z14 } from "zod";
 
 // ../schemas/src/draft-scoring-references.ts
 function hasClause(clauses2, expected2) {
-  return clauses2.some((clause) => JSON.stringify(clause) === JSON.stringify(expected2));
+  return clauses2.some((clause) => isGuardImplied(expected2, clause));
 }
 function mayOverlap(left, right, definitions) {
   for (const clause of left) {
@@ -1461,7 +1476,7 @@ function clauseIssues(clause, scope2) {
   }
   for (const key3 of conditionKeys(clause)) {
     if (activationGuards(key3, byKey).some((guard) => !hasClause(active, guard))) {
-      issues.push("Scoring applicability must include every exact requirement activation guard");
+      issues.push("Scoring applicability must include every requirement activation guard, or an answer condition on its key within its answers");
     }
   }
   return issues;
@@ -1469,8 +1484,8 @@ function clauseIssues(clause, scope2) {
 function inspectScoringReferences(scoring, requirements3, context3) {
   const definitions = new Map(requirements3.map((row2) => [row2.definition.key, row2.definition]));
   const byKey = new Map(requirements3.map((row2) => [row2.definition.key, row2]));
-  for (const [index, criterion2] of scoring.criteria.entries()) {
-    const active = criterion2.activeWhen ?? [];
+  for (const [index, criterion3] of scoring.criteria.entries()) {
+    const active = criterion3.activeWhen ?? [];
     const fail = (message) => {
       context3.addIssue({ code: "custom", path: ["criteria", index], message });
     };
@@ -1479,15 +1494,15 @@ function inspectScoringReferences(scoring, requirements3, context3) {
         fail("Scoring applicability requires unconditional requirements");
       }
     }
-    const all = [...active, ...criterion2.cases.flatMap((item) => item.when)];
+    const all = [...active, ...criterion3.cases.flatMap((item) => item.when)];
     for (const clause of all) {
       const messages = clauseIssues(clause, { active, definitions, byKey });
       for (const message of messages) {
         fail(message);
       }
     }
-    for (const [caseIndex, item] of criterion2.cases.entries()) {
-      if (criterion2.cases.slice(caseIndex + 1).some((other) => mayOverlap(item.when, other.when, definitions))) {
+    for (const [caseIndex, item] of criterion3.cases.entries()) {
+      if (criterion3.cases.slice(caseIndex + 1).some((other) => mayOverlap(item.when, other.when, definitions))) {
         fail("Scoring contribution cases must be provably disjoint");
       }
     }
@@ -1519,7 +1534,7 @@ function inspectScoredPolicy(proposal, context3) {
   }
   inspectScoringReferences(scoring, proposal.requirements, context3);
   const ids3 = new Set(rules2.map((rule3) => rule3.id));
-  if (gates.some((id12) => !ids3.has(id12))) {
+  if (gates.some((id13) => !ids3.has(id13))) {
     fail("Unknown mandatory gate rule");
   }
   if (rules2.every((rule3) => gates.includes(rule3.id))) {
@@ -1532,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((id12) => gates.includes(id12) !== isGate)) {
+    if (rule3.overrides.some((id13) => gates.includes(id13) !== isGate)) {
       fail("Explicit overrides cannot cross mandatory-gate and score-band classes");
     }
     const range2 = rule3.scoreRange;
@@ -1620,19 +1635,19 @@ function hasCycle(rules2) {
   const graph = new Map(rules2.map((item) => [item.id, item.overrides]));
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const hasPathCycle = (id12) => {
-    if (visiting.has(id12)) {
+  const hasPathCycle = (id13) => {
+    if (visiting.has(id13)) {
       return true;
     }
-    if (visited.has(id12)) {
+    if (visited.has(id13)) {
       return false;
     }
-    visiting.add(id12);
-    if ((graph.get(id12) ?? []).some(hasPathCycle)) {
+    visiting.add(id13);
+    if ((graph.get(id13) ?? []).some(hasPathCycle)) {
       return true;
     }
-    visiting.delete(id12);
-    visited.add(id12);
+    visiting.delete(id13);
+    visited.add(id13);
     return false;
   };
   return rules2.some((item) => hasPathCycle(item.id));
@@ -1661,11 +1676,11 @@ function inspectRules(proposal, context3) {
         fail("Undeclared condition key or value");
       }
     }
-    if (item.overrides.some((id12) => id12 === item.id || !ids3.has(id12))) {
+    if (item.overrides.some((id13) => id13 === item.id || !ids3.has(id13))) {
       fail("Unknown or self override");
     }
-    if (item.overrides.some((id12) => {
-      const target = byId.get(id12);
+    if (item.overrides.some((id13) => {
+      const target = byId.get(id13);
       return target !== void 0 && draftRulePriority(target) > draftRulePriority(item);
     })) {
       fail("Override points to a higher priority tier");
@@ -1838,8 +1853,8 @@ function checkExpected(candidate2, context3) {
   }
   unique2(result.observationIds, context3, ["expected", "observationIds"]);
   const observationIds = new Set(candidate2.observations.map((entry2) => entry2.id));
-  for (const [index, id12] of result.observationIds.entries()) {
-    requireBinding2(observationIds.has(id12), context3, {
+  for (const [index, id13] of result.observationIds.entries()) {
+    requireBinding2(observationIds.has(id13), context3, {
       path: ["expected", "observationIds", index],
       message: "Unknown observation"
     });
@@ -2131,7 +2146,7 @@ var bundleNodeLimit = 65536;
 function boundedDraftInput(limits2) {
   return z21.unknown().transform((input, context3) => {
     let nodes = 0;
-    let text7 = 0;
+    let text8 = 0;
     const budgetError = new Error("Draft input budget exceeded or non-data input");
     function copy(value, depth) {
       nodes += 1;
@@ -2139,8 +2154,8 @@ function boundedDraftInput(limits2) {
         throw budgetError;
       }
       if (typeof value === "string") {
-        text7 += value.length;
-        if (value.length > limits2.stringLength || text7 > limits2.totalText) {
+        text8 += value.length;
+        if (value.length > limits2.stringLength || text8 > limits2.totalText) {
           throw budgetError;
         }
         return value;
@@ -2192,7 +2207,7 @@ function boundedDraftInput(limits2) {
   });
 }
 var isUnicodeText = (value) => !/[\uD800-\uDFFF]/u.test(value);
-var isSplitCharacter = (text7, offset) => offset > 0 && offset < text7.length && /[\uDC00-\uDFFF]/u.test(text7.charAt(offset));
+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"),
   offsetUnit: z21.literal("utf16_code_units"),
@@ -3023,13 +3038,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((id12) => id12 !== null);
+  const named = [escalations.unresolved, escalations.attemptLimit].filter((id13) => id13 !== null);
   return [
     ids3.size === escalations.routes.length,
     escalations.routes.every((row2) => isIsolated(row2.entryId, "routing_jobs")),
     hasUniqueValues(escalations.outcomes.map((row2) => row2.outcome)),
     escalations.outcomes.every((row2) => ids3.has(row2.escalation) && outcomes.has(row2.outcome)),
-    named.every((id12) => ids3.has(id12))
+    named.every((id13) => ids3.has(id13))
   ].every(Boolean);
 }
 function isGuideValid(guide, isIsolated) {
@@ -3119,7 +3134,7 @@ var DraftContextSelectionPlanSchema = z31.strictObject({
   if (candidateIds.length > 64 || !hasUniqueIds(candidateIds) || !hasUniqueIds(plan.groups.map((item) => item.id)) || !hasUniqueIds(plan.entries.map((item) => item.id))) {
     context3.addIssue({ code: "custom", message: "Duplicate identities or too many candidates" });
   }
-  if (plan.requiredIds.some((id12) => candidateIds.includes(id12))) {
+  if (plan.requiredIds.some((id13) => candidateIds.includes(id13))) {
     context3.addIssue({ code: "custom", message: "Global required root cannot be a candidate" });
   }
   const guidanceId = plan.unresolvedGuidanceEntryId;
@@ -3710,7 +3725,7 @@ var DraftApplicationReleaseSchema = z43.strictObject({
 });
 
 // ../schemas/src/draft-hosted-application.ts
-import { z as z50 } from "zod";
+import { z as z53 } from "zod";
 
 // ../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;
@@ -4368,60 +4383,244 @@ var HostedOutputChecksSchema = z49.strictObject({
   }
 });
 
+// ../schemas/src/draft-pack-revision.ts
+import { z as z52 } 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");
+var packDraftOutputLimits = {
+  maxOutputs: 8,
+  maxChecks: 16,
+  maxQuestions: 24,
+  maxContext: 8,
+  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({
+  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({
+    id: identifier21,
+    quote,
+    kind: z50.enum(["require", "prohibit"]),
+    question: z50.string().min(1).max(2e3).regex(/\S/u)
+  })).max(packDraftOutputLimits.maxQuestions).optional(),
+  states: z50.array(z50.strictObject({
+    id: identifier21,
+    quote,
+    question: identifier21,
+    wording: z50.record(identifier21, z50.array(wording).min(1).max(8)).optional()
+  })).max(packDraftOutputLimits.maxQuestions).optional()
+}).refine((output) => {
+  const ids3 = [
+    ...output.require ?? [],
+    ...output.prohibit ?? [],
+    ...output.ask ?? [],
+    ...output.states ?? []
+  ];
+  return hasUniqueValues(ids3.map((row2) => row2.id));
+}, "Duplicate check id").refine((output) => {
+  return (output.ask?.length ?? 0) + (output.states?.length ?? 0) <= packDraftOutputLimits.maxQuestions;
+}, `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");
+
+// ../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({
+  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;
+  if (lower + upper + Number(hasEquality) === 0) {
+    context3.addIssue({ code: "custom", message: "Give a bound: lt, lte, gt, gte or eq" });
+  } else if (lower > 1 || upper > 1) {
+    context3.addIssue({ code: "custom", message: "At most one lower and one upper bound" });
+  } else if (hasEquality && lower + upper > 0) {
+    context3.addIssue({ code: "custom", message: "eq stands alone" });
+  }
+});
+var contribution2 = z51.strictObject({
+  id: draftIdentifier,
+  points,
+  quote: draftQuote,
+  when: PackDraftConditionsSchema
+});
+var criterion2 = z51.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()
+});
+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 packDraftScoreExpectation = {
+  score: z51.number().min(0).optional(),
+  points: z51.record(draftIdentifier, z51.number().min(0).nullable()).optional()
+};
+
+// ../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 id6 = z52.string().min(1).max(200);
+var text7 = z52.string().min(1).max(262144);
+var texts = z52.array(z52.string()).max(8);
+var when = PackDraftConditionsSchema;
+var conventions = packConventionFields;
+var PackOutlineSchema = z52.strictObject({
+  schema: z52.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(),
+  dateOrder: conventions.dateOrder.unwrap().nullable(),
+  timeZone: z52.string().min(1).max(64).nullable(),
+  subject: id6.nullable(),
+  subjects: z52.array(z52.strictObject({
+    id: id6,
+    definition: text7,
+    identifier: z52.string().nullable(),
+    example: z52.string().nullable(),
+    match: z52.string(),
+    relationships: z52.array(z52.strictObject({
+      name: id6,
+      subject: id6,
+      cardinality: z52.enum(["one", "many"]),
+      required: z52.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({
+    key: id6,
+    type: z52.enum(["enum", "boolean", "number", "date"]),
+    meaning: text7,
+    about: id6.nullable(),
+    askOnlyWhen: z52.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({
+      value: id6,
+      meaning: z52.string().nullable(),
+      inclusions: texts,
+      exclusions: texts,
+      examples: texts,
+      edgeCases: texts
+    })).max(64),
+    whereToLook: texts
+  })).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({
+    id: id6,
+    meaning: text7,
+    outcome: id6,
+    when: when.nullable(),
+    conditions: z52.string().nullable(),
+    scoreRange: z52.record(z52.string(), z52.unknown()).nullable(),
+    score: PackDraftScoreSchema.nullable(),
+    gate: z52.boolean()
+  })).max(256),
+  scoring: PackDraftScoringSchema.nullable(),
+  cases: z52.array(z52.strictObject({
+    id: id6,
+    why: z52.string().nullable(),
+    facts: z52.record(id6, caseFactSchema),
+    decisionDate: CalendarDateSchema.nullable(),
+    subject: z52.strictObject({ id: id6 }).nullable(),
+    expect: z52.strictObject({ outcome: id6, rule: id6, score: z52.number().nullable() })
+  })).max(200),
+  outputChecks: PackDraftOutputsSchema.nullable(),
+  notKept: z52.array(z52.strictObject({ path: z52.string().min(1), reason: z52.string().min(1) })).max(64)
+});
+
 // ../schemas/src/draft-hosted-application.ts
-var id6 = z50.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+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 = z50.strictObject({
-  sourceId: id6,
-  revision: id6,
-  title: z50.string().min(1).max(200),
-  text: z50.string().min(1).max(1048576)
-});
-var HostedProposalInputV0Schema = z50.strictObject({
-  sourceObjectId: id6,
+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,
   material: DraftApplicationJobMaterialSchema,
   compilation: DraftCompilationSchema
 });
-var HostedProposalInputV2Schema = z50.strictObject({
-  schema: z50.literal("felspar.hosted-proposal.draft/v2"),
-  sourceObjectId: id6,
+var HostedProposalInputV2Schema = z53.strictObject({
+  schema: z53.literal("felspar.hosted-proposal.draft/v2"),
+  sourceObjectId: id7,
   expectedSourceDigest: digest23,
   material: DraftApplicationJobMaterialV2Schema,
-  outputChecks: HostedOutputChecksSchema.optional()
+  outputChecks: HostedOutputChecksSchema.optional(),
+  draft: KeptPackDraftSchema.optional()
 });
-var HostedProposalInputSchema = z50.union([
+var HostedProposalInputSchema = z53.union([
   HostedProposalInputV2Schema,
   HostedProposalInputV0Schema
 ]);
-var HostedApprovalInputSchema = z50.strictObject({
+var HostedApprovalInputSchema = z53.strictObject({
   expectedProposalDigest: digest23,
-  reviewedMeaning: z50.literal(true),
-  reviewedFixtures: z50.literal(true),
-  reviewNote: z50.string().min(1).max(2e3)
+  reviewedMeaning: z53.literal(true),
+  reviewedFixtures: z53.literal(true),
+  reviewNote: z53.string().min(1).max(2e3)
 });
-var HostedReleaseInputSchema = z50.strictObject({ expectedApprovalDigest: digest23 });
-var HostedReleaseBundleSchema = z50.strictObject({
+var HostedReleaseInputSchema = z53.strictObject({ expectedApprovalDigest: digest23 });
+var HostedReleaseBundleSchema = z53.strictObject({
   release: DraftApplicationReleaseSchema,
   material: DraftAnyApplicationJobMaterialSchema,
-  approvalObjectId: id6,
+  approvalObjectId: id7,
   approvalDigest: digest23,
   proposalDigest: digest23,
   sourceDigest: digest23,
   verifiedCompilation: DraftVerifiedCompilationSchema.optional()
 });
-var HostedJobInputSchema = z50.strictObject({
-  executionId: id6,
+var HostedJobInputSchema = z53.strictObject({
+  executionId: id7,
   expectedReleaseDigest: digest23,
   material: DraftAnyApplicationJobMaterialSchema
 });
-var HostedSuppliedJobInputSchema = z50.strictObject({
-  mode: z50.literal("supplied"),
-  executionId: id6,
+var HostedSuppliedJobInputSchema = z53.strictObject({
+  mode: z53.literal("supplied"),
+  executionId: id7,
   expectedReleaseDigest: digest23,
   expectedAuthorityDigest: digest23,
-  jobId: id6,
-  entityId: id6,
+  jobId: id7,
+  entityId: id7,
   evidence: DraftRequiredDecisionSchema.shape.evidence,
   passages: DraftLayeredEvaluationSchema.shape.passages.max(256)
 });
@@ -4431,97 +4630,97 @@ var hostedFactsLimits = {
   maxFactsBytes: 524288,
   maxQuestions: 64
 };
-var factSourceId = z50.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 = z50.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 = z50.strictObject({
-  class: id6,
+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,
   id: factSourceId,
-  revision: id6.optional(),
-  locator: z50.string().min(1).max(4096).optional(),
+  revision: id7.optional(),
+  locator: z53.string().min(1).max(4096).optional(),
   observedAt,
-  sensitivity: id6.optional()
+  sensitivity: id7.optional()
 });
-var excerptText = z50.string().min(1).refine((text7) => text7.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
-var about = z50.string().min(1).max(200).optional();
-var HostedExcerptSchema = z50.strictObject({ text: excerptText, source: factSource, about });
-var HostedValueFactSchema = z50.strictObject({
-  value: z50.union([z50.string().min(1).max(200), z50.number(), z50.boolean()]),
+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 = z50.union([
+var HostedFactSchema = z53.union([
   HostedValueFactSchema,
   HostedExcerptSchema,
-  z50.array(HostedExcerptSchema).min(1).refine((excerpts2) => excerpts2.length <= hostedFactsLimits.maxExcerptsPerQuestion, "too_many_excerpts")
+  z53.array(HostedExcerptSchema).min(1).refine((excerpts2) => excerpts2.length <= hostedFactsLimits.maxExcerptsPerQuestion, "too_many_excerpts")
 ]);
 function factsBytes(facts) {
   const encoder2 = new TextEncoder();
   return encoder2.encode(JSON.stringify(facts)).length;
 }
-var HostedFactsJobInputSchema = z50.strictObject({
-  mode: z50.literal("facts"),
-  executionId: id6,
+var HostedFactsJobInputSchema = z53.strictObject({
+  mode: z53.literal("facts"),
+  executionId: id7,
   expectedReleaseDigest: digest23,
-  jobId: id6,
-  entityId: id6,
+  jobId: id7,
+  entityId: id7,
   related: HostedRelatedSubjectsSchema.optional(),
-  identity: z50.record(z50.string().min(1).max(128), z50.string().min(1).max(200)).optional(),
-  facts: z50.record(id6, HostedFactSchema).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions").refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large")
+  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")
 });
 var HostedFactsRequestSchema = HostedFactsJobInputSchema.extend({
-  entityId: id6.optional()
+  entityId: id7.optional()
 });
-var HostedJobRequestSchema = z50.union([
+var HostedJobRequestSchema = z53.union([
   HostedJobInputSchema,
   HostedSuppliedJobInputSchema,
   HostedFactsJobInputSchema
 ]);
-var HostedClassificationResultSchema = z50.strictObject({
-  key: id6,
-  observationId: id6,
+var HostedClassificationResultSchema = z53.strictObject({
+  key: id7,
+  observationId: id7,
   record: DraftNormalizedEvidenceSchema.shape.normalizations.element,
-  reason: z50.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
-  cached: z50.boolean()
+  reason: z53.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
+  cached: z53.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 = z50.strictObject({
-  schema: z50.enum([
+var HostedSuppliedExecutionRecordSchema = z53.strictObject({
+  schema: z53.enum([
     "felspar.hosted-supplied-execution/v1",
     "felspar.hosted-supplied-execution/v2",
     "felspar.hosted-supplied-execution/v3"
   ]),
-  release: z50.strictObject({ releaseId: id6, releaseDigest: digest23, materialDigest: digest23 }),
-  evaluationTime: z50.iso.datetime(),
+  release: z53.strictObject({ releaseId: id7, releaseDigest: digest23, materialDigest: digest23 }),
+  evaluationTime: z53.iso.datetime(),
   input: HostedSuppliedJobInputSchema,
   facts: HostedFactsJobInputSchema.optional(),
-  judgments: z50.array(HostedClassificationResultSchema).max(192).optional(),
+  judgments: z53.array(HostedClassificationResultSchema).max(192).optional(),
   judgmentsDigest: digest23.optional(),
-  expansion: z50.literal("agreeing-excerpts").optional(),
-  job: z50.record(z50.string(), z50.unknown())
+  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 = z50.strictObject({
-  id: id6,
-  kind: z50.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
+var HostedObjectSchema = z53.strictObject({
+  id: id7,
+  kind: z53.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
   payloadDigest: digest23,
-  objectKey: z50.string().min(1).max(1e3),
-  parentId: id6.nullable(),
-  status: z50.enum(["active", "released", "revoked"]),
-  metadata: z50.record(z50.string(), z50.unknown())
-});
-var HostedJobResultSchema = z50.object({
-  status: z50.string(),
-  reason: z50.string().nullable(),
-  result: z50.object({
-    executionId: z50.string(),
-    releaseId: id6,
+  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: z50.string().nullable(),
-    scoring: z50.unknown(),
-    context: z50.unknown(),
-    receipt: z50.unknown()
+    outcome: z53.string().nullable(),
+    scoring: z53.unknown(),
+    context: z53.unknown(),
+    receipt: z53.unknown()
   }).loose().nullable()
 });
 
@@ -4530,12 +4729,12 @@ var limits = hostedFactsLimits;
 var formatFix = "The request does not match the facts request format at this path; follow input.example from get_job_requirements (input.jsonSchema in the REST brief).";
 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 the page 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_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).`,
   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.",
   duplicate_excerpt: "The same words from the same source were sent twice for this question. Send each excerpt once.",
-  duplicate_source_locator: "Another excerpt in this request names the same source and locator with different words. Give each passage its own locator (for example the page URL with the section heading after #); the same words may answer several questions.",
+  duplicate_source_locator: "Another excerpt in this request names the same source and locator with different words. Give each passage its own locator (for example the document URL with the section heading after #, or the message ID); the same words may answer several questions.",
   label_needs_mapping: "Felspar decides answer choices and yes/no questions from source text. Send the words the source says, not a label.",
   value_not_allowed: "A typed value must be a finite number for a number question or a YYYY-MM-DD date for a date question.",
   answer_choice_needs_excerpt: "Send this question in a facts request with the source text; Felspar classifies answer choices itself.",
@@ -4545,6 +4744,7 @@ var fixes = {
   request_too_large: `The facts in one request are at most ${limits.maxFactsBytes} bytes. Send shorter excerpts.`,
   release_changed: "The release changed. Describe the job again and resend with the current release digest.",
   job_mismatch: "This release serves a different job. Use the job and release from describe.",
+  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.",
   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.",
@@ -4566,14 +4766,45 @@ var fixes = {
   invalid_body: "The body must be JSON or content parts within the size limit.",
   context_graph_invalid: "Felspar would block every decision of this pack because of the context issues listed. Build the pack again from its draft with check_pack until it is clean, then propose it again; a pack with these issues can't be proposed, approved or released.",
   forbidden: "This caller may not run this job on this release, or the release is not available. Check the release ID and the caller's access.",
+  access_denied: "This caller may not do this, or what it names is not available to it. Use a job list_jobs shows; if it should be there, ask a workspace owner to add the job to this agent on the Felspar web page.",
+  unauthenticated: "No credential was sent. Send the agent key as a Bearer token, or sign in.",
+  invalid_arguments: "The tool's arguments don't match its input schema. Correct the field at each issue's path and call the tool again.",
+  not_found: "No Felspar route matches this path and method. Check the URL against the REST reference.",
+  check_not_found: "No output check by this caller with this ID on this job. Send the checkId from your own check_output result.",
+  history_not_found: "No case history matches. Check the case ID.",
+  history_unavailable: "Case history could not be read or changed just now. Try again later.",
+  no_current_release: "The job has no current release to compare with. Release a first version, then backtest later changes.",
+  source_access_required: "Your own connection can't read a document behind this object. Connect or reconnect it on the Felspar Sources page, or ask the document's owner to share it.",
+  operation_unavailable: "Felspar could not complete this request. Try again later with the same request; if it keeps failing, tell a person.",
   source_read_failed: "Felspar couldn't read the document's current version with your own connection. If access is not_connected or reconnect, connect or reconnect Google Drive on the Felspar Sources page; if no_access, ask the document's owner to share it with you; otherwise try again later.",
   source_text_not_allowed: "An MCP client can't submit text as a source. To use a document's newest text, call add_current_version with its sourceObjectId from list_sources.",
   source_not_connected: "This source was not added from a connected document. Use a sourceObjectId from list_sources.",
+  pack_not_found: "No released version or proposal of this job matches. Call list_jobs for the workspace's jobs, their current release and open proposals; for a job not yet released, pass a proposalId it lists.",
+  proposal_out_of_date: "A newer version of this job was released after this proposal was made, so it can't be approved or released. Update it: read_pack for the live pack, apply the change again, preview_change, then propose_pack, which replaces your earlier proposal.",
+  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.",
+  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.",
+  change_request_definition_reason_required: "Give a reason for each definition the revised pack adds or changes: add { id, reason } under definitions for every id details.definitions lists.",
+  change_request_definition_unknown: "A definition under definitions is not one the revised pack adds or changes. Use the question key or question/answer IDs from the revised pack's diff, or drop it.",
+  change_request_too_large: "This change request is too large to store. Split it into smaller change requests.",
+  change_request_not_found: "No change request with this ID. Call list_change_requests for the job's change requests.",
+  change_request_edit_not_found: "The change request has no change at this index. Use an index from its changes, or leave edit out to comment on the whole request.",
+  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.",
+  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.",
+  preview_reinterpret_blocked: "Fix the draft's blocking findings (check_pack lists them) before previewing with reinterpret: true. A preview without reinterpret still runs.",
+  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.",
   no_output_checks: "This job's release declares no output checks. Use the decision's next step; nothing is checked before sending.",
   output_not_required: "The decided outcome does not require this output. Send one of the outputs listed in required, or none when it is empty.",
   output_too_large: "The text is longer than this output allows. Shorten it and check again.",
+  invalid_input: "The request does not match the format. Correct each issue at its path: follow input.example from get_job_requirements (input.jsonSchema in the REST brief).",
   invalid_type: formatFix,
   invalid_union: formatFix,
   invalid_value: formatFix,
@@ -4582,231 +4813,252 @@ var fixes = {
   too_big: formatFix,
   too_small: formatFix
 };
+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 escalated = /* @__PURE__ */ new Set([
+  "unauthenticated",
+  "forbidden",
+  "access_denied",
+  "job_retired",
+  "attempt_limit_reached",
+  "source_access_required",
+  "source_read_failed",
+  "no_current_release"
+]);
+function hostedRefusalRecovery(code) {
+  if (!Object.hasOwn(fixes, code)) {
+    return null;
+  }
+  if (retried.has(code)) {
+    return "retry";
+  }
+  return escalated.has(code) ? "escalate" : "fix_input";
+}
 
 // ../schemas/src/draft-hosted-job-description.ts
-import { z as z52 } from "zod";
+import { z as z55 } from "zod";
 
 // ../schemas/src/draft-hosted-output-guides.ts
-import { z as z51 } from "zod";
-var id7 = z51.string().min(1).max(200);
-var located = z51.strictObject({
-  text: z51.string().min(1).max(262144),
-  locator: z51.string().min(1).max(4096)
+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)
 });
 var hostedOutputGuideLimits = { maxOutputs: 8, maxContext: 8, maxChecks: 64 };
-var HostedOutputGuideSchema = z51.strictObject({
-  id: id7,
+var HostedOutputGuideSchema = z54.strictObject({
+  id: id8,
   what: located,
-  maxCharacters: z51.number().int().min(1),
-  context: z51.array(located.extend({ id: id7 })).max(hostedOutputGuideLimits.maxContext).optional(),
-  checks: z51.array(z51.strictObject({
-    check: id7,
-    rule: z51.string().nullable(),
-    must: z51.string().min(1).max(8e3)
+  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)
   })).max(hostedOutputGuideLimits.maxChecks)
 });
-var HostedOutputGuidesSchema = z51.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
+var HostedOutputGuidesSchema = z54.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
 
 // ../schemas/src/draft-hosted-job-description.ts
-var id8 = z52.string().min(1).max(200);
+var id9 = z55.string().min(1).max(200);
 var digest24 = DraftApplicationReleaseSchema.shape.releaseDigest;
 var { requirements, rules } = DraftRequiredProposalSchema.shape;
-var quotedText = z52.strictObject({
-  text: z52.string().min(1).max(262144),
+var quotedText = z55.strictObject({
+  text: z55.string().min(1).max(262144),
   source: DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
-    locator: z52.string().min(1).max(4096),
+    locator: z55.string().min(1).max(4096),
     contentDigest: digest24
   }),
-  parts: z52.array(z52.strictObject({ locator: z52.string().min(1).max(4096), text: z52.string() })).max(16)
+  parts: z55.array(z55.strictObject({ locator: z55.string().min(1).max(4096), text: z55.string() })).max(16)
 });
 var subjectShape = {
-  identifier: z52.string().min(1).max(200),
-  example: z52.string().min(1).max(200),
-  match: z52.enum(subjectMatchRules)
+  identifier: z55.string().min(1).max(200),
+  example: z55.string().min(1).max(200),
+  match: z55.enum(subjectMatchRules)
 };
-var HostedJobSubjectSchema = z52.strictObject({
-  type: id8,
+var HostedJobSubjectSchema = z55.strictObject({
+  type: id9,
   definition: quotedText,
   identifier: subjectShape.identifier.optional(),
   example: subjectShape.example.optional(),
   match: subjectShape.match,
-  related: z52.array(z52.strictObject({
-    relationship: id8,
+  related: z55.array(z55.strictObject({
+    relationship: id9,
     meaning: quotedText,
-    cardinality: z52.enum(relationshipCardinalities),
-    required: z52.boolean(),
-    subject: id8,
+    cardinality: z55.enum(relationshipCardinalities),
+    required: z55.boolean(),
+    subject: id9,
     definition: quotedText,
     ...subjectShape
   })).max(16),
-  send: z52.string().min(1).max(2e4)
+  send: z55.string().min(1).max(2e4)
 });
-var HostedJobEscalationsSchema = z52.strictObject({
-  routes: z52.array(z52.strictObject({ id: id8, quote: quotedText })).min(1).max(16),
-  unresolved: id8.nullable(),
-  attemptLimit: id8.nullable(),
-  rule: z52.string().min(1).max(1e3)
+var 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 HostedEscalationSchema = z52.strictObject({
-  id: id8,
-  trigger: z52.enum(escalationTriggers),
+var HostedEscalationSchema = z55.strictObject({
+  id: id9,
+  trigger: z55.enum(escalationTriggers),
   why: quotedText
 });
-var HostedJobDescriptionSchema = z52.strictObject({
-  schema: z52.literal("felspar.hosted-job-description.draft/v0"),
-  job: id8,
+var HostedJobDescriptionSchema = z55.strictObject({
+  schema: z55.literal("felspar.hosted-job-description.draft/v0"),
+  job: id9,
   purpose: quotedText.optional(),
-  useWhen: z52.array(quotedText).max(8).optional(),
-  notFor: z52.array(quotedText).max(8).optional(),
+  useWhen: z55.array(quotedText).max(8).optional(),
+  notFor: z55.array(quotedText).max(8).optional(),
   owner: quotedText.optional(),
   subject: HostedJobSubjectSchema.optional(),
-  identity: z52.strictObject({
-    mode: z52.enum(identityModes),
-    send: z52.string().min(1).max(4e3),
-    fields: z52.array(z52.strictObject({ name: id8, ...subjectShape })).max(8).optional(),
-    question: id8.optional()
+  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()
   }).optional(),
-  trustDomain: id8,
-  release: z52.strictObject({
-    releaseId: id8,
+  trustDomain: id9,
+  release: z55.strictObject({
+    releaseId: id9,
     releaseDigest: digest24,
     materialDigest: digest24,
     expectedAuthorityDigest: digest24
   }),
   resolutionPolicy: DraftRequiredProposalSchema.shape.resolutionPolicy,
-  questions: z52.array(requirements.element.extend({
-    key: id8,
-    type: z52.enum(["enum", "boolean", "number", "date"]),
+  questions: z55.array(requirements.element.extend({
+    key: id9,
+    type: z55.enum(["enum", "boolean", "number", "date"]),
     meaning: quotedText,
-    answer: z52.strictObject({
-      send: z52.enum(["text", "text_or_value"]),
-      valueFormat: z52.enum(["number", "calendar-date"]).nullable(),
-      interpretation: z52.enum(["classified", "exact_read", "unsupported"]),
-      threshold: z52.number().gt(0).max(1).nullable(),
-      applies: z52.enum(["always", "conditional"]),
-      dependsOn: z52.array(id8).max(32),
-      appliesWhen: z52.string().min(1).max(2e3).nullable(),
+    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(),
       reading: ExactReaderSchema.optional()
     }),
-    answers: z52.array(z52.strictObject({
-      value: id8,
-      meaning: z52.string().nullable(),
-      inclusions: z52.array(z52.string()).max(8),
-      exclusions: z52.array(z52.string()).max(8),
-      examples: z52.array(z52.string()).max(8),
-      edgeCases: z52.array(z52.string()).max(8)
+    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)
     })).max(64).optional(),
-    whereToLook: z52.array(quotedText).max(8).optional(),
-    about: z52.strictObject({ relationship: id8, subject: id8 }).optional()
+    whereToLook: z55.array(quotedText).max(8).optional(),
+    about: z55.strictObject({ relationship: id9, subject: id9 }).optional()
   })).max(64),
-  rules: z52.array(rules.element.extend({ text: quotedText })).max(256),
-  outcomes: z52.array(z52.strictObject({
-    id: id8,
+  rules: z55.array(rules.element.extend({ text: quotedText })).max(256),
+  outcomes: z55.array(z55.strictObject({
+    id: id9,
     meaning: quotedText.nullable(),
     nextStep: quotedText.nullable().optional(),
     outputs: HostedOutputGuidesSchema.optional(),
-    escalate: id8.optional()
+    escalate: id9.optional()
   })).max(64),
   escalations: HostedJobEscalationsSchema.optional(),
   whenUnresolved: quotedText.nullable().optional(),
-  attempts: z52.strictObject({
-    max: z52.number().int().min(1).max(10),
-    withProgress: z52.number().int().min(1).max(10),
-    rule: z52.string().min(1).max(1e3)
+  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)
   }).optional(),
-  guidance: z52.strictObject({ gather: z52.string().min(1).max(2e3) }),
-  input: z52.strictObject({
-    jsonSchema: z52.record(z52.string(), z52.unknown()),
+  guidance: z55.strictObject({ gather: z55.string().min(1).max(2e3) }),
+  input: z55.strictObject({
+    jsonSchema: z55.record(z55.string(), z55.unknown()),
     example: HostedFactsJobInputSchema.nullable(),
-    exampleNote: z52.string().max(1e3)
+    exampleNote: z55.string().max(1e3)
   }),
-  limits: z52.strictObject({
-    maxEvidenceItems: z52.number().int().positive(),
-    maxPassages: z52.number().int().positive(),
-    facts: z52.strictObject({
-      maxExcerptCharacters: z52.literal(hostedFactsLimits.maxExcerptCharacters),
-      maxExcerptsPerQuestion: z52.literal(hostedFactsLimits.maxExcerptsPerQuestion),
-      maxFactsBytes: z52.literal(hostedFactsLimits.maxFactsBytes),
-      maxQuestions: z52.literal(hostedFactsLimits.maxQuestions)
+  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)
     })
   })
 });
-var interpretedExcerpt = z52.strictObject({
-  id: id8,
-  method: z52.enum(["value", "exact_read", "classified"]),
-  status: z52.enum(["accepted", "needs_evidence", "not_needed"]),
-  value: z52.union([z52.string(), z52.number(), z52.boolean()]).optional(),
-  reasons: z52.array(z52.string()),
-  classification: z52.strictObject({
-    candidate: z52.string().nullable(),
-    probability: z52.number().min(0).max(1).nullable(),
-    abstention: z52.number().min(0).max(1).nullable(),
-    threshold: z52.number().min(0).max(1),
-    alternatives: z52.array(z52.strictObject({ value: z52.string(), probability: z52.number() }))
+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() }))
   }).optional()
 });
-var ruleSummary = z52.strictObject({ id: id8, outcome: id8, text: quotedText });
-var HostedJobExplanationSchema = z52.strictObject({
-  schema: z52.literal("felspar.hosted-job-explanation.draft/v0"),
-  decision: z52.strictObject({ status: z52.string().nullable(), reasons: z52.array(z52.string()) }),
-  needs: z52.array(z52.strictObject({
-    key: id8,
-    status: z52.string(),
-    reasons: z52.array(z52.string()),
-    acceptedSourceClasses: z52.array(z52.string()),
-    maxAgeMs: z52.number().int().nonnegative(),
+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(),
     requiredWhen: HostedJobDescriptionSchema.shape.questions.element.shape.requiredWhen,
-    excerpts: z52.array(interpretedExcerpt).optional()
+    excerpts: z55.array(interpretedExcerpt).optional()
   })),
-  why: z52.strictObject({
-    rules: z52.array(ruleSummary),
-    overrides: z52.array(z52.strictObject({ by: id8, target: id8 })),
-    suppressedRuleIds: z52.array(id8),
-    evidence: z52.array(z52.record(z52.string(), z52.unknown()))
+  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()))
   }).nullable(),
-  context: z52.strictObject({ status: z52.string(), reason: z52.string().nullable() }).nullable(),
-  reviewNeeds: z52.array(z52.string()),
-  evidenceFreshUntil: z52.iso.datetime().nullable()
+  context: z55.strictObject({ status: z55.string(), reason: z55.string().nullable() }).nullable(),
+  reviewNeeds: z55.array(z55.string()),
+  evidenceFreshUntil: z55.iso.datetime().nullable()
 });
-var HostedReceiptVerificationInputSchema = z52.strictObject({
+var HostedReceiptVerificationInputSchema = z55.strictObject({
   receipt: DraftJobReceiptSchema,
   expectedReceiptDigest: digest24,
   deliveredCapsule: DraftContextVerificationOptionsSchema.shape.deliveredCapsule
 });
-var HostedReceiptVerificationSchema = z52.strictObject({
-  authority: z52.literal("unapproved"),
-  status: z52.enum(["reproduced", "mismatch"]),
-  mismatches: z52.array(z52.string()),
-  decided: z52.strictObject({
-    jobId: id8,
-    entityId: id8,
-    releaseId: id8,
-    outcome: id8.nullable(),
-    case: z52.strictObject({ id: id8, mode: z52.enum(identityModes) }).optional(),
-    subject: z52.strictObject({
-      type: id8,
-      related: z52.array(z52.strictObject({ relationship: id8, subject: id8, id: id8, questions: z52.array(id8).max(64) })).max(256)
+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)
     }).optional(),
     escalation: HostedEscalationSchema.omit({ why: true }).optional()
   }).optional()
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-import { z as z55 } from "zod";
+import { z as z58 } from "zod";
 
 // ../schemas/src/draft-artifact-lint.ts
-import { z as z54 } from "zod";
+import { z as z57 } from "zod";
 
 // ../schemas/src/draft-job-obligations.ts
-import { z as z53 } from "zod";
-var id9 = DraftApplicationScopeSchema.shape.authorityId;
+import { z as z56 } from "zod";
+var id10 = DraftApplicationScopeSchema.shape.authorityId;
 var digest25 = DraftJobReceiptSchema.shape.receiptDigest;
 var outcome2 = DraftJobObligationsOutcomeSchema;
 var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.extend({
-  schema: z53.literal("felspar.application-job-material.draft/v3"),
+  schema: z56.literal("felspar.application-job-material.draft/v3"),
   obligations: DraftJobObligationsSchema
 }).superRefine((value, context3) => {
   if (context3.issues.length > 0) {
@@ -4834,57 +5086,57 @@ var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.ex
   }
 });
 var HostedProposalInputV3Schema = HostedProposalInputV2Schema.extend({
-  schema: z53.literal("felspar.hosted-proposal.draft/v3"),
+  schema: z56.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 = z53.strictObject({
-  authority: z53.literal("unapproved"),
-  discovery: z53.record(z53.string(), z53.unknown()),
-  executed: z53.record(z53.string(), z53.unknown()),
+var DraftJobObligationsNativeResultSchema = z56.strictObject({
+  authority: z56.literal("unapproved"),
+  discovery: z56.record(z56.string(), z56.unknown()),
+  executed: z56.record(z56.string(), z56.unknown()),
   receipt: DraftJobReceiptSchema
 });
-var DraftJobObligationsInputSchema = z53.strictObject({
+var DraftJobObligationsInputSchema = z56.strictObject({
   release: DraftApplicationReleaseSchema,
-  material: z53.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
+  material: z56.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
   execution: DraftJobObligationsExecutionSchema,
   expectedReceiptDigest: digest25,
   job: DraftJobObligationsNativeResultSchema,
   explanation: HostedJobExplanationSchema,
-  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id9 })
+  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id10 })
 });
-var requirements2 = z53.strictObject({
-  status: z53.enum(["established", "unresolved"]),
+var requirements2 = z56.strictObject({
+  status: z56.enum(["established", "unresolved"]),
   scope: DraftJobObligationsScopeSchema,
   artifacts: outcome2.shape.artifacts,
   approvals: outcome2.shape.approvals,
-  unresolved: z53.array(z53.strictObject({ scopeRef: id9, reasonCodes: z53.array(id9).min(1).max(64) })).max(64)
+  unresolved: z56.array(z56.strictObject({ scopeRef: id10, reasonCodes: z56.array(id10).min(1).max(64) })).max(64)
 });
-var nextReference = z53.discriminatedUnion("kind", [
-  z53.strictObject({ kind: z53.literal("evidence_need"), id: id9 }),
-  z53.strictObject({ kind: z53.literal("artifact_requirement"), id: id9 }),
-  z53.strictObject({ kind: z53.literal("approval_requirement"), id: id9 }),
-  z53.strictObject({ kind: z53.literal("unresolved_scope"), scopeRef: id9 })
+var 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 DraftJobObligationsAssessmentBodySchema = z53.strictObject({
-  schema: z53.literal("felspar.job-obligations-assessment.draft/v0"),
-  binding: z53.strictObject({
+var DraftJobObligationsAssessmentBodySchema = z56.strictObject({
+  schema: z56.literal("felspar.job-obligations-assessment.draft/v0"),
+  binding: z56.strictObject({
     releaseDigest: digest25,
     materialDigest: digest25,
     nativeReceiptDigest: digest25,
-    jobId: id9,
+    jobId: id10,
     applicationScope: DraftApplicationScopeSchema,
-    caseId: id9,
-    entityId: id9,
-    evaluationTime: z53.iso.datetime({ offset: true }),
-    purposeRef: id9,
-    useRef: id9.nullable()
+    caseId: id10,
+    entityId: id10,
+    evaluationTime: z56.iso.datetime({ offset: true }),
+    purposeRef: id10,
+    useRef: id10.nullable()
   }),
   requirements: requirements2,
-  next: z53.strictObject({
-    kind: z53.enum([
+  next: z56.strictObject({
+    kind: z56.enum([
       "stop",
       "review_required",
       "gather_evidence",
@@ -4892,8 +5144,8 @@ var DraftJobObligationsAssessmentBodySchema = z53.strictObject({
       "verify_before_action",
       "return_result"
     ]),
-    reasonCodes: z53.array(id9).max(64),
-    refs: z53.array(nextReference).max(64)
+    reasonCodes: z56.array(id10).max(64),
+    refs: z56.array(nextReference).max(64)
   })
 });
 function isNextRefDeclared(ref, required) {
@@ -4930,48 +5182,48 @@ var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchem
 });
 
 // ../schemas/src/draft-artifact-lint.ts
-var id10 = DraftApplicationScopeSchema.shape.authorityId;
+var id11 = DraftApplicationScopeSchema.shape.authorityId;
 var digest26 = DraftJobReceiptSchema.shape.receiptDigest;
 var passage3 = ArtifactSpecificationSchema;
-var plainArtifact = z54.strictObject({
-  id: id10,
-  revision: id10,
-  mediaType: z54.literal("text/plain"),
-  exportProfile: id10.nullable(),
-  content: z54.string().max(artifactLintLimits.maxTotalBytes),
+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 = z54.strictObject({
-  id: id10,
-  revision: id10,
-  mediaType: z54.literal("application/vnd.felspar.structured-output+json"),
-  exportProfile: id10.nullable(),
+var structuredArtifact = z57.strictObject({
+  id: id11,
+  revision: id11,
+  mediaType: z57.literal("application/vnd.felspar.structured-output+json"),
+  exportProfile: id11.nullable(),
   content: DraftStructuredOutputSchema,
   expectedContentDigest: digest26
 });
-var ArtifactLintArtifactSchema = z54.discriminatedUnion("mediaType", [
+var ArtifactLintArtifactSchema = z57.discriminatedUnion("mediaType", [
   plainArtifact,
   structuredArtifact
 ]);
-var ArtifactLintDecisionSchema = z54.strictObject({
+var ArtifactLintDecisionSchema = z57.strictObject({
   inputs: DraftJobObligationsInputSchema,
   assessment: DraftJobObligationsAssessmentSchema,
   expectedAssessmentDigest: digest26
 });
-var ArtifactLintInputSchema = z54.strictObject({
-  schema: z54.literal("felspar.lint.draft/v1"),
-  requestId: id10,
+var ArtifactLintInputSchema = z57.strictObject({
+  schema: z57.literal("felspar.lint.draft/v1"),
+  requestId: id11,
   release: DraftApplicationReleaseSchema,
   material: DraftApplicationJobMaterialV3Schema,
   manifest: ArtifactCheckManifestSchema,
   expectedManifestDigest: digest26,
-  attachedObligations: z54.strictObject({ expectedObligationsDigest: digest26 }).optional(),
-  attachedCase: z54.strictObject({
+  attachedObligations: z57.strictObject({ expectedObligationsDigest: digest26 }).optional(),
+  attachedCase: z57.strictObject({
     decisionReceiptDigest: digest26,
-    answers: z54.array(z54.strictObject({ key: id10, value: z54.union([z54.string().min(1).max(200), z54.null()]) })).max(256)
+    answers: z57.array(z57.strictObject({ key: id11, value: z57.union([z57.string().min(1).max(200), z57.null()]) })).max(256)
   }).optional(),
-  case: z54.strictObject({ caseId: id10, purposeRef: id10, useRef: id10.nullable() }),
-  artifactRequirementId: id10.nullable(),
+  case: z57.strictObject({ caseId: id11, purposeRef: id11, useRef: id11.nullable() }),
+  artifactRequirementId: id11.nullable(),
   decision: ArtifactLintDecisionSchema.nullable(),
   artifact: ArtifactLintArtifactSchema
 });
@@ -4984,11 +5236,11 @@ var artifactCheckStatuses = [
   "not_applicable",
   "skipped"
 ];
-var range = z54.strictObject({
-  sectionId: id10,
-  start: z54.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
-  end: z54.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
-  offsetUnit: z54.literal("utf16_code_units")
+var 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 findingCodes = [
   "section_missing",
@@ -5016,148 +5268,148 @@ var findingCodes = [
   "evaluation_budget_exceeded",
   "evaluation_skipped"
 ];
-var ArtifactFindingSchema = z54.strictObject({
-  code: z54.enum(findingCodes),
-  checkId: id10.nullable(),
-  severity: z54.enum(["error", "warning"]),
+var ArtifactFindingSchema = z57.strictObject({
+  code: z57.enum(findingCodes),
+  checkId: id11.nullable(),
+  severity: z57.enum(["error", "warning"]),
   specification: passage3.nullable(),
   location: range.nullable(),
-  insertionAnchor: z54.strictObject({ sectionId: id10.nullable(), at: z54.number().int().min(0) }).nullable(),
-  literalIndex: z54.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
-});
-var ArtifactCheckObservationSchema = z54.strictObject({
-  checkId: id10,
-  kind: z54.enum(artifactCheckKinds),
-  required: z54.boolean(),
-  method: z54.enum(["deterministic", "semantic"]),
-  status: z54.enum(artifactCheckStatuses),
-  occurrences: z54.number().int().min(0),
-  parsedValue: z54.number().nullable(),
-  caseValue: z54.number().nullable()
-});
-var ArtifactLintRecordBodySchema = z54.strictObject({
-  schema: z54.literal("felspar.lint-record.draft/v1"),
-  requestId: id10,
-  status: z54.enum(["pass", "revise", "unavailable", "review_required"]),
-  caseContext: z54.enum(["bound", "not_required"]),
-  binding: z54.strictObject({
+  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({
     scope: DraftApplicationScopeSchema,
-    releaseId: id10,
+    releaseId: id11,
     releaseDigest: digest26,
     materialDigest: digest26,
     obligationsDigest: digest26.optional(),
     caseFactsDigest: digest26.optional(),
-    jobId: id10,
-    manifestId: id10,
+    jobId: id11,
+    manifestId: id11,
     manifestDigest: digest26,
-    contract: z54.strictObject({ id: id10, digest: digest26 }),
-    caseId: id10,
-    purposeRef: id10,
-    useRef: id10.nullable(),
-    artifactRequirementId: id10.nullable(),
+    contract: z57.strictObject({ id: id11, digest: digest26 }),
+    caseId: id11,
+    purposeRef: id11,
+    useRef: id11.nullable(),
+    artifactRequirementId: id11.nullable(),
     decisionReceiptDigest: digest26.nullable(),
     obligationsAssessmentDigest: digest26.nullable()
   }),
-  artifact: z54.strictObject({
-    id: id10,
-    revision: id10,
-    mediaType: z54.enum(artifactLintMediaTypes),
-    exportProfile: id10.nullable(),
+  artifact: z57.strictObject({
+    id: id11,
+    revision: id11,
+    mediaType: z57.enum(artifactLintMediaTypes),
+    exportProfile: id11.nullable(),
     contentDigest: digest26,
-    sections: z54.array(z54.strictObject({
-      id: id10,
-      units: z54.number().int().min(0),
+    sections: z57.array(z57.strictObject({
+      id: id11,
+      units: z57.number().int().min(0),
       contentDigest: digest26.nullable()
     })).max(artifactLintLimits.maxSections)
   }),
-  checks: z54.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
-  findings: z54.array(ArtifactFindingSchema).max(2048),
+  checks: z57.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
+  findings: z57.array(ArtifactFindingSchema).max(2048),
   semantic: ArtifactSemanticRecordSchema.nullable(),
-  coverage: z54.strictObject({
-    scope: z54.literal("declared_checks_only"),
-    declared: z54.number().int().min(0),
-    applicable: z54.number().int().min(0),
-    completed: z54.number().int().min(0),
-    required: z54.number().int().min(0),
-    requiredCompleted: z54.number().int().min(0),
-    textAssigned: z54.enum(["complete", "incomplete"]),
-    semantic: z54.enum(["not_declared", "complete", "incomplete"]),
-    nativeDocumentLayout: z54.literal("not_checked")
+  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")
   }),
-  actionAuthorized: z54.literal(false)
+  actionAuthorized: z57.literal(false)
 });
 var ArtifactLintRecordSchema = ArtifactLintRecordBodySchema.extend({
   recordDigest: digest26
 });
-var ArtifactLintReceiptSchema = z54.strictObject({
-  schema: z54.literal("felspar.lint-receipt.draft/v1"),
+var ArtifactLintReceiptSchema = z57.strictObject({
+  schema: z57.literal("felspar.lint-receipt.draft/v1"),
   recordDigest: digest26,
   releaseDigest: digest26,
   manifestDigest: digest26,
   contractDigest: digest26,
-  caseId: id10,
-  caseContext: z54.enum(["bound", "not_required"]),
+  caseId: id11,
+  caseContext: z57.enum(["bound", "not_required"]),
   decisionReceiptDigest: digest26.nullable(),
   obligationsAssessmentDigest: digest26.nullable(),
-  artifactId: id10,
-  artifactRevision: id10,
+  artifactId: id11,
+  artifactRevision: id11,
   artifactDigest: digest26,
-  actionAuthorized: z54.literal(false),
+  actionAuthorized: z57.literal(false),
   receiptDigest: digest26
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-var id11 = DraftApplicationScopeSchema.shape.authorityId;
+var id12 = DraftApplicationScopeSchema.shape.authorityId;
 var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
-var HostedOutputCheckInputSchema = z55.strictObject({
-  executionId: id11,
-  output: id11.optional(),
-  text: z55.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
-  revision: id11.optional()
-});
-var HostedOutputCheckRecordSchema = z55.strictObject({
-  schema: z55.literal("felspar.hosted-output-check/v0"),
-  checkId: id11,
-  jobId: id11,
-  output: id11,
-  decision: z55.strictObject({ executionId: id11, outcome: id11, receiptDigest: digest27 }),
-  release: z55.strictObject({ releaseId: id11, releaseDigest: digest27 }),
+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 }),
   record: ArtifactLintRecordSchema,
   receipt: ArtifactLintReceiptSchema.nullable(),
-  evaluation: z55.strictObject({
-    modelCalls: z55.number().int().min(0),
-    reason: z55.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
+  evaluation: z58.strictObject({
+    modelCalls: z58.number().int().min(0),
+    reason: z58.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
   })
 });
 
 // src/draft-hosted-client.ts
-import { z as z56 } from "zod";
-var digestText = z56.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var HostedOutputCheckReplySchema = z56.object({
-  status: z56.enum(["pass", "revise", "review_required", "unavailable"]),
-  checkId: z56.string(),
-  output: z56.string(),
-  findings: z56.array(z56.record(z56.string(), z56.unknown())),
-  receipt: z56.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
-  decision: z56.object({ executionId: z56.string(), receiptDigest: digestText }),
-  actionAuthorized: z56.literal(false)
+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)
 }).loose();
-var quotedWords = z56.object({ text: z56.string() }).loose();
-var FelsparCaseSchema = z56.object({ id: z56.string().min(1).max(200), mode: z56.enum(identityModes) });
-var FelsparRelatedSchema = z56.object({
-  relationship: z56.string(),
-  subject: z56.string(),
-  id: z56.string(),
-  questions: z56.array(z56.string())
-});
-var FelsparResultSubjectSchema = z56.object({
-  type: z56.string(),
-  id: z56.string(),
-  related: z56.array(FelsparRelatedSchema)
-});
-var FelsparEscalationSchema = z56.object({
-  id: z56.string().min(1).max(200),
-  trigger: z56.enum(escalationTriggers),
+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),
   why: quotedWords
 });
 var FelsparJobResultSchema = HostedJobResultSchema.extend({
@@ -5165,11 +5417,11 @@ var FelsparJobResultSchema = HostedJobResultSchema.extend({
     case: FelsparCaseSchema.optional(),
     subject: FelsparResultSubjectSchema.optional(),
     escalation: FelsparEscalationSchema.optional(),
-    missing: z56.array(z56.string()).optional()
+    missing: z59.array(z59.string()).optional()
   }).nullable()
 });
-var FelsparJobListSchema = z56.object({
-  jobs: z56.array(z56.object({ id: z56.string().min(1).max(200) })).max(256)
+var FelsparJobListSchema = z59.object({
+  jobs: z59.array(z59.object({ id: z59.string().min(1).max(200) })).max(256)
 });
 var hostedPartsContentType = "application/x.felspar-content-parts";
 async function partsBody(value) {
@@ -5221,27 +5473,29 @@ ${jobId}`;
     return result;
   };
 }
-var refusalCode = z56.string().regex(/^[a-z][a-z_]{2,63}$/u);
-var fieldPath = z56.array(z56.string().max(256)).max(32);
-var refusalEscalationSchema = z56.object({
-  id: z56.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]{0,199}$/u),
-  trigger: z56.enum(escalationTriggers),
-  why: z56.object({ text: z56.string().max(2e4) })
+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 refusalSchema = z56.object({
+var refusalSchema = z59.object({
   error: refusalCode,
   path: fieldPath.optional(),
-  currentReleaseDigest: z56.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
-  retryAfterSeconds: z56.number().int().min(1).max(3600).optional(),
-  escalation: z56.unknown().optional(),
-  issues: z56.array(z56.object({ code: refusalCode, path: fieldPath })).max(64).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);
   const escalation = refusalEscalationSchema.safeParse(named).data;
   return {
     ...value,
     ...escalation !== void 0 && { escalation },
     ...fix !== null && { fix },
+    ...recovery !== null && { recovery },
     ...value.issues && {
       issues: value.issues.map((issue) => {
         const issueFix = hostedRefusalFix(issue.code);
@@ -5262,8 +5516,8 @@ var FelsparRequestError = class extends Error {
   }
 };
 async function refusalOf(response) {
-  const text7 = await response.text();
-  const parsed = refusalSchema.safeParse(text7.length <= 65536 ? JSON.parse(text7) : null);
+  const text8 = await response.text();
+  const parsed = refusalSchema.safeParse(text8.length <= 65536 ? JSON.parse(text8) : null);
   return parsed.success ? parsed.data : null;
 }
 async function requestError(response) {
@@ -5295,9 +5549,10 @@ function agentCalls(call) {
   const objectId = HostedObjectSchema.shape.id;
   return {
     listJobs: async () => await call("/v0/jobs", FelsparJobListSchema),
-    resolveJob: async (id12, value) => {
+    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(id12);
+      const releaseId = objectId.parse(id13);
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
       return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
     }
@@ -5342,16 +5597,16 @@ function createHostedFelsparClient(configuration) {
   return {
     submitSource: async (value) => await call("/v0/sources", HostedObjectSchema, HostedSourceInputSchema.parse(value)),
     submitProposal: async (value) => await call("/v0/proposals", HostedObjectSchema, HostedProposalInputSchema.parse(value)),
-    approveProposal: async (id12, value) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id12))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value)),
-    releasePack: async (id12, value) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id12))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value)),
-    loadRelease: async (id12) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id12))}`, HostedReleaseBundleSchema),
-    describeJob: async (id12, job) => await describe(objectId.parse(id12), objectId.parse(job)),
+    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)),
     ...outputCheckCalls(call),
-    executeJob: async (id12, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id12))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
+    executeJob: async (id13, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id13))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
     ...agentCalls(call),
-    resolveFacts: async (id12, value) => {
-      const releaseId = objectId.parse(id12);
+    resolveFacts: async (id13, value) => {
+      const releaseId = objectId.parse(id13);
       const input = await factsRequest(value, async (jobId) => await describe(releaseId, jobId));
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
       return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);