@felspar/sdk 0.2.0 → 0.2.1

package/dist/chunks/{chunk-IY6A2423.js → chunk-Y6KRRIQI.js}

@@ -1,119 +1,6 @@
 import {
   createHostedFelsparClient
-} from "./chunk-HACK7D24.js";
-
-// src/draft-action-gate-cases.ts
-var emailRecipientFields = ["to", "cc", "bcc", "replyTo", "reply_to"];
-var emailSubjectFields = ["subject"];
-var foldCase = (text2) => text2.replaceAll(/[A-Z]/gu, (letter) => letter.toLowerCase());
-var caseKeyOf = (rule) => rule.entity === void 0 ? foldCase : (id) => id.trim();
-var sameField = (names) => {
-  const lower = new Set(names.map((name) => name.toLowerCase()));
-  return (field) => lower.has(field.toLowerCase());
-};
-function fieldValues(input, names) {
-  const isWanted = sameField(names);
-  const values = [];
-  const unreadable = [];
-  for (const [field, value] of Object.entries(input)) {
-    if (!isWanted(field)) {
-      continue;
-    }
-    for (const item of [value].flat()) {
-      if (typeof item === "string") {
-        values.push(item.trim());
-      } else if (item !== void 0 && item !== null) {
-        unreadable.push(field);
-      }
-    }
-  }
-  return { values, unreadable };
-}
-var isAscii = (text2) => /^[!-~]+$/u.test(text2);
-var plainAddress = /^[a-z0-9._+-]+@([a-z0-9-]+(?:\.[a-z0-9-]+)+)$/u;
-var isUnder = (domain, entity) => domain === entity || domain.endsWith(`.${entity}`);
-function domainsIn(text2, entities) {
-  return entities.filter((entity) => {
-    const escaped = entity.replaceAll(".", String.raw`\.`);
-    const whole = new RegExp(`(?:^|[^a-z0-9.-])${escaped}(?:$|[^a-z0-9-])`, "u");
-    return whole.test(text2);
-  });
-}
-function offTestList(recipients, rules) {
-  const listed = new Set((rules.testRecipients ?? []).map((address) => address.trim().toLowerCase()));
-  const outside = recipients.filter((address) => !listed.has(address));
-  return outside.length > 0 ? `recipient not on the test list: ${outside.join(", ")}` : null;
-}
-function testCompany(recipients, subject, scope) {
-  const outside = offTestList(recipients, scope.rules);
-  if (outside !== null) {
-    return { reason: outside };
-  }
-  const named = domainsIn(subject.toLowerCase(), scope.entities);
-  return named.length === 1 ? { company: named[0] } : { reason: `the subject names ${named.length} decided companies, not one` };
-}
-function recipientCompany(recipients, entities) {
-  const companies = /* @__PURE__ */ new Set();
-  for (const address of recipients) {
-    const domain = plainAddress.exec(address)?.[1] ?? "";
-    const owners = entities.filter((entity) => isUnder(domain, entity));
-    if (owners.length === 0) {
-      return { reason: `${address} is not at a company Felspar decided on`, missing: true };
-    }
-    for (const owner of owners) {
-      companies.add(owner);
-    }
-  }
-  return companies.size === 1 ? { company: [...companies][0] } : { reason: "the recipients belong to more than one company" };
-}
-function recipientsOf(scope, input) {
-  const { rules, rule } = scope;
-  const recipientFields = rule.recipientFields ?? rules.recipientFields ?? emailRecipientFields;
-  const recipients = fieldValues(input, recipientFields);
-  if (recipients.unreadable.length > 0) {
-    return { reason: `${recipients.unreadable.join(", ")} holds a value that is not an address` };
-  }
-  const malformed = recipients.values.find((address) => !isAscii(address) || !plainAddress.test(address.toLowerCase()));
-  return malformed === void 0 ? { addresses: recipients.values.map((address) => address.toLowerCase()) } : { reason: `"${malformed}" is not one plain address` };
-}
-function companyFor(scope, input) {
-  const { rules, rule } = scope;
-  const { addresses, reason } = recipientsOf(scope, input);
-  if (addresses === void 0) {
-    return { reason };
-  }
-  if (addresses.length === 0) {
-    return { reason: "the call has no recipients" };
-  }
-  if (rules.testRecipients === void 0) {
-    return recipientCompany(addresses, scope.entities);
-  }
-  const subjectFields = rule.subjectFields ?? rules.subjectFields ?? emailSubjectFields;
-  const subject = fieldValues(input, subjectFields).values.join("\n");
-  return testCompany(addresses, subject, scope);
-}
-function fieldEntity(scope, field, input) {
-  const { values, unreadable } = fieldValues(input, [field]);
-  if (unreadable.length > 0 || values.length !== 1) {
-    return { reason: `the call must set ${field} to exactly one ID` };
-  }
-  const [value = ""] = values;
-  if (value.length === 0) {
-    return { reason: `the call's ${field} is empty` };
-  }
-  if (scope.rules.testRecipients !== void 0) {
-    const { addresses, reason } = recipientsOf(scope, input);
-    const outside = addresses === void 0 ? reason : offTestList(addresses, scope.rules);
-    if (outside !== null) {
-      return { reason: outside };
-    }
-  }
-  return { company: value };
-}
-function caseFor(scope, input) {
-  const { entity } = scope.rule;
-  return entity === void 0 ? companyFor(scope, input) : fieldEntity(scope, entity.field, input);
-}
+} from "./chunk-XLKRU5RA.js";
 
 // src/draft-action-gate-outputs.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -220,6 +107,10 @@ function felsparOutputCheckVerifier(configuration) {
 }
 
 // src/draft-action-gate-decisions.ts
