mixdog 0.9.175 → 1.0.0

package/src/runtime/office/capabilities-catalog.mjs

@@ -139,6 +139,7 @@ export const CATALOG = {
     properties: {
       paragraph: ['style'],
       font: ['name', 'nameEastAsia', 'size', 'bold', 'italic', 'underline', 'color', 'hidden'],
+      documentFont: ['name', 'nameEastAsia', 'size', 'color'],
       page: [
         'pageSize',
         'orientation',
@@ -169,6 +170,7 @@ export const CATALOG = {
         'headerRows',
         'keepWithNext',
       ],
+      tableStyle: ['style', 'alignment', 'columnAlignments', 'columnWidths', 'borders', 'shading'],
       tableCell: [
         'fillColor',
         'horizontalAlignment',

package/src/runtime/office/capabilities-signatures.mjs

@@ -1,8 +1,13 @@
 // Operation input signatures: which fields each Office operation requires,
 // accepts, or takes as alternatives, per format.
+import { XLSX_VALIDATION_OPERATORS, XLSX_VALIDATION_TYPES } from './portable/xlsx-contract.mjs';
 
-export function signature(required = [], optional = [], { oneOf = [], propertySets = [], notes = '' } = {}) {
-  return { required, optional, oneOf, propertySets, notes };
+export function signature(
+  required = [],
+  optional = [],
+  { oneOf = [], propertySets = [], propertyBackends = {}, notes = '' } = {}
+) {
+  return { required, optional, oneOf, propertySets, propertyBackends, notes };
 }
 
 export const COMMON_SIGNATURES = {
@@ -66,9 +71,10 @@ export const FORMAT_SIGNATURES = {
         'properties.alignment places the table on the page (left, center, right); properties.columnAlignments sets the text of each column (one of left, center, right, justify per column); without it a column of figures (184,200, 2.1%, 2.6억 원) sets right and the rest left. Without style, borders, or shading the table takes a bold header row with a rule under it and hairlines between rows; headerBold:false keeps the header plain. properties.headerRows (default 1) is how many rows the header takes: a two-level header, its group label merged across the columns it spans (merge_table_cells), is headerRows:2, and every header row is set bold on its bottom edge and repeats on a continuation page.',
     }),
     set_table_style: signature(['table', 'properties'], [], {
-      propertySets: ['table'],
+      propertySets: ['tableStyle'],
+      propertyBackends: { columnWidths: ['microsoft-office-com'] },
       notes:
-        'Replaces the table-level properties; columnAlignments re-aligns the text of every existing cell in each column.',
+        'Replaces table-level properties; columnAlignments re-aligns existing cells. columnWidths is Microsoft Office only. For existing cell fonts or fills use set_table_cell_style, not set_table_style.',
     }),
     merge_table_cells: signature(['table', 'row', 'col'], ['rowSpan', 'colSpan'], {
       notes:
@@ -91,7 +97,7 @@ export const FORMAT_SIGNATURES = {
     move_paragraph: signature(['paragraph', 'index']),
     set_paragraph_style: signature(['paragraph', 'style']),
     set_document_font: signature(['properties'], [], {
-      propertySets: ['font'],
+      propertySets: ['documentFont'],
       notes:
         "The document's own face, size, and ink — what every paragraph without its own reads, and what a paragraph added later in Word or by append_text starts from. properties: name, nameEastAsia, size, color.",
     }),
@@ -325,7 +331,7 @@ export const FORMAT_SIGNATURES = {
       ['sheet', 'type', 'operator', 'formula2', 'inputMessage', 'errorMessage'],
       {
         notes:
-          'type is list, whole, decimal, date, time, textLength, or custom; without it a formula naming choices ("a,b,c" or $A$1:$A$9) becomes a list and any other formula a custom rule. A ranged kind takes operator (between by default with formula2) and its bounds. Under protect_sheet the entry cells need set_style properties { locked: false } or nobody can type in them.',
+          `type: ${XLSX_VALIDATION_TYPES.join(', ')}. Without type, choices ("a,b,c" or $A$1:$A$9) mean list; other formulas mean custom. Numeric/date/time/textLength rules take operator: ${XLSX_VALIDATION_OPERATORS.join(', ')} (default between). between/notBetween require formula2; other operators use formula1. Example: type:"whole", operator:"greaterThanOrEqual", formula1:"0". Under protect_sheet unlock entry cells with set_style properties:{ locked:false }.`,
       }
     ),
     freeze_panes: signature([], ['sheet', 'row', 'column'], {

package/src/runtime/office/capabilities.mjs

@@ -3,6 +3,7 @@ import { plainObject } from './shared/values.mjs';
 import { FIELD_ALIASES, OPERATION_ALIASES, PROPERTY_ALIASES } from './capabilities-aliases.mjs';
 import { BACKENDS, CATALOG, COMMON, VIRTUAL_OPERATIONS } from './capabilities-catalog.mjs';
 import { COMMON_SIGNATURES, FORMAT_SIGNATURES, signature } from './capabilities-signatures.mjs';
+import { normalizeXlsxValidation } from './portable/xlsx-contract.mjs';
 
 export { OFFICE_ACTIONS } from './capabilities-catalog.mjs';
 
@@ -141,6 +142,19 @@ function describeHint(format, backend, operation) {
   })}.`;
 }
 
+function operationProperties(catalog, signatureValue, backend) {
+  return Object.fromEntries(
+    signatureValue.propertySets
+      .filter((name) => catalog.properties[name])
+      .map((name) => [
+        name,
+        catalog.properties[name].filter(
+          (field) => !backend || !signatureValue.propertyBackends[field] || signatureValue.propertyBackends[field].includes(backend)
+        ),
+      ])
+  );
+}
+
 function operationDescription(format, backend, catalog, requested) {
   const knownOperations = catalogOperations(format);
   const operation = resolveOperationAlias(format, requested);
@@ -152,11 +166,7 @@ function operationDescription(format, backend, catalog, requested) {
   }
   const available = operationsForBackend(format, backend);
   const signatureValue = operationSignature(format, operation);
-  const properties = Object.fromEntries(
-    signatureValue.propertySets
-      .filter((name) => catalog.properties[name])
-      .map((name) => [name, catalog.properties[name]])
-  );
+  const properties = operationProperties(catalog, signatureValue, backend);
   return {
     name: operation,
     ...(VIRTUAL_OPERATIONS.has(operation) || VIRTUAL_OPERATIONS.has(`${format}:${operation}`) ? { virtual: true } : {}),
@@ -311,10 +321,10 @@ function hoistGeometryProperties(signatureValue, operation, allowed) {
   delete operation.properties;
 }
 
-function propertyKeySet(catalog, signatureValue) {
+function propertyKeySet(catalog, signatureValue, backend) {
   return new Set(
-    signatureValue.propertySets
-      .flatMap((set) => catalog.properties?.[set] || [])
+    Object.values(operationProperties(catalog, signatureValue, backend))
+      .flat()
       .map((entry) => String(entry).split('.')[0])
   );
 }
@@ -474,14 +484,24 @@ function operationContractFaults(batch, operation, index) {
   if (cellFault) return [cellFault];
   hoistComposeSheetTable(format, name, operation);
   hoistGeometryProperties(signatureValue, operation, allowed);
-  const propertyKeys = propertyKeySet(catalog, signatureValue);
+  const propertyKeys = propertyKeySet(catalog, signatureValue, backend);
   const missing = signatureValue.required.filter((field) => !suppliedField(operation, field, stableTargets));
-  return [
+  const faults = [
     unknownFieldsFault(batch, name, operation, index, { allowed, propertyKeys, missing }),
     unknownPropertiesFault(batch, name, operation, index, propertyKeys),
     ...docxTableAlignmentFaults(format, name, operation, index),
     requiredInputFault(batch, name, operation, index, signatureValue, stableTargets),
   ].filter(Boolean);
+  if (!faults.length && format === 'xlsx' && name === 'add_validation') {
+    try {
+      Object.assign(operation, normalizeXlsxValidation(operation));
+    } catch (error) {
+      faults.push(
+        `XLSX operation "${name}" at operation ${index + 1}: ${error.message}. ${describeHint(format, backend, name)}`
+      );
+    }
+  }
+  return faults;
 }
 
 export function assertOfficeOperationContracts({ format = '', backend = '', operations = [] } = {}) {

package/src/runtime/office/core/office-actions-open.mjs

@@ -10,12 +10,7 @@ import {
   releaseOfficeSession,
   toolResult,
 } from './office-core.mjs';
-import { createSession, openSession, snapshot } from './office-sessions.mjs';
-
-function initialOfficeOperations(args) {
-  if (Array.isArray(args.operations) && args.operations.length) return args.operations;
-  return Array.isArray(args.design?.operations) ? args.design.operations : [];
-}
+import { createSession, initialOfficeOperations, openSession, snapshot } from './office-sessions.mjs';
 
 async function discardFailedOfficeSession(session, { action, initialEditSettled }) {
   if (session.reused) return;

package/src/runtime/office/core/office-sessions.mjs

@@ -3,6 +3,7 @@ import { constants as fsConstants } from 'node:fs';
 import { basename, dirname, extname, isAbsolute, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
+import { assertOfficeOperationContracts } from '../capabilities.mjs';
 import {
   callMicrosoftOffice,
   detectMicrosoftOffice,
@@ -496,6 +497,11 @@ async function createMicrosoftOfficeSession(creation, args, mode) {
   });
 }
 
+export function initialOfficeOperations(args) {
+  if (Array.isArray(args.operations) && args.operations.length) return args.operations;
+  return Array.isArray(args.design?.operations) ? args.design.operations : [];
+}
+
 export async function createSession(args, cwd, dataDir) {
   const requestedPath = String(args.path || args.output || '').trim();
   if (!requestedPath) throw new Error('create requires path or output');
@@ -506,6 +512,8 @@ export async function createSession(args, cwd, dataDir) {
   if (format !== inferredFormat)
     throw new Error(`Office create format ${args.format} does not match target .${fileKind}`);
   assertCreateContentFields(format, args);
+  const initialOperations = initialOfficeOperations(args);
+  assertOfficeOperationContracts({ format, operations: initialOperations });
   // Whether this call brings the file into being decides what a failed create
   // may clean up afterwards: a file it wrote itself, never one already there.
   const targetExisted = await exists(target);
@@ -528,6 +536,7 @@ export async function createSession(args, cwd, dataDir) {
     throw new Error('Office create requires visible, background, or portable mode');
   }
   const selected = await selectMode(requestedMode, format, target);
+  assertOfficeOperationContracts({ format, backend: selected.backend, operations: initialOperations });
   if (selected.backend === 'mixdog-ooxml') return createPortableOoxmlSession(creation);
   return createMicrosoftOfficeSession(creation, args, selected.mode);
 }

package/src/runtime/office/portable/portable-xlsx-operations.mjs

@@ -1,7 +1,7 @@
 // Worksheet-level operations the portable XLSX backend applies: sheet
 // management, images, header/footer, conditional formats, validation, sort,
 // autofit, pivot tables and charts.
-import { conditionalFormatKind, listValidationChoices, listValidationFormula } from './xlsx-contract.mjs';
+import { conditionalFormatKind, listValidationChoices, normalizeXlsxValidation } from './xlsx-contract.mjs';
 import { nextRelationshipId, partRelationshipPath, zipText } from './portable-opc.mjs';
 import {
   OFFICE_RELATIONSHIP_BASE,
@@ -45,29 +45,6 @@ function headerFooterFields(text) {
     .replace(/\{file\}/gi, '&F');
 }
 
-// Cell validation as both backends express it: the OOXML names here, the Excel
-// enumeration in the COM host.
-const XLSX_VALIDATION_TYPES = Object.freeze({
-  list: 'list',
-  whole: 'whole',
-  decimal: 'decimal',
-  date: 'date',
-  time: 'time',
-  textlength: 'textLength',
-  custom: 'custom',
-});
-
-const XLSX_VALIDATION_OPERATORS = Object.freeze({
-  between: 'between',
-  notbetween: 'notBetween',
-  equal: 'equal',
-  notequal: 'notEqual',
-  greaterthan: 'greaterThan',
-  lessthan: 'lessThan',
-  greaterthanorequal: 'greaterThanOrEqual',
-  lessthanorequal: 'lessThanOrEqual',
-});
-
 export const TABLE_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml';
 
 // A built-in table style bands the range from the workbook's own theme, which
@@ -330,18 +307,6 @@ async function expressionConditionalRule(zip, op, priority) {
 
 // The comparison a bounded validation applies; a second bound without one
 // means between.
-function validationOperator(op, type) {
-  const requested = String(op.operator || '').trim();
-  let operator = '';
-  if (requested && Object.hasOwn(XLSX_VALIDATION_OPERATORS, requested.toLowerCase())) {
-    operator = XLSX_VALIDATION_OPERATORS[requested.toLowerCase()];
-  } else if (op.formula2 != null && !['list', 'custom'].includes(type)) operator = 'between';
-  if (requested && !operator) {
-    throw new Error(`add_validation operator must be one of ${Object.keys(XLSX_VALIDATION_OPERATORS).join(', ')}`);
-  }
-  return operator;
-}
-
 function dataValidationXml(op, { type, operator, reference }) {
   const formula = (value) => `${xmlEncode(String(value).replace(/^=/, ''))}`;
   return (
@@ -359,19 +324,7 @@ function dataValidationXml(op, { type, operator, reference }) {
 /** One data validation over a range, appended to the validations already there. */
 export function addWorksheetValidation(zip, sheet, xml, op) {
   const reference = areaReference(parseAreaRange(op.range));
-  // A list is the common case and what Excel writes through the same
-  // operation, so it is the default; the other kinds guard a number, a
-  // date, or a length, and take a second bound. A formula that states a
-  // rule rather than naming choices is that rule, not a dropdown of one
-  // entry: "서울,부산" and $A$1:$A$9 are lists, B2>0 is a custom check.
-  const kind = String(op.type || (listValidationFormula(op.formula1) ? 'list' : 'custom'))
-    .trim()
-    .toLowerCase();
-  const type = Object.hasOwn(XLSX_VALIDATION_TYPES, kind) ? XLSX_VALIDATION_TYPES[kind] : '';
-  if (!type) {
-    throw new Error(`add_validation type must be one of ${Object.keys(XLSX_VALIDATION_TYPES).join(', ')}`);
-  }
-  const operator = validationOperator(op, type);
+  const { type, operator = '' } = normalizeXlsxValidation(op);
   const existing = worksheetSection(xml, 'dataValidations');
   const previous = existing ? containerBody(existing[0], 'dataValidations') : '';
   const count = (previous.match(/<dataValidation\b/g) || []).length + 1;

package/src/runtime/office/portable/xlsx-contract.mjs

@@ -246,6 +246,42 @@ export function listValidationChoices(formula1) {
   return `"${text}"`;
 }
 
+export const XLSX_VALIDATION_TYPES = Object.freeze(['list', 'whole', 'decimal', 'date', 'time', 'textLength', 'custom']);
+export const XLSX_VALIDATION_OPERATORS = Object.freeze([
+  'between',
+  'notBetween',
+  'equal',
+  'notEqual',
+  'greaterThan',
+  'lessThan',
+  'greaterThanOrEqual',
+  'lessThanOrEqual',
+]);
+
+// Resolve and validate once, before either Excel COM or the portable writer
+// can interpret an unknown name as a different rule.
+export function normalizeXlsxValidation(operation) {
+  if (!String(operation.formula1 ?? '').trim()) throw new Error('add_validation requires non-empty formula1');
+  const requestedType = String(operation.type ?? '').trim() || (listValidationFormula(operation.formula1) ? 'list' : 'custom');
+  const type = XLSX_VALIDATION_TYPES.find((value) => value.toLowerCase() === requestedType.toLowerCase());
+  if (!type) throw new Error(`add_validation type must be one of ${XLSX_VALIDATION_TYPES.join(', ')}`);
+  const requestedOperator = String(operation.operator ?? '').trim();
+  const bounded = !['list', 'custom'].includes(type);
+  const operator = requestedOperator
+    ? XLSX_VALIDATION_OPERATORS.find((value) => value.toLowerCase() === requestedOperator.toLowerCase())
+    : bounded ? 'between' : '';
+  if (requestedOperator && !operator) {
+    throw new Error(`add_validation operator must be one of ${XLSX_VALIDATION_OPERATORS.join(', ')}`);
+  }
+  if (!bounded && requestedOperator) {
+    throw new Error(`add_validation operator is unsupported for type "${type}"; omit operator`);
+  }
+  if (['between', 'notBetween'].includes(operator) && !String(operation.formula2 ?? '').trim()) {
+    throw new Error(`add_validation operator "${operator}" requires formula2; for one bound use a comparison operator`);
+  }
+  return { type, ...(operator ? { operator } : {}) };
+}
+
 // Three ways a sheet marks its numbers: a rule that paints the cells it picks,
 // a scale that colors every cell by where its value sits, and a bar drawn in
 // the cell. The first needs a formula and a format; the other two carry their
@@ -394,9 +430,7 @@ function validateXlsxOperation(operation) {
   // Both backends write the kind named here, so the default is settled once:
   // a formula that names choices is a dropdown, a formula that states a test
   // is a custom rule. Writing B2>0 as a list would offer it as one entry.
-  if (op === 'add_validation' && !String(operation.type ?? '').trim()) {
-    operation.type = listValidationFormula(operation.formula1) ? 'list' : 'custom';
-  }
+  if (op === 'add_validation') Object.assign(operation, normalizeXlsxValidation(operation));
   if (op === 'set_style' && operation.cell) parseXlsxCell(operation.cell);
   if (operation.range && RANGE_OPERATIONS.includes(op)) validateRangeOperation(operation, op);
   else if (op === 'set_range') throw new Error('XLSX set_range requires range');

package/src/runtime/office/tool-defs.mjs

@@ -26,7 +26,7 @@ export const TOOL_DEFS = [
           type: 'string',
           enum: OFFICE_ACTIONS,
           description:
-            'detect/describe discover; author: PPTX from HTML or pptxgenjs; transactions/recover, begin/diff/commit/rollback checkpoint; create/attach/open start; snapshot/get/query inspect; batch edits; issues/qa/render/validate review; save/finalize/close finish; secure encrypts/decrypts PDF.',
+            'detect/describe discover; author: HTML/pptxgenjs PPTX; transactions/recover/begin/diff/commit/rollback checkpoints; create/attach/open; snapshot/get/query; batch edits; issues/qa/validate review; render exports PDF and page images; save/finalize/close; secure: PDF passwords.',
         },
         path: { type: 'string', description: 'Document path; relative paths resolve from the caller project.' },
         script: { type: 'string', description: 'author: HTML slides or a pptxgenjs script (pptx skill).' },
@@ -75,7 +75,7 @@ export const TOOL_DEFS = [
           description:
             'auto defaults to background with Office, otherwise portable. Only explicit attach (alias live) co-edits an open file; visible opens a window; background edits a copy.',
         },
-        output: { type: 'string', description: 'Output copy or render destination; defaults beside source.' },
+        output: { type: 'string', description: 'Output copy; render: exported PDF path. Defaults beside source.' },
         target: { type: 'string', description: 'Stable path from snapshot/query, e.g. /body/p[2].' },
         query: { type: 'string', description: 'Case-insensitive value search; with pdf-layout, where the text sits.' },
         queryKind: {

package/src/runtime/shared/llm/cost.mjs

@@ -64,7 +64,7 @@ export function priceUsage(args) {
     pricingProvider: meta?.pricingProvider || identity.pricingProvider,
     pricingSource: meta?.pricingSource || null,
     ...(args.inputTokensKnown === false ? { inputTokensKnown: false } : {}),
-    ...(args.fast ? { fast: true } : {}),
+    ...(args.requestServiceTier ? { requestServiceTier: args.requestServiceTier } : {}),
     ...(args.serviceTier ? { serviceTier: args.serviceTier } : {}),
     ...(written1h ? { cacheWrite1hTokens: written1h } : {}),
   };
@@ -78,7 +78,19 @@ export function priceUsage(args) {
       },
     };
   const promptTokens = input + cached + written;
-  if (args.historicalAggregate && meta.pricingTiers?.some((tier) => promptTokens > tier.aboveInputTokens)) {
+  // The tier the request itself carried decides its rate: subscription quota
+  // is charged by the tier sent, and an Anthropic fast request either runs
+  // fast or is rejected (its retry is a new, standard request). Only the
+  // OpenAI API bills a ramp-downgraded Priority request at Standard rates,
+  // reporting it as service_tier "default".
+  const sentTier = args.requestServiceTier || '';
+  const premium =
+    (sentTier === 'priority' || sentTier === 'fast') && !(args.kind === 'api' && args.serviceTier === 'default');
+  // Anthropic fast mode is a flat 2x on fast-capable Opus; every other
+  // premium request needs the model's published Fast/Priority rates.
+  const anthropicFast = premium && sentTier === 'fast' && supportsAnthropicFastMode(identity.pricingModel);
+  const rateMeta = premium && !anthropicFast ? meta.fastPricing || {} : meta;
+  if (args.historicalAggregate && rateMeta.pricingTiers?.some((tier) => promptTokens > tier.aboveInputTokens)) {
     // A daily sum cannot establish which individual requests crossed a
     // context boundary. Do not price the whole day as one huge prompt.
     return { input, costUsd: null, rates: { ...provenance, unpricedReason: 'request-boundaries-unavailable' } };
@@ -93,10 +105,10 @@ export function priceUsage(args) {
     if (!peak) multiplier *= meta.offPeakMultiplier;
   }
   // Fast mode bills 2x standard rates on every fast-capable Opus.
-  if (supportsAnthropicFastMode(identity.pricingModel) && (args.fast || args.serviceTier === 'fast')) multiplier *= 2;
+  if (anthropicFast) multiplier *= 2;
   const keys = PRICING_RATE_KEYS;
   const tokens = [input, n(args.outputTokens), cached, written - written1h];
-  const tierRates = ratesForPrompt(meta, promptTokens);
+  const tierRates = ratesForPrompt(rateMeta, promptTokens);
   const rates = {
     ...provenance,
     ...Object.fromEntries(keys.map((key) => [key, tierRates[key] == null ? null : tierRates[key] * multiplier])),

package/src/runtime/shared/llm/model-catalog-projection.mjs

@@ -144,10 +144,11 @@ function projectLitellmRow(row) {
     const value = row[field];
     if (typeof value === 'number' && Number.isFinite(value)) out[field] = value;
   }
-  // Preserve the published context-rate columns, not just the base price.
+  // Preserve the published context-rate and Priority-tier columns (read by
+  // litellmPricing), not just the base price.
   for (const [field, value] of Object.entries(row)) {
     if (
-      /^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)_above_\d+k_tokens$/.test(
+      /^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)(?:_above_\d+k_tokens)?(?:_priority)?$/.test(
         field
       ) &&
       typeof value === 'number' &&

package/src/runtime/shared/llm/model-catalog.mjs

@@ -443,6 +443,44 @@ const PRICED_VARIANTS = Object.freeze({
   }),
 });
 
+// Cursor-billed rates no catalog publishes: Cursor's first-party SKUs and Fast
+// rates Cursor sells beyond the vendor's own catalog. `fast` is the rate of a
+// request Cursor ran in Fast mode. Other Cursor Fast requests bill at the
+// vendor's Fast rate (Anthropic fast mode, OpenAI Priority/Fast).
+// Source: https://cursor.com/docs/models-and-pricing — list $/M, verified 2026-09-30.
+const CURSOR_PRICING = Object.freeze({
+  'composer-2.5': {
+    inputCostPerM: 0.5,
+    cacheReadCostPerM: 0.2,
+    outputCostPerM: 2.5,
+    fast: { inputCostPerM: 3, cacheReadCostPerM: 0.5, outputCostPerM: 15 },
+  },
+  'grok-4.7': {
+    fast: {
+      inputCostPerM: 4,
+      cacheReadCostPerM: 1,
+      outputCostPerM: 12,
+      // Fast long context (>256k input) bills at 3x the standard rates.
+      pricingTiers: [{ aboveInputTokens: 256000, inputCostPerM: 6, cacheReadCostPerM: 1.5, outputCostPerM: 18 }],
+    },
+  },
+  'grok-4.6': { fast: { inputCostPerM: 4, cacheReadCostPerM: 1, outputCostPerM: 12 } },
+  'grok-4.5': { fast: { inputCostPerM: 4, cacheReadCostPerM: 1, outputCostPerM: 18 } },
+  'claude-opus-4-7': {
+    fast: { inputCostPerM: 30, cacheWriteCostPerM: 37.5, cacheReadCostPerM: 3, outputCostPerM: 150 },
+  },
+});
+
+function listedRates(row) {
+  return {
+    ...Object.fromEntries(PRICING_RATE_KEYS.map((key) => [key, row[key] ?? null])),
+    pricingTiers: (row.pricingTiers || []).map((tier) => ({
+      aboveInputTokens: tier.aboveInputTokens,
+      ...Object.fromEntries(PRICING_RATE_KEYS.map((key) => [key, tier[key] ?? null])),
+    })),
+  };
+}
+
 function scaledRates(row, factor) {
   return Object.fromEntries(PRICING_RATE_KEYS.map((key) => [key, row?.[key] == null ? null : row[key] * factor]));
 }
@@ -512,6 +550,13 @@ function lookupModelMetadata(originalId, provider, catalog, modelsDevCatalog) {
       };
     }
   }
+  const cursorRow = /^cursor-(?:oauth|api)$/.test(String(provider || '').toLowerCase()) ? CURSOR_PRICING[id] : null;
+  if (cursorRow) {
+    if (!PRICING_RATE_KEYS.some((key) => meta?.[key] != null)) {
+      meta = { ...meta, ...listedRates(cursorRow), pricingSource: 'override' };
+    }
+    if (cursorRow.fast) meta = { ...meta, fastPricing: listedRates(cursorRow.fast) };
+  }
   if (providerUsesEndpointScopedLimits(provider) && !providerNative && meta) {
     // OAuth/backend routes can expose smaller account/backend windows than
     // the public API SKU. External catalogs and manual overrides remain useful
@@ -546,10 +591,13 @@ function lookupModelMetadata(originalId, provider, catalog, modelsDevCatalog) {
 
 function _normalize(entry) {
   if (!entry || typeof entry !== 'object') return null;
+  // OpenAI's Priority processing (since renamed Fast mode) columns.
+  const fastPricing = litellmPricing(entry, '_priority');
   return {
     contextWindow: entry.max_input_tokens || entry.max_tokens || null,
     outputTokens: entry.max_output_tokens || null,
     ...litellmPricing(entry),
+    ...(PRICING_RATE_KEYS.some((key) => fastPricing[key] != null) ? { fastPricing } : {}),
     ...(entry.off_peak_multiplier ? { offPeakMultiplier: entry.off_peak_multiplier } : {}),
     supportsVision: entry.supports_vision === true,
     supportsFunctionCalling: entry.supports_function_calling === true,

package/src/runtime/shared/llm/model-pricing-rates.mjs

@@ -20,24 +20,31 @@ function rates(source, keys, multiplier) {
   );
 }
 
-export function litellmPricing(entry) {
+// `suffix` selects a service-tier column set (e.g. `_priority`), published as
+// `<key>_priority` and `<key>_above_<N>k_tokens_priority`.
+export function litellmPricing(entry, suffix = '') {
   const thresholds = new Set();
+  const tierKey = new RegExp(`^_above_(\\d+)k_tokens${suffix}$`);
   for (const key of Object.keys(entry || {})) {
     for (const prefix of LITELLM_KEYS) {
       if (!key.startsWith(`${prefix}_above_`)) continue;
-      const match = key.slice(prefix.length).match(/^_above_(\d+)k_tokens$/);
+      const match = key.slice(prefix.length).match(tierKey);
       if (match) thresholds.add(Number(match[1]) * 1000);
     }
   }
   return {
-    ...rates(entry, LITELLM_KEYS, 1_000_000),
+    ...rates(
+      entry,
+      LITELLM_KEYS.map((key) => `${key}${suffix}`),
+      1_000_000
+    ),
     pricingTiers: [...thresholds]
       .sort((a, b) => a - b)
       .map((aboveInputTokens) => ({
         aboveInputTokens,
         ...rates(
           entry,
-          LITELLM_KEYS.map((key) => `${key}_above_${aboveInputTokens / 1000}k_tokens`),
+          LITELLM_KEYS.map((key) => `${key}_above_${aboveInputTokens / 1000}k_tokens${suffix}`),
           1_000_000
         ),
       })),

package/src/runtime/shared/llm/usage-accounting.mjs

@@ -23,8 +23,18 @@ export async function accountProviderSend(provider, instance, send, model, opts
   } catch (error) {
     openingError = error;
   }
+  const identity = {
+    provider,
+    requestedModel: model,
+    sessionId,
+    sourceType,
+    inputTokensInclusive,
+  };
   const record = async (result) => {
     if (!result?.usage) return;
+    // A nested send (e.g. a fallback model re-send) already stamped its own
+    // final attempt's tier; the outer context only saw the abandoned attempt.
+    result.requestServiceTier ??= identity.requestServiceTier || '';
     if (openingError) throw openingError;
     if (!ledger) return;
     const usage = result.usage;
@@ -46,7 +56,7 @@ export async function accountProviderSend(provider, instance, send, model, opts
       cacheWrite1hTokens: usage.cacheWrite1hTokens,
       costUsd: usage.costUsd,
       serviceTier: result.serviceTier || usage.raw?.service_tier,
-      fast: opts.fast === true,
+      requestServiceTier: result.requestServiceTier,
       responseId: result.responseId,
       // The account this send is bound to, so quota history can tell one
       // connected subscription's records from another's.
@@ -68,16 +78,7 @@ export async function accountProviderSend(provider, instance, send, model, opts
   };
   let result;
   try {
-    result = await withUsageContext(
-      {
-        provider,
-        requestedModel: model,
-        sessionId,
-        sourceType,
-        inputTokensInclusive,
-      },
-      send
-    );
+    result = await withUsageContext(identity, send);
   } catch (error) {
     // Only provider-reported partial usage is recordable; never invent
     // tokens for a failed request or reinterpret an error as a success.

package/src/runtime/shared/llm/usage-context.mjs

@@ -4,3 +4,10 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 const context = new AsyncLocalStorage();
 export const withUsageContext = (identity, send) => context.run(identity, send);
 export const currentUsageContext = () => context.getStore();
+// Each wire attempt stamps the tier it actually sent on its own send's
+// context object, so the last attempt (the one that produced the usage) wins
+// and concurrent sends never observe each other's tier.
+export const noteRequestServiceTier = (tier) => {
+  const identity = context.getStore();
+  if (identity) identity.requestServiceTier = tier || '';
+};

package/src/runtime/shared/llm/usage-ledger-repair.mjs

@@ -81,8 +81,10 @@ function* planUsageRepair(rows, { providerOverrides = {}, price = priceUsage })
               cacheReadTokens: row.cache_read,
               cacheWriteTokens: row.cache_write,
               cacheWrite1hTokens: oldRates?.cacheWrite1hTokens,
-              fast: oldRates?.fast,
+              // Rows written before the sent tier was recorded carry `fast`.
+              requestServiceTier: oldRates?.requestServiceTier ?? (oldRates?.fast ? 'fast' : undefined),
               serviceTier: oldRates?.serviceTier,
+              kind,
               ts: row.ts,
               historical: true,
             });

package/src/runtime/shared/llm/usage-ledger.mjs

@@ -232,7 +232,7 @@ export function makeUsageRecord(args) {
   const ts = Number(args.ts ?? Date.now());
   if (!Number.isSafeInteger(ts) || ts <= 0) throw new Error('Usage requires a valid timestamp');
   const kind = args.kind || usageRouteKind(provider);
-  const priced = priceUsage({ ...args, provider, model, ts });
+  const priced = priceUsage({ ...args, provider, model, ts, kind });
   const supplied =
     args.costUsd !== null &&
     args.costUsd !== undefined &&

package/src/runtime/shared/tool-card-model/card-status.mjs

@@ -8,7 +8,8 @@ import { agentTerminalDetail, isAgentTool } from './agent-surface.mjs';
 import { backgroundTaskElapsed, backgroundTaskFailureDetail, isBackgroundTaskTool } from './background-task.mjs';
 import { shellDisplayStatus } from './shell-surface.mjs';
 import { normalizeTerminalStatus, resultTerminalStatus, shellResultElapsed } from './terminal-status.mjs';
-import { gitResultError, gitResultExitCode } from './git-result.mjs';
+import { gitTerminalStatus } from './git-result.mjs';
+import { isUserControlCancellation } from '../tool-status.mjs';
 
 function shellFragments(base, display, isShellSurface) {
   if (!isShellSurface) return { shellStatus: '', shellElapsed: '' };
@@ -59,16 +60,17 @@ export function deriveCardStatus(base, { normalizedName, parsedArgs, isShellSurf
     !pending && isAgentTool(normalizedName) && !agentHeaderFailure
       ? agentTerminalDetail(parsedArgs?.status, isError, elapsed, parsedArgs?.error)
       : '';
-  const gitFailed =
-    normalizedName === 'git' &&
-    (gitResultExitCode(display.displayedResultText) !== null || Boolean(gitResultError(display.displayedResultText)));
-  const failedOrCompleted = isError || failedCount > 0 || gitFailed ? 'failed' : 'completed';
+  const gitStatus = normalizedName === 'git' ? gitTerminalStatus(display.displayedResultText) : '';
+  const failedOrCompleted = isError || failedCount > 0 ? 'failed' : 'completed';
   const terminalStatus = pending
     ? 'running'
     : shellStatus ||
+      gitStatus ||
       normalizeTerminalStatus(display.backgroundMeta?.status) ||
       normalizeTerminalStatus(parsedArgs?.status) ||
       resultTerminalStatus(display.displayedResultText) ||
+      // A one-line error body is hidden from display, so read the raw result.
+      (isUserControlCancellation(base.rt) ? 'cancelled' : '') ||
       failedOrCompleted;
   return {
     shellStatus,