@mcpjam/inspector 3.7.2 → 3.8.0

package/dist/server/index.js

@@ -35,7 +35,7 @@ import {
   supportsOwnershipProof,
   terminateOwnedProcess,
   terminateOwnedProcessGroup
-} from "./chunk-XWZ5Q2R3.js";
+} from "./chunk-ZXGRD3M7.js";
 import {
   ALLOWED_HOSTS,
   BROWSER_CONSENT_HEADER,
@@ -3683,11 +3683,11 @@ function messagesOf(trace) {
 }
 function countUserTurns(messages) {
   if (!Array.isArray(messages)) return void 0;
-  let count4 = 0;
+  let count5 = 0;
   for (const message of messages) {
-    if (isRecord3(message) && message.role === "user") count4 += 1;
+    if (isRecord3(message) && message.role === "user") count5 += 1;
   }
-  return count4;
+  return count5;
 }
 function buildTurnTranscript(input) {
   return {
@@ -21155,8 +21155,8 @@ function errorCheck(detail) {
 function skippedCheck(detail) {
   return { status: "skipped", detail };
 }
-function describeCount(count22, label) {
-  return `${count22} ${label}${count22 === 1 ? "" : "s"} discovered.`;
+function describeCount(count32, label) {
+  return `${count32} ${label}${count32 === 1 ? "" : "s"} discovered.`;
 }
 function isServerDoctorError(error) {
   return !!error && typeof error === "object" && typeof error.code === "string" && typeof error.message === "string";
@@ -24145,6 +24145,374 @@ z2.discriminatedUnion("status", [
     ...suspectedConditionProvenance
   }).strict()
 ]);
+var SWARM_SESSION_VERDICT_CONTRACT_VERSION = 1;
+var SWARM_ATTEMPT_STATUSES = [
+  "pending",
+  "running",
+  "succeeded",
+  "failed",
+  "rate_limited"
+];
+var SWARM_SESSION_LIFECYCLES = [
+  "pending",
+  "running",
+  "ran",
+  "broke",
+  "limited",
+  "withdrawn"
+];
+var SWARM_SESSION_VERDICTS = [
+  "passed",
+  "failed",
+  "inconclusive",
+  "notEstablished"
+];
+var SWARM_GRADING_STATES = [
+  "notRequested",
+  "queued",
+  "running",
+  "settled",
+  "unavailable"
+];
+var SWARM_SESSION_VERDICT_OF_REASON = {
+  attemptPending: "notEstablished",
+  attemptRunning: "notEstablished",
+  withdrawn: "notEstablished",
+  spendCapReached: "notEstablished",
+  notRun: "notEstablished",
+  executionFailed: "notEstablished",
+  ungraded: "notEstablished",
+  gradingNotClaimed: "notEstablished",
+  criteriaPending: "notEstablished",
+  judgePending: "notEstablished",
+  gatingCriterionFailed: "failed",
+  judgeFailed: "failed",
+  criteriaGradingErrored: "inconclusive",
+  gatingCriterionUnmeasured: "inconclusive",
+  judgeErrored: "inconclusive",
+  gradingUnavailable: "inconclusive",
+  allGatingCriteriaPassed: "passed",
+  judgePassed: "passed",
+  allGradersPassed: "passed"
+};
+var SWARM_SESSION_VERDICT_REASONS = Object.keys(
+  SWARM_SESSION_VERDICT_OF_REASON
+);
+var swarmSessionLifecycleSchema = z2.enum(SWARM_SESSION_LIFECYCLES);
+var swarmSessionVerdictValueSchema = z2.enum(SWARM_SESSION_VERDICTS);
+var swarmGraderRoleSchema = z2.enum(["advisory", "required"]);
+var swarmSessionAttemptInputSchema = z2.object({
+  status: z2.enum(SWARM_ATTEMPT_STATUSES),
+  errorCode: z2.string().nullable().optional()
+}).strict();
+var swarmGradingReadinessSchema = z2.object({
+  /** Durable readiness for decisive grading only, not background observations. */
+  state: z2.enum(SWARM_GRADING_STATES),
+  reasonCode: z2.string().min(1).optional()
+}).strict();
+var criterionResultSchema = z2.object({
+  criterionId: z2.string().min(1),
+  passed: z2.boolean(),
+  status: z2.enum(["scored", "error"]).optional()
+}).strict();
+z2.object({
+  attempt: swarmSessionAttemptInputSchema.nullable(),
+  hasTranscript: z2.boolean(),
+  rubric: z2.array(
+    z2.object({
+      id: z2.string().min(1),
+      role: swarmGraderRoleSchema,
+      predicateType: z2.string().min(1).optional()
+    }).strict()
+  ),
+  criteria: z2.object({
+    status: z2.enum(["pending", "completed", "failed"]),
+    criterionIds: z2.array(z2.string().min(1)).optional(),
+    results: z2.array(criterionResultSchema).optional()
+  }).strict().nullable(),
+  goalScore: z2.discriminatedUnion("status", [
+    z2.object({ status: z2.literal("completed"), passed: z2.boolean() }).strict(),
+    z2.object({ status: z2.literal("running") }).strict(),
+    z2.object({ status: z2.literal("failed") }).strict()
+  ]).nullable(),
+  judge: z2.object({
+    automatic: z2.boolean(),
+    role: swarmGraderRoleSchema,
+    /** Explicit on-demand intent; automatic:false alone does not mean a judge was requested. */
+    requested: z2.boolean().optional()
+  }).strict(),
+  grading: swarmGradingReadinessSchema
+}).strict().superRefine((value, ctx) => {
+  const definitions = new Set(value.rubric.map((entry22) => entry22.id));
+  if (definitions.size !== value.rubric.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rubric"],
+      message: "Duplicate criterion definition"
+    });
+  }
+  for (const [field2, ids] of [
+    ["criterionIds", value.criteria?.criterionIds ?? []],
+    ["results", value.criteria?.results?.map((row2) => row2.criterionId) ?? []]
+  ]) {
+    if (new Set(ids).size !== ids.length || ids.some((id3) => !definitions.has(id3))) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["criteria", field2],
+        message: "Criterion IDs must be unique and defined in the snapshot"
+      });
+    }
+  }
+  const claimed = value.criteria?.criterionIds;
+  if (claimed && value.criteria?.results?.some((row2) => !claimed.includes(row2.criterionId))) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["criteria", "results"],
+      message: "Result outside claimed scope"
+    });
+  }
+});
+var SWARM_SESSION_TRIAL_STATUSES = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "setup_failed",
+  "cancelled"
+];
+var swarmSessionTrialSchema = z2.object({
+  status: z2.enum(SWARM_SESSION_TRIAL_STATUSES),
+  taskVerdict: z2.enum(["passed", "failed"]).optional(),
+  evaluatorError: z2.literal(true).optional()
+}).strict().superRefine((value, ctx) => {
+  const verdict = value.taskVerdict !== void 0;
+  const error = value.evaluatorError === true;
+  if (value.status === "completed" ? verdict === error : verdict || error) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Only completed trials carry exactly one verdict or evaluator error"
+    });
+  }
+});
+var swarmSessionGraderCountsSchema = z2.object({
+  gating: z2.number().int().nonnegative(),
+  gatingPassed: z2.number().int().nonnegative(),
+  gatingFailed: z2.number().int().nonnegative(),
+  gatingUnmeasured: z2.number().int().nonnegative(),
+  advisoryFailed: z2.number().int().nonnegative()
+}).strict();
+var swarmSessionVerdictSchema = z2.object({
+  contractVersion: z2.literal(SWARM_SESSION_VERDICT_CONTRACT_VERSION),
+  lifecycle: swarmSessionLifecycleSchema,
+  verdict: swarmSessionVerdictValueSchema,
+  reason: z2.enum(SWARM_SESSION_VERDICT_REASONS),
+  verdictSource: z2.enum([
+    "goalJudge",
+    "requiredAssertions",
+    "combined",
+    "none"
+  ]),
+  grading: swarmGradingReadinessSchema,
+  graders: z2.object({
+    criteria: z2.enum([
+      "notConfigured",
+      "notClaimed",
+      "pending",
+      "scored",
+      "errored"
+    ]),
+    judge: z2.enum([
+      "notConfigured",
+      "silent",
+      "pending",
+      "scored",
+      "errored"
+    ])
+  }).strict(),
+  counts: swarmSessionGraderCountsSchema,
+  trial: swarmSessionTrialSchema.nullable()
+}).strict().superRefine((value, ctx) => {
+  const fail3 = (message) => ctx.addIssue({ code: "custom", message });
+  if (SWARM_SESSION_VERDICT_OF_REASON[value.reason] !== value.verdict)
+    fail3("Reason contradicts verdict");
+  const c = value.counts;
+  if (c.gating !== c.gatingPassed + c.gatingFailed + c.gatingUnmeasured)
+    fail3("Required measurement counts do not add up");
+  const trial = value.trial;
+  if (trial?.status === "completed") {
+    if (value.lifecycle !== "ran")
+      fail3("Only a completed execution can be a completed trial");
+    if (trial.taskVerdict !== void 0 && trial.taskVerdict !== value.verdict)
+      fail3("Trial contradicts goal result");
+    if (trial.evaluatorError && value.verdict !== "inconclusive")
+      fail3("Evaluator error requires inconclusive grading");
+  }
+  const expected = {
+    pending: "pending",
+    running: "running",
+    broke: "failed",
+    limited: "setup_failed",
+    withdrawn: "cancelled"
+  };
+  if (value.lifecycle !== "ran" && trial?.status !== expected[value.lifecycle])
+    fail3("Trial must preserve execution lifecycle");
+  if (value.lifecycle === "ran" && trial !== null && trial.status !== "completed")
+    fail3("Completed execution must not become skipped or running");
+  if ((value.verdict === "passed" || value.verdict === "failed") && value.verdictSource === "none")
+    fail3("A measured goal verdict needs a source");
+  if (value.lifecycle === "ran" && value.verdict !== "notEstablished" && trial === null)
+    fail3("Settled grading on completed execution needs an observation");
+  if (value.verdict === "notEstablished" && value.verdictSource !== "none")
+    fail3("An undecided goal has no verdict source");
+});
+var SWARM_FINDING_CONTRACT_VERSION = 1;
+var SWARM_FINDING_DISPOSITIONS = [
+  "notRun",
+  "blockedConnecting",
+  "lostFindingTool",
+  "blockedCallingTool",
+  "blockedByResponse",
+  "goalMissed",
+  "goalMetWithFriction",
+  "goalMet",
+  "notMeasured"
+];
+var SWARM_FINDING_TONES = ["fail", "warn", "ok", "muted"];
+var SWARM_FINDING_SUMMARY_KINDS = [
+  "notLaunched",
+  "broken",
+  "friction",
+  "landed",
+  "ungraded",
+  "unread"
+];
+var SWARM_FINDING_COVERAGE_NOTES = [
+  "sessionScanCapped",
+  "budgetExhausted",
+  "transcriptMissing",
+  "contextTooLarge",
+  "extractionRejected",
+  "chainUnmeasured",
+  "judgeNotRun",
+  "sessionsWithdrawn",
+  "sessionsRateLimited",
+  "partialRead",
+  "toolCatalogMissing"
+];
+var SWARM_FINDING_SCOPE_LEVELS = [
+  "session",
+  "goal",
+  "persona",
+  "target",
+  "wave"
+];
+var SWARM_FINDING_BASES = [
+  "verifiedMechanism",
+  "sessionReport",
+  "populationFact"
+];
+var SWARM_FINDING_CHAIN_STAGE_BASES = [
+  "derived",
+  "reported",
+  "unmeasured"
+];
+var SWARM_FINDING_TONE_OF_DISPOSITION = Object.freeze({
+  notRun: "muted",
+  blockedConnecting: "fail",
+  lostFindingTool: "fail",
+  blockedCallingTool: "fail",
+  blockedByResponse: "fail",
+  goalMissed: "fail",
+  goalMetWithFriction: "warn",
+  goalMet: "ok",
+  notMeasured: "muted"
+});
+var vocabulary = (members) => members.map((value) => "`" + value + "`").join(", ");
+var count = z2.number().int().nonnegative();
+var persona = z2.object({ personaRefId: z2.string().nullable(), name: z2.string() }).strict();
+var disposition = z2.enum(SWARM_FINDING_DISPOSITIONS).describe(vocabulary(SWARM_FINDING_DISPOSITIONS));
+var coverageNotes = z2.array(
+  z2.enum(SWARM_FINDING_COVERAGE_NOTES).describe(vocabulary(SWARM_FINDING_COVERAGE_NOTES))
+);
+var citations = z2.array(z2.string().regex(/^[^/]+\/.+$/)).max(30);
+var toneMatchesDisposition = (row2) => row2.tone === SWARM_FINDING_TONE_OF_DISPOSITION[row2.disposition];
+var toneMismatch = {
+  message: "tone must equal SWARM_FINDING_TONE_OF_DISPOSITION[disposition]",
+  path: ["tone"]
+};
+var swarmJourneyFindingSchema = z2.object({
+  id: z2.string().min(1),
+  basis: z2.enum(SWARM_FINDING_BASES).describe(vocabulary(SWARM_FINDING_BASES)),
+  scopeLevel: z2.enum(SWARM_FINDING_SCOPE_LEVELS).describe(vocabulary(SWARM_FINDING_SCOPE_LEVELS)),
+  persona,
+  goal: z2.object({
+    runId: z2.string(),
+    journeyRefId: z2.string(),
+    title: z2.string()
+  }).strict(),
+  target: z2.object({
+    kind: z2.enum(["environment", "host"]),
+    id: z2.string(),
+    label: z2.string(),
+    modelId: z2.string().nullable()
+  }).strict(),
+  population: z2.object({ count, total: count, unit: z2.literal("sessions") }).strict(),
+  sessionIds: z2.array(z2.string()).max(1e3),
+  citations,
+  verdictSeen: swarmSessionVerdictValueSchema,
+  chainStage: userValueStageSchema.nullable().describe(vocabulary(USER_VALUE_STAGES)),
+  chainStageState: stageStateSchema.nullable().describe(vocabulary(STAGE_STATES)),
+  chainStageBasis: z2.enum(SWARM_FINDING_CHAIN_STAGE_BASES),
+  disposition,
+  tone: z2.enum(SWARM_FINDING_TONES),
+  coverageNotes,
+  outcomePhrase: z2.string().max(100).regex(/^[^0-9]*$/).refine(
+    (value) => value.trim().split(/\s+/).length <= 8,
+    "At most eight words"
+  ).nullable(),
+  mechanismPhrase: z2.string().nullable(),
+  fixPhrase: z2.string().nullable(),
+  reportExcerpt: z2.object({ actual: z2.string().max(1800), citations }).strict().nullable(),
+  mechanismId: z2.string().nullable()
+}).strict().refine(toneMatchesDisposition, toneMismatch);
+z2.object({
+  contractVersion: z2.literal(SWARM_FINDING_CONTRACT_VERSION),
+  generatedAt: count,
+  sourceRevision: z2.string(),
+  pipelineVersion: count,
+  extractionVersion: count,
+  extractionModel: z2.string(),
+  reasoningModel: z2.string(),
+  summaryKind: z2.enum(SWARM_FINDING_SUMMARY_KINDS).describe(vocabulary(SWARM_FINDING_SUMMARY_KINDS)),
+  population: z2.object({
+    configured: count,
+    started: count,
+    read: count,
+    unread: count,
+    withdrawn: count,
+    limited: count,
+    graded: count
+  }).strict(),
+  coverageNotes,
+  disclosure: z2.object({
+    rail: z2.enum(["gateway", "openrouter"]),
+    evidenceSent: z2.array(z2.string())
+  }).strict(),
+  personas: z2.array(
+    z2.object({
+      persona,
+      disposition,
+      tone: z2.enum(SWARM_FINDING_TONES),
+      goalRunIds: z2.array(z2.string())
+    }).strict().refine(toneMatchesDisposition, toneMismatch)
+  ),
+  findings: z2.array(swarmJourneyFindingSchema).max(200)
+}).strict();
+z2.object({
+  status: z2.enum(["pending", "completed", "failed", "skipped"]),
+  errorCode: z2.string().optional(),
+  updatedAt: count
+}).strict();
 var USER_VALUE_STAGE_LABELS = Object.freeze({
   connection: "Connection",
   discovery: "Discovery",
@@ -25683,248 +26051,28 @@ var evalBacktestContinuationSchema = z2.object({
 evalBacktestDraftSchema.extend({
   continuation: evalBacktestContinuationSchema.optional()
 });
-var SWARM_SESSION_VERDICT_CONTRACT_VERSION = 1;
-var SWARM_ATTEMPT_STATUSES = [
-  "pending",
-  "running",
-  "succeeded",
-  "failed",
-  "rate_limited"
-];
-var SWARM_SESSION_LIFECYCLES = [
-  "pending",
-  "running",
-  "ran",
-  "broke",
-  "limited",
-  "withdrawn"
-];
-var SWARM_SESSION_VERDICTS = [
-  "passed",
-  "failed",
-  "inconclusive",
-  "notEstablished"
-];
-var SWARM_GRADING_STATES = [
-  "notRequested",
-  "queued",
-  "running",
-  "settled",
-  "unavailable"
-];
-var SWARM_SESSION_VERDICT_OF_REASON = {
-  attemptPending: "notEstablished",
-  attemptRunning: "notEstablished",
-  withdrawn: "notEstablished",
-  spendCapReached: "notEstablished",
-  notRun: "notEstablished",
-  executionFailed: "notEstablished",
-  ungraded: "notEstablished",
-  gradingNotClaimed: "notEstablished",
-  criteriaPending: "notEstablished",
-  judgePending: "notEstablished",
-  gatingCriterionFailed: "failed",
-  judgeFailed: "failed",
-  criteriaGradingErrored: "inconclusive",
-  gatingCriterionUnmeasured: "inconclusive",
-  judgeErrored: "inconclusive",
-  gradingUnavailable: "inconclusive",
-  allGatingCriteriaPassed: "passed",
-  judgePassed: "passed",
-  allGradersPassed: "passed"
-};
-var SWARM_SESSION_VERDICT_REASONS = Object.keys(
-  SWARM_SESSION_VERDICT_OF_REASON
-);
-var swarmSessionLifecycleSchema = z2.enum(SWARM_SESSION_LIFECYCLES);
-var swarmSessionVerdictValueSchema = z2.enum(SWARM_SESSION_VERDICTS);
-var swarmGraderRoleSchema = z2.enum(["advisory", "required"]);
-var swarmSessionAttemptInputSchema = z2.object({
-  status: z2.enum(SWARM_ATTEMPT_STATUSES),
-  errorCode: z2.string().nullable().optional()
-}).strict();
-var swarmGradingReadinessSchema = z2.object({
-  /** Durable readiness for decisive grading only, not background observations. */
-  state: z2.enum(SWARM_GRADING_STATES),
-  reasonCode: z2.string().min(1).optional()
-}).strict();
-var criterionResultSchema = z2.object({
-  criterionId: z2.string().min(1),
-  passed: z2.boolean(),
-  status: z2.enum(["scored", "error"]).optional()
-}).strict();
-z2.object({
-  attempt: swarmSessionAttemptInputSchema.nullable(),
-  hasTranscript: z2.boolean(),
-  rubric: z2.array(
-    z2.object({
-      id: z2.string().min(1),
-      role: swarmGraderRoleSchema,
-      predicateType: z2.string().min(1).optional()
-    }).strict()
-  ),
-  criteria: z2.object({
-    status: z2.enum(["pending", "completed", "failed"]),
-    criterionIds: z2.array(z2.string().min(1)).optional(),
-    results: z2.array(criterionResultSchema).optional()
-  }).strict().nullable(),
-  goalScore: z2.discriminatedUnion("status", [
-    z2.object({ status: z2.literal("completed"), passed: z2.boolean() }).strict(),
-    z2.object({ status: z2.literal("running") }).strict(),
-    z2.object({ status: z2.literal("failed") }).strict()
-  ]).nullable(),
-  judge: z2.object({
-    automatic: z2.boolean(),
-    role: swarmGraderRoleSchema,
-    /** Explicit on-demand intent; automatic:false alone does not mean a judge was requested. */
-    requested: z2.boolean().optional()
-  }).strict(),
-  grading: swarmGradingReadinessSchema
-}).strict().superRefine((value, ctx) => {
-  const definitions = new Set(value.rubric.map((entry22) => entry22.id));
-  if (definitions.size !== value.rubric.length) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["rubric"],
-      message: "Duplicate criterion definition"
-    });
-  }
-  for (const [field2, ids] of [
-    ["criterionIds", value.criteria?.criterionIds ?? []],
-    ["results", value.criteria?.results?.map((row2) => row2.criterionId) ?? []]
-  ]) {
-    if (new Set(ids).size !== ids.length || ids.some((id3) => !definitions.has(id3))) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["criteria", field2],
-        message: "Criterion IDs must be unique and defined in the snapshot"
-      });
-    }
-  }
-  const claimed = value.criteria?.criterionIds;
-  if (claimed && value.criteria?.results?.some((row2) => !claimed.includes(row2.criterionId))) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["criteria", "results"],
-      message: "Result outside claimed scope"
-    });
-  }
-});
-var SWARM_SESSION_TRIAL_STATUSES = [
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "setup_failed",
-  "cancelled"
-];
-var swarmSessionTrialSchema = z2.object({
-  status: z2.enum(SWARM_SESSION_TRIAL_STATUSES),
-  taskVerdict: z2.enum(["passed", "failed"]).optional(),
-  evaluatorError: z2.literal(true).optional()
-}).strict().superRefine((value, ctx) => {
-  const verdict = value.taskVerdict !== void 0;
-  const error = value.evaluatorError === true;
-  if (value.status === "completed" ? verdict === error : verdict || error) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Only completed trials carry exactly one verdict or evaluator error"
-    });
-  }
-});
-var swarmSessionGraderCountsSchema = z2.object({
-  gating: z2.number().int().nonnegative(),
-  gatingPassed: z2.number().int().nonnegative(),
-  gatingFailed: z2.number().int().nonnegative(),
-  gatingUnmeasured: z2.number().int().nonnegative(),
-  advisoryFailed: z2.number().int().nonnegative()
-}).strict();
-var swarmSessionVerdictSchema = z2.object({
-  contractVersion: z2.literal(SWARM_SESSION_VERDICT_CONTRACT_VERSION),
-  lifecycle: swarmSessionLifecycleSchema,
-  verdict: swarmSessionVerdictValueSchema,
-  reason: z2.enum(SWARM_SESSION_VERDICT_REASONS),
-  verdictSource: z2.enum([
-    "goalJudge",
-    "requiredAssertions",
-    "combined",
-    "none"
-  ]),
-  grading: swarmGradingReadinessSchema,
-  graders: z2.object({
-    criteria: z2.enum([
-      "notConfigured",
-      "notClaimed",
-      "pending",
-      "scored",
-      "errored"
-    ]),
-    judge: z2.enum([
-      "notConfigured",
-      "silent",
-      "pending",
-      "scored",
-      "errored"
-    ])
-  }).strict(),
-  counts: swarmSessionGraderCountsSchema,
-  trial: swarmSessionTrialSchema.nullable()
-}).strict().superRefine((value, ctx) => {
-  const fail3 = (message) => ctx.addIssue({ code: "custom", message });
-  if (SWARM_SESSION_VERDICT_OF_REASON[value.reason] !== value.verdict)
-    fail3("Reason contradicts verdict");
-  const c = value.counts;
-  if (c.gating !== c.gatingPassed + c.gatingFailed + c.gatingUnmeasured)
-    fail3("Required measurement counts do not add up");
-  const trial = value.trial;
-  if (trial?.status === "completed") {
-    if (value.lifecycle !== "ran")
-      fail3("Only a completed execution can be a completed trial");
-    if (trial.taskVerdict !== void 0 && trial.taskVerdict !== value.verdict)
-      fail3("Trial contradicts goal result");
-    if (trial.evaluatorError && value.verdict !== "inconclusive")
-      fail3("Evaluator error requires inconclusive grading");
-  }
-  const expected = {
-    pending: "pending",
-    running: "running",
-    broke: "failed",
-    limited: "setup_failed",
-    withdrawn: "cancelled"
-  };
-  if (value.lifecycle !== "ran" && trial?.status !== expected[value.lifecycle])
-    fail3("Trial must preserve execution lifecycle");
-  if (value.lifecycle === "ran" && trial !== null && trial.status !== "completed")
-    fail3("Completed execution must not become skipped or running");
-  if ((value.verdict === "passed" || value.verdict === "failed") && value.verdictSource === "none")
-    fail3("A measured goal verdict needs a source");
-  if (value.lifecycle === "ran" && value.verdict !== "notEstablished" && trial === null)
-    fail3("Settled grading on completed execution needs an observation");
-  if (value.verdict === "notEstablished" && value.verdictSource !== "none")
-    fail3("An undecided goal has no verdict source");
-});
 var SWARM_REPORT_CONTRACT_VERSION = 1;
