mixdog 0.9.175 → 1.0.1

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/config-patch.mjs

@@ -25,6 +25,8 @@ function applyField(current, path, change) {
   const next = isPlainObject(current) ? { ...current } : {};
   const [key, ...rest] = path;
   if (change.remove && rest.length && !Object.hasOwn(next, key)) return next;
+  // Seed-only field: written where it is missing, never over a stored value.
+  if (change.ifAbsent && !rest.length && Object.hasOwn(next, key)) return next;
   if (!rest.length && change.remove) {
     delete next[key];
   } else {

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,

package/src/runtime/shared/tool-card-model/git-result.mjs

@@ -1,3 +1,5 @@
+import { hasBenignExitOutcome } from '../tool-status.mjs';
+
 // Only command result headers, not arbitrary lines in a patch, carry exits.
 export function gitResultExitCode(text) {
   const match = /(?:^(?:## [^\n]+\n)?|\n## [^\n]+\n)exit ([1-9]\d*)\r?(?:\n|$)/.exec(String(text ?? ''));
@@ -7,3 +9,11 @@ export function gitResultExitCode(text) {
 export function gitResultError(text) {
   return /(?:^|\n)error: command failed: [^\n]+|^error: [^\n]+/.exec(String(text ?? ''))?.[0].trim() || '';
 }
+
+// A tool error fails the call; a git process that ran and exited non-zero is
+// a command exit, like the shell's, unless the tool marked the exit a signal.
+export function gitTerminalStatus(text) {
+  if (gitResultError(text)) return 'failed';
+  if (gitResultExitCode(text) !== null && !hasBenignExitOutcome(text)) return 'exit';
+  return '';
+}

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

@@ -2,11 +2,11 @@
  * terminal-status.mjs — terminal status words, their outcome tone, status
  * marker stripping and the ` · <time>` detail conventions.
  */
-import { normalizeToolTerminalStatus, toolResultTerminalStatus } from '../tool-status.mjs';
+import { leadingResultBlock, normalizeToolTerminalStatus, toolResultTerminalStatus } from '../tool-status.mjs';
 import { formatElapsed } from '../time-format.mjs';
 
 export function shellResultStatus(value) {
-  const match = String(value || '').match(
+  const match = leadingResultBlock(value).match(
     /(?:^|\b)status:\s*(running|pending|queued|completed|failed|cancelled|canceled)\b/im
   );
   return match ? String(match[1] || '').toLowerCase() : '';
@@ -48,6 +48,7 @@ const TERMINAL_STATUS_LABELS = new Map([
   ['cancelled', 'Cancelled'],
   ['denied', 'Denied'],
 ]);
+const BARE_STATUS_WORDS = new Set([...TERMINAL_STATUS_LABELS.values()].map((label) => label.toLowerCase()));
 
 export function displayTerminalStatus(value) {
   // 'exit' is a shell-only pseudo-status (command RAN but exited non-zero); it
@@ -107,5 +108,8 @@ export function mergeTerminalDetail(status, detail = '') {
   if (label === 'Finished' && text) return text;
   if (!text) return label;
   if (text.toLowerCase().startsWith(label.toLowerCase())) return text;
+  // A bare status word (the generic "Failed" of an error without a body) is
+  // superseded by the resolved status, e.g. a user-takeover "Cancelled".
+  if (BARE_STATUS_WORDS.has(text.toLowerCase())) return label;
   return `${label} · ${text}`;
 }

package/src/runtime/shared/tool-card-model.golden-cases.mjs

@@ -16,7 +16,8 @@ export const GIT_GOLDEN_CASES = [
     summary: 'diff --git a/a.txt b/a.txt',
     status: 'completed',
   },
-  { result: 'exit 128\nfatal: missing ref\n', summary: 'Exit 128', status: 'failed' },
+  { result: 'exit 128\nfatal: missing ref\n', summary: 'Exit 128', status: 'exit' },
+  { result: 'exit 1\n[outcome: no-match]\ndiff --git a/a.txt b/a.txt\n', summary: 'Exit 1', status: 'completed' },
   {
     result: '## git show missing\nexit 128\nfatal: missing\nerror: command failed: git show missing',
     summary: 'Exit 128',

package/src/runtime/shared/tool-result-summary.mjs

@@ -312,6 +312,7 @@ function summarizeLineCount({ text, trimmed }, { zero, singular, plural }) {
 function summarizeReadResult({ text, trimmed }) {
   if (/^\[image:/i.test(trimmed)) return 'Image';
   if (!trimmed) return null;
+  if (trimmed.startsWith('(no lines in range')) return '0 lines';
   const n = text.split('\n').length;
   return `${n} ${pluralize(n, 'line')}`;
 }

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

@@ -23,15 +23,48 @@ export function normalizeToolTerminalStatus(value) {
   return '';
 }
 
+// Status markers live in the result's leading block: the cancel marker, the
+// shell exit header, a background-task header, a task/agent status line.
+// Command output and fetched documents follow a blank line and can carry
+// `status:` text of their own, which says nothing about the tool call.
+export function leadingResultBlock(text) {
+  const lines = String(text || '').split('\n');
+  let index = 0;
+  if (/^\[tool output offloaded:/i.test(String(lines[0] || '').trim())) {
+    index = 1;
+    while (index < lines.length && !lines[index].trim()) index += 1;
+  }
+  const block = [];
+  for (; index < lines.length && lines[index].trim(); index += 1) block.push(lines[index]);
+  return block.join('\n');
+}
+
+// The user taking over the browser/desktop, or the session cancelling a
+// computer command, stops the call on purpose; it is not a failed invocation.
+const USER_CONTROL_CANCELLATION_RE =
+  /^(?:Error:\s*)?(?:Browser command interrupted by local user input\.|computer_session_aborted:|computer_user_control_active:)/i;
+
+export function isUserControlCancellation(text) {
+  return USER_CONTROL_CANCELLATION_RE.test(String(text || '').trimStart());
+}
+
+// A non-zero exit the tool itself marked as a signal (search no-match, a
+// `git diff --exit-code` difference) rather than a command failure.
+export function hasBenignExitOutcome(text) {
+  return /^\[outcome:\s*(?:no-match|no-change)\]\s*$/im.test(String(text || ''));
+}
+
 export function toolResultTerminalStatus(text) {
   const body = String(text || '');
   const tagged = body.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
   if (tagged) return normalizeToolTerminalStatus(tagged);
-  const bracketed = body.match(/^\[status:\s*([^\]]*)\]/im)?.[1]?.trim();
+  const head = leadingResultBlock(body);
+  const bracketed = head.match(/^\[status:\s*([^\]]*)\]/im)?.[1]?.trim();
   if (bracketed) return normalizeToolTerminalStatus(bracketed);
-  const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/im)?.[1]?.trim();
+  const inline = head.match(/^(?:status|state):\s*([^\s·,;]+)/im)?.[1]?.trim();
   const fromInline = normalizeToolTerminalStatus(inline);
   if (fromInline) return fromInline;
+  if (isUserControlCancellation(body)) return 'cancelled';
   // Bare control bodies written on cancel/crash (current + legacy).
   const trimmed = body.trim();
   if (/^(?:cancelled|canceled)$/i.test(trimmed)) return 'cancelled';

package/src/runtime/shared/user-data-guard.mjs

@@ -28,7 +28,7 @@ function getBackupRoot() {
   return process.env.MIXDOG_USER_DATA_BACKUP_ROOT || join(mixdogConfigBaseDir(), 'backups', 'user-data');
 }
 
-const USER_DATA_FILES = ['mixdog-config.json', 'instructions.md', 'user-workflow.md'];
+const USER_DATA_FILES = ['mixdog-config.json'];
 
 const USER_DATA_DIRS = ['schedules', 'webhooks', 'workflows'];
 

package/src/runtime/tidy/report.mjs

@@ -11,10 +11,10 @@ const FILE_LIST_CAP = 25;
 export const RESULTS_PAGE_MAX = 100;
 const TRIM_STEPS = [8, 3, 0];
 
-export function tidyToolResult(value, isError = false) {
+export function tidyToolResult(value, isError = value?.ok === false) {
   return {
     content: [{ type: 'text', text: JSON.stringify(value) }],
-    ...(isError || value?.ok === false ? { isError: true } : {}),
+    ...(isError ? { isError: true } : {}),
   };
 }
 

package/src/runtime/tidy/tool.mjs

@@ -571,7 +571,12 @@ export async function executeTidyTool(args = {}, { cwd = process.cwd(), signal =
       return tidyToolResult(await rulesAction({ cwd, signal, startedAt }));
     }
     if (action === 'results') {
-      return tidyToolResult(await resultsAction({ args, cwd, sessionId, engineFilter, pathFilter: scope, startedAt }));
+      // Paging a stored run succeeds even when that run was incomplete; the
+      // report's ok/status still describe the run itself.
+      return tidyToolResult(
+        await resultsAction({ args, cwd, sessionId, engineFilter, pathFilter: scope, startedAt }),
+        false
+      );
     }
     return tidyToolResult(
       await runAction({

package/src/session-runtime/config-lifecycle.mjs

@@ -102,10 +102,20 @@ export function createConfigLifecycle({
     const adopted = adoptConfig(nextConfig, { hasSecrets });
     const changes = cfgMod.createConfigPatch(configSaveBaseline, adopted);
     configSaveBaseline = structuredClone(adopted);
-    if (changes.length) writers.queueConfigChanges(changes);
+    if (changes.length) writers.queueConfigChanges([...changes, ...seedChanges(adopted, changes)]);
     return adopted;
   }
 
+  // A fresh profile's install markers (an empty `builtins`) and off-by-default
+  // agents equal the defaults, so no diff ever carries them — yet on disk
+  // their absence reads as a grandfathered profile with every agent on. The
+  // first write seeds them where the stored section lacks them.
+  function seedChanges(config, changes) {
+    return ['builtins', 'disabledAgents']
+      .filter((key) => config[key] !== undefined && !changes.some((change) => change.path[0] === key))
+      .map((key) => ({ path: [key], value: structuredClone(config[key]), ifAbsent: true }));
+  }
+
   function scheduleSkillsSave(names) {
     // This field belongs to its dedicated writer, not a later unrelated save.
     configSaveBaseline.skills = structuredClone(getConfig().skills);

package/src/session-runtime/cwd-plugins/core-memory-context.mjs

@@ -24,7 +24,7 @@ export function createCoreMemoryContext({ getCurrentCwd, getConfig, bootProfile,
   async function loadCoreMemoryContext() {
     // User-curated core memory injects into new sessions by default. The
     // Memory toggle (settings → General) OFF skips ONLY this accumulated
-    // core-memory block — profile and Project Instructions inject regardless.
+    // core-memory block — the profile injects regardless.
     if (!(featureEnvOverride('MIXDOG_FEATURE_MEMORY') ?? memoryToolsEnabled(getConfig(), true))) {
       bootProfile('core-memory:disabled');
       return '';