openmates 0.15.0-alpha.73 → 0.15.0-alpha.75

package/dist/{chunk-VJLMFEX6.js → chunk-U4XICRVH.js}

@@ -1356,6 +1356,9 @@ function websocketProtocolError(envelope) {
   }
   return null;
 }
+function numberMetric(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function errorFrameBelongsToAiResponse(envelope, userMessageId, chatId, recoveryTurnId) {
   if (envelope.type === "client_update_required") return true;
   if (envelope.type !== "error") return true;
@@ -1722,6 +1725,8 @@ var OpenMatesWsClient = class {
       let taskId = null;
       let category = null;
       let modelName = null;
+      let tokenUsage = null;
+      let promptBudget = null;
       let recoveryJobId = null;
       const compressionCheckpoints = [];
       let followUpSuggestions = [];
@@ -1767,6 +1772,24 @@ var OpenMatesWsClient = class {
         if (typeof p.category === "string" && p.category) category = p.category;
         if (typeof p.model_name === "string" && p.model_name)
           modelName = p.model_name;
+        const promptTokens = numberMetric(p.prompt_tokens);
+        const completionTokens = numberMetric(p.completion_tokens);
+        const userInputTokens = numberMetric(p.user_input_tokens);
+        const systemPromptTokens = numberMetric(p.system_prompt_tokens);
+        const totalCredits = numberMetric(p.total_credits);
+        const hasTokenUsage = promptTokens !== null || completionTokens !== null || userInputTokens !== null || systemPromptTokens !== null || totalCredits !== null;
+        if (hasTokenUsage) {
+          tokenUsage = {
+            ...promptTokens !== null ? { promptTokens } : {},
+            ...completionTokens !== null ? { completionTokens } : {},
+            ...userInputTokens !== null ? { userInputTokens } : {},
+            ...systemPromptTokens !== null ? { systemPromptTokens } : {},
+            ...totalCredits !== null ? { totalCredits } : {}
+          };
+        }
+        if (systemPromptTokens !== null) {
+          promptBudget = { systemPromptTokens };
+        }
         if (typeof p.recovery_job_id === "string" && p.recovery_job_id && p.recovery_protocol_version === 1)
           recoveryJobId = p.recovery_job_id;
       };
@@ -1809,7 +1832,9 @@ var OpenMatesWsClient = class {
             embeds: [...embeds.values()],
             subChatEvents,
             recoveryJobId,
-            compressionCheckpoints
+            compressionCheckpoints,
+            tokenUsage,
+            promptBudget
           });
           return;
         }
@@ -1839,7 +1864,9 @@ var OpenMatesWsClient = class {
               embeds: [...embeds.values()],
               subChatEvents,
               recoveryJobId,
-              compressionCheckpoints
+              compressionCheckpoints,
+              tokenUsage,
+              promptBudget
             });
           }, asyncEmbedWaitMs);
           return;
@@ -1865,7 +1892,9 @@ var OpenMatesWsClient = class {
           embeds: [...embeds.values()],
           subChatEvents,
           recoveryJobId,
-          compressionCheckpoints
+          compressionCheckpoints,
+          tokenUsage,
+          promptBudget
         });
       };
       const handleSubChatEvent = (type, p) => {
@@ -2139,7 +2168,9 @@ var OpenMatesWsClient = class {
             embeds: [...embeds.values()],
             subChatEvents,
             recoveryJobId,
-            compressionCheckpoints
+            compressionCheckpoints,
+            tokenUsage,
+            promptBudget
           });
           return;
         }
