@felspar/sdk 0.2.0 → 0.3.0

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

@@ -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)
@@ -2357,7 +2363,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 +2373,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 +2410,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 +2600,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) {
@@ -3702,6 +3712,73 @@ var DraftApplicationReleaseSchema = z43.strictObject({
 // ../schemas/src/draft-hosted-application.ts
 import { z as z50 } 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 +3929,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,
@@ -4354,12 +4431,14 @@ var hostedFactsLimits = {
   maxFactsBytes: 524288,
   maxQuestions: 64
 };
+var factSourceId = z50.string().refine(isDraftSourceId, "source_id_invalid").describe(`The source's own ID or address, such as its page URL with any query: RFC 3986 characters, starting with a letter or digit, at most ${draftSourceIdLimit} characters.`);
+var observedAt = z50.string().refine((value) => normalizedSourceInstant(value) !== null, "observed_at_invalid").transform((value) => normalizedSourceInstant(value) ?? value).describe(`When the source was read: an RFC 3339 date and time with Z or an offset, such as 2026-10-21T10:00:00Z or 2026-10-21T12:00+02:00, at most ${sourceInstantMaxLength} characters. Stored in UTC.`);
 var factSource = z50.strictObject({
   class: id6,
-  id: DraftSourceReferenceSchema.shape.sourceId,
+  id: factSourceId,
   revision: id6.optional(),
   locator: z50.string().min(1).max(4096).optional(),
-  observedAt: DraftObservationChecksSchema.shape.evaluationTime,
+  observedAt,
   sensitivity: id6.optional()
 });
 var excerptText = z50.string().min(1).refine((text7) => text7.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
@@ -4448,8 +4527,10 @@ var HostedJobResultSchema = z50.object({
 
 // ../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 the page URL with its query: at most ${draftSourceIdLimit} characters, starting with a letter or digit, using URL characters only (percent-encode spaces and non-ASCII characters).`,
   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.",
@@ -4483,6 +4564,7 @@ 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.",
   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.",
@@ -5060,6 +5142,35 @@ var HostedOutputCheckReplySchema = z56.object({
   decision: z56.object({ executionId: z56.string(), receiptDigest: digestText }),
   actionAuthorized: z56.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),
+  why: quotedWords
+});
+var FelsparJobResultSchema = HostedJobResultSchema.extend({
+  result: HostedJobResultSchema.shape.result.unwrap().extend({
+    case: FelsparCaseSchema.optional(),
+    subject: FelsparResultSubjectSchema.optional(),
+    escalation: FelsparEscalationSchema.optional(),
+    missing: z56.array(z56.string()).optional()
+  }).nullable()
+});
+var FelsparJobListSchema = z56.object({
+  jobs: z56.array(z56.object({ id: z56.string().min(1).max(200) })).max(256)
+});
 var hostedPartsContentType = "application/x.felspar-content-parts";
 async function partsBody(value) {
   const packed = await packContentParts(value);
@@ -5067,10 +5178,10 @@ async function partsBody(value) {
 }
 async function factsRequest(value, describeRelease) {
   if (typeof value.expectedReleaseDigest === "string") {
-    return HostedFactsJobInputSchema.parse({ mode: "facts", ...value });
+    return HostedFactsRequestSchema.parse({ mode: "facts", ...value });
   }
   const described = await describeRelease(HostedObjectSchema.shape.id.parse(value.jobId));
-  return HostedFactsJobInputSchema.parse({
+  return HostedFactsRequestSchema.parse({
     mode: "facts",
     ...value,
     expectedReleaseDigest: described.release.releaseDigest
@@ -5112,16 +5223,24 @@ ${jobId}`;
 }
 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 refusalSchema = z56.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()
-}).transform((value) => {
+}).transform(({ escalation: named, ...value }) => {
   const fix = hostedRefusalFix(value.error);
+  const escalation = refusalEscalationSchema.safeParse(named).data;
   return {
     ...value,
+    ...escalation !== void 0 && { escalation },
     ...fix !== null && { fix },
     ...value.issues && {
       issues: value.issues.map((issue) => {
@@ -5172,6 +5291,18 @@ function outputCheckCalls(call) {
     readOutputCheck: async (job, checkId) => await call(`${checksOf(job)}/${encodeURIComponent(objectId.parse(checkId))}`, HostedOutputCheckReplySchema)
   };
 }
+function agentCalls(call) {
+  const objectId = HostedObjectSchema.shape.id;
+  return {
+    listJobs: async () => await call("/v0/jobs", FelsparJobListSchema),
+    resolveJob: async (id12, value) => {
+      const input = HostedSuppliedJobInputSchema.parse(value);
+      const releaseId = objectId.parse(id12);
+      const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
+      return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
+    }
+  };
+}
 function createHostedFelsparClient(configuration) {
   const origin = new URL(configuration.origin);
   const invalid = [
@@ -5218,17 +5349,12 @@ function createHostedFelsparClient(configuration) {
     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)),
+    ...agentCalls(call),
     resolveFacts: async (id12, value) => {
       const releaseId = objectId.parse(id12);
       const input = await factsRequest(value, async (jobId) => await describe(releaseId, jobId));
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
-      return pinnedResult(await call(path3, HostedJobResultSchema, input), releaseId, input);
-    },
-    resolveJob: async (id12, value) => {
-      const input = HostedSuppliedJobInputSchema.parse(value);
-      const releaseId = objectId.parse(id12);
-      const response = await call(`/v0/releases/${encodeURIComponent(releaseId)}/jobs`, HostedJobResultSchema, input);
-      return pinnedResult(response, releaseId, input);
+      return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
     }
   };
 }

package/dist/chunks/{chunk-247XZ6IY.js → chunk-7HN5KUTJ.js}

@@ -2,7 +2,7 @@ import {
   denialText,
   entityIdOf,
   jobOf
-} from "./chunk-IY6A2423.js";
+} from "./chunk-2RV7RPXW.js";
 
 // src/draft-action-gate-eve.ts
 function felsparGate(gate) {
@@ -22,11 +22,10 @@ function felsparDecisionEvents(gate) {
       return;
     }
     for (const action of actions) {
-      const entity = entityIdOf(action.input);
-      if (entity !== void 0 && gate.isDecisionTool(action.toolName ?? "")) {
-        gate.decisions.noteRequest(action.callId, entity);
-      }
       const job = jobOf(action.input);
+      if (gate.isDecisionTool(action.toolName ?? "")) {
+        gate.decisions.noteRequest(action.callId, { entity: entityIdOf(action.input), job });
+      }
       if (job !== void 0 && gate.isOutputCheckTool(action.toolName ?? "")) {
         checks.set(action.callId, job);
       }

package/dist/draft-action-gate-claude.js

@@ -2,8 +2,8 @@ import {
   denialText,
   entityIdOf,
   jobOf
-} from "./chunks/chunk-IY6A2423.js";
-import "./chunks/chunk-HACK7D24.js";
+} from "./chunks/chunk-2RV7RPXW.js";
+import "./chunks/chunk-3YVYBD4H.js";
 
 // src/draft-action-gate-claude.ts
 function felsparPreToolUse(gate) {
@@ -31,9 +31,9 @@ function felsparPostToolUse(gate) {
     if (job !== void 0 && input.hook_event_name === "PostToolUse" && gate.isOutputCheckTool(input.tool_name ?? "")) {
       gate.decisions.recordOutputCheck(input.session_id, job, input.tool_response);
     }
-    const entity = entityIdOf(input.tool_input);
-    if (entity !== void 0 && input.hook_event_name === "PostToolUse" && gate.isDecisionTool(input.tool_name ?? "")) {
-      gate.decisions.record(input.session_id, entity, input.tool_response);
+    if (input.hook_event_name === "PostToolUse" && gate.isDecisionTool(input.tool_name ?? "")) {
+      const entity = entityIdOf(input.tool_input);
+      gate.decisions.record(input.session_id, { entity, job }, input.tool_response);
     }
     return {};
   };

package/dist/draft-action-gate-eve.js

@@ -1,9 +1,9 @@
 import {
   felsparDecisionEvents,
   felsparGate
-} from "./chunks/chunk-247XZ6IY.js";
-import "./chunks/chunk-IY6A2423.js";
-import "./chunks/chunk-HACK7D24.js";
+} from "./chunks/chunk-7HN5KUTJ.js";
+import "./chunks/chunk-2RV7RPXW.js";
+import "./chunks/chunk-3YVYBD4H.js";
 export {
   felsparDecisionEvents,
   felsparGate

package/dist/draft-action-gate-openai.js

@@ -2,8 +2,8 @@ import {
   denialText,
   entityIdOf,
   jobOf
-} from "./chunks/chunk-IY6A2423.js";
-import "./chunks/chunk-HACK7D24.js";
+} from "./chunks/chunk-2RV7RPXW.js";
+import "./chunks/chunk-3YVYBD4H.js";
 
 // src/draft-action-gate-openai.ts
 function argumentsOf(text) {
@@ -47,9 +47,9 @@ function felsparDecisionOutputGuardrail(gate, options) {
       if (job !== void 0 && gate.isOutputCheckTool(data.toolCall.name)) {
         gate.decisions.recordOutputCheck(options.sessionOf(data.context), job, data.output);
       }
-      const entity = entityIdOf(input);
-      if (entity !== void 0 && gate.isDecisionTool(data.toolCall.name)) {
-        gate.decisions.record(options.sessionOf(data.context), entity, data.output);
+      if (gate.isDecisionTool(data.toolCall.name)) {
+        const session = options.sessionOf(data.context);
+        gate.decisions.record(session, { entity: entityIdOf(input), job }, data.output);
       }
       return { behavior: { type: "allow" } };
     }

package/dist/draft-action-gate.js

@@ -16,8 +16,8 @@ import {
   outputCheckFromResult,
   outputTextDigest,
   sharedDomains
-} from "./chunks/chunk-IY6A2423.js";
-import "./chunks/chunk-HACK7D24.js";
+} from "./chunks/chunk-2RV7RPXW.js";
+import "./chunks/chunk-3YVYBD4H.js";
 export {
   checkAction,
   createActionGate,

package/dist/draft-hosted-client.js

@@ -1,7 +1,7 @@
 import {
   FelsparRequestError,
   createHostedFelsparClient
-} from "./chunks/chunk-HACK7D24.js";
+} from "./chunks/chunk-3YVYBD4H.js";
 export {
   FelsparRequestError,
   createHostedFelsparClient

package/dist/eve.js

@@ -1,9 +1,9 @@
 import {
   felsparDecisionEvents,
   felsparGate
-} from "./chunks/chunk-247XZ6IY.js";
-import "./chunks/chunk-IY6A2423.js";
-import "./chunks/chunk-HACK7D24.js";
+} from "./chunks/chunk-7HN5KUTJ.js";
+import "./chunks/chunk-2RV7RPXW.js";
+import "./chunks/chunk-3YVYBD4H.js";
 
 // src/eve.ts
 var felsparMcpUrl = "https://mcp.felspar.ai/mcp";

package/dist/types/draft-action-gate-cases.d.ts

@@ -26,5 +26,6 @@ export interface Found {
 export declare const foldCase: (text: string) => string;
 export declare const caseKeyOf: (rule: CaseRule) => (text: string) => string;
 export declare const sameField: (names: readonly string[]) => (field: string) => boolean;
+export declare function testListProblem(scope: Pick<CaseScope, "rules" | "rule">, input: Input): string | null;
 export declare function caseFor(scope: CaseScope, input: Input): Found;
 export {};

package/dist/types/draft-action-gate-decisions.d.ts

@@ -1,6 +1,23 @@
 import type { FelsparOutputCheck } from "./draft-action-gate-outputs.js";
+declare const identityModes: readonly ["provided", "fields", "content", "issued"];
+export type IdentityMode = (typeof identityModes)[number];
+declare const escalationTriggers: readonly ["outcome", "unresolved", "attempt_limit"];
+export type EscalationTrigger = (typeof escalationTriggers)[number];
+export interface FelsparCase {
+    id: string;
+    mode: IdentityMode;
+}
+export interface FelsparEscalation {
+    id: string;
+    trigger: EscalationTrigger;
+    why: string;
+}
 export interface FelsparDecision {
     entity: string;
+    case?: FelsparCase | undefined;
+    job?: string | undefined;
+    releaseId?: string | undefined;
+    escalation?: FelsparEscalation | undefined;
     outcome: string;
     executionObjectId: string;
     receipt: {
@@ -14,16 +31,28 @@ export interface VerifiedDecision {
     entityId: string;
     releaseId?: string;
     outcome: string | null;
+    case?: {
+        id: string;
+        mode: string;
+    } | undefined;
+    escalation?: {
+        id: string;
+        trigger: string;
+    } | undefined;
 }
 export type ReceiptVerifier = (decision: FelsparDecision) => Promise<VerifiedDecision | null>;
 export declare function jobOf(input: unknown): string | undefined;
 export declare function entityIdOf(input: unknown): string | undefined;
-export declare function decisionFromResult(entity: string, output: unknown): FelsparDecision | null;
+export type DecisionRequest = string | {
+    entity?: string | undefined;
+    job?: string | undefined;
+};
+export declare function decisionFromResult(request: DecisionRequest, output: unknown): FelsparDecision | null;
 export interface DecisionRecorder {
     recordOutputCheck: (sessionId: string, jobId: string, output: unknown) => FelsparOutputCheck | null;
     outputChecksIn: (sessionId: string) => readonly FelsparOutputCheck[];
-    record: (sessionId: string, entity: string, output: unknown) => FelsparDecision | null;
-    noteRequest: (callId: string, entity: string) => void;
+    record: (sessionId: string, request: DecisionRequest, output: unknown) => FelsparDecision | null;
+    noteRequest: (callId: string, request: DecisionRequest) => void;
     noteResult: (sessionId: string, callId: string, output: unknown) => FelsparDecision | null;
     decisionsIn: (sessionId: string) => readonly FelsparDecision[];
     forget: (sessionId: string) => void;
@@ -34,3 +63,4 @@ export interface DecisionRecorderLimits {
     pendingRequests?: number;
 }
 export declare function createDecisionRecorder(limits?: DecisionRecorderLimits): DecisionRecorder;
+export {};

package/dist/types/draft-action-gate-describe.d.ts

@@ -1,3 +1,4 @@
+import type { EscalationTrigger, IdentityMode } from "./draft-action-gate-decisions.js";
 interface Quoted {
     text: string;
 }
@@ -6,13 +7,28 @@ export interface GateJobDescription {
     release: {
         releaseId: string;
     };
+    subject?: {
+        type: string;
+        match: "exact" | "case-insensitive";
+    } | undefined;
+    identity?: {
+        mode: IdentityMode;
+    } | undefined;
     outcomes: readonly {
         id: string;
         nextStep?: Quoted | null | undefined;
         outputs?: readonly {
             id: string;
         }[] | undefined;
+        escalate?: string | undefined;
     }[];
+    escalations?: {
+        routes: readonly {
+            id: string;
+            quote: Quoted;
+        }[];
+        unresolved: string | null;
+    } | undefined;
     whenUnresolved?: Quoted | null | undefined;
 }
 export type JobDescriber = (releaseId: string, jobId: string) => Promise<GateJobDescription>;
@@ -28,6 +44,16 @@ export declare function writesProblem(describe: JobDescriber | undefined, decide
     outcome: string;
     output: string;
 }): Promise<string | null>;
+export declare function subjectOf(describe: JobDescriber, releaseId: string, jobId: string): Promise<{
+    type: string;
+    match: "exact" | "case-insensitive";
+    mode: "provided" | "fields" | "content" | "issued";
+} | null>;
+export interface GateEscalation {
+    id: string;
+    trigger: EscalationTrigger;
+    why: string | null;
+}
 export type EscalationStep = {
     kind: "unresolved";
     releaseId: string | undefined;
@@ -35,9 +61,21 @@ export type EscalationStep = {
     kind: "outcome";
     releaseId: string | undefined;
     outcome: string;
+    replayed?: {
+        id: string;
+        trigger: string;
+    } | undefined;
+    recorded?: {
+        id: string;
+        why: string;
+    } | undefined;
 } | {
     kind: "output-check";
 };
 export declare const fixOutputCheck = "Fix what check_output flagged, check it again, then retry.";
-export declare function escalationFor(step: EscalationStep | undefined, describe: JobDescriber | undefined, jobId: string): Promise<string | null>;
+export interface Escalated {
+    escalate?: string;
+    escalation?: GateEscalation;
+}
+export declare function escalationFor(step: EscalationStep | undefined, describe: JobDescriber | undefined, jobId: string): Promise<Escalated>;
 export {};

package/dist/types/draft-action-gate-subject.d.ts

@@ -0,0 +1,33 @@
+import type { CaseRule, CaseRules } from "./draft-action-gate-cases.js";
+import type { FelsparCase, FelsparDecision } from "./draft-action-gate-decisions.js";
+import type { JobDescriber } from "./draft-action-gate-describe.js";
+export interface GateSubject {
+    type: string;
+    match: "exact" | "case-insensitive";
+    mode: FelsparCase["mode"];
+}
+export interface CaseKeying {
+    key: (id: string) => string;
+    decisionKey: (decision: FelsparDecision) => string;
+}
+export type Selected = {
+    company: string;
+    decision: FelsparDecision;
+    keying: CaseKeying;
+} | {
+    company?: undefined;
+    reason: string;
+    missing?: true;
+};
+interface SelectScope {
+    rules: CaseRules & {
+        job: string;
+        sharedDomains?: readonly string[];
+    };
+    rule: CaseRule;
+    decisions: readonly FelsparDecision[];
+    describe?: JobDescriber | undefined;
+}
+type Input = Record<string, unknown>;
+export declare function selectCase(scope: SelectScope, input: Input): Promise<Selected>;
+export {};

package/dist/types/draft-action-gate.d.ts

@@ -1,12 +1,12 @@
-import type { JobDescriber } from "./draft-action-gate-describe.js";
+import type { GateEscalation, JobDescriber } from "./draft-action-gate-describe.js";
 import type { FelsparOutputCheck, OutputCheckVerifier } from "./draft-action-gate-outputs.js";
 import type { ActionRule } from "./draft-action-gate-rules.js";
 import type { DecisionRecorder, FelsparDecision, ReceiptVerifier } from "./draft-action-gate-decisions.js";
 export { emailRecipientFields, emailSubjectFields } from "./draft-action-gate-cases.js";
 export { createDecisionRecorder, decisionFromResult, entityIdOf, jobOf, } from "./draft-action-gate-decisions.js";
-export type { DecisionRecorder, DecisionRecorderLimits, FelsparDecision, ReceiptVerifier, VerifiedDecision, } from "./draft-action-gate-decisions.js";
+export type { DecisionRecorder, DecisionRecorderLimits, DecisionRequest, EscalationTrigger, FelsparCase, FelsparDecision, FelsparEscalation, IdentityMode, ReceiptVerifier, VerifiedDecision, } from "./draft-action-gate-decisions.js";
 export { felsparJobDescriber } from "./draft-action-gate-describe.js";
-export type { GateJobDescription, JobDescriber } from "./draft-action-gate-describe.js";
+export type { GateEscalation, GateJobDescription, JobDescriber, } from "./draft-action-gate-describe.js";
 export { isCompanyDomain, sharedDomains } from "./draft-action-gate-domains.js";
 export type { ActionRule } from "./draft-action-gate-rules.js";
 export { felsparVerifier } from "./draft-action-gate-verifier.js";
@@ -30,10 +30,12 @@ export type ActionVerdict = {
     allow: false;
     reason: string;
     escalate?: string;
+    escalation?: GateEscalation;
 };
 export declare function denialText(verdict: {
     reason: string;
     escalate?: string;
+    escalation?: GateEscalation;
 }): string;
 export declare function gatedRule(rules: ActionGateRules, toolName: string): ActionRule | undefined;
 export interface CheckActionRequest {