@felspar/sdk 0.2.1 → 0.4.0

package/dist/chunks/{chunk-XLKRU5RA.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,
@@ -535,8 +535,14 @@ function calendarDay(value) {
 // ../schemas/src/draft-evidence-scope.ts
 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);
+}
+var sourceId = z3.string().min(1).max(draftSourceIdLimit).regex(draftSourceIdPattern);
 var reference2 = z3.strictObject({
-  sourceId: identifier,
+  sourceId,
   revision: identifier,
   locator: z3.string().min(1).max(4096).regex(/\S/u),
   contentDigest: z3.string().regex(/^sha256:[a-f0-9]{64}$/u)
@@ -1267,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),
@@ -1324,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"
         });
       }
     }
@@ -1432,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) {
@@ -1455,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;
@@ -1463,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 });
     };
@@ -1473,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");
       }
     }
@@ -1513,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))) {
@@ -1526,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;
@@ -1614,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));
@@ -1655,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");
@@ -1832,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"
     });
@@ -2125,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;
@@ -2133,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;
@@ -2186,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"),
@@ -2357,7 +2378,7 @@ var DraftEvaluatorContractSchema = z24.strictObject({
   evaluator,
   calibration: z24.strictObject({ id: identifier13, version: identifier13, contentDigest: digest9 }),
   minimumSelectedProbability: z24.number().gt(0).max(1),
-  inputContextContract: z24.literal("job-entity-time/v1").optional(),
+  inputContextContract: z24.enum(["job-entity-time/v1", "job-only/v2"]).optional(),
   probabilityContract: z24.enum([
     "closed-distribution-unique-maximum/v1",
     "closed-distribution-with-abstention/v1"
@@ -2367,6 +2388,7 @@ var judgment = z24.discriminatedUnion("status", [
   z24.strictObject({
     status: z24.literal("evaluated"),
     abstentionProbability: z24.number().min(0).max(1).optional(),
+    promptInjectionProbability: z24.number().min(0).max(1).optional(),
     probabilities: z24.array(z24.strictObject({
       value: z24.string().min(1).max(200),
       probability: z24.number().min(0).max(1)
@@ -2403,11 +2425,14 @@ var DraftNormalizedEvidenceSchema = z24.strictObject({
     evaluatorContractDigest: digest9,
     evaluator,
     calibrationDigest: digest9,
-    inputScope: z24.strictObject({
-      job: DraftEvidenceValidationSchema.shape.job,
-      entityId: identifier13,
-      evaluationTime: DraftEvidenceValidationSchema.shape.observationChecks.shape.evaluationTime
-    }).optional(),
+    inputScope: z24.union([
+      z24.strictObject({
+        job: DraftEvidenceValidationSchema.shape.job,
+        entityId: identifier13,
+        evaluationTime: DraftEvidenceValidationSchema.shape.observationChecks.shape.evaluationTime
+      }),
+      z24.strictObject({ job: DraftEvidenceValidationSchema.shape.job })
+    ]).optional(),
     judgment
   })).max(64)
 });
@@ -2590,11 +2615,11 @@ function readObservation(input, ref) {
   if (ref.kind === "interpreter") {
     return { path: `${path3}.interpretation`, value: observation2.interpretation };
   }
-  const { sourceId, revision, locator: locator2 } = observation2.evidence;
+  const { sourceId: sourceId2, revision, locator: locator2 } = observation2.evidence;
   return {
     path: ref.kind === "evidence" ? `${path3}.evidence` : path3,
     value: ref.kind === "evidence" ? observation2.evidence : observation2,
-    source: { sourceId, revision, locator: locator2 }
+    source: { sourceId: sourceId2, revision, locator: locator2 }
   };
 }
 function readReference(input, ref) {
@@ -3013,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) {
@@ -3109,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;
@@ -3700,7 +3725,74 @@ 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;
+var offsetPattern = /^(?:[Zz]|([+-])(\d{2}):?(\d{2}))$/u;
+var utcYear = /^\d{4}-/u;
+var sourceInstantMaxLength = 64;
+function daysIn(year, month) {
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month, 0);
+  return date.getUTCDate();
+}
+function isCalendarValue(local) {
+  const { year, month, day } = local;
+  const isDate = month >= 1 && month <= 12 && day >= 1 && day <= daysIn(year, month);
+  return isDate && local.hour <= 23 && local.minute <= 59 && local.second <= 59;
+}
+function offsetMinutes(suffix) {
+  const match = offsetPattern.exec(suffix);
+  if (match === null) {
+    return null;
+  }
+  const [, sign, hours, minutes] = match;
+  if (sign === void 0) {
+    return 0;
+  }
+  const h = Number(hours);
+  const m = Number(minutes);
+  if (h > 23 || m > 59) {
+    return null;
+  }
+  return (sign === "-" ? -1 : 1) * (h * 60 + m);
+}
+function utcOf(local, offset) {
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(local.year, local.month - 1, local.day);
+  date.setUTCHours(local.hour, local.minute - offset, local.second, 0);
+  const utc = date.toISOString();
+  return utcYear.test(utc) ? utc.slice(0, 19) : null;
+}
+function normalizedSourceInstant(value) {
+  if (value.length > sourceInstantMaxLength) {
+    return null;
+  }
+  const match = localPattern.exec(value);
+  if (match === null) {
+    return null;
+  }
+  const [, year, month, day, hour, minute, second, fraction, suffix] = match;
+  const local = {
+    year: Number(year),
+    month: Number(month),
+    day: Number(day),
+    hour: Number(hour),
+    minute: Number(minute),
+    second: Number(second ?? "0")
+  };
+  const offset = offsetMinutes(suffix ?? "");
+  if (offset === null || !isCalendarValue(local)) {
+    return null;
+  }
+  const utc = utcOf(local, offset);
+  if (utc === null) {
+    return null;
+  }
+  const digits = fraction === void 0 ? "" : `.${fraction.slice(0, 3)}`;
+  return `${utc}${digits}Z`;
+}
 
 // ../schemas/src/draft-hosted-output-checks.ts
 import { z as z49 } from "zod";
@@ -3852,11 +3944,11 @@ var recipe = DraftClaimEvaluationRecipeSchema.shape;
 var recipeQuestion = recipe.questions.element.shape;
 var { judgment: judgment4 } = DraftNormalizedEvidenceSchema.shape.normalizations.element.shape;
 var artifactSemanticLimits = {
-  maxQuestions: 8,
+  maxQuestions: 24,
   maxUnits: 64,
-  maxEvaluations: 128,
+  maxEvaluations: 24 * 64,
   maxRequestBytes: 32768,
-  maxTotalBytes: 1048576
+  maxTotalBytes: 16777216
 };
 var ArtifactSemanticQuestionSchema = z46.strictObject({
   id: id3,
@@ -4291,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)
 });
@@ -4354,107 +4630,111 @@ var hostedFactsLimits = {
   maxFactsBytes: 524288,
   maxQuestions: 64
 };
-var factSource = z50.strictObject({
-  class: id6,
-  id: DraftSourceReferenceSchema.shape.sourceId,
-  revision: id6.optional(),
-  locator: z50.string().min(1).max(4096).optional(),
-  observedAt: DraftObservationChecksSchema.shape.evaluationTime,
-  sensitivity: id6.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 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: id7.optional(),
+  locator: z53.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 = 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()
 });
 
 // ../schemas/src/draft-hosted-refusals.ts
 var limits = hostedFactsLimits;
-var formatFix = "The request does not match the facts request format at this path; follow input.jsonSchema from describe.";
+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 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.",
@@ -4464,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.",
@@ -4483,15 +4764,47 @@ var fixes = {
   rate_limited: "This caller or workspace sent more decision requests in the last minute than its plan allows. Wait retryAfterSeconds, then resend the same request with the same execution ID. Send every question you have evidence for in one facts request per entity instead of one request per question, and spread a large run over time; for runs of thousands of entities, ask Felspar about batch scoring.",
   execution_id_reused: "This execution ID was already used for a different request. Use a new execution ID, or resend the original request unchanged.",
   invalid_body: "The body must be JSON or content parts within the size limit.",
+  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,
@@ -4500,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) {
@@ -4752,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",
@@ -4810,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) {
@@ -4848,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
 });
@@ -4902,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",
@@ -4934,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({
@@ -5083,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) {
@@ -5139,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);
@@ -5180,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) {
@@ -5213,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);
     }
@@ -5260,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);