+var identityModes = ["provided", "fields", "content", "issued"];
+var escalationTriggers = ["outcome", "unresolved", "attempt_limit"];
+var isIdentityMode = (value) => identityModes.includes(value);
+var isEscalationTrigger = (value) => escalationTriggers.includes(value);
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function parsedJson2(text2) {
   try {
@@ -269,20 +160,51 @@ function entityIdOf(input) {
 function freshnessOf(explanation) {
   return isRecord2(explanation) && typeof explanation.evidenceFreshUntil === "string" ? explanation.evidenceFreshUntil : null;
 }
-function decisionFromResult(entity, output) {
+var isId = (value) => typeof value === "string" && value.length > 0 && value.length <= 200;
+function caseOf(result) {
+  if (!Object.hasOwn(result, "case")) {
+    return void 0;
+  }
+  const found = result.case;
+  return isRecord2(found) && isId(found.id) && isIdentityMode(found.mode) ? { id: found.id, mode: found.mode } : null;
+}
+function escalationOf(result) {
+  const found = result.escalation;
+  if (!isRecord2(found) || !isId(found.id) || !isEscalationTrigger(found.trigger)) {
+    return void 0;
+  }
+  const why = isRecord2(found.why) && typeof found.why.text === "string" ? found.why.text : "";
+  return { id: found.id, trigger: found.trigger, why };
+}
+var requestOf = (request) => typeof request === "string" ? { entity: request } : request;
+function decidedOf(result) {
+  const { receipt, outcome, executionObjectId } = result;
+  if (typeof outcome !== "string" || typeof executionObjectId !== "string" || !isRecord2(receipt)) {
+    return null;
+  }
+  const { receiptDigest } = receipt;
+  return typeof receiptDigest === "string" ? { outcome, executionObjectId, receipt: { ...receipt, receiptDigest } } : null;
+}
+function decisionFromResult(request, output) {
   const result = jobResponse(output)?.result;
-  if (!isRecord2(result) || entity.length === 0) {
+  if (!isRecord2(result)) {
     return null;
   }
-  const { receipt } = result;
-  if (typeof result.outcome !== "string" || typeof result.executionObjectId !== "string" || !isRecord2(receipt) || typeof receipt.receiptDigest !== "string") {
+  const { entity, job } = requestOf(request);
+  const found = caseOf(result);
+  const key = found === void 0 ? entity : found?.id;
+  const decided = decidedOf(result);
+  if (decided === null || found === null || key === void 0 || key.length === 0) {
     return null;
   }
+  const escalation = escalationOf(result);
   return {
-    entity,
-    outcome: result.outcome,
-    executionObjectId: result.executionObjectId,
-    receipt: { ...receipt, receiptDigest: receipt.receiptDigest },
+    entity: key,
+    ...found !== void 0 && { case: found },
+    ...job !== void 0 && { job },
+    ...isId(result.releaseId) && { releaseId: result.releaseId },
+    ...escalation !== void 0 && { escalation },
+    ...decided,
     context: result.context ?? null,
     evidenceFreshUntil: freshnessOf(result.explanation)
   };
@@ -302,8 +224,8 @@ function createDecisionRecorder(limits = {}) {
   const requested = /* @__PURE__ */ new Map();
   const decided = /* @__PURE__ */ new Map();
   const checked = /* @__PURE__ */ new Map();
-  function record(sessionId, entity, output) {
-    const decision = decisionFromResult(entity, output);
+  function record(sessionId, request, output) {
+    const decision = decisionFromResult(request, output);
     if (decision === null) {
       return null;
     }
@@ -315,14 +237,14 @@ function createDecisionRecorder(limits = {}) {
   }
   return {
     record,
-    noteRequest(callId, entity) {
-      requested.set(callId, entity);
+    noteRequest(callId, request) {
+      requested.set(callId, request);
       trim(requested, maxPending);
     },
     noteResult(sessionId, callId, output) {
-      const entity = requested.get(callId);
+      const noted = requested.get(callId);
       requested.delete(callId);
-      return entity === void 0 ? null : record(sessionId, entity, output);
+      return noted === void 0 ? null : record(sessionId, noted, output);
     },
     decisionsIn: (sessionId) => decided.get(sessionId) ?? [],
     recordOutputCheck(sessionId, jobId, output) {
@@ -379,28 +301,208 @@ async function writesProblem(describe, decided) {
   const outputs = outcomeIn(description, decided.outcome)?.outputs ?? [];
   return outputs.some((row) => row.id === decided.output) ? null : `${decided.outcome} doesn't ask for ${decided.output}`;
 }
+async function subjectOf(describe, releaseId, jobId) {
+  const { subject, identity } = await describedFor(describe, releaseId, jobId);
+  return subject === void 0 ? null : { type: subject.type, match: subject.match, mode: identity?.mode ?? "provided" };
+}
 var fixOutputCheck = "Fix what check_output flagged, check it again, then retry.";
-async function quotedStep(step, describe, jobId) {
-  if (step.releaseId === void 0) {
-    return null;
+var quotedText = (quoted) => typeof quoted?.text === "string" && quoted.text.length > 0 ? quoted.text : null;
+function escalationIdOf(step, description) {
+  if (step.kind === "unresolved") {
+    const id2 = description?.escalations?.unresolved ?? null;
+    return id2 === null ? null : { id: id2, trigger: "unresolved" };
+  }
+  if (step.replayed !== void 0) {
+    return step.replayed.trigger === "outcome" ? { id: step.replayed.id, trigger: "outcome" } : null;
   }
-  const description = await describedFor(describe, step.releaseId, jobId);
-  const quoted = step.kind === "unresolved" ? description.whenUnresolved : outcomeIn(description, step.outcome)?.nextStep;
-  return typeof quoted?.text === "string" && quoted.text.length > 0 ? quoted.text : null;
+  const id = description === null ? void 0 : outcomeIn(description, step.outcome)?.escalate;
+  return id === void 0 ? null : { id, trigger: "outcome" };
 }
-async function escalationFor(step, describe, jobId) {
-  if (step?.kind === "output-check") {
-    return fixOutputCheck;
+function escalationOf2(step, description) {
+  const named = escalationIdOf(step, description);
+  if (named === null) {
+    return null;
   }
-  if (step === void 0 || describe === void 0) {
+  const route = description?.escalations?.routes.find((row) => row.id === named.id);
+  const recorded = step.kind === "outcome" && step.recorded?.id === named.id ? step.recorded.why : null;
+  const why = quotedText(route?.quote) ?? (recorded === "" ? null : recorded);
+  return { ...named, why };
+}
+function nextStepOf(step, description) {
+  return step.kind === "unresolved" ? description.whenUnresolved : outcomeIn(description, step.outcome)?.nextStep;
+}
+async function describedStep(step, describe, jobId) {
+  if (describe === void 0 || step.releaseId === void 0) {
     return null;
   }
   try {
-    return await quotedStep(step, describe, jobId);
+    return await describedFor(describe, step.releaseId, jobId);
   } catch {
     return null;
   }
 }
+async function escalationFor(step, describe, jobId) {
+  if (step?.kind === "output-check") {
+    return { escalate: fixOutputCheck };
+  }
+  if (step === void 0) {
+    return {};
+  }
+  const description = await describedStep(step, describe, jobId);
+  const escalate = description === null ? null : quotedText(nextStepOf(step, description));
+  const escalation = escalationOf2(step, description);
+  return {
+    ...escalate !== null && { escalate },
+    ...escalation !== null && { escalation }
+  };
+}
+
+// src/draft-action-gate-cases.ts
+var emailRecipientFields = ["to", "cc", "bcc", "replyTo", "reply_to"];
+var emailSubjectFields = ["subject"];
+var foldCase = (text2) => text2.replaceAll(/[A-Z]/gu, (letter) => letter.toLowerCase());
+var sameField = (names) => {
+  const lower = new Set(names.map((name) => name.toLowerCase()));
+  return (field) => lower.has(field.toLowerCase());
+};
+function fieldValues(input, names) {
+  const isWanted = sameField(names);
+  const values = [];
+  const unreadable = [];
+  for (const [field, value] of Object.entries(input)) {
+    if (!isWanted(field)) {
+      continue;
+    }
+    for (const item of [value].flat()) {
+      if (typeof item === "string") {
+        values.push(item.trim());
+      } else if (item !== void 0 && item !== null) {
+        unreadable.push(field);
+      }
+    }
+  }
+  return { values, unreadable };
+}
+var isAscii = (text2) => /^[!-~]+$/u.test(text2);
+var plainAddress = /^[a-z0-9._+-]+@([a-z0-9-]+(?:\.[a-z0-9-]+)+)$/u;
+var isUnder = (domain, entity) => domain === entity || domain.endsWith(`.${entity}`);
+function domainsIn(text2, entities) {
+  return entities.filter((entity) => {
+    const escaped = entity.replaceAll(".", String.raw`\.`);
+    const whole = new RegExp(`(?:^|[^a-z0-9.-])${escaped}(?:$|[^a-z0-9-])`, "u");
+    return whole.test(text2);
+  });
+}
+function offTestList(recipients, rules) {
+  const listed = new Set((rules.testRecipients ?? []).map((address) => address.trim().toLowerCase()));
+  const outside = recipients.filter((address) => !listed.has(address));
+  return outside.length > 0 ? `recipient not on the test list: ${outside.join(", ")}` : null;
+}
+function testCompany(recipients, subject, scope) {
+  const outside = offTestList(recipients, scope.rules);
+  if (outside !== null) {
+    return { reason: outside };
+  }
+  const named = domainsIn(subject.toLowerCase(), scope.entities);
+  return named.length === 1 ? { company: named[0] } : { reason: `the subject names ${named.length} decided companies, not one` };
+}
+function recipientCompany(recipients, entities) {
+  const companies = /* @__PURE__ */ new Set();
+  for (const address of recipients) {
+    const domain = plainAddress.exec(address)?.[1] ?? "";
+    const owners = entities.filter((entity) => isUnder(domain, entity));
+    if (owners.length === 0) {
+      return { reason: `${address} is not at a company Felspar decided on`, missing: true };
+    }
+    for (const owner of owners) {
+      companies.add(owner);
+    }
+  }
+  return companies.size === 1 ? { company: [...companies][0] } : { reason: "the recipients belong to more than one company" };
+}
+function recipientsOf(scope, input) {
+  const { rules, rule } = scope;
+  const recipientFields = rule.recipientFields ?? rules.recipientFields ?? emailRecipientFields;
+  const recipients = fieldValues(input, recipientFields);
+  if (recipients.unreadable.length > 0) {
+    return { reason: `${recipients.unreadable.join(", ")} holds a value that is not an address` };
+  }
+  const malformed = recipients.values.find((address) => !isAscii(address) || !plainAddress.test(address.toLowerCase()));
+  return malformed === void 0 ? { addresses: recipients.values.map((address) => address.toLowerCase()) } : { reason: `"${malformed}" is not one plain address` };
+}
+function companyFor(scope, input) {
+  const { rules, rule } = scope;
+  const { addresses, reason } = recipientsOf(scope, input);
+  if (addresses === void 0) {
+    return { reason };
+  }
+  if (addresses.length === 0) {
+    return { reason: "the call has no recipients" };
+  }
+  if (rules.testRecipients === void 0) {
+    return recipientCompany(addresses, scope.entities);
+  }
+  const subjectFields = rule.subjectFields ?? rules.subjectFields ?? emailSubjectFields;
+  const subject = fieldValues(input, subjectFields).values.join("\n");
+  return testCompany(addresses, subject, scope);
+}
+function testListProblem(scope, input) {
+  if (scope.rules.testRecipients === void 0) {
+    return null;
+  }
+  const { addresses, reason } = recipientsOf({ ...scope, entities: [] }, input);
+  return addresses === void 0 ? reason : offTestList(addresses, scope.rules);
+}
+function fieldEntity(scope, field, input) {
+  const { values, unreadable } = fieldValues(input, [field]);
+  if (unreadable.length > 0 || values.length !== 1) {
+    return { reason: `the call must set ${field} to exactly one ID` };
+  }
+  const [value = ""] = values;
+  if (value.length === 0) {
+    return { reason: `the call's ${field} is empty` };
+  }
+  const outside = testListProblem(scope, input);
+  return outside === null ? { company: value } : { reason: outside };
+}
+function caseFor(scope, input) {
+  const { entity } = scope.rule;
+  return entity === void 0 ? companyFor(scope, input) : fieldEntity(scope, entity.field, input);
+}
+
+// src/draft-action-gate-rules.ts
+var isText = (value) => typeof value === "string" && value.trim().length > 0;
+function ruleProblem(rule) {
+  if (rule.outcomes === void 0 === (rule.writes === void 0)) {
+    return "this tool's rule must give exactly one of outcomes or writes";
+  }
+  const { outcomes, writes, entity } = rule;
+  if (outcomes !== void 0 && !(Array.isArray(outcomes) && outcomes.every(isText))) {
+    return "this tool's rule has unreadable outcomes";
+  }
+  if (writes !== void 0 && !isText(writes)) {
+    return "this tool's rule has an unreadable writes";
+  }
+  if (entity !== void 0 && !isText(entity.field)) {
+    return "this tool's rule has an unreadable entity field";
+  }
+  const checked = rule.outputCheck?.output;
+  return writes !== void 0 && checked !== void 0 && checked !== writes ? "this tool's output check is for a different output than it writes" : null;
+}
+function fieldProblem(refuse, rule, input) {
+  const isAllowed = sameField(rule.fields);
+  const isRefused = sameField(refuse);
+  const unknown = Object.keys(input).filter((field) => !isAllowed(field));
+  if (unknown.length > 0) {
+    return `the call sets ${unknown.join(", ")}, which this tool's rule doesn't allow`;
+  }
+  const refused = Object.keys(input).filter((field) => isRefused(field));
+  return refused.length > 0 ? `the call sets ${refused.join(", ")}` : null;
+}
+function checkRuleOf(rule) {
+  const { outputCheck, writes } = rule;
+  return outputCheck !== void 0 && writes !== void 0 && outputCheck.output === void 0 ? { ...outputCheck, output: writes } : outputCheck;
+}
 
 // src/draft-action-gate-domains.ts
 var publicSuffixes = [
@@ -512,38 +614,72 @@ function isCompanyDomain(entity, extraShared = []) {
   return domainShape.test(entity) && !builtIn.has(entity) && extraShared.every((domain) => domain.toLowerCase() !== entity);
 }
 
-// src/draft-action-gate-rules.ts
-var isText = (value) => typeof value === "string" && value.trim().length > 0;
-function ruleProblem(rule) {
-  if (rule.outcomes === void 0 === (rule.writes === void 0)) {
-    return "this tool's rule must give exactly one of outcomes or writes";
-  }
-  const { outcomes, writes, entity } = rule;
-  if (outcomes !== void 0 && !(Array.isArray(outcomes) && outcomes.every(isText))) {
-    return "this tool's rule has unreadable outcomes";
-  }
-  if (writes !== void 0 && !isText(writes)) {
-    return "this tool's rule has an unreadable writes";
+// src/draft-action-gate-subject.ts
+var trimmed = (id) => id.trim();
+var folded = (id) => foldCase(id.trim());
+function keyingFor(subject, path) {
+  const isFolded = path === "recipients" || subject?.match === "case-insensitive";
+  const key = isFolded ? folded : trimmed;
+  return { key, decisionKey: (decision) => key(decision.case?.id ?? decision.entity) };
+}
+async function subjectFor(scope, decision) {
+  if (decision === void 0) {
+    return null;
   }
-  if (entity !== void 0 && !isText(entity.field)) {
-    return "this tool's rule has an unreadable entity field";
+  const { describe } = scope;
+  const { releaseId } = decision;
+  const described = describe === void 0 || releaseId === void 0 ? null : await subjectOf(describe, releaseId, scope.rules.job);
+  const mode = decision.case?.mode ?? "provided";
+  return described === null && mode !== "provided" ? { type: "case", match: "exact", mode } : described;
+}
+var isRecipientJob = (subject) => subject === null || subject.mode === "provided" && subject.match === "case-insensitive";
+var distinct = (keys) => [...new Set(keys)];
+async function pick(scope, found) {
+  const { company, keying, subject } = found;
+  const decision = scope.decisions.filter((row) => keying.decisionKey(row) === company).at(-1);
+  if (decision === void 0) {
+    return { reason: `no decision for ${company}`, missing: true };
+  }
+  const own = await subjectFor(scope, decision);
+  return JSON.stringify(own) === JSON.stringify(subject) ? { company, decision, keying } : { reason: `${company} was decided on a release that identifies cases differently` };
+}
+async function onlyCase(scope, subject, input) {
+  const keying = keyingFor(subject, "case");
+  const keys = distinct(scope.decisions.map((row) => keying.decisionKey(row)));
+  if (keys.length !== 1) {
+    return {
+      reason: keys.length === 0 ? `no decision for this job's ${subject.type}` : `this session decided ${keys.length} ${subject.type} cases and the call doesn't say which; give the tool's rule an entity field holding the case ID`,
+      ...keys.length === 0 && { missing: true }
+    };
   }
-  const checked = rule.outputCheck?.output;
-  return writes !== void 0 && checked !== void 0 && checked !== writes ? "this tool's output check is for a different output than it writes" : null;
+  const outside = testListProblem(scope, input);
+  const [company = ""] = keys;
+  return outside === null ? await pick(scope, { company, keying, subject }) : { reason: outside };
 }
-function fieldProblem(refuse, rule, input) {
-  const isAllowed = sameField(rule.fields);
-  const isRefused = sameField(refuse);
-  const unknown = Object.keys(input).filter((field) => !isAllowed(field));
-  if (unknown.length > 0) {
-    return `the call sets ${unknown.join(", ")}, which this tool's rule doesn't allow`;
+async function selected(scope, input) {
+  const { rules, rule } = scope;
+  const subject = await subjectFor(scope, scope.decisions.at(-1));
+  if (rule.entity !== void 0) {
+    const keying2 = keyingFor(subject, "case");
+    const found2 = caseFor({ rules, rule, entities: [] }, input);
+    return found2.company === void 0 ? { reason: found2.reason ?? "no case" } : await pick(scope, { company: keying2.key(found2.company), keying: keying2, subject });
+  }
+  const keying = keyingFor(subject, "recipients");
+  const keys = distinct(scope.decisions.map((row) => keying.decisionKey(row)));
+  if (subject !== null && !isRecipientJob(subject)) {
+    return await onlyCase(scope, subject, input);
+  }
+  const entities = keys.filter((key) => isCompanyDomain(key, rules.sharedDomains));
+  const found = caseFor({ rules, rule, entities }, input);
+  return found.company === void 0 ? { reason: found.reason ?? "no case", ...found.missing === true && { missing: true } } : await pick(scope, { company: found.company, keying, subject });
+}
+async function selectCase(scope, input) {
+  const decisions = scope.decisions.filter((row) => row.job === void 0 || row.job === scope.rules.job);
+  try {
+    return await selected({ ...scope, decisions }, input);
+  } catch (error) {
+    return { reason: `Felspar's job description could not be read: ${String(error)}` };
   }
-  const refused = Object.keys(input).filter((field) => isRefused(field));
-  return refused.length > 0 ? `the call sets ${refused.join(", ")}` : null;
-}
-function checkRuleOf(rule) {
-  const { outputCheck, writes } = rule;
-  return outputCheck !== void 0 && writes !== void 0 && outputCheck.output === void 0 ? { ...outputCheck, output: writes } : outputCheck;
 }
 
 // src/draft-action-gate-verifier.ts
@@ -562,20 +698,42 @@ function felsparVerifier(configuration) {
 
 // src/draft-action-gate.ts
 function denialText(verdict) {
-  return verdict.escalate === void 0 ? verdict.reason : `${verdict.reason}. Next step: ${verdict.escalate}`;
+  const parts = [verdict.reason];
+  if (verdict.escalate !== void 0) {
+    parts.push(`Next step: ${verdict.escalate}`);
+  }
+  const { escalation } = verdict;
+  if (escalation !== void 0) {
+    const why = escalation.why === null ? "" : `: ${escalation.why}`;
+    parts.push(`Escalation ${escalation.id} (${escalation.trigger})${why}`);
+  }
+  return parts.join(". ");
 }
 function gatedRule(rules, toolName) {
   return Object.hasOwn(rules.tools, toolName) ? rules.tools[toolName] : void 0;
 }
 var isInput = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function replayProblem(scope, company, verified) {
-  const { rules } = scope;
+function caseProblem(decision, verified) {
+  const recorded = decision.case;
+  const replayed = verified.case;
+  if (recorded === void 0 && replayed === void 0) {
+    return null;
+  }
+  const isSame = recorded?.id === replayed?.id && recorded?.mode === replayed?.mode && replayed?.id === verified.entityId;
+  return isSame ? null : `the receipt is for case ${replayed?.id ?? "(none)"}, not ${recorded?.id ?? "(none)"}`;
+}
+function replayProblem(rules, found, verified) {
+  const { company, decision, keying } = found;
   if (verified.jobId !== rules.job) {
     return `the receipt is for job ${verified.jobId}, not ${rules.job}`;
   }
-  if (caseKeyOf(scope.rule)(verified.entityId) !== company) {
+  if (keying.key(verified.entityId) !== company) {
     return `the receipt is for ${verified.entityId}, not ${company}`;
   }
+  const mismatch = caseProblem(decision, verified);
+  if (mismatch !== null) {
+    return mismatch;
+  }
   const { releases } = rules;
   const isUnpinned = releases !== void 0 && !releases.includes(verified.releaseId ?? "");
   return isUnpinned ? `the receipt is for release ${verified.releaseId ?? "(none)"}, which is not allowed` : null;
@@ -587,7 +745,8 @@ function staleness(decision, now) {
   }
   return Date.parse(until) > now ? null : `the decision's evidence went stale at ${until}`;
 }
-async function permitProblem(rule, verified, request) {
+async function permitProblem(rule, decided, request) {
+  const { verified, decision } = decided;
   const { releaseId, outcome } = verified;
   let problem = null;
   if (rule.writes !== void 0) {
@@ -600,7 +759,18 @@ async function permitProblem(rule, verified, request) {
   } else if (rule.outcomes?.includes(outcome) !== true) {
     problem = `${verified.entityId} is ${outcome}, which doesn't allow this`;
   }
-  return problem === null ? null : { allow: false, reason: problem, step: { kind: "outcome", releaseId, outcome } };
+  if (problem === null) {
+    return null;
+  }
+  const recorded = decision.escalation;
+  const step = {
+    kind: "outcome",
+    releaseId,
+    outcome,
+    ...verified.escalation !== void 0 && { replayed: verified.escalation },
+    ...recorded?.trigger === "outcome" && { recorded }
+  };
+  return { allow: false, reason: problem, step };
 }
 async function verifiedFor(rule, found, request) {
   const { company, decision } = found;
@@ -612,7 +782,7 @@ async function verifiedFor(rule, found, request) {
   if (verified === null) {
     return { allow: false, reason: `Felspar did not reproduce ${company}'s receipt` };
   }
-  const problem = replayProblem({ rules: request.rules, rule }, company, verified);
+  const problem = replayProblem(request.rules, found, verified);
   if (problem !== null) {
     return { allow: false, reason: problem };
   }
@@ -621,7 +791,7 @@ async function verifiedFor(rule, found, request) {
     const reason = `${verified.entityId} is undecided, which doesn't allow this`;
     return { allow: false, reason, step: { kind: "unresolved", releaseId: verified.releaseId } };
   }
-  const denied = await permitProblem(rule, { ...verified, outcome }, request);
+  const denied = await permitProblem(rule, { verified: { ...verified, outcome }, decision }, request);
   if (denied !== null) {
     return denied;
   }
@@ -658,20 +828,16 @@ async function decide(request) {
   if (problem !== null) {
     return { allow: false, reason: problem };
   }
-  const keyOf = caseKeyOf(rule);
-  const entities = rule.entity === void 0 ? [...new Set(decisions.map((row) => keyOf(row.entity)))].filter((entity) => isCompanyDomain(entity, rules.sharedDomains)) : [];
-  const pinned = rules.releases?.length === 1 ? rules.releases[0] : void 0;
-  const unresolved = { kind: "unresolved", releaseId: pinned };
-  const { company, reason, missing } = caseFor({ rules, rule, entities }, input);
-  if (company === void 0) {
+  const selected2 = await selectCase({ rules, rule, decisions, describe: request.describe }, input);
+  if (selected2.company === void 0) {
+    const pinned = rules.releases?.length === 1 ? rules.releases[0] : void 0;
     return {
       allow: false,
-      reason: reason ?? "no case",
-      ...missing === true && { step: unresolved }
+      reason: selected2.reason,
+      ...selected2.missing === true && { step: { kind: "unresolved", releaseId: pinned } }
     };
   }
-  const decision = decisions.filter((row) => keyOf(row.entity) === company).at(-1);
-  return decision === void 0 ? { allow: false, reason: `no decision for ${company}`, step: unresolved } : await verifiedFor(rule, { company, decision, input }, request);
+  return await verifiedFor(rule, { ...selected2, input }, request);
 }
 async function checkAction(request) {
   let decided;
@@ -684,8 +850,7 @@ async function checkAction(request) {
     return decided;
   }
   const { step, ...denied } = decided;
-  const escalate = await escalationFor(step, request.describe, request.rules.job);
-  return escalate === null ? denied : { ...denied, escalate };
+  return { ...denied, ...await escalationFor(step, request.describe, request.rules.job) };
 }
 function report(onVerdict, toolName, verdict) {
   if (onVerdict === void 0) {
@@ -723,8 +888,6 @@ function createActionGate(config) {
 }
 
 export {
-  emailRecipientFields,
-  emailSubjectFields,
   outputCheckFromResult,
   outputTextDigest,
   felsparOutputCheckVerifier,
@@ -733,6 +896,8 @@ export {
   decisionFromResult,
   createDecisionRecorder,
   felsparJobDescriber,
+  emailRecipientFields,
+  emailSubjectFields,
   sharedDomains,
   isCompanyDomain,
   felsparVerifier,