-var count = z2.number().int().nonnegative();
+var count2 = z2.number().int().nonnegative();
 var journeyRunVerdictSummarySchema = z2.discriminatedUnion("status", [
   z2.object({
     status: z2.literal("pending"),
-    pendingSessions: count,
-    updatedAt: count
+    pendingSessions: count2,
+    updatedAt: count2
   }).strict(),
   z2.object({
     status: z2.literal("decided"),
     decision: evalVerdictDecisionSchema,
-    updatedAt: count
+    updatedAt: count2
   }).strict(),
   z2.object({
     status: z2.literal("notEstablished"),
     reason: z2.literal("gradingNotConfigured"),
-    updatedAt: count
+    updatedAt: count2
   }).strict(),
   z2.object({
     status: z2.literal("integrityFailed"),
     reason: z2.string().min(1),
-    updatedAt: count
+    updatedAt: count2
   }).strict()
 ]);
 var swarmObservationInputSchema = z2.object({
@@ -25962,7 +26110,7 @@ var swarmReportSessionSchema = z2.object({
 z2.object({
   runId: z2.string().min(1),
   executionComplete: z2.boolean(),
-  configuredSessions: count,
+  configuredSessions: count2,
   verdictSummary: journeyRunVerdictSummarySchema.nullable(),
   /** Frozen run-wide definitions: absent measurement rows still count as unavailable. */
   evaluatorDefinitions: z2.array(
@@ -26017,11 +26165,11 @@ var swarmObservationCoverageSchema = z2.object({
     "The stage this observation was read from, and the only stage it is evidence ABOUT. `connection` \u2014 the server was reachable and the session initialized. `discovery` \u2014 its tools and resources were listed and readable. `selection` \u2014 the model chose the right tool for the request. `call` \u2014 the call was made with usable arguments. `response` \u2014 the server returned data the model could use. `userValue` \u2014 the user's actual request was satisfied."
   ),
   unit: z2.literal("sessions"),
-  total: count,
-  passed: count,
-  failed: count,
-  pending: count,
-  unavailable: count
+  total: count2,
+  passed: count2,
+  failed: count2,
+  pending: count2,
+  unavailable: count2
 }).strict().superRefine((value, ctx) => {
   if (value.total !== value.passed + value.failed + value.pending + value.unavailable) {
     ctx.addIssue({
@@ -26051,26 +26199,26 @@ z2.object({
   ]).optional(),
   execution: z2.object({
     unit: z2.literal("sessions"),
-    configured: count,
-    reported: count,
-    started: count,
-    notStarted: count,
-    unknown: count,
-    completed: count,
-    interrupted: count,
+    configured: count2,
+    reported: count2,
+    started: count2,
+    notStarted: count2,
+    unknown: count2,
+    completed: count2,
+    interrupted: count2,
     /** Only explicit complete execution evidence can establish this. */
     neverLaunched: z2.boolean()
   }).strict(),
   goalGrading: z2.object({
     unit: z2.literal("sessions"),
-    reported: count,
-    passed: count,
-    failed: count,
-    pending: count,
-    unavailable: count,
-    notRequested: count,
+    reported: count2,
+    passed: count2,
+    failed: count2,
+    pending: count2,
+    unavailable: count2,
+    notRequested: count2,
     /** Readiness is separate: a proven failure can exist while other required grading is pending. */
-    waitingForDecisiveGrading: count
+    waitingForDecisiveGrading: count2
   }).strict(),
   observations: z2.array(swarmObservationCoverageSchema)
 }).strict().superRefine((report, ctx) => {
@@ -26176,7 +26324,7 @@ var noopPosthog = {
 var posthog = isTelemetryDisabled ? noopPosthog : new PostHog("phc_dTOPniyUNU2kD8Jx8yHMXSqiZHM8I91uWopTMX6EBE9", {
   host: "https://us.i.posthog.com"
 });
-var SDK_VERSION = "8.10.1";
+var SDK_VERSION = "8.11.0";
 var SDK_RELEASE = `@mcpjam/sdk@${SDK_VERSION}`;
 var CAPTURED_ERROR_SYMBOL = Symbol.for("@mcpjam/sdk/captured-eval-error");
 init_internal();
@@ -26187,7 +26335,7 @@ init_eval_tool_execution();
 init_internal();
 init_internal();
 function readSdkVersion() {
-  return "8.10.1";
+  return "8.11.0";
 }
 var DEFAULT_PLATFORM_USER_AGENT = `mcpjam-sdk/${readSdkVersion()}`;
 init_HostRunner();
@@ -41192,7 +41340,7 @@ async function runTransportChecks(ctx, selectedCheckIds) {
           const readErrors = sseResponses.map(
             ({ response }) => response.bodyError
           );
-          const allStreamsReadable = requestErrors.every((error) => error === void 0) && !responseFailures && readErrors.every((error) => error === void 0) && eventCounts.every((count22) => count22 > 0);
+          const allStreamsReadable = requestErrors.every((error) => error === void 0) && !responseFailures && readErrors.every((error) => error === void 0) && eventCounts.every((count32) => count32 > 0);
           results.push(
             allStreamsReadable ? passedResult2(
               TRANSPORT_CHECK_METADATA["server-sse-streams-functional"],
@@ -73552,17 +73700,8 @@ function resolveSlug(error) {
   if (/missing\s+(?:or\s+invalid\s+)?bearer/i.test(message) || /bearer\s+token\s+(?:is\s+)?required/i.test(message)) {
     return { slug: "auth/missing_bearer" };
   }
-  const limitPeriod = /\b(daily|monthly)\s+mcpjam[\w\s-]{0,40}model limit/i.exec(
-    message
-  );
-  if (limitPeriod) {
-    return {
-      slug: limitPeriod[1].toLowerCase() === "monthly" ? "provider/mcpjam_limit_monthly" : "provider/mcpjam_limit_daily"
-    };
-  }
-  if (/mcpjam[\w\s-]{0,40}model limit/i.test(message)) {
-    return { slug: "provider/mcpjam_limit" };
-  }
+  const limitSlug = mcpjamLimitSlugForMessage(message);
+  if (limitSlug) return { slug: limitSlug };
   const httpStatus2 = getHttpStatus(error);
   if (httpStatus2 !== void 0) {
     const slug = classifyHttpStatus(httpStatus2);
@@ -73743,6 +73882,16 @@ function crashFallback(error, emptyPlaceholder) {
     rawMessage
   };
 }
+function mcpjamLimitSlugForMessage(message) {
+  const limitPeriod = /\b(daily|monthly)\s+mcpjam[\w\s-]{0,40}model limit/i.exec(message);
+  if (limitPeriod) {
+    return limitPeriod[1].toLowerCase() === "monthly" ? "provider/mcpjam_limit_monthly" : "provider/mcpjam_limit_daily";
+  }
+  if (/mcpjam[\w\s-]{0,40}model limit/i.test(message)) {
+    return "provider/mcpjam_limit";
+  }
+  return void 0;
+}
 var MAX_FIELD_CHARS2 = 120;
 function clip(value) {
   value = String(redactForTelemetry(value));
@@ -82916,7 +83065,7 @@ var NEGATIVE_TEST_MODE_DETAILS = {
   }
 };
 function readSdkVersion2() {
-  return "8.10.1";
+  return "8.11.0";
 }
 var CONFORMANCE_CHECKER_VERSION2 = readSdkVersion2();
 var MUST_POINTS2 = 95;
@@ -86966,6 +87115,9 @@ function backoffDelayMs(attempt, policy) {
   );
   return Math.max(0, Math.round((policy.jitter ?? defaultJitter)(exponential)));
 }
+function clampDelay(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
 function abortableSleep(ms, signal) {
   if (signal?.aborted || ms <= 0) return Promise.resolve();
   return new Promise((resolve11) => {
@@ -89159,8 +89311,8 @@ var CommandQueue = class {
   }
   /** Whether every per-tab FIFO is drained. Used for profile snapshots. */
   isIdle() {
-    for (const count4 of this.depth.values()) {
-      if (count4 > 0) return false;
+    for (const count5 of this.depth.values()) {
+      if (count5 > 0) return false;
     }
     return true;
   }
@@ -94170,14 +94322,14 @@ function assignRefs(root) {
   const entries = /* @__PURE__ */ new Map();
   if (!root) return entries;
   const seen = /* @__PURE__ */ new Map();
-  const count4 = (node) => {
+  const count5 = (node) => {
     if (isRefWorthy(node)) {
       const key = `${node.role}:${node.name ?? ""}`;
       seen.set(key, (seen.get(key) ?? 0) + 1);
     }
-    for (const child of node.children ?? []) count4(child);
+    for (const child of node.children ?? []) count5(child);
   };
-  count4(root);
+  count5(root);
   const position = /* @__PURE__ */ new Map();
   let next = 1;
   const visit2 = (node) => {
@@ -94455,7 +94607,7 @@ var WebMcpBridge = class {
     }
     return false;
   }
-  allowChanges(count4) {
+  allowChanges(count5) {
     if (!this.localSecurity) return true;
     if (this.discoveryBlocked) return false;
     const now = Date.now();
@@ -94465,8 +94617,8 @@ var WebMcpBridge = class {
       rate.tokens + Math.max(0, now - rate.at) * 1.024
     );
     rate.at = now;
-    if (count4 > rate.tokens) return this.blockDiscovery();
-    rate.tokens -= count4;
+    if (count5 > rate.tokens) return this.blockDiscovery();
+    rate.tokens -= count5;
     this.changeTokens = rate.tokens;
     this.changeAt = now;
     return true;
@@ -102463,8 +102615,8 @@ function createFrameRelayStats(options) {
     countDrop(n = 1) {
       dropped += Math.max(0, Math.round(n));
     },
-    setSubscribers(count4) {
-      subscribers3 = Math.max(0, Math.round(count4));
+    setSubscribers(count5) {
+      subscribers3 = Math.max(0, Math.round(count5));
     },
     mergeDaemon(counters) {
       daemon = counters;
@@ -125646,7 +125798,7 @@ function cloneTraceValue(value) {
 }
 function getPromptIndex(messageHistory) {
   const userCount = messageHistory.reduce(
-    (count4, message) => count4 + (message?.role === "user" ? 1 : 0),
+    (count5, message) => count5 + (message?.role === "user" ? 1 : 0),
     0
   );
   return Math.max(0, userCount - 1);
@@ -130521,6 +130673,375 @@ function projectSuspectedConditionVerdict(metadata) {
   if (parsed.success) return { suspectedConditionVerdict: parsed.data };
   return { suspectedConditionUnverified: true };
 }
+var SWARM_SESSION_VERDICT_CONTRACT_VERSION2 = 1;
+var SWARM_STAGE_EVIDENCE_VERSION = 2;
+var SWARM_ATTEMPT_STATUSES2 = [
+  "pending",
+  "running",
+  "succeeded",
+  "failed",
+  "rate_limited"
+];
+var SWARM_SESSION_LIFECYCLES2 = [
+  "pending",
+  "running",
+  "ran",
+  "broke",
+  "limited",
+  "withdrawn"
+];
+var SWARM_SESSION_VERDICTS2 = [
+  "passed",
+  "failed",
+  "inconclusive",
+  "notEstablished"
+];
+var SWARM_GRADING_STATES2 = [
+  "notRequested",
+  "queued",
+  "running",
+  "settled",
+  "unavailable"
+];
+var SWARM_SESSION_VERDICT_OF_REASON2 = {
+  attemptPending: "notEstablished",
+  attemptRunning: "notEstablished",
+  withdrawn: "notEstablished",
+  spendCapReached: "notEstablished",
+  notRun: "notEstablished",
+  executionFailed: "notEstablished",
+  ungraded: "notEstablished",
+  gradingNotClaimed: "notEstablished",
+  criteriaPending: "notEstablished",
+  judgePending: "notEstablished",
+  gatingCriterionFailed: "failed",
+  judgeFailed: "failed",
+  criteriaGradingErrored: "inconclusive",
+  gatingCriterionUnmeasured: "inconclusive",
+  judgeErrored: "inconclusive",
+  gradingUnavailable: "inconclusive",
+  allGatingCriteriaPassed: "passed",
+  judgePassed: "passed",
+  allGradersPassed: "passed"
+};
+var SWARM_SESSION_VERDICT_REASONS2 = Object.keys(
+  SWARM_SESSION_VERDICT_OF_REASON2
+);
+var swarmSessionLifecycleSchema2 = z14.enum(SWARM_SESSION_LIFECYCLES2);
+var swarmSessionVerdictValueSchema2 = z14.enum(SWARM_SESSION_VERDICTS2);
+var swarmGraderRoleSchema2 = z14.enum(["advisory", "required"]);
+var swarmSessionAttemptInputSchema2 = z14.object({
+  status: z14.enum(SWARM_ATTEMPT_STATUSES2),
+  errorCode: z14.string().nullable().optional()
+}).strict();
+var swarmGradingReadinessSchema2 = z14.object({
+  /** Durable readiness for decisive grading only, not background observations. */
+  state: z14.enum(SWARM_GRADING_STATES2),
+  reasonCode: z14.string().min(1).optional()
+}).strict();
+var criterionResultSchema2 = z14.object({
+  criterionId: z14.string().min(1),
+  passed: z14.boolean(),
+  status: z14.enum(["scored", "error"]).optional()
+}).strict();
+var swarmSessionVerdictInputSchema = z14.object({
+  attempt: swarmSessionAttemptInputSchema2.nullable(),
+  hasTranscript: z14.boolean(),
+  rubric: z14.array(
+    z14.object({
+      id: z14.string().min(1),
+      role: swarmGraderRoleSchema2,
+      predicateType: z14.string().min(1).optional()
+    }).strict()
+  ),
+  criteria: z14.object({
+    status: z14.enum(["pending", "completed", "failed"]),
+    criterionIds: z14.array(z14.string().min(1)).optional(),
+    results: z14.array(criterionResultSchema2).optional()
+  }).strict().nullable(),
+  goalScore: z14.discriminatedUnion("status", [
+    z14.object({ status: z14.literal("completed"), passed: z14.boolean() }).strict(),
+    z14.object({ status: z14.literal("running") }).strict(),
+    z14.object({ status: z14.literal("failed") }).strict()
+  ]).nullable(),
+  judge: z14.object({
+    automatic: z14.boolean(),
+    role: swarmGraderRoleSchema2,
+    /** Explicit on-demand intent; automatic:false alone does not mean a judge was requested. */
+    requested: z14.boolean().optional()
+  }).strict(),
+  grading: swarmGradingReadinessSchema2
+}).strict().superRefine((value, ctx) => {
+  const definitions = new Set(value.rubric.map((entry3) => entry3.id));
+  if (definitions.size !== value.rubric.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rubric"],
+      message: "Duplicate criterion definition"
+    });
+  }
+  for (const [field, ids] of [
+    ["criterionIds", value.criteria?.criterionIds ?? []],
+    ["results", value.criteria?.results?.map((row2) => row2.criterionId) ?? []]
+  ]) {
+    if (new Set(ids).size !== ids.length || ids.some((id3) => !definitions.has(id3))) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["criteria", field],
+        message: "Criterion IDs must be unique and defined in the snapshot"
+      });
+    }
+  }
+  const claimed = value.criteria?.criterionIds;
+  if (claimed && value.criteria?.results?.some((row2) => !claimed.includes(row2.criterionId))) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["criteria", "results"],
+      message: "Result outside claimed scope"
+    });
+  }
+});
+var SWARM_SESSION_TRIAL_STATUSES2 = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "setup_failed",
+  "cancelled"
+];
+var swarmSessionTrialSchema2 = z14.object({
+  status: z14.enum(SWARM_SESSION_TRIAL_STATUSES2),
+  taskVerdict: z14.enum(["passed", "failed"]).optional(),
+  evaluatorError: z14.literal(true).optional()
+}).strict().superRefine((value, ctx) => {
+  const verdict = value.taskVerdict !== void 0;
+  const error = value.evaluatorError === true;
+  if (value.status === "completed" ? verdict === error : verdict || error) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Only completed trials carry exactly one verdict or evaluator error"
+    });
+  }
+});
+var swarmSessionGraderCountsSchema2 = z14.object({
+  gating: z14.number().int().nonnegative(),
+  gatingPassed: z14.number().int().nonnegative(),
+  gatingFailed: z14.number().int().nonnegative(),
+  gatingUnmeasured: z14.number().int().nonnegative(),
+  advisoryFailed: z14.number().int().nonnegative()
+}).strict();
+var swarmSessionVerdictSchema2 = z14.object({
+  contractVersion: z14.literal(SWARM_SESSION_VERDICT_CONTRACT_VERSION2),
+  lifecycle: swarmSessionLifecycleSchema2,
+  verdict: swarmSessionVerdictValueSchema2,
+  reason: z14.enum(SWARM_SESSION_VERDICT_REASONS2),
+  verdictSource: z14.enum([
+    "goalJudge",
+    "requiredAssertions",
+    "combined",
+    "none"
+  ]),
+  grading: swarmGradingReadinessSchema2,
+  graders: z14.object({
+    criteria: z14.enum([
+      "notConfigured",
+      "notClaimed",
+      "pending",
+      "scored",
+      "errored"
+    ]),
+    judge: z14.enum([
+      "notConfigured",
+      "silent",
+      "pending",
+      "scored",
+      "errored"
+    ])
+  }).strict(),
+  counts: swarmSessionGraderCountsSchema2,
+  trial: swarmSessionTrialSchema2.nullable()
+}).strict().superRefine((value, ctx) => {
+  const fail3 = (message) => ctx.addIssue({ code: "custom", message });
+  if (SWARM_SESSION_VERDICT_OF_REASON2[value.reason] !== value.verdict)
+    fail3("Reason contradicts verdict");
+  const c = value.counts;
+  if (c.gating !== c.gatingPassed + c.gatingFailed + c.gatingUnmeasured)
+    fail3("Required measurement counts do not add up");
+  const trial = value.trial;
+  if (trial?.status === "completed") {
+    if (value.lifecycle !== "ran")
+      fail3("Only a completed execution can be a completed trial");
+    if (trial.taskVerdict !== void 0 && trial.taskVerdict !== value.verdict)
+      fail3("Trial contradicts goal result");
+    if (trial.evaluatorError && value.verdict !== "inconclusive")
+      fail3("Evaluator error requires inconclusive grading");
+  }
+  const expected = {
+    pending: "pending",
+    running: "running",
+    broke: "failed",
+    limited: "setup_failed",
+    withdrawn: "cancelled"
+  };
+  if (value.lifecycle !== "ran" && trial?.status !== expected[value.lifecycle])
+    fail3("Trial must preserve execution lifecycle");
+  if (value.lifecycle === "ran" && trial !== null && trial.status !== "completed")
+    fail3("Completed execution must not become skipped or running");
+  if ((value.verdict === "passed" || value.verdict === "failed") && value.verdictSource === "none")
+    fail3("A measured goal verdict needs a source");
+  if (value.lifecycle === "ran" && value.verdict !== "notEstablished" && trial === null)
+    fail3("Settled grading on completed execution needs an observation");
+  if (value.verdict === "notEstablished" && value.verdictSource !== "none")
+    fail3("An undecided goal has no verdict source");
+});
+var SWARM_FINDING_CONTRACT_VERSION2 = 1;
+var SWARM_FINDING_DISPOSITIONS2 = [
+  "notRun",
+  "blockedConnecting",
+  "lostFindingTool",
+  "blockedCallingTool",
+  "blockedByResponse",
+  "goalMissed",
+  "goalMetWithFriction",
+  "goalMet",
+  "notMeasured"
+];
+var SWARM_FINDING_TONES2 = ["fail", "warn", "ok", "muted"];
+var SWARM_FINDING_SUMMARY_KINDS2 = [
+  "notLaunched",
+  "broken",
+  "friction",
+  "landed",
+  "ungraded",
+  "unread"
+];
+var SWARM_FINDING_COVERAGE_NOTES2 = [
+  "sessionScanCapped",
+  "budgetExhausted",
+  "transcriptMissing",
+  "contextTooLarge",
+  "extractionRejected",
+  "chainUnmeasured",
+  "judgeNotRun",
+  "sessionsWithdrawn",
+  "sessionsRateLimited",
+  "partialRead",
+  "toolCatalogMissing"
+];
+var SWARM_FINDING_SCOPE_LEVELS2 = [
+  "session",
+  "goal",
+  "persona",
+  "target",
+  "wave"
+];
+var SWARM_FINDING_BASES2 = [
+  "verifiedMechanism",
+  "sessionReport",
+  "populationFact"
+];
+var SWARM_FINDING_CHAIN_STAGE_BASES2 = [
+  "derived",
+  "reported",
+  "unmeasured"
+];
+var SWARM_FINDING_TONE_OF_DISPOSITION2 = Object.freeze({
+  notRun: "muted",
+  blockedConnecting: "fail",
+  lostFindingTool: "fail",
+  blockedCallingTool: "fail",
+  blockedByResponse: "fail",
+  goalMissed: "fail",
+  goalMetWithFriction: "warn",
+  goalMet: "ok",
+  notMeasured: "muted"
+});
+var vocabulary2 = (members) => members.map((value) => "`" + value + "`").join(", ");
+var count3 = z14.number().int().nonnegative();
+var persona2 = z14.object({ personaRefId: z14.string().nullable(), name: z14.string() }).strict();
+var disposition2 = z14.enum(SWARM_FINDING_DISPOSITIONS2).describe(vocabulary2(SWARM_FINDING_DISPOSITIONS2));
+var coverageNotes2 = z14.array(
+  z14.enum(SWARM_FINDING_COVERAGE_NOTES2).describe(vocabulary2(SWARM_FINDING_COVERAGE_NOTES2))
+);
+var citations2 = z14.array(z14.string().regex(/^[^/]+\/.+$/)).max(30);
+var toneMatchesDisposition2 = (row2) => row2.tone === SWARM_FINDING_TONE_OF_DISPOSITION2[row2.disposition];
+var toneMismatch2 = {
+  message: "tone must equal SWARM_FINDING_TONE_OF_DISPOSITION[disposition]",
+  path: ["tone"]
+};
+var swarmJourneyFindingSchema2 = z14.object({
+  id: z14.string().min(1),
+  basis: z14.enum(SWARM_FINDING_BASES2).describe(vocabulary2(SWARM_FINDING_BASES2)),
+  scopeLevel: z14.enum(SWARM_FINDING_SCOPE_LEVELS2).describe(vocabulary2(SWARM_FINDING_SCOPE_LEVELS2)),
+  persona: persona2,
+  goal: z14.object({
+    runId: z14.string(),
+    journeyRefId: z14.string(),
+    title: z14.string()
+  }).strict(),
+  target: z14.object({
+    kind: z14.enum(["environment", "host"]),
+    id: z14.string(),
+    label: z14.string(),
+    modelId: z14.string().nullable()
+  }).strict(),
+  population: z14.object({ count: count3, total: count3, unit: z14.literal("sessions") }).strict(),
+  sessionIds: z14.array(z14.string()).max(1e3),
+  citations: citations2,
+  verdictSeen: swarmSessionVerdictValueSchema2,
+  chainStage: userValueStageSchema2.nullable().describe(vocabulary2(USER_VALUE_STAGES2)),
+  chainStageState: stageStateSchema2.nullable().describe(vocabulary2(STAGE_STATES2)),
+  chainStageBasis: z14.enum(SWARM_FINDING_CHAIN_STAGE_BASES2),
+  disposition: disposition2,
+  tone: z14.enum(SWARM_FINDING_TONES2),
+  coverageNotes: coverageNotes2,
+  outcomePhrase: z14.string().max(100).regex(/^[^0-9]*$/).refine(
+    (value) => value.trim().split(/\s+/).length <= 8,
+    "At most eight words"
+  ).nullable(),
+  mechanismPhrase: z14.string().nullable(),
+  fixPhrase: z14.string().nullable(),
+  reportExcerpt: z14.object({ actual: z14.string().max(1800), citations: citations2 }).strict().nullable(),
+  mechanismId: z14.string().nullable()
+}).strict().refine(toneMatchesDisposition2, toneMismatch2);
+var swarmJourneyFindingsSchema = z14.object({
+  contractVersion: z14.literal(SWARM_FINDING_CONTRACT_VERSION2),
+  generatedAt: count3,
+  sourceRevision: z14.string(),
+  pipelineVersion: count3,
+  extractionVersion: count3,
+  extractionModel: z14.string(),
+  reasoningModel: z14.string(),
+  summaryKind: z14.enum(SWARM_FINDING_SUMMARY_KINDS2).describe(vocabulary2(SWARM_FINDING_SUMMARY_KINDS2)),
+  population: z14.object({
+    configured: count3,
+    started: count3,
+    read: count3,
+    unread: count3,
+    withdrawn: count3,
+    limited: count3,
+    graded: count3
+  }).strict(),
+  coverageNotes: coverageNotes2,
+  disclosure: z14.object({
+    rail: z14.enum(["gateway", "openrouter"]),
+    evidenceSent: z14.array(z14.string())
+  }).strict(),
+  personas: z14.array(
+    z14.object({
+      persona: persona2,
+      disposition: disposition2,
+      tone: z14.enum(SWARM_FINDING_TONES2),
+      goalRunIds: z14.array(z14.string())
+    }).strict().refine(toneMatchesDisposition2, toneMismatch2)
+  ),
+  findings: z14.array(swarmJourneyFindingSchema2).max(200)
+}).strict();
+var swarmJourneyFindingsJobSchema = z14.object({
+  status: z14.enum(["pending", "completed", "failed", "skipped"]),
+  errorCode: z14.string().optional(),
+  updatedAt: count3
+}).strict();
 var USER_VALUE_STAGE_LABELS2 = Object.freeze({
   connection: "Connection",
   discovery: "Discovery",
@@ -130719,7 +131240,51 @@ var SUSPECTED_CONDITION_CONFIDENCE_LABELS = Object.freeze({
   medium: "medium confidence",
   high: "high confidence"
 });
+var SWARM_FINDING_DISPOSITION_LABELS = Object.freeze({
+  notRun: "Not run",
+  blockedConnecting: "Stuck",
+  lostFindingTool: "Lost",
+  blockedCallingTool: "Annoyed",
+  blockedByResponse: "Frustrated",
+  goalMissed: "Stalled",
+  goalMetWithFriction: "Uneasy",
+  goalMet: "Relieved",
+  notMeasured: "Unscored"
+});
+var SWARM_FINDING_COVERAGE_NOTE_LABELS = Object.freeze({
+  sessionScanCapped: "Session scan limit reached",
+  budgetExhausted: "Analysis budget exhausted",
+  transcriptMissing: "Transcript unavailable",
+  contextTooLarge: "Transcript exceeds analysis limits",
+  extractionRejected: "Analysis could not be verified",
+  chainUnmeasured: "Journey stages not measured",
+  judgeNotRun: "Judge did not run",
+  sessionsWithdrawn: "Some sessions were withdrawn",
+  sessionsRateLimited: "Some sessions were rate limited",
+  partialRead: "Only part of this wave was read",
+  toolCatalogMissing: "Tool catalog unavailable"
+});
+var SWARM_FINDING_SUMMARY_KIND_LABELS = Object.freeze({
+  notLaunched: "Not launched",
+  broken: "Goals blocked",
+  friction: "Goals met with friction",
+  landed: "Goals met",
+  ungraded: "Not graded",
+  unread: "Not fully read"
+});
+var SWARM_FINDING_BASIS_LABELS = Object.freeze({
+  verifiedMechanism: "Verified explanation",
+  sessionReport: "Session report",
+  populationFact: "Population fact"
+});
 var DECISION_LABEL_VOCABULARIES = Object.freeze({
+  swarmFindingDispositions: SWARM_FINDING_DISPOSITIONS2,
+  swarmFindingCoverageNotes: SWARM_FINDING_COVERAGE_NOTES2,
+  swarmFindingSummaryKinds: SWARM_FINDING_SUMMARY_KINDS2,
+  swarmFindingBases: SWARM_FINDING_BASES2,
+  swarmFindingScopeLevels: SWARM_FINDING_SCOPE_LEVELS2,
+  // Tones are presentation vocabulary shared with unrelated UI schemas.
+  // Their totality is tested directly against the disposition-to-tone map.
   stages: USER_VALUE_STAGES2,
   stageStates: STAGE_STATES2,
   failureCategories: FAILURE_CATEGORIES2,
@@ -131140,10 +131705,10 @@ function assembleEvalRunDecisionSummary(input) {
 }
 function legacyTrialCounts(summary) {
   if (!summary || typeof summary !== "object") return void 0;
-  const count22 = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
-  const total = count22(summary.total);
-  const passed2 = count22(summary.passed);
-  const failed3 = count22(summary.failed);
+  const count32 = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+  const total = count32(summary.total);
+  const passed2 = count32(summary.passed);
+  const failed3 = count32(summary.failed);
   if (total === void 0 && passed2 === void 0 && failed3 === void 0) {
     return void 0;
   }
@@ -132557,249 +133122,28 @@ var evalBacktestContinuationSchema2 = z14.object({
 var evalBacktestRequestSchema = evalBacktestDraftSchema2.extend({
   continuation: evalBacktestContinuationSchema2.optional()
 });
-var SWARM_SESSION_VERDICT_CONTRACT_VERSION2 = 1;
-var SWARM_STAGE_EVIDENCE_VERSION = 2;
-var SWARM_ATTEMPT_STATUSES2 = [
-  "pending",
-  "running",
-  "succeeded",
-  "failed",
-  "rate_limited"
-];
-var SWARM_SESSION_LIFECYCLES2 = [
-  "pending",
-  "running",
-  "ran",
-  "broke",
-  "limited",
-  "withdrawn"
-];
-var SWARM_SESSION_VERDICTS2 = [
-  "passed",
-  "failed",
-  "inconclusive",
-  "notEstablished"
-];
-var SWARM_GRADING_STATES2 = [
-  "notRequested",
-  "queued",
-  "running",
-  "settled",
-  "unavailable"
-];
-var SWARM_SESSION_VERDICT_OF_REASON2 = {
-  attemptPending: "notEstablished",
-  attemptRunning: "notEstablished",
-  withdrawn: "notEstablished",
-  spendCapReached: "notEstablished",
-  notRun: "notEstablished",
-  executionFailed: "notEstablished",
-  ungraded: "notEstablished",
-  gradingNotClaimed: "notEstablished",
-  criteriaPending: "notEstablished",
-  judgePending: "notEstablished",
-  gatingCriterionFailed: "failed",
-  judgeFailed: "failed",
-  criteriaGradingErrored: "inconclusive",
-  gatingCriterionUnmeasured: "inconclusive",
-  judgeErrored: "inconclusive",
-  gradingUnavailable: "inconclusive",
-  allGatingCriteriaPassed: "passed",
-  judgePassed: "passed",
-  allGradersPassed: "passed"
-};
-var SWARM_SESSION_VERDICT_REASONS2 = Object.keys(
-  SWARM_SESSION_VERDICT_OF_REASON2
-);
-var swarmSessionLifecycleSchema2 = z14.enum(SWARM_SESSION_LIFECYCLES2);
-var swarmSessionVerdictValueSchema2 = z14.enum(SWARM_SESSION_VERDICTS2);
-var swarmGraderRoleSchema2 = z14.enum(["advisory", "required"]);
-var swarmSessionAttemptInputSchema2 = z14.object({
-  status: z14.enum(SWARM_ATTEMPT_STATUSES2),
-  errorCode: z14.string().nullable().optional()
-}).strict();
-var swarmGradingReadinessSchema2 = z14.object({
-  /** Durable readiness for decisive grading only, not background observations. */
-  state: z14.enum(SWARM_GRADING_STATES2),
-  reasonCode: z14.string().min(1).optional()
-}).strict();
-var criterionResultSchema2 = z14.object({
-  criterionId: z14.string().min(1),
-  passed: z14.boolean(),
-  status: z14.enum(["scored", "error"]).optional()
-}).strict();
-var swarmSessionVerdictInputSchema = z14.object({
-  attempt: swarmSessionAttemptInputSchema2.nullable(),
-  hasTranscript: z14.boolean(),
-  rubric: z14.array(
-    z14.object({
-      id: z14.string().min(1),
-      role: swarmGraderRoleSchema2,
-      predicateType: z14.string().min(1).optional()
-    }).strict()
-  ),
-  criteria: z14.object({
-    status: z14.enum(["pending", "completed", "failed"]),
-    criterionIds: z14.array(z14.string().min(1)).optional(),
-    results: z14.array(criterionResultSchema2).optional()
-  }).strict().nullable(),
-  goalScore: z14.discriminatedUnion("status", [
-    z14.object({ status: z14.literal("completed"), passed: z14.boolean() }).strict(),
-    z14.object({ status: z14.literal("running") }).strict(),
-    z14.object({ status: z14.literal("failed") }).strict()
-  ]).nullable(),
-  judge: z14.object({
-    automatic: z14.boolean(),
-    role: swarmGraderRoleSchema2,
-    /** Explicit on-demand intent; automatic:false alone does not mean a judge was requested. */
-    requested: z14.boolean().optional()
-  }).strict(),
-  grading: swarmGradingReadinessSchema2
-}).strict().superRefine((value, ctx) => {
-  const definitions = new Set(value.rubric.map((entry3) => entry3.id));
-  if (definitions.size !== value.rubric.length) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["rubric"],
-      message: "Duplicate criterion definition"
-    });
-  }
-  for (const [field, ids] of [
-    ["criterionIds", value.criteria?.criterionIds ?? []],
-    ["results", value.criteria?.results?.map((row2) => row2.criterionId) ?? []]
-  ]) {
-    if (new Set(ids).size !== ids.length || ids.some((id3) => !definitions.has(id3))) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["criteria", field],
-        message: "Criterion IDs must be unique and defined in the snapshot"
-      });
-    }
-  }
-  const claimed = value.criteria?.criterionIds;
-  if (claimed && value.criteria?.results?.some((row2) => !claimed.includes(row2.criterionId))) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["criteria", "results"],
-      message: "Result outside claimed scope"
-    });
-  }
-});
-var SWARM_SESSION_TRIAL_STATUSES2 = [
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "setup_failed",
-  "cancelled"
-];
-var swarmSessionTrialSchema2 = z14.object({
-  status: z14.enum(SWARM_SESSION_TRIAL_STATUSES2),
-  taskVerdict: z14.enum(["passed", "failed"]).optional(),
-  evaluatorError: z14.literal(true).optional()
-}).strict().superRefine((value, ctx) => {
-  const verdict = value.taskVerdict !== void 0;
-  const error = value.evaluatorError === true;
-  if (value.status === "completed" ? verdict === error : verdict || error) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Only completed trials carry exactly one verdict or evaluator error"
-    });
-  }
-});
-var swarmSessionGraderCountsSchema2 = z14.object({
-  gating: z14.number().int().nonnegative(),
-  gatingPassed: z14.number().int().nonnegative(),
-  gatingFailed: z14.number().int().nonnegative(),
-  gatingUnmeasured: z14.number().int().nonnegative(),
-  advisoryFailed: z14.number().int().nonnegative()
-}).strict();
-var swarmSessionVerdictSchema2 = z14.object({
-  contractVersion: z14.literal(SWARM_SESSION_VERDICT_CONTRACT_VERSION2),
-  lifecycle: swarmSessionLifecycleSchema2,
-  verdict: swarmSessionVerdictValueSchema2,
-  reason: z14.enum(SWARM_SESSION_VERDICT_REASONS2),
-  verdictSource: z14.enum([
-    "goalJudge",
-    "requiredAssertions",
-    "combined",
-    "none"
-  ]),
-  grading: swarmGradingReadinessSchema2,
-  graders: z14.object({
-    criteria: z14.enum([
-      "notConfigured",
-      "notClaimed",
-      "pending",
-      "scored",
-      "errored"
-    ]),
-    judge: z14.enum([
-      "notConfigured",
-      "silent",
-      "pending",
-      "scored",
-      "errored"
-    ])
-  }).strict(),
-  counts: swarmSessionGraderCountsSchema2,
-  trial: swarmSessionTrialSchema2.nullable()
-}).strict().superRefine((value, ctx) => {
-  const fail3 = (message) => ctx.addIssue({ code: "custom", message });
-  if (SWARM_SESSION_VERDICT_OF_REASON2[value.reason] !== value.verdict)
-    fail3("Reason contradicts verdict");
-  const c = value.counts;
-  if (c.gating !== c.gatingPassed + c.gatingFailed + c.gatingUnmeasured)
-    fail3("Required measurement counts do not add up");
-  const trial = value.trial;
-  if (trial?.status === "completed") {
-    if (value.lifecycle !== "ran")
-      fail3("Only a completed execution can be a completed trial");
-    if (trial.taskVerdict !== void 0 && trial.taskVerdict !== value.verdict)
-      fail3("Trial contradicts goal result");
-    if (trial.evaluatorError && value.verdict !== "inconclusive")
-      fail3("Evaluator error requires inconclusive grading");
-  }
-  const expected = {
-    pending: "pending",
-    running: "running",
-    broke: "failed",
-    limited: "setup_failed",
-    withdrawn: "cancelled"
-  };
-  if (value.lifecycle !== "ran" && trial?.status !== expected[value.lifecycle])
-    fail3("Trial must preserve execution lifecycle");
-  if (value.lifecycle === "ran" && trial !== null && trial.status !== "completed")
-    fail3("Completed execution must not become skipped or running");
-  if ((value.verdict === "passed" || value.verdict === "failed") && value.verdictSource === "none")
-    fail3("A measured goal verdict needs a source");
-  if (value.lifecycle === "ran" && value.verdict !== "notEstablished" && trial === null)
-    fail3("Settled grading on completed execution needs an observation");
-  if (value.verdict === "notEstablished" && value.verdictSource !== "none")
-    fail3("An undecided goal has no verdict source");
-});
 var SWARM_REPORT_CONTRACT_VERSION2 = 1;
-var count2 = z14.number().int().nonnegative();
+var count22 = z14.number().int().nonnegative();
 var journeyRunVerdictSummarySchema2 = z14.discriminatedUnion("status", [
   z14.object({
     status: z14.literal("pending"),
-    pendingSessions: count2,
-    updatedAt: count2
+    pendingSessions: count22,
+    updatedAt: count22
   }).strict(),
   z14.object({
     status: z14.literal("decided"),
     decision: evalVerdictDecisionSchema2,
-    updatedAt: count2
+    updatedAt: count22
   }).strict(),
   z14.object({
     status: z14.literal("notEstablished"),
     reason: z14.literal("gradingNotConfigured"),
-    updatedAt: count2
+    updatedAt: count22
   }).strict(),
   z14.object({
     status: z14.literal("integrityFailed"),
     reason: z14.string().min(1),
-    updatedAt: count2
+    updatedAt: count22
   }).strict()
 ]);
 var swarmObservationInputSchema2 = z14.object({
@@ -132837,7 +133181,7 @@ var swarmReportSessionSchema2 = z14.object({
 var swarmReportInputSchema = z14.object({
   runId: z14.string().min(1),
   executionComplete: z14.boolean(),
-  configuredSessions: count2,
+  configuredSessions: count22,
   verdictSummary: journeyRunVerdictSummarySchema2.nullable(),
   /** Frozen run-wide definitions: absent measurement rows still count as unavailable. */
   evaluatorDefinitions: z14.array(
@@ -132892,11 +133236,11 @@ var swarmObservationCoverageSchema2 = z14.object({
     "The stage this observation was read from, and the only stage it is evidence ABOUT. `connection` \u2014 the server was reachable and the session initialized. `discovery` \u2014 its tools and resources were listed and readable. `selection` \u2014 the model chose the right tool for the request. `call` \u2014 the call was made with usable arguments. `response` \u2014 the server returned data the model could use. `userValue` \u2014 the user's actual request was satisfied."
   ),
   unit: z14.literal("sessions"),
-  total: count2,
-  passed: count2,
-  failed: count2,
-  pending: count2,
-  unavailable: count2
+  total: count22,
+  passed: count22,
+  failed: count22,
+  pending: count22,
+  unavailable: count22
 }).strict().superRefine((value, ctx) => {
   if (value.total !== value.passed + value.failed + value.pending + value.unavailable) {
     ctx.addIssue({
@@ -132926,26 +133270,26 @@ var swarmReportSchema = z14.object({
   ]).optional(),
   execution: z14.object({
     unit: z14.literal("sessions"),
-    configured: count2,
-    reported: count2,
-    started: count2,
-    notStarted: count2,
-    unknown: count2,
-    completed: count2,
-    interrupted: count2,
+    configured: count22,
+    reported: count22,
+    started: count22,
+    notStarted: count22,
+    unknown: count22,
+    completed: count22,
+    interrupted: count22,
     /** Only explicit complete execution evidence can establish this. */
     neverLaunched: z14.boolean()
   }).strict(),
   goalGrading: z14.object({
     unit: z14.literal("sessions"),
-    reported: count2,
-    passed: count2,
-    failed: count2,
-    pending: count2,
-    unavailable: count2,
-    notRequested: count2,
+    reported: count22,
+    passed: count22,
+    failed: count22,
+    pending: count22,
+    unavailable: count22,
+    notRequested: count22,
     /** Readiness is separate: a proven failure can exist while other required grading is pending. */
-    waitingForDecisiveGrading: count2
+    waitingForDecisiveGrading: count22
   }).strict(),
   observations: z14.array(swarmObservationCoverageSchema2)
 }).strict().superRefine((report, ctx) => {
@@ -147013,22 +147357,23 @@ function attachedFailureCode(error) {
   return typeof code === "string" ? code : void 0;
 }
 function parseEngineErrorBody(status, bodyText) {
-  let code;
   try {
     const body = JSON.parse(bodyText);
-    if (body?.error) {
+    if (body && typeof body === "object") {
       return {
-        message: body.details ? `${body.error} ${body.details}` : body.error,
+        message: body.error ? body.details ? `${body.error} ${body.details}` : body.error : `Backend stream error: ${status} ${bodyText}`,
         ...body.code ? { code: body.code } : {},
-        ...body.details ? { details: body.details } : {}
+        ...body.details ? { details: body.details } : {},
+        ...typeof body.retryAfter === "number" && Number.isFinite(body.retryAfter) ? { retryAfterMs: body.retryAfter } : {},
+        ...typeof body.isRetryable === "boolean" ? { isRetryable: body.isRetryable } : {},
+        ...typeof body.refusalReason === "string" ? { refusalReason: body.refusalReason } : {},
+        ...typeof body.outstandingHolds === "number" ? { outstandingHolds: body.outstandingHolds } : {}
       };
     }
-    code = typeof body?.code === "string" ? body.code : void 0;
   } catch {
   }
   return {
-    message: status !== void 0 ? `Backend stream error: ${status} ${bodyText}` : bodyText,
-    ...code ? { code } : {}
+    message: status !== void 0 ? `Backend stream error: ${status} ${bodyText}` : bodyText
   };
 }
 function safelyEmitEngineError(onEngineError, event) {
@@ -147802,7 +148147,7 @@ async function processOneStep(ctx) {
       });
     }
     safelyEmitEngineError(onEngineError, {
-      message: parsed.message,
+      ...parsed,
       ...parsed.code ? { code: parsed.code } : {},
       ...parsed.details ? { details: parsed.details } : {},
       httpStatus: res.status,
@@ -153446,7 +153791,7 @@ function platformRefusalHint(refusal) {
   return refusal.canTopUp === false ? `${when} This is a usage limit: topping up credits does not lift it.` : when;
 }
 function readSdkVersion3() {
-  return "8.10.1";
+  return "8.11.0";
 }
 var DEFAULT_PLATFORM_API_BASE_URL = "https://app.mcpjam.com/api/v1";
 function resolvePlatformRequestUrl(spec) {
@@ -153612,11 +153957,11 @@ var PlatformApiClient = class _PlatformApiClient {
    * header more. The original client is untouched; the CLI keeps it for the
    * operations that still speak vocabulary 1.
    */
-  withEvalVocabulary(vocabulary) {
-    if (vocabulary === this.evalVocabulary) return this;
+  withEvalVocabulary(vocabulary22) {
+    if (vocabulary22 === this.evalVocabulary) return this;
     return new _PlatformApiClient({
       ...this.constructorOptions,
-      evalVocabulary: vocabulary
+      evalVocabulary: vocabulary22
     });
   }
   /** Coding-agent browser entry point; command outcomes are returned in-band. */
@@ -159992,6 +160337,374 @@ z24.discriminatedUnion("status", [
     ...suspectedConditionProvenance3
   }).strict()
 ]);
+var SWARM_SESSION_VERDICT_CONTRACT_VERSION3 = 1;
+var SWARM_ATTEMPT_STATUSES3 = [
+  "pending",
+  "running",
+  "succeeded",
+  "failed",
+  "rate_limited"
+];
+var SWARM_SESSION_LIFECYCLES3 = [
+  "pending",
+  "running",
+  "ran",
+  "broke",
+  "limited",
+  "withdrawn"
+];
+var SWARM_SESSION_VERDICTS3 = [
+  "passed",
+  "failed",
+  "inconclusive",
+  "notEstablished"
+];
+var SWARM_GRADING_STATES3 = [
+  "notRequested",
+  "queued",
+  "running",
+  "settled",
+  "unavailable"
+];
+var SWARM_SESSION_VERDICT_OF_REASON3 = {
+  attemptPending: "notEstablished",
+  attemptRunning: "notEstablished",
+  withdrawn: "notEstablished",
+  spendCapReached: "notEstablished",
+  notRun: "notEstablished",
+  executionFailed: "notEstablished",
+  ungraded: "notEstablished",
+  gradingNotClaimed: "notEstablished",
+  criteriaPending: "notEstablished",
+  judgePending: "notEstablished",
+  gatingCriterionFailed: "failed",
+  judgeFailed: "failed",
+  criteriaGradingErrored: "inconclusive",
+  gatingCriterionUnmeasured: "inconclusive",
+  judgeErrored: "inconclusive",
+  gradingUnavailable: "inconclusive",
+  allGatingCriteriaPassed: "passed",
+  judgePassed: "passed",
+  allGradersPassed: "passed"
+};
+var SWARM_SESSION_VERDICT_REASONS3 = Object.keys(
+  SWARM_SESSION_VERDICT_OF_REASON3
+);
+var swarmSessionLifecycleSchema3 = z24.enum(SWARM_SESSION_LIFECYCLES3);
+var swarmSessionVerdictValueSchema3 = z24.enum(SWARM_SESSION_VERDICTS3);
+var swarmGraderRoleSchema3 = z24.enum(["advisory", "required"]);
+var swarmSessionAttemptInputSchema3 = z24.object({
+  status: z24.enum(SWARM_ATTEMPT_STATUSES3),
+  errorCode: z24.string().nullable().optional()
+}).strict();
+var swarmGradingReadinessSchema3 = z24.object({
+  /** Durable readiness for decisive grading only, not background observations. */
+  state: z24.enum(SWARM_GRADING_STATES3),
+  reasonCode: z24.string().min(1).optional()
+}).strict();
+var criterionResultSchema3 = z24.object({
+  criterionId: z24.string().min(1),
+  passed: z24.boolean(),
+  status: z24.enum(["scored", "error"]).optional()
+}).strict();
+z24.object({
+  attempt: swarmSessionAttemptInputSchema3.nullable(),
+  hasTranscript: z24.boolean(),
+  rubric: z24.array(
+    z24.object({
+      id: z24.string().min(1),
+      role: swarmGraderRoleSchema3,
+      predicateType: z24.string().min(1).optional()
+    }).strict()
+  ),
+  criteria: z24.object({
+    status: z24.enum(["pending", "completed", "failed"]),
+    criterionIds: z24.array(z24.string().min(1)).optional(),
+    results: z24.array(criterionResultSchema3).optional()
+  }).strict().nullable(),
+  goalScore: z24.discriminatedUnion("status", [
+    z24.object({ status: z24.literal("completed"), passed: z24.boolean() }).strict(),
+    z24.object({ status: z24.literal("running") }).strict(),
+    z24.object({ status: z24.literal("failed") }).strict()
+  ]).nullable(),
+  judge: z24.object({
+    automatic: z24.boolean(),
+    role: swarmGraderRoleSchema3,
+    /** Explicit on-demand intent; automatic:false alone does not mean a judge was requested. */
+    requested: z24.boolean().optional()
+  }).strict(),
+  grading: swarmGradingReadinessSchema3
+}).strict().superRefine((value, ctx) => {
+  const definitions = new Set(value.rubric.map((entry3) => entry3.id));
+  if (definitions.size !== value.rubric.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rubric"],
+      message: "Duplicate criterion definition"
+    });
+  }
+  for (const [field, ids] of [
+    ["criterionIds", value.criteria?.criterionIds ?? []],
+    ["results", value.criteria?.results?.map((row2) => row2.criterionId) ?? []]
+  ]) {
+    if (new Set(ids).size !== ids.length || ids.some((id3) => !definitions.has(id3))) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["criteria", field],
+        message: "Criterion IDs must be unique and defined in the snapshot"
+      });
+    }
+  }
+  const claimed = value.criteria?.criterionIds;
+  if (claimed && value.criteria?.results?.some((row2) => !claimed.includes(row2.criterionId))) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["criteria", "results"],
+      message: "Result outside claimed scope"
+    });
+  }
+});
+var SWARM_SESSION_TRIAL_STATUSES3 = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "setup_failed",
+  "cancelled"
+];
+var swarmSessionTrialSchema3 = z24.object({
+  status: z24.enum(SWARM_SESSION_TRIAL_STATUSES3),
+  taskVerdict: z24.enum(["passed", "failed"]).optional(),
+  evaluatorError: z24.literal(true).optional()
+}).strict().superRefine((value, ctx) => {
+  const verdict = value.taskVerdict !== void 0;
+  const error = value.evaluatorError === true;
+  if (value.status === "completed" ? verdict === error : verdict || error) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Only completed trials carry exactly one verdict or evaluator error"
+    });
+  }
+});
+var swarmSessionGraderCountsSchema3 = z24.object({
+  gating: z24.number().int().nonnegative(),
+  gatingPassed: z24.number().int().nonnegative(),
+  gatingFailed: z24.number().int().nonnegative(),
+  gatingUnmeasured: z24.number().int().nonnegative(),
+  advisoryFailed: z24.number().int().nonnegative()
+}).strict();
+var swarmSessionVerdictSchema3 = z24.object({
+  contractVersion: z24.literal(SWARM_SESSION_VERDICT_CONTRACT_VERSION3),
+  lifecycle: swarmSessionLifecycleSchema3,
+  verdict: swarmSessionVerdictValueSchema3,
+  reason: z24.enum(SWARM_SESSION_VERDICT_REASONS3),
+  verdictSource: z24.enum([
+    "goalJudge",
+    "requiredAssertions",
+    "combined",
+    "none"
+  ]),
+  grading: swarmGradingReadinessSchema3,
+  graders: z24.object({
+    criteria: z24.enum([
+      "notConfigured",
+      "notClaimed",
+      "pending",
+      "scored",
+      "errored"
+    ]),
+    judge: z24.enum([
+      "notConfigured",
+      "silent",
+      "pending",
+      "scored",
+      "errored"
+    ])
+  }).strict(),
+  counts: swarmSessionGraderCountsSchema3,
+  trial: swarmSessionTrialSchema3.nullable()
+}).strict().superRefine((value, ctx) => {
+  const fail3 = (message) => ctx.addIssue({ code: "custom", message });
+  if (SWARM_SESSION_VERDICT_OF_REASON3[value.reason] !== value.verdict)
+    fail3("Reason contradicts verdict");
+  const c = value.counts;
+  if (c.gating !== c.gatingPassed + c.gatingFailed + c.gatingUnmeasured)
+    fail3("Required measurement counts do not add up");
+  const trial = value.trial;
+  if (trial?.status === "completed") {
+    if (value.lifecycle !== "ran")
+      fail3("Only a completed execution can be a completed trial");
+    if (trial.taskVerdict !== void 0 && trial.taskVerdict !== value.verdict)
+      fail3("Trial contradicts goal result");
+    if (trial.evaluatorError && value.verdict !== "inconclusive")
+      fail3("Evaluator error requires inconclusive grading");
+  }
+  const expected = {
+    pending: "pending",
+    running: "running",
+    broke: "failed",
+    limited: "setup_failed",
+    withdrawn: "cancelled"
+  };
+  if (value.lifecycle !== "ran" && trial?.status !== expected[value.lifecycle])
+    fail3("Trial must preserve execution lifecycle");
+  if (value.lifecycle === "ran" && trial !== null && trial.status !== "completed")
+    fail3("Completed execution must not become skipped or running");
+  if ((value.verdict === "passed" || value.verdict === "failed") && value.verdictSource === "none")
+    fail3("A measured goal verdict needs a source");
+  if (value.lifecycle === "ran" && value.verdict !== "notEstablished" && trial === null)
+    fail3("Settled grading on completed execution needs an observation");
+  if (value.verdict === "notEstablished" && value.verdictSource !== "none")
+    fail3("An undecided goal has no verdict source");
+});
+var SWARM_FINDING_CONTRACT_VERSION3 = 1;
+var SWARM_FINDING_DISPOSITIONS3 = [
+  "notRun",
+  "blockedConnecting",
+  "lostFindingTool",
+  "blockedCallingTool",
+  "blockedByResponse",
+  "goalMissed",
+  "goalMetWithFriction",
+  "goalMet",
+  "notMeasured"
+];
+var SWARM_FINDING_TONES3 = ["fail", "warn", "ok", "muted"];
+var SWARM_FINDING_SUMMARY_KINDS3 = [
+  "notLaunched",
+  "broken",
+  "friction",
+  "landed",
+  "ungraded",
+  "unread"
+];
+var SWARM_FINDING_COVERAGE_NOTES3 = [
+  "sessionScanCapped",
+  "budgetExhausted",
+  "transcriptMissing",
+  "contextTooLarge",
+  "extractionRejected",
+  "chainUnmeasured",
+  "judgeNotRun",
+  "sessionsWithdrawn",
+  "sessionsRateLimited",
+  "partialRead",
+  "toolCatalogMissing"
+];
+var SWARM_FINDING_SCOPE_LEVELS3 = [
+  "session",
+  "goal",
+  "persona",
+  "target",
+  "wave"
+];
+var SWARM_FINDING_BASES3 = [
+  "verifiedMechanism",
+  "sessionReport",
+  "populationFact"
+];
+var SWARM_FINDING_CHAIN_STAGE_BASES3 = [
+  "derived",
+  "reported",
+  "unmeasured"
+];
+var SWARM_FINDING_TONE_OF_DISPOSITION3 = Object.freeze({
+  notRun: "muted",
+  blockedConnecting: "fail",
+  lostFindingTool: "fail",
+  blockedCallingTool: "fail",
+  blockedByResponse: "fail",
+  goalMissed: "fail",
+  goalMetWithFriction: "warn",
+  goalMet: "ok",
+  notMeasured: "muted"
+});
+var vocabulary3 = (members) => members.map((value) => "`" + value + "`").join(", ");
+var count4 = z24.number().int().nonnegative();
+var persona3 = z24.object({ personaRefId: z24.string().nullable(), name: z24.string() }).strict();
+var disposition3 = z24.enum(SWARM_FINDING_DISPOSITIONS3).describe(vocabulary3(SWARM_FINDING_DISPOSITIONS3));
+var coverageNotes3 = z24.array(
+  z24.enum(SWARM_FINDING_COVERAGE_NOTES3).describe(vocabulary3(SWARM_FINDING_COVERAGE_NOTES3))
+);
+var citations3 = z24.array(z24.string().regex(/^[^/]+\/.+$/)).max(30);
+var toneMatchesDisposition3 = (row2) => row2.tone === SWARM_FINDING_TONE_OF_DISPOSITION3[row2.disposition];
+var toneMismatch3 = {
+  message: "tone must equal SWARM_FINDING_TONE_OF_DISPOSITION[disposition]",
+  path: ["tone"]
+};
+var swarmJourneyFindingSchema3 = z24.object({
+  id: z24.string().min(1),
+  basis: z24.enum(SWARM_FINDING_BASES3).describe(vocabulary3(SWARM_FINDING_BASES3)),
+  scopeLevel: z24.enum(SWARM_FINDING_SCOPE_LEVELS3).describe(vocabulary3(SWARM_FINDING_SCOPE_LEVELS3)),
+  persona: persona3,
+  goal: z24.object({
+    runId: z24.string(),
+    journeyRefId: z24.string(),
+    title: z24.string()
+  }).strict(),
+  target: z24.object({
+    kind: z24.enum(["environment", "host"]),
+    id: z24.string(),
+    label: z24.string(),
+    modelId: z24.string().nullable()
+  }).strict(),
+  population: z24.object({ count: count4, total: count4, unit: z24.literal("sessions") }).strict(),
+  sessionIds: z24.array(z24.string()).max(1e3),
+  citations: citations3,
+  verdictSeen: swarmSessionVerdictValueSchema3,
+  chainStage: userValueStageSchema3.nullable().describe(vocabulary3(USER_VALUE_STAGES3)),
+  chainStageState: stageStateSchema3.nullable().describe(vocabulary3(STAGE_STATES3)),
+  chainStageBasis: z24.enum(SWARM_FINDING_CHAIN_STAGE_BASES3),
+  disposition: disposition3,
+  tone: z24.enum(SWARM_FINDING_TONES3),
+  coverageNotes: coverageNotes3,
+  outcomePhrase: z24.string().max(100).regex(/^[^0-9]*$/).refine(
+    (value) => value.trim().split(/\s+/).length <= 8,
+    "At most eight words"
+  ).nullable(),
+  mechanismPhrase: z24.string().nullable(),
+  fixPhrase: z24.string().nullable(),
+  reportExcerpt: z24.object({ actual: z24.string().max(1800), citations: citations3 }).strict().nullable(),
+  mechanismId: z24.string().nullable()
+}).strict().refine(toneMatchesDisposition3, toneMismatch3);
+z24.object({
+  contractVersion: z24.literal(SWARM_FINDING_CONTRACT_VERSION3),
+  generatedAt: count4,
+  sourceRevision: z24.string(),
+  pipelineVersion: count4,
+  extractionVersion: count4,
+  extractionModel: z24.string(),
+  reasoningModel: z24.string(),
+  summaryKind: z24.enum(SWARM_FINDING_SUMMARY_KINDS3).describe(vocabulary3(SWARM_FINDING_SUMMARY_KINDS3)),
+  population: z24.object({
+    configured: count4,
+    started: count4,
+    read: count4,
+    unread: count4,
+    withdrawn: count4,
+    limited: count4,
+    graded: count4
+  }).strict(),
+  coverageNotes: coverageNotes3,
+  disclosure: z24.object({
+    rail: z24.enum(["gateway", "openrouter"]),
+    evidenceSent: z24.array(z24.string())
+  }).strict(),
+  personas: z24.array(
+    z24.object({
+      persona: persona3,
+      disposition: disposition3,
+      tone: z24.enum(SWARM_FINDING_TONES3),
+      goalRunIds: z24.array(z24.string())
+    }).strict().refine(toneMatchesDisposition3, toneMismatch3)
+  ),
+  findings: z24.array(swarmJourneyFindingSchema3).max(200)
+}).strict();
+z24.object({
+  status: z24.enum(["pending", "completed", "failed", "skipped"]),
+  errorCode: z24.string().optional(),
+  updatedAt: count4
+}).strict();
 var NEXT_ACTION_BY_FAILURE_CATEGORY3 = Object.freeze({
   setup: "check the server connection and environment configuration",
   metadata: "review the tool metadata and descriptions in the server catalog",
@@ -160314,10 +161027,10 @@ function assembleEvalRunDecisionSummary2(input) {
 }
 function legacyTrialCounts2(summary) {
   if (!summary || typeof summary !== "object") return void 0;
-  const count22 = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
-  const total = count22(summary.total);
-  const passed2 = count22(summary.passed);
-  const failed3 = count22(summary.failed);
+  const count32 = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+  const total = count32(summary.total);
+  const passed2 = count32(summary.passed);
+  const failed3 = count32(summary.failed);
   if (total === void 0 && passed2 === void 0 && failed3 === void 0) {
     return void 0;
   }
@@ -161576,248 +162289,28 @@ var evalBacktestContinuationSchema3 = z24.object({
 evalBacktestDraftSchema3.extend({
   continuation: evalBacktestContinuationSchema3.optional()
 });
-var SWARM_SESSION_VERDICT_CONTRACT_VERSION3 = 1;
-var SWARM_ATTEMPT_STATUSES3 = [
-  "pending",
-  "running",
-  "succeeded",
-  "failed",
-  "rate_limited"
-];
-var SWARM_SESSION_LIFECYCLES3 = [
-  "pending",
-  "running",
-  "ran",
-  "broke",
-  "limited",
-  "withdrawn"
-];
-var SWARM_SESSION_VERDICTS3 = [
-  "passed",
-  "failed",
-  "inconclusive",
-  "notEstablished"
-];
-var SWARM_GRADING_STATES3 = [
-  "notRequested",
-  "queued",
-  "running",
-  "settled",
-  "unavailable"
-];
-var SWARM_SESSION_VERDICT_OF_REASON3 = {
-  attemptPending: "notEstablished",
-  attemptRunning: "notEstablished",
-  withdrawn: "notEstablished",
-  spendCapReached: "notEstablished",
-  notRun: "notEstablished",
-  executionFailed: "notEstablished",
-  ungraded: "notEstablished",
-  gradingNotClaimed: "notEstablished",
-  criteriaPending: "notEstablished",
-  judgePending: "notEstablished",
-  gatingCriterionFailed: "failed",
-  judgeFailed: "failed",
-  criteriaGradingErrored: "inconclusive",
-  gatingCriterionUnmeasured: "inconclusive",
-  judgeErrored: "inconclusive",
-  gradingUnavailable: "inconclusive",
-  allGatingCriteriaPassed: "passed",
-  judgePassed: "passed",
-  allGradersPassed: "passed"
-};
-var SWARM_SESSION_VERDICT_REASONS3 = Object.keys(
-  SWARM_SESSION_VERDICT_OF_REASON3
-);
-var swarmSessionLifecycleSchema3 = z24.enum(SWARM_SESSION_LIFECYCLES3);
-var swarmSessionVerdictValueSchema3 = z24.enum(SWARM_SESSION_VERDICTS3);
-var swarmGraderRoleSchema3 = z24.enum(["advisory", "required"]);
-var swarmSessionAttemptInputSchema3 = z24.object({
-  status: z24.enum(SWARM_ATTEMPT_STATUSES3),
-  errorCode: z24.string().nullable().optional()
-}).strict();
-var swarmGradingReadinessSchema3 = z24.object({
-  /** Durable readiness for decisive grading only, not background observations. */
-  state: z24.enum(SWARM_GRADING_STATES3),
-  reasonCode: z24.string().min(1).optional()
-}).strict();
-var criterionResultSchema3 = z24.object({
-  criterionId: z24.string().min(1),
-  passed: z24.boolean(),
-  status: z24.enum(["scored", "error"]).optional()
-}).strict();
-z24.object({
-  attempt: swarmSessionAttemptInputSchema3.nullable(),
-  hasTranscript: z24.boolean(),
-  rubric: z24.array(
-    z24.object({
-      id: z24.string().min(1),
-      role: swarmGraderRoleSchema3,
-      predicateType: z24.string().min(1).optional()
-    }).strict()
-  ),
-  criteria: z24.object({
-    status: z24.enum(["pending", "completed", "failed"]),
-    criterionIds: z24.array(z24.string().min(1)).optional(),
-    results: z24.array(criterionResultSchema3).optional()
-  }).strict().nullable(),
-  goalScore: z24.discriminatedUnion("status", [
-    z24.object({ status: z24.literal("completed"), passed: z24.boolean() }).strict(),
-    z24.object({ status: z24.literal("running") }).strict(),
-    z24.object({ status: z24.literal("failed") }).strict()
-  ]).nullable(),
-  judge: z24.object({
-    automatic: z24.boolean(),
-    role: swarmGraderRoleSchema3,
-    /** Explicit on-demand intent; automatic:false alone does not mean a judge was requested. */
-    requested: z24.boolean().optional()
-  }).strict(),
-  grading: swarmGradingReadinessSchema3
-}).strict().superRefine((value, ctx) => {
-  const definitions = new Set(value.rubric.map((entry3) => entry3.id));
-  if (definitions.size !== value.rubric.length) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["rubric"],
-      message: "Duplicate criterion definition"
-    });
-  }
-  for (const [field, ids] of [
-    ["criterionIds", value.criteria?.criterionIds ?? []],
-    ["results", value.criteria?.results?.map((row2) => row2.criterionId) ?? []]
-  ]) {
-    if (new Set(ids).size !== ids.length || ids.some((id3) => !definitions.has(id3))) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["criteria", field],
-        message: "Criterion IDs must be unique and defined in the snapshot"
-      });
-    }
-  }
-  const claimed = value.criteria?.criterionIds;
-  if (claimed && value.criteria?.results?.some((row2) => !claimed.includes(row2.criterionId))) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["criteria", "results"],
-      message: "Result outside claimed scope"
-    });
-  }
-});
-var SWARM_SESSION_TRIAL_STATUSES3 = [
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "setup_failed",
-  "cancelled"
-];
-var swarmSessionTrialSchema3 = z24.object({
-  status: z24.enum(SWARM_SESSION_TRIAL_STATUSES3),
-  taskVerdict: z24.enum(["passed", "failed"]).optional(),
-  evaluatorError: z24.literal(true).optional()
-}).strict().superRefine((value, ctx) => {
-  const verdict = value.taskVerdict !== void 0;
-  const error = value.evaluatorError === true;
-  if (value.status === "completed" ? verdict === error : verdict || error) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Only completed trials carry exactly one verdict or evaluator error"
-    });
-  }
-});
-var swarmSessionGraderCountsSchema3 = z24.object({
-  gating: z24.number().int().nonnegative(),
-  gatingPassed: z24.number().int().nonnegative(),
-  gatingFailed: z24.number().int().nonnegative(),
-  gatingUnmeasured: z24.number().int().nonnegative(),
-  advisoryFailed: z24.number().int().nonnegative()
-}).strict();
-var swarmSessionVerdictSchema3 = z24.object({
-  contractVersion: z24.literal(SWARM_SESSION_VERDICT_CONTRACT_VERSION3),
-  lifecycle: swarmSessionLifecycleSchema3,
-  verdict: swarmSessionVerdictValueSchema3,
-  reason: z24.enum(SWARM_SESSION_VERDICT_REASONS3),
-  verdictSource: z24.enum([
-    "goalJudge",
-    "requiredAssertions",
-    "combined",
-    "none"
-  ]),
-  grading: swarmGradingReadinessSchema3,
-  graders: z24.object({
-    criteria: z24.enum([
-      "notConfigured",
-      "notClaimed",
-      "pending",
-      "scored",
-      "errored"
-    ]),
-    judge: z24.enum([
-      "notConfigured",
-      "silent",
-      "pending",
-      "scored",
-      "errored"
-    ])
-  }).strict(),
-  counts: swarmSessionGraderCountsSchema3,
-  trial: swarmSessionTrialSchema3.nullable()
-}).strict().superRefine((value, ctx) => {
-  const fail3 = (message) => ctx.addIssue({ code: "custom", message });
-  if (SWARM_SESSION_VERDICT_OF_REASON3[value.reason] !== value.verdict)
-    fail3("Reason contradicts verdict");
-  const c = value.counts;
-  if (c.gating !== c.gatingPassed + c.gatingFailed + c.gatingUnmeasured)
-    fail3("Required measurement counts do not add up");
-  const trial = value.trial;
-  if (trial?.status === "completed") {
-    if (value.lifecycle !== "ran")
-      fail3("Only a completed execution can be a completed trial");
-    if (trial.taskVerdict !== void 0 && trial.taskVerdict !== value.verdict)
-      fail3("Trial contradicts goal result");
-    if (trial.evaluatorError && value.verdict !== "inconclusive")
-      fail3("Evaluator error requires inconclusive grading");
-  }
-  const expected = {
-    pending: "pending",
-    running: "running",
-    broke: "failed",
-    limited: "setup_failed",
-    withdrawn: "cancelled"
-  };
-  if (value.lifecycle !== "ran" && trial?.status !== expected[value.lifecycle])
-    fail3("Trial must preserve execution lifecycle");
-  if (value.lifecycle === "ran" && trial !== null && trial.status !== "completed")
-    fail3("Completed execution must not become skipped or running");
-  if ((value.verdict === "passed" || value.verdict === "failed") && value.verdictSource === "none")
-    fail3("A measured goal verdict needs a source");
-  if (value.lifecycle === "ran" && value.verdict !== "notEstablished" && trial === null)
-    fail3("Settled grading on completed execution needs an observation");
-  if (value.verdict === "notEstablished" && value.verdictSource !== "none")
-    fail3("An undecided goal has no verdict source");
-});
 var SWARM_REPORT_CONTRACT_VERSION3 = 1;
-var count3 = z24.number().int().nonnegative();
+var count23 = z24.number().int().nonnegative();
 var journeyRunVerdictSummarySchema3 = z24.discriminatedUnion("status", [
   z24.object({
     status: z24.literal("pending"),
-    pendingSessions: count3,
-    updatedAt: count3
+    pendingSessions: count23,
+    updatedAt: count23
   }).strict(),
   z24.object({
     status: z24.literal("decided"),
     decision: evalVerdictDecisionSchema3,
-    updatedAt: count3
+    updatedAt: count23
   }).strict(),
   z24.object({
     status: z24.literal("notEstablished"),
     reason: z24.literal("gradingNotConfigured"),
-    updatedAt: count3
+    updatedAt: count23
   }).strict(),
   z24.object({
     status: z24.literal("integrityFailed"),
     reason: z24.string().min(1),
-    updatedAt: count3
+    updatedAt: count23
   }).strict()
 ]);
 var swarmObservationInputSchema3 = z24.object({
@@ -161855,7 +162348,7 @@ var swarmReportSessionSchema3 = z24.object({
 z24.object({
   runId: z24.string().min(1),
   executionComplete: z24.boolean(),
-  configuredSessions: count3,
+  configuredSessions: count23,
   verdictSummary: journeyRunVerdictSummarySchema3.nullable(),
   /** Frozen run-wide definitions: absent measurement rows still count as unavailable. */
   evaluatorDefinitions: z24.array(
@@ -161910,11 +162403,11 @@ var swarmObservationCoverageSchema3 = z24.object({
     "The stage this observation was read from, and the only stage it is evidence ABOUT. `connection` \u2014 the server was reachable and the session initialized. `discovery` \u2014 its tools and resources were listed and readable. `selection` \u2014 the model chose the right tool for the request. `call` \u2014 the call was made with usable arguments. `response` \u2014 the server returned data the model could use. `userValue` \u2014 the user's actual request was satisfied."
   ),
   unit: z24.literal("sessions"),
-  total: count3,
-  passed: count3,
-  failed: count3,
-  pending: count3,
-  unavailable: count3
+  total: count23,
+  passed: count23,
+  failed: count23,
+  pending: count23,
+  unavailable: count23
 }).strict().superRefine((value, ctx) => {
   if (value.total !== value.passed + value.failed + value.pending + value.unavailable) {
     ctx.addIssue({
@@ -161944,26 +162437,26 @@ z24.object({
   ]).optional(),
   execution: z24.object({
     unit: z24.literal("sessions"),
-    configured: count3,
-    reported: count3,
-    started: count3,
-    notStarted: count3,
-    unknown: count3,
-    completed: count3,
-    interrupted: count3,
+    configured: count23,
+    reported: count23,
+    started: count23,
+    notStarted: count23,
+    unknown: count23,
+    completed: count23,
+    interrupted: count23,
     /** Only explicit complete execution evidence can establish this. */
     neverLaunched: z24.boolean()
   }).strict(),
   goalGrading: z24.object({
     unit: z24.literal("sessions"),
-    reported: count3,
-    passed: count3,
-    failed: count3,
-    pending: count3,
-    unavailable: count3,
-    notRequested: count3,
+    reported: count23,
+    passed: count23,
+    failed: count23,
+    pending: count23,
+    unavailable: count23,
+    notRequested: count23,
     /** Readiness is separate: a proven failure can exist while other required grading is pending. */
-    waitingForDecisiveGrading: count3
+    waitingForDecisiveGrading: count23
   }).strict(),
   observations: z24.array(swarmObservationCoverageSchema3)
 }).strict().superRefine((report, ctx) => {
@@ -162842,27 +163335,27 @@ function evaluateHostCompat(requirements, profile) {
       (name15) => !requirements.appOnlyWidgets.includes(name15)
     );
     if (blockedAppOnly.length > 0) {
-      const count22 = blockedAppOnly.length;
+      const count32 = blockedAppOnly.length;
       findings.push({
         lane: "apps",
         severity: "blocker",
         code: "app_only_unrenderable",
         tools: blockedAppOnly,
-        title: `${count22 === 1 ? "Interactive tool" : `${count22} interactive tools`} unavailable`,
-        detail: `${formatToolNames(blockedAppOnly)} only ${count22 === 1 ? "works" : "work"} inside a widget. ${profile.label} does not render ${count22 === 1 ? "it" : "them"}.`,
+        title: `${count32 === 1 ? "Interactive tool" : `${count32} interactive tools`} unavailable`,
+        detail: `${formatToolNames(blockedAppOnly)} only ${count32 === 1 ? "works" : "work"} inside a widget. ${profile.label} does not render ${count32 === 1 ? "it" : "them"}.`,
         remediation,
         provenance: profile.provenance
       });
     }
     if (degradedFallback.length > 0) {
-      const count22 = degradedFallback.length;
+      const count32 = degradedFallback.length;
       findings.push({
         lane: "apps",
         severity: "degraded",
         code: "widget_text_fallback",
         tools: degradedFallback,
-        title: `${count22 === 1 ? "Interactive view" : `${count22} interactive views`} unavailable`,
-        detail: `${formatToolNames(degradedFallback)} provide${count22 === 1 ? "s" : ""} an interactive view. ${profile.label} shows the plain-text result instead.`,
+        title: `${count32 === 1 ? "Interactive view" : `${count32} interactive views`} unavailable`,
+        detail: `${formatToolNames(degradedFallback)} provide${count32 === 1 ? "s" : ""} an interactive view. ${profile.label} shows the plain-text result instead.`,
         remediation,
         provenance: profile.provenance
       });
@@ -175105,11 +175598,11 @@ var getPersonaOperation = {
       { client: client3, signal, onScopeResolved },
       input.project
     );
-    const persona = await client3.getPersona(
+    const persona22 = await client3.getPersona(
       { projectId: project.id, personaId: input.persona },
       { signal }
     );
-    return { project: toSelectedProjectInfo(project), persona };
+    return { project: toSelectedProjectInfo(project), persona: persona22 };
   }
 };
 var createPersonaInput = z24.object({
@@ -175139,7 +175632,7 @@ var createPersonaOperation = {
       { client: client3, signal, onScopeResolved },
       input.project
     );
-    const persona = await client3.createPersona(
+    const persona22 = await client3.createPersona(
       {
         projectId: project.id,
         name: input.name,
@@ -175151,7 +175644,7 @@ var createPersonaOperation = {
         ...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}
       }
     );
-    return { project: toSelectedProjectInfo(project), persona };
+    return { project: toSelectedProjectInfo(project), persona: persona22 };
   }
 };
 var updatePersonaInput = personaSelectorInput.extend({
@@ -175175,7 +175668,7 @@ var updatePersonaOperation = {
       { client: client3, signal, onScopeResolved },
       input.project
     );
-    const persona = await client3.updatePersona(
+    const persona22 = await client3.updatePersona(
       {
         projectId: project.id,
         personaId: input.persona,
@@ -175185,7 +175678,7 @@ var updatePersonaOperation = {
       },
       { signal }
     );
-    return { project: toSelectedProjectInfo(project), persona };
+    return { project: toSelectedProjectInfo(project), persona: persona22 };
   }
 };
 var deletePersonaOperation = {
@@ -175201,11 +175694,11 @@ var deletePersonaOperation = {
       { client: client3, signal, onScopeResolved },
       input.project
     );
-    const persona = await client3.deletePersona(
+    const persona22 = await client3.deletePersona(
       { projectId: project.id, personaId: input.persona },
       { signal }
     );
-    return { project: toSelectedProjectInfo(project), persona };
+    return { project: toSelectedProjectInfo(project), persona: persona22 };
   }
 };
 var secretSelectorInput = z24.object({
@@ -187960,24 +188453,24 @@ function appendVary(c) {
   if (names.includes(EVAL_VOCABULARY_HEADER2)) return;
   c.header?.("Vary", `${existing}, ${EVAL_VOCABULARY_HEADER2}`);
 }
-function projectRoleForVocabulary(role, vocabulary) {
+function projectRoleForVocabulary(role, vocabulary4) {
   if (role === void 0) return void 0;
   if (role === "advisory") return "advisory";
   if (!isRequiredRole(role)) return role;
-  return vocabulary === 2 ? "required" : "gating";
+  return vocabulary4 === 2 ? "required" : "gating";
 }
-function refusesCanonicalRole(role, vocabulary) {
-  return vocabulary === 1 && role === "required";
+function refusesCanonicalRole(role, vocabulary4) {
+  return vocabulary4 === 1 && role === "required";
 }
 function canonicalRoleRefusalMessage(path8) {
   return `${path8}: role "required" needs ${EVAL_VOCABULARY_HEADER2}: 2. Without the header this endpoint speaks today's contract, where the spelling is "gating".`;
 }
-function normalizeCheckRolesForVocabulary(checks2, vocabulary, path8) {
+function normalizeCheckRolesForVocabulary(checks2, vocabulary4, path8) {
   if (!Array.isArray(checks2)) return checks2;
   let changed = false;
   const out = checks2.map((check, index) => {
     const role = check?.role;
-    if (refusesCanonicalRole(role, vocabulary)) {
+    if (refusesCanonicalRole(role, vocabulary4)) {
       throw new WebRouteError(
         400,
         ErrorCode.VALIDATION_ERROR,
@@ -187991,18 +188484,18 @@ function normalizeCheckRolesForVocabulary(checks2, vocabulary, path8) {
   });
   return changed ? out : checks2;
 }
-function normalizeCheckRolesInOverrideForVocabulary(override, vocabulary, path8) {
+function normalizeCheckRolesInOverrideForVocabulary(override, vocabulary4, path8) {
   if (!override || typeof override !== "object") return override;
   const list = override.list;
   if (!Array.isArray(list)) return override;
   const next = normalizeCheckRolesForVocabulary(
     list,
-    vocabulary,
+    vocabulary4,
     `${path8}.list`
   );
   return next === list ? override : { ...override, list: next };
 }
-function normalizeStepRolesForVocabulary(steps, vocabulary, path8) {
+function normalizeStepRolesForVocabulary(steps, vocabulary4, path8) {
   if (!Array.isArray(steps)) return steps;
   let changed = false;
   const out = steps.map((step, index) => {
@@ -188010,7 +188503,7 @@ function normalizeStepRolesForVocabulary(steps, vocabulary, path8) {
     if (!row2 || row2.kind !== "assert") return step;
     const assertion2 = row2.assertion;
     const role = assertion2?.role;
-    if (refusesCanonicalRole(role, vocabulary)) {
+    if (refusesCanonicalRole(role, vocabulary4)) {
       throw new WebRouteError(
         400,
         ErrorCode.VALIDATION_ERROR,
@@ -188024,10 +188517,10 @@ function normalizeStepRolesForVocabulary(steps, vocabulary, path8) {
   });
   return changed ? out : steps;
 }
-function normalizeJudgeRoleForVocabulary(slot, vocabulary, path8) {
+function normalizeJudgeRoleForVocabulary(slot, vocabulary4, path8) {
   if (!slot || typeof slot !== "object") return slot;
   const role = slot.role;
-  if (refusesCanonicalRole(role, vocabulary)) {
+  if (refusesCanonicalRole(role, vocabulary4)) {
     throw new WebRouteError(
       400,
       ErrorCode.VALIDATION_ERROR,
@@ -188037,9 +188530,9 @@ function normalizeJudgeRoleForVocabulary(slot, vocabulary, path8) {
   if (role !== "required") return slot;
   return { ...slot, role: "gating" };
 }
-function projectCheckRolesForVocabulary(checks2, vocabulary) {
+function projectCheckRolesForVocabulary(checks2, vocabulary4) {
   if (!Array.isArray(checks2)) return checks2;
-  if (vocabulary === 1) return checks2;
+  if (vocabulary4 === 1) return checks2;
   let changed = false;
   const out = checks2.map((check) => {
     const role = check?.role;
@@ -188049,9 +188542,9 @@ function projectCheckRolesForVocabulary(checks2, vocabulary) {
   });
   return changed ? out : checks2;
 }
-function projectStepRolesForVocabulary(steps, vocabulary) {
+function projectStepRolesForVocabulary(steps, vocabulary4) {
   if (!Array.isArray(steps)) return steps;
-  if (vocabulary === 1) return steps;
+  if (vocabulary4 === 1) return steps;
   let changed = false;
   const out = steps.map((step) => {
     const row2 = step;
@@ -188104,7 +188597,7 @@ function addBothSpellingsIssues(body, ctx, pairs) {
 // server/routes/v1/eval-score-projection.ts
 var ITERATION_SCORE_INTEGRITY = /* @__PURE__ */ new Set(["score_integrity_invalid"]);
 var RUN_SCORE_INTEGRITY = /* @__PURE__ */ new Set(["valid", "invalid"]);
-function toScoreProjection(metadata, vocabulary = 1) {
+function toScoreProjection(metadata, vocabulary4 = 1) {
   if (!metadata || typeof metadata !== "object") return {};
   const record5 = metadata;
   const integrity = typeof record5.scoreIntegrity === "string" && ITERATION_SCORE_INTEGRITY.has(record5.scoreIntegrity) ? { scoreIntegrity: record5.scoreIntegrity } : {};
@@ -188123,7 +188616,7 @@ function toScoreProjection(metadata, vocabulary = 1) {
     evaluationConfig: {
       ...config.data,
       definitions: config.data.definitions.map((definition) => {
-        const role = projectRoleForVocabulary(definition.role, vocabulary);
+        const role = projectRoleForVocabulary(definition.role, vocabulary4);
         return role === definition.role ? definition : { ...definition, role };
       })
     }
@@ -188300,12 +188793,12 @@ function costCoverage(value) {
   const source = value;
   const side = (raw) => {
     const inner = isRecord29(raw) ? raw : {};
-    const count4 = (raw2) => {
+    const count5 = (raw2) => {
       const n = numOrNull(raw2);
       return typeof n === "number" && Number.isSafeInteger(n) && n >= 0 ? n : 0;
     };
-    const costed = count4(inner.costed);
-    const total = count4(inner.total);
+    const costed = count5(inner.costed);
+    const total = count5(inner.total);
     return { costed: costed <= total ? costed : 0, total };
   };
   return { base: side(source.base), compare: side(source.compare) };
@@ -188441,8 +188934,8 @@ function toRunCompareDto(diff, baseline) {
 import { ConvexHttpClient as ConvexHttpClient10 } from "convex/browser";
 
 // server/routes/v1/eval-case-vocabulary-2.ts
-function countFieldNames(vocabulary) {
-  return vocabulary === 2 ? {
+function countFieldNames(vocabulary4) {
+  return vocabulary4 === 2 ? {
     floor: "legacyIterations",
     exactCount: "iterations",
     settingsExactCount: "settings.iterations"
@@ -188528,8 +189021,8 @@ function renameKeys(value, renames) {
   }
   return out;
 }
-function projectCaseDto(dto, vocabulary) {
-  if (vocabulary === 1) return dto;
+function projectCaseDto(dto, vocabulary4) {
+  if (vocabulary4 === 1) return dto;
   return renameKeys(dto, CASE_DTO_RENAMES);
 }
 function suiteSettingsShapeV2(v12) {
@@ -188567,8 +189060,8 @@ function foldSuiteSettingsV2ToV1(settings) {
     ...exact !== void 0 ? { repetitions: exact } : {}
   };
 }
-function projectSuiteDetailDto(dto, vocabulary) {
-  if (vocabulary === 1) return dto;
+function projectSuiteDetailDto(dto, vocabulary4) {
+  if (vocabulary4 === 1) return dto;
   const settings = renameKeys(dto.settings, { checks: "defaultAssertions" });
   if (dto.settings.verdictPolicyDefaults) {
     settings.verdictPolicyDefaults = renameKeys(
@@ -206649,7 +207142,7 @@ var publicInlineTestSchema = z35.strictObject({
     });
   }
 });
-function publicInlineTestToRunTest(input, vocabulary) {
+function publicInlineTestToRunTest(input, vocabulary4) {
   const test = foldInlineTestAliases(input);
   const derived = stepsToInternalCaseFields(test.steps);
   return {
@@ -206659,7 +207152,7 @@ function publicInlineTestToRunTest(input, vocabulary) {
     steps: [
       ...normalizeStepRolesForVocabulary(
         withImplicitRenderAssertForSingleToolCall(test.steps),
-        vocabulary,
+        vocabulary4,
         "tests[].steps"
       )
     ],
@@ -206678,7 +207171,7 @@ function publicInlineTestToRunTest(input, vocabulary) {
     ...test.predicates !== void 0 ? {
       predicates: normalizeCheckRolesInOverrideForVocabulary(
         test.predicates,
-        vocabulary,
+        vocabulary4,
         "tests[].predicates"
       )
     } : {},
@@ -206847,7 +207340,7 @@ var syncFileOwnedSuiteSchema = z35.object({
     });
   }
 });
-function normalizeCreateTestsToRunTests(tests, suite, vocabulary) {
+function normalizeCreateTestsToRunTests(tests, suite, vocabulary4) {
   return tests.map((input) => {
     const test = foldInlineTestAliases(input);
     const runs = test.runs ?? 1;
@@ -206859,7 +207352,7 @@ function normalizeCreateTestsToRunTests(tests, suite, vocabulary) {
       steps: [
         ...normalizeStepRolesForVocabulary(
           withImplicitRenderAssertForSingleToolCall(test.steps),
-          vocabulary,
+          vocabulary4,
           "tests[].steps"
         )
       ],
@@ -206877,7 +207370,7 @@ function normalizeCreateTestsToRunTests(tests, suite, vocabulary) {
       ...test.predicates !== void 0 ? {
         predicates: normalizeCheckRolesInOverrideForVocabulary(
           test.predicates,
-          vocabulary,
+          vocabulary4,
           "tests[].predicates"
         )
       } : {},
@@ -207460,7 +207953,7 @@ function toImportEligibilityProjection(raw) {
     }
   };
 }
-function toIterationDto(iteration, vocabulary = 1) {
+function toIterationDto(iteration, vocabulary4 = 1) {
   const snapshot2 = iteration.testCaseSnapshot ?? {};
   const startedAt = typeof iteration.startedAt === "number" ? iteration.startedAt : null;
   const isTerminal = TERMINAL_ITERATION_STATUSES.has(iteration.status);
@@ -207493,7 +207986,7 @@ function toIterationDto(iteration, vocabulary = 1) {
     expectedToolCalls: snapshot2.expectedToolCalls ?? [],
     ...snapshot2.isNegativeTest === true ? { isNegativeTest: true } : {},
     error: iteration.error ?? null,
-    ...toScoreProjection(iteration.metadata, vocabulary),
+    ...toScoreProjection(iteration.metadata, vocabulary4),
     ...toStageProjection(iteration.metadata),
     // Observable patterns in this trial's tool calls — a report beside the
     // verdict, never an input to one. ABSENT for every iteration that
@@ -207611,7 +208104,7 @@ function toPublicCaseImportClaim(raw) {
     ...typeof record5.note === "string" && record5.note ? { note: record5.note } : {}
   };
 }
-function toCaseDto(testCase, vocabulary = 1) {
+function toCaseDto(testCase, vocabulary4 = 1) {
   const importClaim = toPublicCaseImportClaim(testCase.import);
   return {
     id: String(testCase._id),
@@ -207629,7 +208122,7 @@ function toCaseDto(testCase, vocabulary = 1) {
     // the case's own checks — so it projects the same way.
     steps: projectStepRolesForVocabulary(
       internalCaseToSteps(testCase),
-      vocabulary
+      vocabulary4
     ),
     ...testCase.expectedOutput !== void 0 ? { expectedOutput: testCase.expectedOutput } : {},
     iterations: typeof testCase.runs === "number" ? testCase.runs : 1,
@@ -207664,7 +208157,7 @@ function toCaseDto(testCase, vocabulary = 1) {
         // unannounced rename in a response would empty its gating set.
         list: projectCheckRolesForVocabulary(
           testCase.predicates.list ?? [],
-          vocabulary
+          vocabulary4
         ) ?? []
       }
     } : {},
@@ -207680,7 +208173,7 @@ function isCiOwnedSuiteDoc(suite) {
   const declared = suite.declaredSuiteId;
   return typeof declared === "string" && declared.length > 0 || suite.source === "sdk";
 }
-function toSuiteDetailDto(suite, execConfig, resolved = {}, vocabulary = 1) {
+function toSuiteDetailDto(suite, execConfig, resolved = {}, vocabulary4 = 1) {
   const goal = suite.judgePolicy?.effective ?? suite.judgeConfig?.goalCompletion;
   return {
     id: String(suite._id),
@@ -207751,7 +208244,7 @@ function toSuiteDetailDto(suite, execConfig, resolved = {}, vocabulary = 1) {
       matchOptions: toPublicMatchOptions(suite.defaultMatchOptions),
       checks: projectCheckRolesForVocabulary(
         Array.isArray(suite.defaultPredicates) ? suite.defaultPredicates : [],
-        vocabulary
+        vocabulary4
       ) ?? [],
       // FULLY RESOLVED, every field layered over GOAL_COMPLETION_DEFAULTS —
       // the same resolution the backend's `resolveGoalCompletionConfig`
@@ -207778,7 +208271,7 @@ function toSuiteDetailDto(suite, execConfig, resolved = {}, vocabulary = 1) {
         // Projected, never echoed raw: after the storage switch this field
         // holds `required`, and a published `eval gate` filters judge roles on
         // the literal `"gating"`.
-        ...goal?.role !== void 0 ? { role: projectRoleForVocabulary(goal.role, vocabulary) } : {},
+        ...goal?.role !== void 0 ? { role: projectRoleForVocabulary(goal.role, vocabulary4) } : {},
         ...goal?.severity === "warn" ? { severity: "warn" } : {},
         // Stored groundedness, when present. Not resolved over defaults —
         // C1 registers no configurable groundedness defaults.
@@ -208092,10 +208585,10 @@ function parseCreateCasesBatchBody(c, raw) {
   };
 }
 function caseResource(c, doc, status = 200) {
-  const vocabulary = vocabularyOf(c);
+  const vocabulary4 = vocabularyOf(c);
   return v1Resource(
     c,
-    projectCaseDto(toCaseDto(doc, vocabulary), vocabulary),
+    projectCaseDto(toCaseDto(doc, vocabulary4), vocabulary4),
     status
   );
 }
@@ -208363,7 +208856,7 @@ var generateCasesSchema = z35.object({
   message: "environmentId and servers are mutually exclusive \u2014 an environment supplies its own closed server set."
 });
 function buildCaseMutationArgs(body, opts) {
-  const vocabulary = opts.vocabulary ?? 1;
+  const vocabulary4 = opts.vocabulary ?? 1;
   const args = {};
   let isModelFreeStepsCase = false;
   if ("id" in body && body.id !== void 0) args.caseId = body.id;
@@ -208382,7 +208875,7 @@ function buildCaseMutationArgs(body, opts) {
   if (body.steps !== void 0) {
     const steps = normalizeStepRolesForVocabulary(
       withImplicitRenderAssertForSingleToolCall(body.steps),
-      vocabulary,
+      vocabulary4,
       "steps"
     );
     args.steps = steps;
@@ -208430,7 +208923,7 @@ function buildCaseMutationArgs(body, opts) {
       // not mint two signatures.
       list: normalizeCheckRolesForVocabulary(
         body.checks.list,
-        vocabulary,
+        vocabulary4,
         "checks.list"
       )
     };
@@ -211109,7 +211602,7 @@ evals.get(
     return v1Resource(c, toDescriptionExperimentDto(raw));
   }
 );
-async function readSuiteDetail(convexAuthToken, projectId, suiteId, vocabulary) {
+async function readSuiteDetail(convexAuthToken, projectId, suiteId, vocabulary4) {
   const convex = createConvexReadClient(convexAuthToken);
   let suite;
   try {
@@ -211146,7 +211639,7 @@ async function readSuiteDetail(convexAuthToken, projectId, suiteId, vocabulary)
     suite,
     execConfig,
     { computerEnvironmentName },
-    vocabulary
+    vocabulary4
   );
 }
 async function defaultCaseModels(convex, suiteId) {
@@ -211260,7 +211753,7 @@ function applyVerdictPolicySettings(suite, settings, updateArgs, names = countFi
 evals.patch("/projects/:projectId/eval-suites/:suiteId", async (c) => {
   const projectId = c.req.param("projectId");
   const suiteId = evalIdParam(c, "suiteId", "Eval suite");
-  const vocabulary = vocabularyOf(c);
+  const vocabulary4 = vocabularyOf(c);
   const body = parseUpdateSuiteBody(c, await readJsonObjectBody(c));
   const token = await getConvexBearerForRequest(c);
   const { convexClient: convexClient6 } = createConvexClients(token);
@@ -211317,7 +211810,7 @@ evals.patch("/projects/:projectId/eval-suites/:suiteId", async (c) => {
     if (s.checks !== void 0)
       updateArgs.defaultPredicates = s.checks === null ? null : normalizeCheckRolesForVocabulary(
         s.checks,
-        vocabulary,
+        vocabulary4,
         "settings.checks"
       );
     if (s.judge !== void 0) {
@@ -211335,7 +211828,7 @@ evals.patch("/projects/:projectId/eval-suites/:suiteId", async (c) => {
       if (s.judge.role !== void 0)
         goalCompletion.role = normalizeJudgeRoleForVocabulary(
           { role: s.judge.role },
-          vocabulary,
+          vocabulary4,
           "settings.judge"
         ).role;
       if (s.judge.severity !== void 0)
@@ -212411,13 +212904,13 @@ async function completeGeneratedAuthoringJob(c, convex, job, suiteId) {
   const docs = reads.flatMap(
     (read) => read.status === "fulfilled" && read.value ? [read.value] : []
   );
-  const vocabulary = vocabularyOf(c);
+  const vocabulary4 = vocabularyOf(c);
   return v1Resource(c, {
     jobId: job.jobId,
     status: job.status,
     generationModel: "anthropic/claude-haiku-4.5",
     created: docs.map(
-      (doc) => projectCaseDto(toCaseDto(doc, vocabulary), vocabulary)
+      (doc) => projectCaseDto(toCaseDto(doc, vocabulary4), vocabulary4)
     ),
     counts: {
       normal: docs.filter((doc) => !doc.isNegativeTest).length,
@@ -229679,6 +230172,148 @@ var scenarios_default = scenarios;
 import { Hono as Hono47 } from "hono";
 import { z as z45 } from "zod";
 
+// shared/error-page.ts
+var HTML_PREAMBLE = /^(?:|\s|<!--[\s\S]*?-->|<\?xml[\s\S]*?\?>)+/i;
+var MARKUP_OPENER = /^<(?:!doctype\s+html|html|head|body|title)\b/i;
+var DOCTYPE_MARKER = /<!doctype\s+html/i;
+function looksLikeErrorPage(trimmed) {
+  if (DOCTYPE_MARKER.test(trimmed)) return true;
+  if (/<\/html>\s*$/i.test(trimmed)) return true;
+  return MARKUP_OPENER.test(trimmed.replace(HTML_PREAMBLE, ""));
+}
+
+// shared/swarm-attempt-error.ts
+var AGENT_ERROR_ENVELOPE = /^(?:swarm-agent\s+\S+\s+failed\s+\((\d{3})\):|Backend stream error:\s*(\d{3}))\s*/i;
+var URL_PATTERN2 = /https?:\/\/\S+/g;
+function isTransientSpendRefusal(code, refusalReason) {
+  return code === "user_rate_limit" && refusalReason === "holds_committed";
+}
+var MAX_ATTEMPT_ERROR_CHARS = 500;
+function parseJsonObject(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function str3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function num2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function scrub(text2) {
+  return text2.replace(URL_PATTERN2, "").replace(/\s+/g, " ").trim();
+}
+function compose(headline, details) {
+  if (!details) return headline;
+  if (headline.toLowerCase().includes(details.toLowerCase())) return headline;
+  const separator = /[.!?]$/.test(headline) ? " " : ". ";
+  return `${headline}${separator}${details}`;
+}
+var SANDBOX_ERROR_CODE_MESSAGES = {
+  sandbox_unavailable: "This session needed an MCPJam cloud sandbox for its computer commands, but this inspector can't run cloud sandboxes \u2014 the session could not execute commands.",
+  sandbox_at_capacity: "MCPJam cloud is at capacity right now \u2014 try the run again in a few minutes.",
+  sandbox_error: "The cloud sandbox for this session hit an error while starting \u2014 try the run again."
+};
+var XAA_REASON_FALLBACK_MESSAGES = {
+  [XaaConnectFailureReason.REAUTH_REQUIRED]: "Your sign-in expired before this server's enterprise access token could be issued \u2014 sign in again, then re-run.",
+  [XaaConnectFailureReason.AUTHORIZATION_SERVER_UNKNOWN]: "MCPJam couldn't find the authorization server protecting this server \u2014 set its issuer in the server's auth settings.",
+  [XaaConnectFailureReason.NOT_SUPPORTED_HERE]: "This server's enterprise authorization mode can't run on this deployment \u2014 use pre-registered credentials in the server's auth settings.",
+  [XaaConnectFailureReason.AUTHORIZATION_REJECTED]: "The authorization server rejected MCPJam's access request \u2014 check the server's XAA client credentials and issuer in its auth settings.",
+  [XaaConnectFailureReason.CONFIGURATION_INVALID]: "This server isn't fully configured for enterprise-managed authorization \u2014 finish its XAA settings, or set an explicit auth method.",
+  [XaaConnectFailureReason.HANDSHAKE_FAILED]: "This server couldn't complete its enterprise authorization handshake \u2014 try again, and check its auth settings if it keeps failing."
+};
+function humanizeSwarmAttemptError(raw, errorCode2) {
+  if (errorCode2 === "stale_runner") {
+    return {
+      code: errorCode2,
+      message: "The runner stopped reporting progress, so this run was marked interrupted. Sessions may have run before the interruption; inspect their saved traces. The reason contact was lost was not recorded."
+    };
+  }
+  const sandboxMessage = errorCode2 ? SANDBOX_ERROR_CODE_MESSAGES[errorCode2] : void 0;
+  if (sandboxMessage && errorCode2) {
+    return { message: sandboxMessage, code: errorCode2 };
+  }
+  const input = (raw ?? "").trim();
+  if (errorCode2 === "spending_reservation_busy" || input.includes("streamSpendingReservations") && input.includes("changed while this mutation was being run")) {
+    return {
+      code: "spending_reservation_busy",
+      message: "MCPJam could not reserve spending capacity because concurrent requests kept changing it. This is an internal execution failure. Retry this attempt."
+    };
+  }
+  if (isXaaConnectFailureReason(errorCode2)) {
+    return {
+      message: (scrub(input) || XAA_REASON_FALLBACK_MESSAGES[errorCode2]).slice(
+        0,
+        MAX_ATTEMPT_ERROR_CHARS
+      ),
+      code: errorCode2,
+      ...isRerunnableXaaFailure(errorCode2) ? { rerunnable: true } : {}
+    };
+  }
+  if (!input) return { message: "The session failed for an unknown reason." };
+  let body = input;
+  let httpStatus2;
+  const envelope = AGENT_ERROR_ENVELOPE.exec(input);
+  if (envelope) {
+    httpStatus2 = Number(envelope[1] ?? envelope[2]);
+    body = input.slice(envelope[0].length).trim();
+  }
+  if (looksLikeErrorPage(body)) {
+    return {
+      code: "upstream_error_page",
+      message: `The request was answered with an HTML error page instead of a response${httpStatus2 ? ` (HTTP ${httpStatus2})` : ""}. This usually means a proxy or CDN blocked it.`,
+      ...httpStatus2 !== void 0 ? { httpStatus: httpStatus2 } : {}
+    };
+  }
+  const parsed = parseJsonObject(body);
+  if (!parsed) {
+    const cleaned = scrub(body) || scrub(input);
+    return {
+      message: (cleaned || "The session failed for an unknown reason.").slice(
+        0,
+        MAX_ATTEMPT_ERROR_CHARS
+      ),
+      ...httpStatus2 !== void 0 ? { httpStatus: httpStatus2 } : {}
+    };
+  }
+  const headline = str3(parsed.error) ?? str3(parsed.message) ?? "The session could not run.";
+  const details = str3(parsed.details);
+  const code = str3(parsed.code);
+  const retryAfterMs = num2(parsed.retryAfter);
+  const canTopUp = parsed.canTopUp === true;
+  return {
+    message: scrub(compose(headline, details)).slice(
+      0,
+      MAX_ATTEMPT_ERROR_CHARS
+    ),
+    ...code ? { code } : {},
+    ...str3(parsed.refusalReason) ? { refusalReason: str3(parsed.refusalReason) } : {},
+    ...typeof parsed.isRetryable === "boolean" ? { isRetryable: parsed.isRetryable } : {},
+    ...num2(parsed.outstandingHolds) !== void 0 ? { outstandingHolds: num2(parsed.outstandingHolds) } : {},
+    ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
+    ...canTopUp ? { canTopUp } : {},
+    ...httpStatus2 !== void 0 ? { httpStatus: httpStatus2 } : {}
+  };
+}
+function humanizeSwarmAttemptErrorMessage(raw) {
+  return humanizeSwarmAttemptError(raw).message;
+}
+var ACCOUNT_LIMIT_CODE = /\b(?:user_rate_limit|org_rate_limit|mcpjam_rate_limit|billing_limit_reached|spend_budget_reached|wallet_locked|billing_feature_not_included|free_tier_model_restricted|spend_cap_exceeded|platform_free_budget_exhausted|account_suspended|guest_model_not_allowed|guest_input_too_large)\b/i;
+function isAccountLimit(message, code) {
+  if (accountLimitCode(message, code)) return true;
+  return !!message && MCPJAM_MODEL_LIMIT_SENTENCE.test(message);
+}
+var MCPJAM_MODEL_LIMIT_SENTENCE = /\b(?:Daily|Monthly) MCPJam model limit reached\b/i;
+function accountLimitCode(message, code) {
+  const match = (code ? ACCOUNT_LIMIT_CODE.exec(code) : null) ?? (message ? ACCOUNT_LIMIT_CODE.exec(message) : null);
+  return match?.[0].toLowerCase();
+}
+
 // shared/swarm-grounding.ts
 var GROUNDING_LIMITS = {
   tools: 12,
@@ -229935,6 +230570,53 @@ async function probeReadOnlyTools(args) {
   }
 }
 
+// server/services/sessionSimulation/admission-retry.ts
+function spendRefusalOf(error) {
+  if (!error || typeof error !== "object") return void 0;
+  if ("refusal" in error) return error.refusal;
+  if (error instanceof Error && error.name === "RecordedAssistantTurnError")
+    return void 0;
+  if (!(error instanceof Error)) return void 0;
+  const info = humanizeSwarmAttemptError(error.message);
+  return info.refusalReason ? info : void 0;
+}
+var AdmissionWaitBudget = class {
+  constructor(totalMs = 5 * 6e4, maxAttemptsPerCall = 8) {
+    this.maxAttemptsPerCall = maxAttemptsPerCall;
+    this.remainingMs = totalMs;
+  }
+  take(delayMs) {
+    if (delayMs > this.remainingMs) return false;
+    this.remainingMs -= delayMs;
+    return true;
+  }
+};
+async function withAdmissionRetry(op, options) {
+  let attempt = 0;
+  for (; ; ) {
+    options.signal?.throwIfAborted();
+    try {
+      return await op();
+    } catch (error) {
+      const refusal = spendRefusalOf(error);
+      if (!refusal || !isTransientSpendRefusal(refusal.code, refusal.refusalReason) || ++attempt >= options.budget.maxAttemptsPerCall)
+        throw error;
+      const base = Number.isFinite(refusal.retryAfterMs) ? refusal.retryAfterMs : 15e3;
+      const delay5 = Math.round(
+        defaultJitter(clampDelay(base * attempt, 5e3, 6e4))
+      );
+      if (!options.budget.take(delay5)) throw error;
+      const resume = options.onWait?.(delay5);
+      try {
+        await abortableSleep(delay5, options.signal);
+      } finally {
+        resume?.();
+      }
+      options.signal?.throwIfAborted();
+    }
+  }
+}
+
 // server/services/sessionSimulation/runner.ts
 import { ConvexHttpClient as ConvexHttpClient12 } from "convex/browser";
 
@@ -230061,6 +230743,7 @@ function extractToolResults2(messages) {
 
 // server/utils/turn-failure-classification.ts
 function classifyTurnFailure(message) {
+  if (/\bprovider_empty_response\b/.test(message)) return "failed";
   return /rate.?limit|too many requests|(?:^|[^\w.:])429\b|\bspend\b|spend_budget_reached|\bquota\b|\bbudget\b|\bcap\b/i.test(
     message
   ) ? "rate_limited" : "failed";
@@ -230297,6 +230980,21 @@ async function runSyntheticHostSession(adapter) {
   );
   const sessionSignal = sessionDeadline.signal;
   let turnDeadline;
+  const admissionBudget = new AdmissionWaitBudget();
+  const admissionOptions = {
+    budget: admissionBudget,
+    signal: sessionSignal,
+    onWait: () => {
+      turnDeadline?.dispose();
+      return () => {
+        turnDeadline = withDeadline3(
+          sessionSignal,
+          budgets.turnTimeoutMs,
+          "turn"
+        );
+      };
+    }
+  };
   let manager;
   let dispose;
   let browser;
@@ -230583,7 +231281,10 @@ async function runSyntheticHostSession(adapter) {
       }
       turnDeadline?.dispose();
       turnDeadline = withDeadline3(sessionSignal, budgets.turnTimeoutMs, "turn");
-      const next = await nextPersonaTurn(lastTranscript);
+      const next = await withAdmissionRetry(
+        () => nextPersonaTurn(lastTranscript),
+        admissionOptions
+      );
       if (next.endSession) {
         if (turn === 0) {
           throw Object.assign(
@@ -230622,130 +231323,133 @@ async function runSyntheticHostSession(adapter) {
         turnTrace,
         modelSource: turnModelSource,
         harnessSessionCommit
-      } = await drainAssistantTurn({
-        messages: messageHistory,
-        modelId: String(modelDefinition.id),
-        modelDefinition,
-        chatSessionId,
-        // Tag the engine-facing turn (usage rows) with THIS surface's source:
-        // "scenario" for the session-simulation surface, "swarm" for the
-        // journey-execution runner. The persist attribution already carries
-        // this; forwarding it keeps hosted + local-BYOK usage rows correctly
-        // sourced instead of hardcoding every journey turn as "scenario".
-        sourceType: persist.sourceType,
-        systemPrompt: prepared.enhancedSystemPrompt,
-        temperature: prepared.resolvedTemperature,
-        ...maxSteps !== void 0 ? { maxSteps } : {},
-        // `computer` / `finish_widget` merge into the advertised set; the
-        // prepareAdvertisedTools hook hides them until a widget is mounted.
-        tools: { ...prepared.allTools, ...browser.computerWidgetTools },
-        hooks: {
-          onToolCall: (event) => {
-            browser.noteToolCallInput(event);
-            const args = event.input && typeof event.input === "object" && !Array.isArray(event.input) ? event.input : { value: event.input };
-            emit?.({
-              type: "tool_call",
-              toolName: event.toolName,
-              toolCallId: event.toolCallId,
-              args
-            });
-          },
-          onToolResult: (event) => {
-            void browser.handleEngineToolResult(event);
-            emit?.({
-              type: "tool_result",
-              toolCallId: event.toolCallId,
-              result: event.output
-            });
-          },
-          ...browser.prepareAdvertisedTools ? { prepareAdvertisedTools: browser.prepareAdvertisedTools } : {},
-          onToolResultChunk: async (chunk) => {
-            await browser.handleDirectToolResultChunk(chunk);
-            emit?.({
-              type: "tool_result",
-              toolCallId: chunk.toolCallId,
-              result: chunk.output
-            });
-          },
-          onToolCallChunk: (chunk) => {
-            emit?.({
-              type: "tool_call",
-              toolName: chunk.toolName,
-              toolCallId: chunk.toolCallId,
-              args: chunk.input
-            });
-          },
-          ...emit ? {
-            onLiveTextDelta: (content) => {
-              emit({ type: "text_delta", content });
+      } = await withAdmissionRetry(
+        () => drainAssistantTurn({
+          messages: messageHistory,
+          modelId: String(modelDefinition.id),
+          modelDefinition,
+          chatSessionId,
+          // Tag the engine-facing turn (usage rows) with THIS surface's source:
+          // "scenario" for the session-simulation surface, "swarm" for the
+          // journey-execution runner. The persist attribution already carries
+          // this; forwarding it keeps hosted + local-BYOK usage rows correctly
+          // sourced instead of hardcoding every journey turn as "scenario".
+          sourceType: persist.sourceType,
+          systemPrompt: prepared.enhancedSystemPrompt,
+          temperature: prepared.resolvedTemperature,
+          ...maxSteps !== void 0 ? { maxSteps } : {},
+          // `computer` / `finish_widget` merge into the advertised set; the
+          // prepareAdvertisedTools hook hides them until a widget is mounted.
+          tools: { ...prepared.allTools, ...browser.computerWidgetTools },
+          hooks: {
+            onToolCall: (event) => {
+              browser.noteToolCallInput(event);
+              const args = event.input && typeof event.input === "object" && !Array.isArray(event.input) ? event.input : { value: event.input };
+              emit?.({
+                type: "tool_call",
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+                args
+              });
             },
-            onStepFinish: (event) => {
-              emit({
-                type: "step_finish",
-                stepNumber: event.stepIndex,
-                ...event.turnUsage ? {
-                  usage: {
-                    inputTokens: event.turnUsage.inputTokens ?? 0,
-                    outputTokens: event.turnUsage.outputTokens ?? 0
-                  }
-                } : {}
+            onToolResult: (event) => {
+              void browser.handleEngineToolResult(event);
+              emit?.({
+                type: "tool_result",
+                toolCallId: event.toolCallId,
+                result: event.output
               });
-            }
-          } : {}
-        },
-        progressivePlan: prepared.progressivePlan,
-        discoveryState: prepared.discoveryState,
-        mcpClientManager: manager,
-        selectedServers: selectedServerIds,
-        requireToolApproval,
-        ...harness2 ? { harness: harness2 } : {},
-        // Harness MCP-proxy plane (harness hosts with MCP servers) + swarm
-        // continuity identity (`swarm-chat` owner lane). `harnessMcpProxy` is
-        // resolved once above; `journeyRunId`/`hostId` are the swarm run + pinned
-        // host. All three are inert for the emulated engine / non-swarm surfaces.
-        ...harnessMcpProxy ? { harnessMcpProxy } : {},
-        // Pinned harness skills (env-based swarm target running a real
-        // harness): the harness turn skips the live skills fetch and delivers
-        // exactly these artifacts (skillsHash derives from their fingerprints).
-        // Passed even when EMPTY — an empty authoritative set means the
-        // harness must run skill-less, not fall back to the live pool.
-        ...harness2 && pinnedSkills !== void 0 ? { pinnedHarnessSkills: pinnedSkills } : {},
-        // The attempt's own disposable box for the HARNESS turn. Only meaningful
-        // when a harness is selected — the emulated engine's shell binds through
-        // `resolveHostTools` above instead.
-        ...harness2 && harnessSandboxBinding ? { harnessSandboxBinding } : {},
-        // The target's Project Environment — the GRANT BOUNDARY the harness
-        // turn checks a BROKERED external-account credential against. Harness
-        // only: the emulated engine resolves no such credential, and this
-        // runner delivers no materialized secrets on either path (see the
-        // `runtimeSecrets` contract on `MCPJamHandlerOptions`), so brokered
-        // delivery is the only one a swarm attempt can use.
-        ...harness2 && environmentId ? { environmentId } : {},
-        // Server-executed built-ins (`web_search`, …) for the HARNESS turn.
-        // The emulated engine already receives them merged into `tools` via
-        // prepareChatV2's `allTools`; the harness reads them off this separate
-        // option instead, because it hands them to the runtime as specs and
-        // executes them here, while MCP-server tools go via `.mcp.json`. Only
-        // for a harness target — passing them on the emulated path would
-        // duplicate what `allTools` already carries.
-        ...harness2 && builtInTools2 && Object.keys(builtInTools2).length > 0 ? { builtInTools: builtInTools2 } : {},
-        ...persist.hostId ? { hostId: persist.hostId } : {},
-        // Scenario surface only. The scenario runtime-config redeem returns an
-        // accessVersion that /stream/org/resolve uses to authorize the actor
-        // against the versioned scenario; threading it (instead of undefined)
-        // matches what real-visitor synthetic-equivalent chats send. The swarm
-        // surface authorizes via project membership and leaves both undefined.
-        ...scenarioId ? { scenarioId } : {},
-        accessVersion,
-        projectId,
-        authHeader,
-        abortSignal: turnDeadline.signal,
-        // Threaded into the per-step /stream (or /stream/org) body and the
-        // /stream/org/local-usage writeback so the backend BYOK and JAM-paid
-        // writers can stamp the run id onto llmUsageRecord for per-run spend
-        // attribution.
-        ...persist.journeyRunId ? { journeyRunId: persist.journeyRunId } : {}
-      }).catch((error) => {
+            },
+            ...browser.prepareAdvertisedTools ? { prepareAdvertisedTools: browser.prepareAdvertisedTools } : {},
+            onToolResultChunk: async (chunk) => {
+              await browser.handleDirectToolResultChunk(chunk);
+              emit?.({
+                type: "tool_result",
+                toolCallId: chunk.toolCallId,
+                result: chunk.output
+              });
+            },
+            onToolCallChunk: (chunk) => {
+              emit?.({
+                type: "tool_call",
+                toolName: chunk.toolName,
+                toolCallId: chunk.toolCallId,
+                args: chunk.input
+              });
+            },
+            ...emit ? {
+              onLiveTextDelta: (content) => {
+                emit({ type: "text_delta", content });
+              },
+              onStepFinish: (event) => {
+                emit({
+                  type: "step_finish",
+                  stepNumber: event.stepIndex,
+                  ...event.turnUsage ? {
+                    usage: {
+                      inputTokens: event.turnUsage.inputTokens ?? 0,
+                      outputTokens: event.turnUsage.outputTokens ?? 0
+                    }
+                  } : {}
+                });
+              }
+            } : {}
+          },
+          progressivePlan: prepared.progressivePlan,
+          discoveryState: prepared.discoveryState,
+          mcpClientManager: manager,
+          selectedServers: selectedServerIds,
+          requireToolApproval,
+          ...harness2 ? { harness: harness2 } : {},
+          // Harness MCP-proxy plane (harness hosts with MCP servers) + swarm
+          // continuity identity (`swarm-chat` owner lane). `harnessMcpProxy` is
+          // resolved once above; `journeyRunId`/`hostId` are the swarm run + pinned
+          // host. All three are inert for the emulated engine / non-swarm surfaces.
+          ...harnessMcpProxy ? { harnessMcpProxy } : {},
+          // Pinned harness skills (env-based swarm target running a real
+          // harness): the harness turn skips the live skills fetch and delivers
+          // exactly these artifacts (skillsHash derives from their fingerprints).
+          // Passed even when EMPTY — an empty authoritative set means the
+          // harness must run skill-less, not fall back to the live pool.
+          ...harness2 && pinnedSkills !== void 0 ? { pinnedHarnessSkills: pinnedSkills } : {},
+          // The attempt's own disposable box for the HARNESS turn. Only meaningful
+          // when a harness is selected — the emulated engine's shell binds through
+          // `resolveHostTools` above instead.
+          ...harness2 && harnessSandboxBinding ? { harnessSandboxBinding } : {},
+          // The target's Project Environment — the GRANT BOUNDARY the harness
+          // turn checks a BROKERED external-account credential against. Harness
+          // only: the emulated engine resolves no such credential, and this
+          // runner delivers no materialized secrets on either path (see the
+          // `runtimeSecrets` contract on `MCPJamHandlerOptions`), so brokered
+          // delivery is the only one a swarm attempt can use.
+          ...harness2 && environmentId ? { environmentId } : {},
+          // Server-executed built-ins (`web_search`, …) for the HARNESS turn.
+          // The emulated engine already receives them merged into `tools` via
+          // prepareChatV2's `allTools`; the harness reads them off this separate
+          // option instead, because it hands them to the runtime as specs and
+          // executes them here, while MCP-server tools go via `.mcp.json`. Only
+          // for a harness target — passing them on the emulated path would
+          // duplicate what `allTools` already carries.
+          ...harness2 && builtInTools2 && Object.keys(builtInTools2).length > 0 ? { builtInTools: builtInTools2 } : {},
+          ...persist.hostId ? { hostId: persist.hostId } : {},
+          // Scenario surface only. The scenario runtime-config redeem returns an
+          // accessVersion that /stream/org/resolve uses to authorize the actor
+          // against the versioned scenario; threading it (instead of undefined)
+          // matches what real-visitor synthetic-equivalent chats send. The swarm
+          // surface authorizes via project membership and leaves both undefined.
+          ...scenarioId ? { scenarioId } : {},
+          accessVersion,
+          projectId,
+          authHeader,
+          abortSignal: turnDeadline.signal,
+          // Threaded into the per-step /stream (or /stream/org) body and the
+          // /stream/org/local-usage writeback so the backend BYOK and JAM-paid
+          // writers can stamp the run id onto llmUsageRecord for per-run spend
+          // attribution.
+          ...persist.journeyRunId ? { journeyRunId: persist.journeyRunId } : {}
+        }),
+        admissionOptions
+      ).catch((error) => {
         if (!(error instanceof RecordedAssistantTurnError)) throw error;
         failedTurn = error;
         return error.turn;
@@ -230896,13 +231600,14 @@ async function runSyntheticHostSession(adapter) {
       };
     }
     const message = error instanceof Error ? error.message : String(error);
+    const errorRefusal = error instanceof RecordedAssistantTurnError ? error.errorRefusal : spendRefusalOf(error);
     if (classifyTurnFailure(message) === "rate_limited") {
       emit?.({
         type: "session_complete",
         status: "rate_limited",
         errorMessage: message
       });
-      return { outcome: "rate_limited", errorMessage: message };
+      return { outcome: "rate_limited", errorMessage: message, errorRefusal };
     }
     logger.warn("[sessionSimulation.runner] session failed", {
       runId,
@@ -230919,7 +231624,8 @@ async function runSyntheticHostSession(adapter) {
     return {
       outcome: "failed",
       errorMessage: message,
-      ...errorReason ? { errorReason } : {}
+      ...errorReason ? { errorReason } : {},
+      errorRefusal
     };
   } finally {
     turnDeadline?.dispose();
@@ -231254,12 +231960,24 @@ async function drainAssistantTurn(args) {
     newMessageCount: result.newMessages.length
   });
   if (turnFailure && !args.abortSignal?.aborted) {
-    const failed3 = (message) => new RecordedAssistantTurnError(message, {
-      history: result.messages,
-      turnTrace: result.turnTrace,
-      modelSource: rt.modelSource,
-      ...result.harnessSessionCommit ? { harnessSessionCommit: result.harnessSessionCommit } : {}
-    });
+    const failed3 = (message) => {
+      const error = new RecordedAssistantTurnError(message, {
+        history: result.messages,
+        turnTrace: result.turnTrace,
+        modelSource: rt.modelSource,
+        ...result.harnessSessionCommit ? { harnessSessionCommit: result.harnessSessionCommit } : {}
+      });
+      error.errorRefusal = lastEngineError ? {
+        code: lastEngineError.code,
+        refusalReason: lastEngineError.refusalReason,
+        retryAfterMs: lastEngineError.retryAfterMs,
+        httpStatus: lastEngineError.httpStatus,
+        stepIndex: lastEngineError.stepIndex,
+        outstandingHolds: lastEngineError.outstandingHolds
+      } : void 0;
+      if (result.newMessages.length === 0) error.refusal = error.errorRefusal;
+      return error;
+    };
     if (lastEngineError) {
       const detail = [
         lastEngineError.code,
@@ -232457,125 +233175,6 @@ function swarmAttemptChatSessionId(runId, target, sessionIndex) {
   return `synth_${runId}_${target.hostId}_${sessionIndex}`;
 }
 
-// shared/swarm-attempt-error.ts
-var AGENT_ERROR_ENVELOPE = /^(?:swarm-agent\s+\S+\s+failed\s+\((\d{3})\):|Backend stream error:\s*(\d{3}))\s*/i;
-var URL_PATTERN2 = /https?:\/\/\S+/g;
-var MAX_ATTEMPT_ERROR_CHARS = 500;
-function parseJsonObject(text2) {
-  const trimmed = text2.trim();
-  if (!trimmed.startsWith("{")) return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function str3(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function num2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function scrub(text2) {
-  return text2.replace(URL_PATTERN2, "").replace(/\s+/g, " ").trim();
-}
-function compose(headline, details) {
-  if (!details) return headline;
-  if (headline.toLowerCase().includes(details.toLowerCase())) return headline;
-  const separator = /[.!?]$/.test(headline) ? " " : ". ";
-  return `${headline}${separator}${details}`;
-}
-var SANDBOX_ERROR_CODE_MESSAGES = {
-  sandbox_unavailable: "This session needed an MCPJam cloud sandbox for its computer commands, but this inspector can't run cloud sandboxes \u2014 the session could not execute commands.",
-  sandbox_at_capacity: "MCPJam cloud is at capacity right now \u2014 try the run again in a few minutes.",
-  sandbox_error: "The cloud sandbox for this session hit an error while starting \u2014 try the run again."
-};
-var XAA_REASON_FALLBACK_MESSAGES = {
-  [XaaConnectFailureReason.REAUTH_REQUIRED]: "Your sign-in expired before this server's enterprise access token could be issued \u2014 sign in again, then re-run.",
-  [XaaConnectFailureReason.AUTHORIZATION_SERVER_UNKNOWN]: "MCPJam couldn't find the authorization server protecting this server \u2014 set its issuer in the server's auth settings.",
-  [XaaConnectFailureReason.NOT_SUPPORTED_HERE]: "This server's enterprise authorization mode can't run on this deployment \u2014 use pre-registered credentials in the server's auth settings.",
-  [XaaConnectFailureReason.AUTHORIZATION_REJECTED]: "The authorization server rejected MCPJam's access request \u2014 check the server's XAA client credentials and issuer in its auth settings.",
-  [XaaConnectFailureReason.CONFIGURATION_INVALID]: "This server isn't fully configured for enterprise-managed authorization \u2014 finish its XAA settings, or set an explicit auth method.",
-  [XaaConnectFailureReason.HANDSHAKE_FAILED]: "This server couldn't complete its enterprise authorization handshake \u2014 try again, and check its auth settings if it keeps failing."
-};
-function humanizeSwarmAttemptError(raw, errorCode2) {
-  if (errorCode2 === "stale_runner") {
-    return {
-      code: errorCode2,
-      message: "The runner stopped reporting progress, so this run was marked interrupted. Sessions may have run before the interruption; inspect their saved traces. The reason contact was lost was not recorded."
-    };
-  }
-  const sandboxMessage = errorCode2 ? SANDBOX_ERROR_CODE_MESSAGES[errorCode2] : void 0;
-  if (sandboxMessage && errorCode2) {
-    return { message: sandboxMessage, code: errorCode2 };
-  }
-  const input = (raw ?? "").trim();
-  if (errorCode2 === "spending_reservation_busy" || input.includes("streamSpendingReservations") && input.includes("changed while this mutation was being run")) {
-    return {
-      code: "spending_reservation_busy",
-      message: "MCPJam could not reserve spending capacity because concurrent requests kept changing it. This is an internal execution failure. Retry this attempt."
-    };
-  }
-  if (isXaaConnectFailureReason(errorCode2)) {
-    return {
-      message: (scrub(input) || XAA_REASON_FALLBACK_MESSAGES[errorCode2]).slice(
-        0,
-        MAX_ATTEMPT_ERROR_CHARS
-      ),
-      code: errorCode2,
-      ...isRerunnableXaaFailure(errorCode2) ? { rerunnable: true } : {}
-    };
-  }
-  if (!input) return { message: "The session failed for an unknown reason." };
-  let body = input;
-  let httpStatus2;
-  const envelope = AGENT_ERROR_ENVELOPE.exec(input);
-  if (envelope) {
-    httpStatus2 = Number(envelope[1] ?? envelope[2]);
-    body = input.slice(envelope[0].length).trim();
-  }
-  const parsed = parseJsonObject(body);
-  if (!parsed) {
-    const cleaned = scrub(body) || scrub(input);
-    return {
-      message: (cleaned || "The session failed for an unknown reason.").slice(
-        0,
-        MAX_ATTEMPT_ERROR_CHARS
-      ),
-      ...httpStatus2 !== void 0 ? { httpStatus: httpStatus2 } : {}
-    };
-  }
-  const headline = str3(parsed.error) ?? str3(parsed.message) ?? "The session could not run.";
-  const details = str3(parsed.details);
-  const code = str3(parsed.code);
-  const retryAfterMs = num2(parsed.retryAfter);
-  const canTopUp = parsed.canTopUp === true;
-  return {
-    message: scrub(compose(headline, details)).slice(
-      0,
-      MAX_ATTEMPT_ERROR_CHARS
-    ),
-    ...code ? { code } : {},
-    ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
-    ...canTopUp ? { canTopUp } : {},
-    ...httpStatus2 !== void 0 ? { httpStatus: httpStatus2 } : {}
-  };
-}
-function humanizeSwarmAttemptErrorMessage(raw) {
-  return humanizeSwarmAttemptError(raw).message;
-}
-var ACCOUNT_LIMIT_CODE = /\b(?:user_rate_limit|org_rate_limit|mcpjam_rate_limit|billing_limit_reached|spend_budget_reached|wallet_locked|billing_feature_not_included|free_tier_model_restricted|spend_cap_exceeded|platform_free_budget_exhausted|account_suspended|guest_model_not_allowed|guest_input_too_large)\b/i;
-function isAccountLimit(message, code) {
-  if (accountLimitCode(message, code)) return true;
-  return !!message && MCPJAM_MODEL_LIMIT_SENTENCE.test(message);
-}
-var MCPJAM_MODEL_LIMIT_SENTENCE = /\b(?:Daily|Monthly) MCPJam model limit reached\b/i;
-function accountLimitCode(message, code) {
-  const match = (code ? ACCOUNT_LIMIT_CODE.exec(code) : null) ?? (message ? ACCOUNT_LIMIT_CODE.exec(message) : null);
-  return match?.[0].toLowerCase();
-}
-
 // server/services/sessionSimulation/swarm-stream-hub.ts
 var RING_BUFFER_SIZE = 200;
 var MAX_RETAINED_FRAME_SESSIONS = 64;
@@ -232741,7 +233340,8 @@ function terminalForOutcome(outcome, errorMessage7, errorReason) {
   if (outcome === "succeeded") {
     return { status: "succeeded" };
   }
-  const safeMessage = errorMessage7 ? humanizeSwarmAttemptErrorMessage(errorMessage7) : void 0;
+  const info = errorMessage7 ? humanizeSwarmAttemptError(errorMessage7) : void 0;
+  const safeMessage = info?.message;
   if (outcome === "rate_limited") {
     return {
       status: "rate_limited",
@@ -232755,11 +233355,14 @@ function terminalForOutcome(outcome, errorMessage7, errorReason) {
   }
   return {
     status: "failed",
-    errorCode: errorReason ?? "session_failed",
+    errorCode: errorReason ?? info?.code ?? "session_failed",
     ...safeMessage ? { errorMessage: safeMessage } : {}
   };
 }
-function classifyRateLimit(message) {
+function classifyRateLimit(message, hint) {
+  const refusal = hint ?? humanizeSwarmAttemptError(message);
+  if (isTransientSpendRefusal(refusal.code, refusal.refusalReason))
+    return "transient_capacity";
   if (!message) return "provider_rate_limit";
   if (isAccountLimit(message)) return "org_spend_cap";
   if (/\bspend\b|\bcap\b|\bquota\b|\bbudget\b/i.test(message)) {
@@ -233051,7 +233654,7 @@ async function runJourneyFanOut(opts) {
             emit({
               type: "attempt_status",
               status: "failed",
-              errorMessage: message.slice(0, MAX_ATTEMPT_ERROR_CHARS)
+              errorMessage: humanizeSwarmAttemptErrorMessage(message)
             });
             await reportAttempt(convexHttpUrl3, bearer, {
               projectId,
@@ -233062,7 +233665,7 @@ async function runJourneyFanOut(opts) {
               status: "failed",
               chatSessionId,
               errorCode: "sandbox_unavailable",
-              errorMessage: message.slice(0, MAX_ATTEMPT_ERROR_CHARS)
+              errorMessage: humanizeSwarmAttemptErrorMessage(message)
             }).catch((err) => {
               logger.error(
                 "[swarm.runner] failed to report sandbox-unavailable terminal",
@@ -233119,9 +233722,8 @@ async function runJourneyFanOut(opts) {
               const failure = {
                 status: "failed",
                 errorCode: provisioned.code,
-                errorMessage: provisioned.message.slice(
-                  0,
-                  MAX_ATTEMPT_ERROR_CHARS
+                errorMessage: humanizeSwarmAttemptErrorMessage(
+                  provisioned.message
                 )
               };
               emit({
@@ -233289,7 +233891,7 @@ async function runJourneyFanOut(opts) {
               });
             }
           });
-          const { outcome, errorMessage: errorMessage7, errorReason } = sessionResult;
+          const { outcome, errorMessage: errorMessage7, errorReason, errorRefusal } = sessionResult;
           if (stoppedByBackend) return;
           const abortedBySpendCap = spendCapTripped && outcome === "failed" && sessionSignal.aborted;
           const abortedByRunDeadline = outcome === "failed" && sessionSignal.aborted && runDeadline.firedClock() === "run";
@@ -233398,7 +234000,7 @@ async function runJourneyFanOut(opts) {
           });
           const accountLimitFailure = outcome === "failed" && !abortedBySpendCap && isAccountLimit(errorMessage7, errorReason);
           if (outcome === "rate_limited" || accountLimitFailure) {
-            const cause = classifyRateLimit(errorMessage7);
+            const cause = classifyRateLimit(errorMessage7, errorRefusal);
             if (cause === "org_spend_cap") {
               spendCapTripped = true;
               spendCapMessage = errorMessage7 ? humanizeSwarmAttemptErrorMessage(errorMessage7) : void 0;
@@ -233421,7 +234023,8 @@ async function runJourneyFanOut(opts) {
             await markRemainingTargetAttemptsRateLimited(
               { convexHttpUrl: convexHttpUrl3, bearer, projectId, runId, target },
               sessionIdx + 1,
-              sessionsPerTarget
+              sessionsPerTarget,
+              cause === "transient_capacity" ? humanizeSwarmAttemptErrorMessage(errorMessage7) : void 0
             );
             return;
           }
@@ -233635,7 +234238,7 @@ async function resolveTargetPinnedSkills(args) {
   }
   return artifacts;
 }
-async function markRemainingTargetAttemptsRateLimited(ctx, fromIdx, toIdx) {
+async function markRemainingTargetAttemptsRateLimited(ctx, fromIdx, toIdx, transientMessage) {
   const { convexHttpUrl: convexHttpUrl3, bearer, projectId, runId, target } = ctx;
   const { hostId, targetId: targetId2 } = target;
   for (let sessionIdx = fromIdx; sessionIdx < toIdx; sessionIdx++) {
@@ -233662,7 +234265,8 @@ async function markRemainingTargetAttemptsRateLimited(ctx, fromIdx, toIdx) {
         sessionIdx,
         status: "rate_limited",
         chatSessionId,
-        errorCode: "rate_limited"
+        errorCode: transientMessage ? "user_rate_limit" : "rate_limited",
+        ...transientMessage ? { errorMessage: transientMessage } : {}
       });
     } catch (err) {
       logger.warn(
@@ -233803,6 +234407,20 @@ async function resolveTargetPluginServers(getConvexClient, args) {
 }
 
 // server/services/sessionSimulation/launch-journey-run.ts
+var BROWSER_TOOL_ID2 = "browser";
+async function withoutBrowserOutsideRollout(hosts, workosUserId) {
+  const wantsBrowser = (host) => (host.builtInToolIds ?? []).includes(BROWSER_TOOL_ID2);
+  if (!hosts.some(wantsBrowser)) return hosts;
+  if (workosUserId && await rolloutEnabled(false, workosUserId)) return hosts;
+  return hosts.map(
+    (host) => wantsBrowser(host) ? {
+      ...host,
+      builtInToolIds: (host.builtInToolIds ?? []).filter(
+        (id3) => id3 !== BROWSER_TOOL_ID2
+      )
+    } : host
+  );
+}
 var MAX_PASSTHROUGH_REASON_LENGTH = 300;
 var LINE_BREAK = /[\r\n\f\u2028\u2029]/;
 function launchFailureMessage(err) {
@@ -233886,12 +234504,15 @@ async function launchJourneyRun(deps, input) {
         429: ErrorCode.RATE_LIMITED
       };
       const code = CODE_BY_STATUS[err.status] ?? ErrorCode.VALIDATION_ERROR;
-      const routeError = new WebRouteError(
-        err.status,
-        code,
-        launchFailureMessage(err),
-        launchFailureDetails(err)
-      );
+      const details = launchFailureDetails(err);
+      const modelError = environmentModelRequiredError({
+        data: {
+          code: details?.code,
+          message: launchFailureMessage(err),
+          details
+        }
+      });
+      const routeError = modelError ?? new WebRouteError(err.status, code, launchFailureMessage(err), details);
       throw err.retryAfter ? routeError.withHeaders({ "Retry-After": err.retryAfter }) : routeError;
     }
     throw err;
@@ -233913,11 +234534,15 @@ async function launchJourneyRun(deps, input) {
   }
   const hosts = snapshot2.hosts;
   const getPluginRegateClient = async () => createConvexClient(await deps.getRunBearer());
-  setImmediate(() => {
+  setImmediate(async () => {
+    const runHosts = await withoutBrowserOutsideRollout(
+      hosts,
+      deps.callerContext.workosUserId
+    );
     startJourneyRun({
       runId,
       projectId,
-      hosts,
+      hosts: runHosts,
       personaSnapshot: snapshot2.personaSnapshot,
       sessionsPerTarget: snapshot2.sessionsPerTarget,
       maxTurns: snapshot2.maxTurns,
@@ -242934,8 +243559,8 @@ function measureClientMessage(buffer2, holdsInput) {
       return decide(20, true);
     case RFB_CLIENT_MESSAGE.SET_ENCODINGS: {
       if (buffer2.length < 4) return { kind: "incomplete" };
-      const count4 = readU16(buffer2, 2);
-      return decide(4 + count4 * 4, true);
+      const count5 = readU16(buffer2, 2);
+      return decide(4 + count5 * 4, true);
     }
     case RFB_CLIENT_MESSAGE.FRAMEBUFFER_UPDATE_REQUEST:
       return decide(10, true);
@@ -243045,10 +243670,10 @@ function parseProtocolVersion(bytes2) {
 }
 function parseSecurityTypes(bytes2) {
   if (bytes2.length < 1) return null;
-  const count4 = bytes2[0];
-  if (count4 === 0) return [];
-  if (bytes2.length < 1 + count4) return null;
-  return Array.from(bytes2.subarray(1, 1 + count4));
+  const count5 = bytes2[0];
+  if (count5 === 0) return [];
+  if (bytes2.length < 1 + count5) return null;
+  return Array.from(bytes2.subarray(1, 1 + count5));
 }
 function vncPasswordKey(password) {
   const key = Buffer.alloc(8, 0);
@@ -254513,7 +255138,7 @@ async function runAssertionBacktest(input) {
   const differences = [];
   const seen = /* @__PURE__ */ new Set();
   let page3;
-  let count4 = 0;
+  let count5 = 0;
   for (let n = 0; n < 10; n++) {
     if (input.signal?.aborted) throw new Error("Backtest cancelled");
     const priorPage = page3;
@@ -254562,7 +255187,7 @@ async function runAssertionBacktest(input) {
         throw new Error("Duplicate or invalid backtest iteration identity");
       seen.add(row2.iterationId);
       differences.push(...backtestIteration(row2, draft));
-      count4++;
+      count5++;
       if (Date.now() > deadline2) throw new Error("Backtest deadline exceeded");
     }
     if (page3.isDone) break;
@@ -254575,7 +255200,7 @@ async function runAssertionBacktest(input) {
     sourceHash: page3.sourceHash,
     draftHash,
     configRevision: page3.configRevision,
-    complete: page3.isDone && count4 > 0 && differences.length > 0 && comparable === differences.length,
+    complete: page3.isDone && count5 > 0 && differences.length > 0 && comparable === differences.length,
     continuationAvailable: !page3.isDone,
     ...!page3.isDone ? {
       continuation: {
@@ -254586,7 +255211,7 @@ async function runAssertionBacktest(input) {
       }
     } : {},
     counts: {
-      iterations: count4,
+      iterations: count5,
       comparable,
       ungradable: differences.length - comparable,
       flipped: differences.filter((row2) => row2.flipped).length
@@ -255290,8 +255915,8 @@ function describeClientImpact(input) {
     [n("scenarioAttachmentCount"), "scenario attachment"],
     [n("activeLegacyJourneyCount"), "active legacy journey"]
   ];
-  const total = parts.reduce((sum2, [count4]) => sum2 + count4, 0);
-  const listed = parts.map(([count4, noun]) => `${count4} ${noun}${count4 === 1 ? "" : "s"}`).join(", ");
+  const total = parts.reduce((sum2, [count5]) => sum2 + count5, 0);
+  const listed = parts.map(([count5, noun]) => `${count5} ${noun}${count5 === 1 ? "" : "s"}`).join(", ");
   const affected = total === 0 ? "Nothing durable currently uses this client" : `This will affect ${listed}`;
   return `${affected}; future direct client and playground use also follows the edit. ${unchanged}`;
 }
@@ -256330,8 +256955,8 @@ var AGENT_OP_REGISTRY = [
     tier: "gated",
     proposal: {
       describe: (input) => {
-        const persona = input.persona;
-        const name15 = persona && typeof persona === "object" ? named(persona, "name") : void 0;
+        const persona4 = input.persona;
+        const name15 = persona4 && typeof persona4 === "object" ? named(persona4, "name") : void 0;
         return name15 ? `Draft journeys for ${name15} with a model` : "Draft journeys with a model";
       },
       buttonLabel: "Draft them",