@@ -6388,7 +6419,9 @@ var OpenMatesClient = class _OpenMatesClient {
       taskProposals: [],
       taskUpdateProposals: [],
       subChatEvents: [],
-      appSettingsMemoryRequests: []
+      appSettingsMemoryRequests: [],
+      tokenUsage: null,
+      promptBudget: null
     };
   }
   async createTurnTokenRefs(params) {
@@ -6574,7 +6607,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (!userId) {
       throw new Error("Could not resolve current user id for local connected-account connector.");
     }
-    const { createHash: createHash14 } = await import("crypto");
+    const { createHash: createHash15 } = await import("crypto");
     const accountId = randomUUID5();
     const masterKey = this.getMasterKeyBytes();
     const encryptLocalConnectorValue = async (value) => {
@@ -6583,9 +6616,9 @@ var OpenMatesClient = class _OpenMatesClient {
     };
     const payload = {
       id: accountId,
-      hashed_user_id: createHash14("sha256").update(userId).digest("hex"),
+      hashed_user_id: createHash15("sha256").update(userId).digest("hex"),
       encrypted_provider_type: await encryptLocalConnectorValue(input.provider_id),
-      provider_type_hash: createHash14("sha256").update(input.provider_id).digest("hex"),
+      provider_type_hash: createHash15("sha256").update(input.provider_id).digest("hex"),
       encrypted_account_label: await encryptLocalConnectorValue(input.label),
       encrypted_capabilities: await encryptLocalConnectorValue(input.capabilities),
       encrypted_app_permissions: await encryptLocalConnectorValue({
@@ -7970,8 +8003,8 @@ var OpenMatesClient = class _OpenMatesClient {
       );
     }
     const embedId = String(embed.embed_id ?? embed.id ?? "");
-    const { createHash: createHash14 } = await import("crypto");
-    const hashedEmbedId = createHash14("sha256").update(embedId).digest("hex");
+    const { createHash: createHash15 } = await import("crypto");
+    const hashedEmbedId = createHash15("sha256").update(embedId).digest("hex");
     const embedKeyBytes = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -8079,7 +8112,7 @@ var OpenMatesClient = class _OpenMatesClient {
   async resolveEmbedKey(cache, masterKey, embed, embedId, hashedEmbedId, visited = /* @__PURE__ */ new Set()) {
     if (visited.has(embedId)) return null;
     visited.add(embedId);
-    const { createHash: createHash14 } = await import("crypto");
+    const { createHash: createHash15 } = await import("crypto");
     const masterKeyEntry = cache.embedKeys.find(
       (ek) => ek.hashed_embed_id === hashedEmbedId && String(ek.key_type) === "master"
     );
@@ -8096,7 +8129,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (chatKeyEntry && typeof chatKeyEntry.encrypted_embed_key === "string") {
       const hashedChatId = String(chatKeyEntry.hashed_chat_id ?? "");
       const owningChat = cache.chats.find((c) => {
-        const chatHash = createHash14("sha256").update(String(c.details.id ?? "")).digest("hex");
+        const chatHash = createHash15("sha256").update(String(c.details.id ?? "")).digest("hex");
         return chatHash === hashedChatId;
       });
       if (owningChat) {
@@ -8125,7 +8158,7 @@ var OpenMatesClient = class _OpenMatesClient {
         const parentFullId = String(
           parentEmbed2.embed_id ?? parentEmbed2.id ?? ""
         );
-        const parentHashedId = createHash14("sha256").update(parentFullId).digest("hex");
+        const parentHashedId = createHash15("sha256").update(parentFullId).digest("hex");
         const parentKey = await this.resolveEmbedKey(
           cache,
           masterKey,
@@ -8555,6 +8588,8 @@ var OpenMatesClient = class _OpenMatesClient {
     let assistantMessageId = null;
     let category = null;
     let modelName = null;
+    let tokenUsage = null;
+    let promptBudget = null;
     let followUpSuggestions = [];
     let taskProposals = [];
     let taskUpdateProposals = [];
@@ -8786,6 +8821,8 @@ var OpenMatesClient = class _OpenMatesClient {
         assistant = resp.content;
         category = resp.category;
         modelName = resp.modelName;
+        tokenUsage = resp.tokenUsage;
+        promptBudget = resp.promptBudget;
         taskEvents = resp.taskEvents;
         pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
         subChatEvents = resp.subChatEvents;
@@ -8805,7 +8842,9 @@ var OpenMatesClient = class _OpenMatesClient {
             taskEvents,
             pendingTaskUpdateJobs,
             subChatEvents,
-            appSettingsMemoryRequests
+            appSettingsMemoryRequests,
+            tokenUsage,
+            promptBudget
           };
         }
       } finally {
@@ -8822,6 +8861,8 @@ var OpenMatesClient = class _OpenMatesClient {
         assistant = resp.content;
         category = resp.category;
         modelName = resp.modelName;
+        tokenUsage = resp.tokenUsage;
+        promptBudget = resp.promptBudget;
         followUpSuggestions = resp.followUpSuggestions;
         taskProposals = resp.taskProposals;
         taskUpdateProposals = resp.taskUpdateProposals;
@@ -8844,7 +8885,9 @@ var OpenMatesClient = class _OpenMatesClient {
             taskEvents,
             pendingTaskUpdateJobs,
             subChatEvents,
-            appSettingsMemoryRequests
+            appSettingsMemoryRequests,
+            tokenUsage,
+            promptBudget
           };
         }
         if (chatKeyBytes) {
@@ -8898,7 +8941,9 @@ var OpenMatesClient = class _OpenMatesClient {
               taskEvents,
               pendingTaskUpdateJobs,
               subChatEvents,
-              appSettingsMemoryRequests
+              appSettingsMemoryRequests,
+              tokenUsage,
+              promptBudget
             };
           }
           if (claim.state !== "LEASED" || !leaseToken || leaseGeneration === null || leaseGeneration < 1 || !assistantId || keyVersion === null || keyVersion !== 1 || claim.chat_id !== chatId || claim.turn_id !== savedTurnId || typeof claim.sealed_payload !== "string") {
@@ -9072,7 +9117,9 @@ var OpenMatesClient = class _OpenMatesClient {
       taskEvents,
       pendingTaskUpdateJobs,
       subChatEvents,
-      appSettingsMemoryRequests
+      appSettingsMemoryRequests,
+      tokenUsage,
+      promptBudget
     };
   }
   async persistEncryptedSystemMessage(ws, systemMessage, targetChatId) {
@@ -11752,7 +11799,7 @@ Required: ${schema.required.join(", ")}`
     const session = this.requireSession();
     const masterKey = base64ToBytes(session.masterKeyExportedB64);
     const cache = await this.ensureSynced();
-    const { createHash: createHash14 } = await import("crypto");
+    const { createHash: createHash15 } = await import("crypto");
     const embed = cache.embeds.find(
       (e) => String(e.embed_id ?? "").startsWith(embedIdOrShort) || String(e.id ?? "").startsWith(embedIdOrShort)
     );
@@ -11760,7 +11807,7 @@ Required: ${schema.required.join(", ")}`
       throw new Error(`Embed '${embedIdOrShort}' not found in local cache.`);
     }
     const embedId = String(embed.embed_id ?? embed.id ?? "");
-    const hashedEmbedId = createHash14("sha256").update(embedId).digest("hex");
+    const hashedEmbedId = createHash15("sha256").update(embedId).digest("hex");
     const embedKeyBytes = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -11868,8 +11915,8 @@ Required: ${schema.required.join(", ")}`
     if (!embed) {
       throw new Error(`Embed '${embedId}' not found in local cache. Run 'openmates chats list' to sync first.`);
     }
-    const { createHash: createHash14 } = await import("crypto");
-    const hashedEmbedId = createHash14("sha256").update(embedId).digest("hex");
+    const { createHash: createHash15 } = await import("crypto");
+    const hashedEmbedId = createHash15("sha256").update(embedId).digest("hex");
     const embedKey = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -11985,8 +12032,8 @@ Required: ${schema.required.join(", ")}`
     if (!embed) {
       throw new Error(`Embed '${embedId}' not found in local cache. Run 'openmates chats list' to sync first.`);
     }
-    const { createHash: createHash14 } = await import("crypto");
-    const hashedEmbedId = createHash14("sha256").update(embedId).digest("hex");
+    const { createHash: createHash15 } = await import("crypto");
+    const hashedEmbedId = createHash15("sha256").update(embedId).digest("hex");
     const embedKey = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -12425,9 +12472,9 @@ Required: ${schema.required.join(", ")}`
     chats.splice(0, chats.length, ...reconciledChats);
     if (totalChatCount === 0) totalChatCount = chats.length;
     if (reconciliation.deleted_chat_ids?.length) {
-      const { createHash: createHash14 } = await import("crypto");
+      const { createHash: createHash15 } = await import("crypto");
       const deletedHashes = new Set(
-        reconciliation.deleted_chat_ids.map((id) => createHash14("sha256").update(id).digest("hex"))
+        reconciliation.deleted_chat_ids.map((id) => createHash15("sha256").update(id).digest("hex"))
       );
       const keptEmbeds = embeds.filter((embed) => !deletedHashes.has(String(embed.hashed_chat_id ?? "")));
       const keptKeys = embedKeys.filter((key) => !deletedHashes.has(String(key.hashed_chat_id ?? "")));
@@ -21185,7 +21232,7 @@ import { stdin as stdin3, stdout as stdout2 } from "process";
 import { readFileSync as readFileSync11, realpathSync as realpathSync2, writeFileSync as writeFileSync7 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { basename as basename3, dirname as dirname5 } from "path";
-import { createHash as createHash13, randomBytes as randomBytes8, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash14, randomBytes as randomBytes8, randomUUID as randomUUID10 } from "crypto";
 import { arch as arch2, platform as platform3 } from "os";
 import WebSocket2 from "ws";
 
@@ -45994,6 +46041,9 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
       },
       all_examples_subtitle: {
         text: "Pick one to see how the workspace feels in practice."
+      },
+      back_to_recent: {
+        text: "Back to recent"
       }
     }
   },
@@ -46107,6 +46157,51 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     }
   },
   chats: {
+    chat: {
+      welcome: {
+        back_to_recent: {
+          text: "Back to recent"
+        }
+      },
+      sub_chats: {
+        confirmation_title: {
+          text: "Start {count} background chats?"
+        },
+        confirmation_description: {
+          text: "OpenMates starts up to {auto} automatically. Larger batches need your approval, and each chat can have up to {max} direct sub-chats."
+        },
+        confirmation_more: {
+          text: "+{count} more"
+        },
+        start_all: {
+          text: "Start all {count}"
+        },
+        progress_label: {
+          text: "Sequential sub-chats: {completed} / {total} complete"
+        },
+        progress_stopping: {
+          text: "Stopping sequential sub-chats..."
+        },
+        stop_queue: {
+          text: "Stop queue"
+        },
+        broadcast_to_siblings: {
+          text: "Send to sibling sub-chats"
+        },
+        return_to_parent: {
+          text: "Return to parent chat"
+        },
+        start_first: {
+          text: "Start first {count}"
+        },
+        confirmation_failed: {
+          text: "Failed to update sub-chat approval."
+        },
+        limit_exceeded: {
+          text: "This chat has reached its sub-chat limit."
+        }
+      }
+    },
     context_menu: {
       download: {
         text: "Download"
@@ -46213,46 +46308,6 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
         text: "Could not start the explanation chat. Please try again."
       }
     },
-    chat: {
-      sub_chats: {
-        confirmation_title: {
-          text: "Start {count} background chats?"
-        },
-        confirmation_description: {
-          text: "OpenMates starts up to {auto} automatically. Larger batches need your approval, and each chat can have up to {max} direct sub-chats."
-        },
-        confirmation_more: {
-          text: "+{count} more"
-        },
-        start_all: {
-          text: "Start all {count}"
-        },
-        progress_label: {
-          text: "Sequential sub-chats: {completed} / {total} complete"
-        },
-        progress_stopping: {
-          text: "Stopping sequential sub-chats..."
-        },
-        stop_queue: {
-          text: "Stop queue"
-        },
-        broadcast_to_siblings: {
-          text: "Send to sibling sub-chats"
-        },
-        return_to_parent: {
-          text: "Return to parent chat"
-        },
-        start_first: {
-          text: "Start first {count}"
-        },
-        confirmation_failed: {
-          text: "Failed to update sub-chat approval."
-        },
-        limit_exceeded: {
-          text: "This chat has reached its sub-chat limit."
-        }
-      }
-    },
     hidden_chats: {
       unlock: {
         text: "Unlock hidden chats"
@@ -62823,14 +62878,126 @@ function buildAssistantFeedbackDecision(rating) {
 }
 
 // src/benchmark.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { createHash as createHash13, randomUUID as randomUUID8 } from "crypto";
 import { existsSync as existsSync8, mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import { tmpdir } from "os";
 import { dirname as dirname4, join as join5, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 var DEFAULT_JUDGE_MODEL = "google/gemini-3-flash-preview";
+var DEFAULT_PROMPT_BUDGET_MODEL = "google/gemini-3.5-flash";
 var DEFAULT_EXTENSIVE_SIZE = 10;
 var DEFAULT_PARALLEL = 4;
+var PROMPT_BUDGET_TARGET_INPUT_TOKENS_PER_TURN = 16e3;
+var PROMPT_BUDGET_TARGET_OUTPUT_TOKENS_PER_TURN = 800;
+var PROMPT_BUDGET_JUDGE_INPUT_TOKENS_PER_RESPONSE = 3e3;
+var PROMPT_BUDGET_JUDGE_OUTPUT_TOKENS_PER_RESPONSE = 300;
+var PROMPT_BUDGET_CASES = [
+  {
+    id: "single-writing-concise-email",
+    title: "Concise email rewrite",
+    category: "writing",
+    qualityRubric: "Warm, concise, under 120 words, directly asks to move the Tuesday sync to Thursday afternoon.",
+    turns: [
+      "Write a concise but warm email to a colleague asking to move our Tuesday 10:00 project sync to Thursday afternoon. Keep it under 120 words."
+    ]
+  },
+  {
+    id: "single-code-palindrome",
+    title: "TypeScript palindrome helper",
+    category: "coding",
+    qualityRubric: "Produces valid TypeScript, ignores spaces/punctuation/case, includes one short usage example, and avoids unrelated prose.",
+    turns: [
+      "Write a TypeScript function isPalindrome(input: string): boolean that ignores spaces, punctuation, and case. Include only the function and one short usage example."
+    ]
+  },
+  {
+    id: "single-current-web-ai-news",
+    title: "Current AI release search",
+    category: "web",
+    qualityRubric: "Uses current web/search behavior, cites sources, and summarizes a major AI model release from the last 30 days without fabricating certainty.",
+    turns: [
+      "Search the web for the latest major AI model release from the last 30 days and summarize what changed, with sources."
+    ]
+  },
+  {
+    id: "single-travel-filtered-flight",
+    title: "Filtered flight search",
+    category: "travel",
+    qualityRubric: "Attempts appropriate travel/tool routing, honors direct flight/date/budget constraints where possible, and explains tradeoffs or uncertainty.",
+    turns: [
+      "Find direct flights from Berlin to Barcelona on 2026-09-10 under 220 EUR if possible, and explain the best tradeoff."
+    ]
+  },
+  {
+    id: "single-events-accessibility",
+    title: "Accessible family events",
+    category: "events",
+    qualityRubric: "Attempts event/tool routing, separates confirmed from unknown accessibility, and avoids claiming accessibility without evidence.",
+    turns: [
+      "Find wheelchair-accessible family events in Berlin this weekend. Separate confirmed accessibility from unknown accessibility."
+    ]
+  },
+  {
+    id: "single-openmates-help",
+    title: "OpenMates skill selection",
+    category: "openmates",
+    qualityRubric: "Correctly explains a suitable OpenMates app/skill path for product comparison and suggests a useful next step.",
+    turns: [
+      "Explain which OpenMates app or skill I should use to compare products before buying a new laptop, and what you would do next."
+    ]
+  },
+  {
+    id: "single-safety-privacy-review",
+    title: "Privacy review",
+    category: "safety",
+    qualityRubric: "Identifies privacy risks in benchmark logging and gives practical safer defaults without overclaiming compliance.",
+    turns: [
+      "Review this benchmark design for privacy risks: it logs prompts, outputs, model ids, usage costs, and debug metadata to a shared file. List risks and safer defaults."
+    ]
+  },
+  {
+    id: "multiturn-model-evaluation-plan",
+    title: "Model evaluation follow-up plan",
+    category: "planning",
+    qualityRubric: "Maintains continuity across all six turns, refines prior outputs instead of restarting, and produces concrete evaluation criteria.",
+    turns: [
+      "Create a three-step plan for evaluating whether a new AI model is ready for production use.",
+      "Make step 2 more concrete with two measurable checks.",
+      "Add a risk register with severity and mitigation for the top three risks.",
+      "Turn the plan into a one-week execution schedule.",
+      "Identify which tasks could be automated with OpenMates skills.",
+      "Summarize the final plan in one sentence."
+    ]
+  },
+  {
+    id: "multiturn-startup-launch",
+    title: "Freelancer AI assistant launch",
+    category: "business",
+    qualityRubric: "Builds on previous launch context, keeps the privacy-first freelancer positioning, and produces specific GTM artifacts.",
+    turns: [
+      "Help me plan the launch of a privacy-first personal AI assistant for freelancers.",
+      "Define the ideal first customer profile and their top pains.",
+      "Draft a landing page hero section for that customer.",
+      "Create a simple pricing experiment with three tiers.",
+      "Write five outbound messages for early customer interviews.",
+      "Summarize the riskiest assumption and how to test it this week."
+    ]
+  },
+  {
+    id: "multiturn-debugging-workflow",
+    title: "SvelteKit stale chat debugging",
+    category: "debugging",
+    qualityRubric: "Maintains the stale-chat bug context, distinguishes frontend cache from backend sync, and uses data-testid selector guidance.",
+    turns: [
+      "A SvelteKit page sometimes shows stale chat messages after refresh. Give me a debugging plan.",
+      "Add likely root causes involving IndexedDB and WebSocket sync.",
+      "Suggest instrumentation I should add before fixing code.",
+      "Write a minimal regression test outline using data-testid selectors.",
+      "Explain how to tell if the bug is backend sync or frontend cache.",
+      "Condense this into a checklist I can hand to another engineer."
+    ]
+  }
+];
 var FIXTURE_IMAGE_SVG = `<?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" width="1200" height="800" viewBox="0 0 1200 800">
   <rect width="1200" height="800" fill="#d8ecff"/>
@@ -63101,6 +63268,10 @@ async function handleBenchmark(client, subcommand, rest, flags) {
     printBenchmarkHelp();
     return;
   }
+  if (subcommand === "prompt-budget") {
+    await handlePromptBudgetBenchmark(client, rest, flags);
+    return;
+  }
   if (subcommand !== "model") {
     throw new Error(`Unknown benchmark command '${subcommand}'. Run 'openmates benchmark --help'.`);
   }
@@ -63175,6 +63346,8 @@ async function handleBenchmark(client, subcommand, rest, flags) {
 function printBenchmarkHelp() {
   console.log(`Benchmark commands:
   openmates benchmark model <provider/model> [provider/model...] --confirm-spend-credits [--compare] [--suite quick|extensive|all] [--json]
+  openmates benchmark prompt-budget --phase baseline|postchange --confirm-spend-credits [--model provider/model] [--resume-from <path>] [--json]
+  openmates benchmark prompt-budget compare --baseline <path> --postchange <path> [--json]
 
 Runs real incognito chat requests through the OpenMates product path. Live runs
 spend the logged-in user's credits and usage entries are grouped as benchmark spend.
@@ -63194,6 +63367,74 @@ Options:
   --output <path>               Save JSON result to a file
   --json                        Print JSON result`);
 }
+async function handlePromptBudgetBenchmark(client, rest, flags) {
+  if (rest[0] === "compare") {
+    writePromptBudgetComparison(comparePromptBudgetArtifacts(flags), flags, stringFlag(flags.output));
+    return;
+  }
+  if (rest.length > 0) {
+    throw new Error(`Unknown prompt-budget benchmark argument '${rest[0]}'. Run 'openmates benchmark --help'.`);
+  }
+  const phase = parsePromptBudgetPhase(flags.phase);
+  const targetModel = stringFlag(flags.model) ?? DEFAULT_PROMPT_BUDGET_MODEL;
+  const judgeModel = stringFlag(flags["judge-model"]) ?? DEFAULT_JUDGE_MODEL;
+  const output = stringFlag(flags.output);
+  const resumeFrom = stringFlag(flags["resume-from"]);
+  const dryRun = flags["dry-run"] === true;
+  const responseTimeoutMs = parseResponseTimeoutMs(flags["response-timeout-seconds"]);
+  if (!dryRun && flags["confirm-spend-credits"] !== true) {
+    throw new Error(
+      "Prompt-budget benchmark runs spend real credits from the logged-in account. Rerun with --confirm-spend-credits, or use --dry-run to preview the plan."
+    );
+  }
+  if (dryRun && resumeFrom) {
+    throw new Error("--resume-from is only supported for live prompt-budget runs");
+  }
+  const pricing = loadPricingForModels([targetModel, judgeModel]);
+  const estimate = estimatePromptBudgetCredits(PROMPT_BUDGET_CASES, targetModel, judgeModel, pricing);
+  const resumeArtifact = resumeFrom ? readPromptBudgetResult(resumeFrom) : null;
+  if (resumeArtifact) {
+    validatePromptBudgetResumeArtifact(resumeArtifact, { phase, targetModel, judgeModel });
+  }
+  const runId = stringFlag(flags["run-id"]) ?? resumeArtifact?.runId ?? randomUUID8();
+  const result = makePromptBudgetBaseResult({
+    phase,
+    runId,
+    targetModel,
+    judgeModel,
+    dryRun,
+    estimate
+  });
+  if (resumeArtifact) {
+    result.cases = resumeArtifact.cases.filter(isCompletePromptBudgetCase);
+    recomputePromptBudgetResult(result);
+  }
+  if (dryRun) {
+    writePromptBudgetResult(result, flags, output);
+    return;
+  }
+  if (!client.hasSession()) {
+    throw new Error("Prompt-budget benchmark runs require login. Run 'openmates login' first.");
+  }
+  const completedCaseIds = new Set(result.cases.map((benchmarkCase) => benchmarkCase.id));
+  for (const benchmarkCase of PROMPT_BUDGET_CASES) {
+    if (completedCaseIds.has(benchmarkCase.id)) continue;
+    const caseResult = await runPromptBudgetCase({
+      client,
+      benchmarkCase,
+      phase,
+      runId,
+      targetModel,
+      judgeModel,
+      responseTimeoutMs
+    });
+    result.cases.push(caseResult);
+    recomputePromptBudgetResult(result);
+    if (caseResult.error) break;
+  }
+  recomputePromptBudgetResult(result);
+  writePromptBudgetResult(result, flags, output);
+}
 function parseSuites(value) {
   if (value === void 0 || value === false) return ["quick"];
   if (value === true) throw new Error("--suite requires a value");
@@ -63240,6 +63481,24 @@ function parseCaseIds(value) {
   if (caseIds.length === 0) throw new Error("--case requires at least one case id");
   return [...new Set(caseIds)];
 }
+function parsePromptBudgetPhase(value) {
+  if (value === void 0 || value === false) return "baseline";
+  if (value === true) throw new Error("--phase requires baseline or postchange");
+  if (value === "baseline" || value === "postchange") return value;
+  throw new Error("--phase must be baseline or postchange");
+}
+function parseResponseTimeoutMs(value) {
+  if (value === void 0 || value === false) return void 0;
+  if (value === true) throw new Error("--response-timeout-seconds requires a value");
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 30 || parsed > 1200) {
+    throw new Error("--response-timeout-seconds must be an integer from 30 to 1200");
+  }
+  return parsed * 1e3;
+}
+function stringFlag(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 function filterCases(cases, caseIds) {
   if (caseIds.length === 0) return cases;
   const availableIds = new Set(cases.map((benchmarkCase) => benchmarkCase.id));
@@ -63296,6 +63555,95 @@ function dedupeCases(cases) {
   }
   return result;
 }
+async function runPromptBudgetCase(params) {
+  const { client, benchmarkCase, phase, runId, targetModel, judgeModel, responseTimeoutMs } = params;
+  const startedAt = Date.now();
+  const history = [];
+  const turns = [];
+  let chatId;
+  try {
+    for (const [index, prompt] of benchmarkCase.turns.entries()) {
+      const turnNumber = index + 1;
+      const rawPrompt = `${modelMention(targetModel)} ${prompt}`;
+      const turnStartedAt = Date.now();
+      const response = await client.sendMessage({
+        message: rawPrompt,
+        chatId,
+        incognito: true,
+        autoApproveSubChats: true,
+        benchmarkMetadata: benchmarkMetadata({
+          runId,
+          suite: `prompt_budget_${phase}`,
+          caseId: `${benchmarkCase.id}:turn-${turnNumber}`,
+          targetModel,
+          judgeModel
+        }),
+        messageHistory: history,
+        precollectResponse: true,
+        responseTimeoutMs
+      });
+      chatId = response.chatId;
+      const turnResult = {
+        turn: turnNumber,
+        prompt,
+        promptHash: stableHash(prompt),
+        assistant: response.assistant,
+        durationMs: Date.now() - turnStartedAt,
+        chatId: response.chatId,
+        messageId: response.messageId,
+        modelName: response.modelName,
+        mateName: response.mateName,
+        category: response.category,
+        tokenUsage: response.tokenUsage,
+        promptBudget: response.promptBudget
+      };
+      turnResult.judge = await judgePromptBudgetTurn({
+        client,
+        benchmarkCase,
+        turn: turnResult,
+        turnNumber,
+        targetModel,
+        judgeModel,
+        runId,
+        phase
+      });
+      turns.push(turnResult);
+      appendHistory(history, "user", rawPrompt);
+      appendHistory(history, "assistant", response.assistant);
+    }
+    const continuityJudge = benchmarkCase.turns.length > 1 ? await judgePromptBudgetContinuity({
+      client,
+      benchmarkCase,
+      turns,
+      targetModel,
+      judgeModel,
+      runId,
+      phase
+    }) : void 0;
+    const passed = turns.every((turn) => (turn.judge?.score ?? 0) >= 4) && (!continuityJudge || (continuityJudge.score ?? 0) >= 4);
+    return {
+      id: benchmarkCase.id,
+      title: benchmarkCase.title,
+      category: benchmarkCase.category,
+      promptHashes: benchmarkCase.turns.map(stableHash),
+      turns,
+      continuityJudge,
+      passed,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (error) {
+    return {
+      id: benchmarkCase.id,
+      title: benchmarkCase.title,
+      category: benchmarkCase.category,
+      promptHashes: benchmarkCase.turns.map(stableHash),
+      turns,
+      passed: false,
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 async function runCaseJob(params) {
   const { client, job, judgeModel, runId, imagePath } = params;
   const { model, benchmarkCase } = job;
@@ -63488,6 +63836,82 @@ async function judgeCase(params) {
     durationMs: Date.now() - startedAt
   };
 }
+async function judgePromptBudgetTurn(params) {
+  const startedAt = Date.now();
+  const judgeResponse = await params.client.sendMessage({
+    message: `${modelMention(params.judgeModel)} ${promptBudgetTurnJudgePrompt(params)}`,
+    incognito: true,
+    autoApproveSubChats: true,
+    benchmarkMetadata: benchmarkMetadata({
+      runId: params.runId,
+      suite: `prompt_budget_${params.phase}`,
+      caseId: `${params.benchmarkCase.id}:turn-${params.turnNumber}:judge`,
+      targetModel: params.targetModel,
+      judgeModel: params.judgeModel
+    }),
+    precollectResponse: true
+  });
+  const judgment = parseJudgment(judgeResponse.assistant);
+  return {
+    model: params.judgeModel,
+    score: judgment.score,
+    reason: judgment.reason,
+    raw: judgeResponse.assistant,
+    durationMs: Date.now() - startedAt
+  };
+}
+async function judgePromptBudgetContinuity(params) {
+  const startedAt = Date.now();
+  const judgeResponse = await params.client.sendMessage({
+    message: `${modelMention(params.judgeModel)} ${promptBudgetContinuityJudgePrompt(params)}`,
+    incognito: true,
+    autoApproveSubChats: true,
+    benchmarkMetadata: benchmarkMetadata({
+      runId: params.runId,
+      suite: `prompt_budget_${params.phase}`,
+      caseId: `${params.benchmarkCase.id}:continuity-judge`,
+      targetModel: params.targetModel,
+      judgeModel: params.judgeModel
+    }),
+    precollectResponse: true
+  });
+  const judgment = parseJudgment(judgeResponse.assistant);
+  return {
+    model: params.judgeModel,
+    score: judgment.score,
+    reason: judgment.reason,
+    raw: judgeResponse.assistant,
+    durationMs: Date.now() - startedAt
+  };
+}
+function promptBudgetTurnJudgePrompt(params) {
+  return [
+    "You are judging a real OpenMates prompt-budget benchmark response.",
+    "Return exactly two plain-text lines, with no markdown, no code block, and no tool use.",
+    "Line 1 format: BENCHMARK_SCORE=<integer from 1 to 5>",
+    "Line 2 format: BENCHMARK_REASON=<one short sentence>",
+    "Score for helpfulness, instruction following, factuality, safety, routing/tool appropriateness, concision, and whether the answer preserves needed context.",
+    `Target model: ${params.targetModel}`,
+    `Case: ${params.benchmarkCase.id}`,
+    `Turn: ${params.turnNumber} of ${params.benchmarkCase.turns.length}`,
+    `Rubric: ${params.benchmarkCase.qualityRubric}`,
+    `User prompt: ${JSON.stringify(params.turn.prompt)}`,
+    `Assistant response: ${JSON.stringify(params.turn.assistant)}`
+  ].join("\n");
+}
+function promptBudgetContinuityJudgePrompt(params) {
+  return [
+    "You are judging multi-turn continuity for a real OpenMates prompt-budget benchmark conversation.",
+    "Return exactly two plain-text lines, with no markdown, no code block, and no tool use.",
+    "Line 1 format: BENCHMARK_SCORE=<integer from 1 to 5>",
+    "Line 2 format: BENCHMARK_REASON=<one short sentence>",
+    "Score whether the assistant consistently builds on earlier turns, avoids restarting, and satisfies the final requested artifact.",
+    `Target model: ${params.targetModel}`,
+    `Case: ${params.benchmarkCase.id}`,
+    `Rubric: ${params.benchmarkCase.qualityRubric}`,
+    `Turns: ${JSON.stringify(params.turns.map((turn) => ({ prompt: turn.prompt, assistant: turn.assistant })))}`
+  ].join("\n");
+}
 async function runPool(items, parallel, worker) {
   let index = 0;
   const workers = Array.from({ length: Math.min(parallel, items.length) }, async () => {
@@ -63725,6 +64149,27 @@ function estimateCredits(cases, targetModels, judgeModel, pricing) {
     assumptions: { targetInputTokens, targetOutputTokens, judgeInputTokens, judgeOutputTokens }
   };
 }
+function estimatePromptBudgetCredits(cases, targetModel, judgeModel, pricing) {
+  const targetPricing = pricing.get(targetModel);
+  const judgePricing = pricing.get(judgeModel);
+  if (!targetPricing || !judgePricing) {
+    throw new Error("Prompt-budget benchmark pricing preflight failed after model pricing lookup.");
+  }
+  const targetTurnCount = cases.reduce((sum, benchmarkCase) => sum + benchmarkCase.turns.length, 0);
+  const judgeTurnCount = targetTurnCount + cases.filter((benchmarkCase) => benchmarkCase.turns.length > 1).length;
+  const targetInputTokens = targetTurnCount * PROMPT_BUDGET_TARGET_INPUT_TOKENS_PER_TURN;
+  const targetOutputTokens = targetTurnCount * PROMPT_BUDGET_TARGET_OUTPUT_TOKENS_PER_TURN;
+  const judgeInputTokens = judgeTurnCount * PROMPT_BUDGET_JUDGE_INPUT_TOKENS_PER_RESPONSE;
+  const judgeOutputTokens = judgeTurnCount * PROMPT_BUDGET_JUDGE_OUTPUT_TOKENS_PER_RESPONSE;
+  const targetCredits = creditsFor(targetPricing, targetInputTokens, targetOutputTokens);
+  const judgeCredits = creditsFor(judgePricing, judgeInputTokens, judgeOutputTokens);
+  return {
+    targetCredits,
+    judgeCredits,
+    totalCredits: targetCredits + judgeCredits,
+    assumptions: { targetInputTokens, targetOutputTokens, judgeInputTokens, judgeOutputTokens }
+  };
+}
 function creditsFor(pricing, inputTokens, outputTokens) {
   return Math.ceil(inputTokens / pricing.inputTokensPerCredit) + Math.ceil(outputTokens / pricing.outputTokensPerCredit);
 }
@@ -63762,6 +64207,21 @@ function makeBaseResult(params) {
     }
   };
 }
+function makePromptBudgetBaseResult(params) {
+  return {
+    command: "benchmark prompt-budget",
+    status: params.dryRun ? "planned" : "completed",
+    phase: params.phase,
+    runId: params.runId,
+    corpusHash: hashPromptBudgetCorpus(PROMPT_BUDGET_CASES),
+    targetModel: params.targetModel,
+    judgeModel: params.judgeModel,
+    spendsCredits: !params.dryRun,
+    estimatedCredits: params.estimate,
+    cases: [],
+    summary: promptBudgetSummary([])
+  };
+}
 function recomputeResult(result, totalJobs, interrupted) {
   const completed = result.cases.length;
   const passed = result.cases.filter((caseResult) => caseResult.passed).length;
@@ -63804,6 +64264,56 @@ function buildComparison(summaries) {
 function round2(value) {
   return Math.round(value * 100) / 100;
 }
+function recomputePromptBudgetResult(result) {
+  result.summary = promptBudgetSummary(result.cases);
+  result.status = result.summary.completedTurns < result.summary.totalTurns || result.cases.some((benchmarkCase) => Boolean(benchmarkCase.error)) ? "partial" : "completed";
+}
+function promptBudgetSummary(cases) {
+  const completedTurns = cases.reduce((sum, benchmarkCase) => sum + benchmarkCase.turns.length, 0);
+  const durations = cases.flatMap((benchmarkCase) => benchmarkCase.turns.map((turn) => turn.durationMs)).filter((value) => value > 0);
+  const judgeScores = cases.flatMap((benchmarkCase) => benchmarkCase.turns.map((turn) => turn.judge?.score)).filter((score) => typeof score === "number" && Number.isFinite(score));
+  const continuityScores = cases.map((benchmarkCase) => benchmarkCase.continuityJudge?.score).filter((score) => typeof score === "number" && Number.isFinite(score));
+  return {
+    totalCases: PROMPT_BUDGET_CASES.length,
+    completedCases: cases.length,
+    totalTurns: PROMPT_BUDGET_CASES.reduce((sum, benchmarkCase) => sum + benchmarkCase.turns.length, 0),
+    completedTurns,
+    passedCases: cases.filter((benchmarkCase) => benchmarkCase.passed).length,
+    failedCases: cases.filter((benchmarkCase) => !benchmarkCase.passed).length,
+    averageTurnDurationMs: durations.length > 0 ? Math.round(durations.reduce((sum, value) => sum + value, 0) / durations.length) : null,
+    averageJudgeScore: judgeScores.length > 0 ? round2(judgeScores.reduce((sum, score) => sum + score, 0) / judgeScores.length) : null,
+    averageContinuityScore: continuityScores.length > 0 ? round2(continuityScores.reduce((sum, score) => sum + score, 0) / continuityScores.length) : null
+  };
+}
+function validatePromptBudgetResumeArtifact(artifact, expected) {
+  if (artifact.command !== "benchmark prompt-budget") {
+    throw new Error("--resume-from must point to a prompt-budget benchmark artifact");
+  }
+  if (artifact.corpusHash !== hashPromptBudgetCorpus(PROMPT_BUDGET_CASES)) {
+    throw new Error("--resume-from artifact uses a different prompt-budget corpus");
+  }
+  if (artifact.phase !== expected.phase) {
+    throw new Error(`--resume-from artifact phase is ${artifact.phase}, expected ${expected.phase}`);
+  }
+  if (artifact.targetModel !== expected.targetModel || artifact.judgeModel !== expected.judgeModel) {
+    throw new Error("--resume-from artifact target or judge model does not match this run");
+  }
+}
+function isCompletePromptBudgetCase(caseResult) {
+  if (caseResult.error) return false;
+  const definition = PROMPT_BUDGET_CASES.find((benchmarkCase) => benchmarkCase.id === caseResult.id);
+  if (!definition) return false;
+  if (caseResult.promptHashes.join("|") !== definition.turns.map(stableHash).join("|")) return false;
+  if (caseResult.turns.length !== definition.turns.length) return false;
+  if (caseResult.turns.some((turn) => !turn.judge)) return false;
+  return definition.turns.length === 1 || Boolean(caseResult.continuityJudge);
+}
+function hashPromptBudgetCorpus(cases) {
+  return stableHash(cases.map((benchmarkCase) => ({ id: benchmarkCase.id, turns: benchmarkCase.turns })));
+}
+function stableHash(value) {
+  return createHash13("sha256").update(JSON.stringify(value)).digest("hex");
+}
 function defaultImageFixturePath() {
   const fixtureDir = join5(dirname4(fileURLToPath(import.meta.url)), "..", "fixtures");
   const fixturePath = join5(fixtureDir, "brandenburger-tor.png");
@@ -63837,6 +64347,143 @@ function writeBenchmarkResult(result, flags, output) {
     }
   }
 }
+function writePromptBudgetResult(result, flags, output) {
+  const json = `${JSON.stringify(result, null, 2)}
+`;
+  if (output) writeFileSync5(output, json, "utf-8");
+  if (flags.json === true || output) {
+    process.stdout.write(json);
+    return;
+  }
+  console.log(`Prompt-budget benchmark ${result.status}: ${result.phase}`);
+  console.log(`Run ID: ${result.runId}`);
+  console.log(`Corpus: ${result.corpusHash}`);
+  console.log(`Target model: ${result.targetModel}`);
+  console.log(`Judge: ${result.judgeModel}`);
+  console.log(`Estimated credits: ${result.estimatedCredits.totalCredits}`);
+  console.log(`Spend credits: ${result.spendsCredits ? "yes" : "no"}`);
+  if (result.status !== "planned") {
+    console.log(`Passed cases: ${result.summary.passedCases}/${result.summary.completedCases}`);
+    console.log(`Average turn duration: ${result.summary.averageTurnDurationMs ?? "n/a"}ms`);
+    console.log(`Average judge score: ${result.summary.averageJudgeScore ?? "n/a"}`);
+    for (const benchmarkCase of result.cases) {
+      const mark = benchmarkCase.passed ? "PASS" : "FAIL";
+      const error = benchmarkCase.error ? ` error=${benchmarkCase.error}` : "";
+      console.log(`${mark} ${benchmarkCase.id} (${benchmarkCase.durationMs}ms)${error}`);
+    }
+  }
+}
+function writePromptBudgetComparison(result, flags, output) {
+  const json = `${JSON.stringify(result, null, 2)}
+`;
+  if (output) writeFileSync5(output, json, "utf-8");
+  if (flags.json === true || output) {
+    process.stdout.write(json);
+    return;
+  }
+  console.log(`Prompt-budget comparison ${result.status}: ${result.recommendation}`);
+  console.log(`Corpus: ${result.corpusHash}`);
+  console.log(`Duration delta: ${formatMetricDelta(result.deltas.averageTurnDurationMs, "ms")}`);
+  console.log(`Quality delta: ${formatMetricDelta(result.deltas.averageJudgeScore, "")}`);
+  if (result.regressions.length > 0) {
+    console.log("Regressions:");
+    for (const regression of result.regressions) console.log(`- ${regression}`);
+  }
+}
+function comparePromptBudgetArtifacts(flags) {
+  const baselinePath = stringFlag(flags.baseline);
+  const postchangePath = stringFlag(flags.postchange);
+  if (!baselinePath || !postchangePath) {
+    throw new Error("prompt-budget compare requires --baseline <path> and --postchange <path>");
+  }
+  const baseline = readPromptBudgetResult(baselinePath);
+  const postchange = readPromptBudgetResult(postchangePath);
+  if (baseline.command !== "benchmark prompt-budget" || postchange.command !== "benchmark prompt-budget") {
+    throw new Error("prompt-budget compare expects prompt-budget benchmark artifacts");
+  }
+  if (baseline.corpusHash !== postchange.corpusHash) {
+    throw new Error("prompt-budget artifacts use different corpus hashes and cannot be compared");
+  }
+  const regressions = findPromptBudgetRegressions(baseline, postchange);
+  const durationDelta = metricDelta(baseline.summary.averageTurnDurationMs, postchange.summary.averageTurnDurationMs);
+  const qualityDelta = metricDelta(baseline.summary.averageJudgeScore, postchange.summary.averageJudgeScore);
+  const continuityDelta = metricDelta(baseline.summary.averageContinuityScore, postchange.summary.averageContinuityScore);
+  const latencyImproved = durationDelta.delta !== null && durationDelta.delta < 0;
+  const qualityRegressed = regressions.length > 0;
+  return {
+    command: "benchmark prompt-budget compare",
+    status: qualityRegressed ? "needs_fix" : "passed",
+    corpusHash: baseline.corpusHash,
+    baseline: baselinePath,
+    postchange: postchangePath,
+    deltas: {
+      averageTurnDurationMs: durationDelta,
+      averageJudgeScore: qualityDelta,
+      averageContinuityScore: continuityDelta
+    },
+    regressions,
+    recommendation: !qualityRegressed && latencyImproved ? "keep" : "adjust_or_revert"
+  };
+}
+function readPromptBudgetResult(path) {
+  const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+  if (!parsed || typeof parsed !== "object") throw new Error(`Invalid prompt-budget artifact: ${path}`);
+  return parsed;
+}
+function findPromptBudgetRegressions(baseline, postchange) {
+  const regressions = [];
+  const postCases = new Map(postchange.cases.map((benchmarkCase) => [benchmarkCase.id, benchmarkCase]));
+  for (const baselineCase of baseline.cases) {
+    const postCase = postCases.get(baselineCase.id);
+    if (!postCase) {
+      regressions.push(`${baselineCase.id}: missing post-change case`);
+      continue;
+    }
+    if (baselineCase.promptHashes.join("|") !== postCase.promptHashes.join("|")) {
+      regressions.push(`${baselineCase.id}: prompt hashes differ`);
+    }
+    for (const baselineTurn of baselineCase.turns) {
+      const postTurn = postCase.turns.find((turn) => turn.turn === baselineTurn.turn);
+      if (!postTurn) {
+        regressions.push(`${baselineCase.id} turn ${baselineTurn.turn}: missing post-change turn`);
+        continue;
+      }
+      const baselineScore = baselineTurn.judge?.score;
+      const postScore = postTurn.judge?.score;
+      if (typeof baselineScore === "number" && typeof postScore === "number") {
+        if (baselineScore >= 4 && postScore < 4) {
+          regressions.push(`${baselineCase.id} turn ${baselineTurn.turn}: score dropped below pass threshold (${baselineScore} -> ${postScore})`);
+        } else if (postScore < baselineScore - 1) {
+          regressions.push(`${baselineCase.id} turn ${baselineTurn.turn}: score dropped materially (${baselineScore} -> ${postScore})`);
+        }
+      }
+    }
+    const baselineContinuity = baselineCase.continuityJudge?.score;
+    const postContinuity = postCase.continuityJudge?.score;
+    if (typeof baselineContinuity === "number" && typeof postContinuity === "number") {
+      if (baselineContinuity >= 4 && postContinuity < 4) {
+        regressions.push(`${baselineCase.id}: continuity score dropped below pass threshold (${baselineContinuity} -> ${postContinuity})`);
+      } else if (postContinuity < baselineContinuity - 1) {
+        regressions.push(`${baselineCase.id}: continuity score dropped materially (${baselineContinuity} -> ${postContinuity})`);
+      }
+    }
+  }
+  return regressions;
+}
+function metricDelta(baseline, postchange) {
+  if (baseline === null || postchange === null) {
+    return { baseline, postchange, delta: null, percent: null };
+  }
+  const delta = round2(postchange - baseline);
+  const percent = baseline === 0 ? null : round2(delta / baseline * 100);
+  return { baseline, postchange, delta, percent };
+}
+function formatMetricDelta(delta, suffix) {
+  if (delta.delta === null) return "n/a";
+  const unit = suffix ? suffix : "";
+  const percent = delta.percent === null ? "" : ` (${delta.percent}%)`;
+  return `${delta.baseline}${unit} -> ${delta.postchange}${unit} (${delta.delta}${unit})${percent}`;
+}
 
 // src/tui.ts
 import { createInterface as createInterface4 } from "readline/promises";
@@ -66263,7 +66910,7 @@ Starting a new chat...
       acceptTaskProposals: flags["accept-task-proposals"] === true,
       piiDetection: flags["no-pii-detection"] !== true,
       taskUpdateJobs: false,
-      responseTimeoutMs: parseResponseTimeoutMs(flags),
+      responseTimeoutMs: parseResponseTimeoutMs2(flags),
       ...teamContextFromFlags(flags)
     },
     redactor
@@ -67233,7 +67880,7 @@ async function handleGoalChat(client, flags, redactor) {
       autoApproveMemories: flags["auto-approve-memories"] === true,
       acceptTaskProposals: flags["accept-task-proposals"] === true,
       piiDetection: flags["no-pii-detection"] !== true,
-      responseTimeoutMs: parseResponseTimeoutMs(flags),
+      responseTimeoutMs: parseResponseTimeoutMs2(flags),
       ...teamContextFromFlags(flags)
     },
     redactor
@@ -67816,7 +68463,7 @@ function parsePositiveIntegerFlag(value, flagName) {
   }
   return parsed;
 }
-function parseResponseTimeoutMs(flags) {
+function parseResponseTimeoutMs2(flags) {
   const seconds = parsePositiveIntegerFlag(flags["response-timeout-seconds"], "--response-timeout-seconds");
   return seconds === void 0 ? void 0 : seconds * 1e3;
 }
@@ -68110,7 +68757,7 @@ async function handleChats(client, subcommand, rest, flags, redactor) {
       send,
       dryRun,
       confirmDestructive: flags.yes === true,
-      responseTimeoutMs: parseResponseTimeoutMs(flags),
+      responseTimeoutMs: parseResponseTimeoutMs2(flags),
       ...teamContext
     });
     if (flags.json === true) {
@@ -68134,7 +68781,7 @@ async function handleChats(client, subcommand, rest, flags, redactor) {
       chatId,
       dryRun,
       confirmDestructive: flags.yes === true,
-      responseTimeoutMs: parseResponseTimeoutMs(flags),
+      responseTimeoutMs: parseResponseTimeoutMs2(flags),
       ...teamContext
     });
     if (flags.json === true) {
@@ -68161,7 +68808,7 @@ async function handleChats(client, subcommand, rest, flags, redactor) {
         autoApproveMemories: flags["auto-approve-memories"] === true,
         acceptTaskProposals: flags["accept-task-proposals"] === true,
         piiDetection: flags["no-pii-detection"] !== true,
-        responseTimeoutMs: parseResponseTimeoutMs(flags),
+        responseTimeoutMs: parseResponseTimeoutMs2(flags),
         ...teamContext,
         anonymousLearningMode: client.hasSession() ? void 0 : parseAnonymousLearningModeFlags(flags)
       },
@@ -68239,7 +68886,7 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         autoApproveMemories: flags["auto-approve-memories"] === true,
         acceptTaskProposals: flags["accept-task-proposals"] === true,
         piiDetection: flags["no-pii-detection"] !== true,
-        responseTimeoutMs: parseResponseTimeoutMs(flags),
+        responseTimeoutMs: parseResponseTimeoutMs2(flags),
         ...teamContext
       },
       redactor
@@ -68270,7 +68917,7 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         autoApproveMemories: flags["auto-approve-memories"] === true,
         acceptTaskProposals: flags["accept-task-proposals"] === true,
         piiDetection: flags["no-pii-detection"] !== true,
-        responseTimeoutMs: parseResponseTimeoutMs(flags),
+        responseTimeoutMs: parseResponseTimeoutMs2(flags),
         ...teamContext
       },
       redactor
@@ -68293,7 +68940,7 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         autoApproveSubChats: flags["auto-approve"] === true,
         autoApproveMemories: flags["auto-approve-memories"] === true,
         piiDetection: flags["no-pii-detection"] !== true,
-        responseTimeoutMs: parseResponseTimeoutMs(flags)
+        responseTimeoutMs: parseResponseTimeoutMs2(flags)
       },
       redactor
     );
@@ -68856,7 +69503,7 @@ async function sendApiKeyChatNew(client, apiKey, message, flags) {
   try {
     response = await sdk.chats.send(message, {
       saveToAccount: false,
-      recoveryTimeoutMs: parseResponseTimeoutMs(flags)
+      recoveryTimeoutMs: parseResponseTimeoutMs2(flags)
     });
   } catch (err) {
     if (!isSdkChatScopeDenied(err)) throw err;
@@ -68998,7 +69645,7 @@ function normalizeApiKeyLoadedChat(payload) {
   const messages = rawMessages.map((message) => {
     const messageId = String(message.client_message_id ?? message.message_id ?? message.id ?? "");
     const directEmbedIds = Array.isArray(message.embedIds) ? message.embedIds : Array.isArray(message.embed_ids) ? message.embed_ids : [];
-    const hashedMessageId = messageId ? createHash13("sha256").update(messageId).digest("hex") : null;
+    const hashedMessageId = messageId ? createHash14("sha256").update(messageId).digest("hex") : null;
     const matchedEmbedIds = hashedMessageId ? rawEmbeds.filter((embed) => embed.hashed_message_id === hashedMessageId && !embed.parent_embed_id).map((embed) => String(embed.embed_id ?? embed.id ?? "")).filter(Boolean) : [];
     return {
       id: messageId,
@@ -69658,9 +70305,9 @@ Run: openmates apps ${command.app_id} ${command.skill_id} --help`
   return value;
 }
 function buildTravelConnectionsRequest(positionals, flags) {
-  const origin = stringFlag(flags, "origin") ?? positionals[0];
-  const destination = stringFlag(flags, "destination") ?? positionals[1];
-  const date = stringFlag(flags, "date") ?? positionals[2];
+  const origin = stringFlag2(flags, "origin") ?? positionals[0];
+  const destination = stringFlag2(flags, "destination") ?? positionals[1];
+  const date = stringFlag2(flags, "date") ?? positionals[2];
   if (!origin || !destination || !date) {
     throw new Error(
       "Missing travel route. Use --origin <place> --destination <place> --date <YYYY-MM-DD>.\n\nExample: openmates apps travel search_connections --origin Berlin --destination Munich --date 2026-08-01 --json"
@@ -69669,12 +70316,12 @@ function buildTravelConnectionsRequest(positionals, flags) {
   const request = {
     legs: [{ origin, destination, date }]
   };
-  const transport = stringFlag(flags, "transport") ?? stringFlag(flags, "transport-method");
+  const transport = stringFlag2(flags, "transport") ?? stringFlag2(flags, "transport-method");
   if (transport) request.transport_methods = [transport];
   return request;
 }
 function buildCodeImageToHtmlRequest(positionals, flags) {
-  const file = stringFlag(flags, "file") ?? positionals[0];
+  const file = stringFlag2(flags, "file") ?? positionals[0];
   if (!file) {
     throw new Error(
       "Missing screenshot file. Use --file <path>.\n\nExample: openmates apps code image_to_html --file ./mockup.png --json"
@@ -69722,7 +70369,7 @@ function primaryPositionalProperty(properties, required) {
 function readFlag(flags, name) {
   return flags[name] ?? flags[kebabCase(name)];
 }
-function stringFlag(flags, name) {
+function stringFlag2(flags, name) {
   const raw = readFlag(flags, name);
   return typeof raw === "string" && raw.trim() ? raw.trim() : void 0;
 }
@@ -70078,7 +70725,7 @@ async function handleDesignIconExport(client, positionals, flags, apiKey) {
     printDesignIconExportHelp();
     return;
   }
-  const outputPath = stringFlag(flags, "output");
+  const outputPath = stringFlag2(flags, "output");
   if (!outputPath) {
     console.error(
       "Missing --output flag.\n\nUsage:\n  openmates apps design export-icon lucide:home --output home.svg [--color '#111827']\n  openmates apps design export-icon --prefix lucide --name home --format png --size 64 --output home.png\n"
@@ -70095,7 +70742,7 @@ async function handleDesignIconExport(client, positionals, flags, apiKey) {
       ...iconRef,
       outputPath,
       format,
-      color: stringFlag(flags, "color"),
+      color: stringFlag2(flags, "color"),
       palette: flags.palette === true,
       allowPaletteRecolor: flags["allow-palette-recolor"] === true,
       size,
@@ -70122,9 +70769,9 @@ async function handleDesignIconExport(client, positionals, flags, apiKey) {
   }
 }
 function parseDesignIconReference(positionals, flags) {
-  const svgPath = stringFlag(flags, "svg-path");
+  const svgPath = stringFlag2(flags, "svg-path");
   if (svgPath) return { svgPath };
-  const icon = stringFlag(flags, "icon") ?? positionals[0];
+  const icon = stringFlag2(flags, "icon") ?? positionals[0];
   if (icon) {
     const [prefix, name, extra] = icon.split(":");
     if (!prefix || !name || extra !== void 0) {
@@ -70133,8 +70780,8 @@ function parseDesignIconReference(positionals, flags) {
     return { prefix, name };
   }
   return {
-    prefix: stringFlag(flags, "prefix"),
-    name: stringFlag(flags, "name")
+    prefix: stringFlag2(flags, "prefix"),
+    name: stringFlag2(flags, "name")
   };
 }
 function parseDesignIconExportFormat(value) {
@@ -71172,12 +71819,12 @@ async function handleFinance(client, subcommand, _rest, flags) {
   if (flags["csv-only"] !== true) {
     try {
       connectedAccount = await client.decryptConnectedAccountForSkill({
-        accountId: stringFlag(flags, "connected-account"),
+        accountId: stringFlag2(flags, "connected-account"),
         appId: "finance",
         providerId: "revolut_business"
       });
     } catch (error) {
-      if (csvStatements.length === 0 || stringFlag(flags, "connected-account")) throw error;
+      if (csvStatements.length === 0 || stringFlag2(flags, "connected-account")) throw error;
     }
   }
   if (!connectedAccount && csvStatements.length === 0) {
@@ -71215,11 +71862,11 @@ function readFinanceCsvStatements(flags) {
 }
 function buildFinanceCheckAccountsInput(flags, csvStatements, connectedAccount) {
   const input = {
-    period: stringFlag(flags, "period") ?? "monthly",
-    projection_horizon: stringFlag(flags, "projection-horizon") ?? "monthly"
+    period: stringFlag2(flags, "period") ?? "monthly",
+    projection_horizon: stringFlag2(flags, "projection-horizon") ?? "monthly"
   };
-  const startDate = stringFlag(flags, "from") ?? stringFlag(flags, "start-date");
-  const endDate = stringFlag(flags, "to") ?? stringFlag(flags, "end-date");
+  const startDate = stringFlag2(flags, "from") ?? stringFlag2(flags, "start-date");
+  const endDate = stringFlag2(flags, "to") ?? stringFlag2(flags, "end-date");
   if (startDate) input.start_date = startDate;
   if (endDate) input.end_date = endDate;
   addFinanceListFilter(input, "account_filters", flags.account);
@@ -71227,7 +71874,7 @@ function buildFinanceCheckAccountsInput(flags, csvStatements, connectedAccount)
   addFinanceListFilter(input, "category_filters", flags.category ?? flags.categories);
   addFinanceListFilter(input, "state_filters", flags.state ?? flags.states);
   addFinanceListFilter(input, "placeholder_filters", flags.placeholder ?? flags.placeholders);
-  const direction = stringFlag(flags, "direction");
+  const direction = stringFlag2(flags, "direction");
   if (direction) input.direction_filter = direction;
   if (csvStatements.length > 0) input.csv_statements = csvStatements;
   if (connectedAccount) {

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   getExtForLang,
   serializeToYaml
-} from "./chunk-VJLMFEX6.js";
+} from "./chunk-U4XICRVH.js";
 import "./chunk-MLWBMJEN.js";
 export {
   getExtForLang,

package/dist/index.d.ts

@@ -80,6 +80,16 @@ interface StreamEvent {
     /** Human-readable model name. */
     modelName: string | null;
 }
+type AiResponseTokenUsage = {
+    promptTokens?: number;
+    completionTokens?: number;
+    userInputTokens?: number;
+    systemPromptTokens?: number;
+    totalCredits?: number;
+};
+type AiResponsePromptBudget = {
+    systemPromptTokens?: number;
+};
 interface ChatCompressionCheckpointEvent {
     chatId: string;
     taskId: string | null;
@@ -242,6 +252,8 @@ declare class OpenMatesWsClient {
         subChatEvents: SubChatEvent[];
         recoveryJobId: string | null;
         compressionCheckpoints: ChatCompressionCheckpointEvent[];
+        tokenUsage: AiResponseTokenUsage | null;
+        promptBudget: AiResponsePromptBudget | null;
     }>;
 }
 
@@ -1634,6 +1646,10 @@ declare class OpenMatesClient {
             approvedKeys: string[];
             entryCount: number;
         }>;
+        /** Final-frame token usage surfaced by the backend when provider usage metadata is available. */
+        tokenUsage: AiResponseTokenUsage | null;
+        /** Prompt-budget metrics surfaced by the backend when available. */
+        promptBudget: AiResponsePromptBudget | null;
     }>;
     createTurnTokenRefs(params: {
         chatId: string;
@@ -1985,6 +2001,10 @@ declare class OpenMatesClient {
             approvedKeys: string[];
             entryCount: number;
         }>;
+        /** Final-frame token usage surfaced by the backend when provider usage metadata is available. */
+        tokenUsage: AiResponseTokenUsage | null;
+        /** Prompt-budget metrics surfaced by the backend when available. */
+        promptBudget: AiResponsePromptBudget | null;
     }>;
     private persistEncryptedSystemMessage;
     private persistPendingTaskUpdateJobs;

package/dist/index.js

@@ -36,7 +36,7 @@ import {
   renderPlanList,
   renderSupportInfo,
   serializeToYaml
-} from "./chunk-VJLMFEX6.js";
+} from "./chunk-U4XICRVH.js";
 import "./chunk-MLWBMJEN.js";
 export {
   APP_SKILL_METADATA,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmates",
-  "version": "0.15.0-alpha.73",
+  "version": "0.15.0-alpha.75",
   "description": "OpenMates CLI and SDK",
   "type": "module",
   "main": "dist/index.js",