mixdog 0.9.104 → 0.9.105

package/README.md

@@ -103,7 +103,7 @@ every number above live under `benchmarks/terminal-bench-2.1/`.
   role mode for scripting.
 - Mixdog Desktop: a full agent workbench for Windows/macOS/Linux (see
   below).
-- Web/mobile companion over relay pairing — scan a QR code to open your
+- Installable web app over relay pairing — scan a QR code to open your
   running sessions in a phone browser and keep going from any network.
 - Optional Discord/Telegram channels, webhook endpoints, and cron schedules
   with quiet hours for remote/event-driven workflows; channel voice messages
@@ -246,7 +246,7 @@ wizard covers first-run setup. For development run `npm run dev` inside
 - **Automation** — visual editors for workflow and agent packs, cron
   schedules, webhooks, and channel integrations.
 - **Settings hub** — provider auth, capability sweep, git identity, and
-  QR device pairing for the web/mobile companion, preloaded so every
+  QR device pairing for the installable web app, preloaded so every
   category opens instantly.
 
 ## Scripts
@@ -302,8 +302,7 @@ src/
   rules/         # Lead and agent instructions
 apps/
   desktop/       # Mixdog Desktop — Electron workbench (main/preload/renderer)
-  mobile/        # mobile companion shell
-  relay/         # relay server for remote/web/mobile access
+  relay/         # relay server for remote web-app access
 scripts/
   smoke*.mjs     # smoke checks
   *test.mjs      # focused node:test checks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.104",
+  "version": "0.9.105",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/rules/shared/01-tool.md

@@ -14,7 +14,9 @@
   facets in one query array. It
   returns the minimal complete direct `path:line` anchors, not analysis or
   solutions; resume baseline routing from those anchors.
-- Use verified paths (cwd/project/user/tool); explicit paths may be outside cwd;
+- Use verified paths (cwd/project/user/tool). Within the current project, pass
+  project-relative paths and omit optional scopes equal to its root; explicit
+  paths may be outside cwd only for targets outside the project;
   stay focused on the requested outcome. Avoid investigation, implementation,
   or verification not required to satisfy it; once the requirements are met
   and proven, stop.

package/src/runtime/agent/orchestrator/providers/anthropic-effort.mjs

@@ -292,20 +292,13 @@ export function applyAnthropicEffortToBody(
         // Adaptive-thinking models (4.6+) require `thinking:{type:"adaptive"}`
         // rather than the legacy budget_tokens shape — sending
         // `thinking:{type:"enabled"}` here 400s on sonnet-5/opus-4-7/4-8.
-        // display:"summarized" keeps reasoning blocks populated (4.7+ defaults
-        // to "omitted", silently hiding reasoning text). Gated on the same
-        // modelSupportsEffort() allowlist so older models never receive it.
-        // Set unconditionally (independent of `normalized`) so effort-capable
-        // turns always carry adaptive thinking + round-trip signatures.
-        // MIXDOG_ANTHROPIC_THINKING_DISPLAY=omitted (operator/bench knob):
-        // thinking blocks are omitted entirely, so nothing is
-        // replayed into later requests (saves the 1h cache-write + re-read on
-        // accumulated thinking) at the cost of losing visible reasoning and
-        // cross-iteration thinking continuity. Default stays summarized.
-        const display = (process.env.MIXDOG_ANTHROPIC_THINKING_DISPLAY || '').trim() === 'omitted'
-            ? 'omitted'
-            : 'summarized';
-        body.thinking = { type: 'adaptive', display };
+        // Match Claude Code's default wire shape: omit `display` and let the
+        // model/API choose its default. Operators and benchmarks can explicitly
+        // request either supported display mode.
+        const display = (process.env.MIXDOG_ANTHROPIC_THINKING_DISPLAY || '').trim();
+        body.thinking = display === 'summarized' || display === 'omitted'
+            ? { type: 'adaptive', display }
+            : { type: 'adaptive' };
         // Adaptive/4.7+ models reject any non-default sampling param with a 400.
         delete body.temperature;
         delete body.top_p;

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -199,6 +199,22 @@ function compactPressureTokens(messageTokensEst, policy) {
     return Math.max(0, Math.round((messageTokensEst + requestReserve) * calibration) + otherReserve);
 }
 
+// Provider-visible context estimate without operator-only compaction reserve.
+// Request/schema reserve remains included because those bytes are sent to the
+// model; configured reserve is merely local headroom and must not inflate the
+// user-facing context gauge.
+function currentContextEstimateTokens(messageTokensEst, policy) {
+    if (messageTokensEst === null) return 0;
+    const calibration = Number(policy?.tokenCalibration) > 0 ? Number(policy.tokenCalibration) : 1;
+    const configured = Math.max(0, Number(policy?.configuredReserveTokens) || 0);
+    const totalReserve = Math.max(0, Number(policy?.reserveTokens) || 0);
+    const requestReserve = Math.min(
+        totalReserve,
+        Math.max(0, Number(policy?.requestReserveTokens ?? (totalReserve - configured)) || 0),
+    );
+    return Math.max(0, Math.round((messageTokensEst + requestReserve) * calibration));
+}
+
 function providerPressureTokens(sessionRef, usage) {
     if (!usage || typeof usage !== 'object') return 0;
     const input = Math.max(0, Number(usage.mainInputTokens ?? usage.inputTokens) || 0);
@@ -268,7 +284,9 @@ export function invalidateProviderContextBaseline(sessionRef) {
 // transcript did NOT grow keeps its baseline regardless of age.
 const BASELINE_MAX_STALE_GROWTH_MS = 30 * 60 * 1000;
 
-function providerBaselinePressureTokens(messages, sessionRef, policy) {
+function providerBaselinePressureTokens(messages, sessionRef, policy, {
+    includeConfiguredReserve = true,
+} = {}) {
     if (!Array.isArray(messages) || !sessionRef
         || sessionRef.lastContextTokensStaleAfterCompact === true) return null;
     let tokens = positiveTokenInt(sessionRef.contextPressureBaselineTokens);
@@ -303,16 +321,31 @@ function providerBaselinePressureTokens(messages, sessionRef, policy) {
         const growth = count < messages.length
             ? Math.round(estimateMessagesTokens(messages.slice(count)) * calibration)
             : 0;
-        return Math.max(0, tokens + growth + Math.max(0, Number(policy?.configuredReserveTokens) || 0));
+        const configuredReserve = includeConfiguredReserve
+            ? Math.max(0, Number(policy?.configuredReserveTokens) || 0)
+            : 0;
+        return Math.max(0, tokens + growth + configuredReserve);
     } catch {
         return null;
     }
 }
 
+function preferAlignedBaseline(baseline, estimate) {
+    if (baseline == null) return estimate;
+    if (Number.isFinite(estimate) && estimate > 0 && baseline * 2 < estimate) return estimate;
+    return baseline;
+}
+
+export function resolveCurrentContextTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
+    const baseline = providerBaselinePressureTokens(messages, sessionRef, policy, {
+        includeConfiguredReserve: false,
+    });
+    return preferAlignedBaseline(baseline, currentContextEstimateTokens(messageTokensEst, policy));
+}
+
 export function resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
     const baseline = providerBaselinePressureTokens(messages, sessionRef, policy);
     const estimate = compactPressureTokens(messageTokensEst, policy);
-    if (baseline == null) return estimate;
     // Sanity band: the baseline exists to correct OVER-counting estimates
     // (dense-data floors can inflate the estimate up to ~2x real usage), so a
     // lower baseline is normally preferred. But a corrupt/stale baseline below
@@ -322,8 +355,7 @@ export function resolveCompactionPressureTokens(messageTokensEst, policy, { mess
     // both the gauge and the compaction decision. Erring toward the estimate
     // may compact somewhat early; erring toward a rotten baseline blows past
     // the context window at full token cost.
-    if (Number.isFinite(estimate) && estimate > 0 && baseline * 2 < estimate) return estimate;
-    return baseline;
+    return preferAlignedBaseline(baseline, estimate);
 }
 
 /** Telemetry pressure when a reactive overflow retry forces the next compact. */

package/src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs

@@ -856,6 +856,32 @@ function dropUndefinedArgs(args) {
     }
 }
 
+// Provider-facing built-ins use short keys/enum values to reduce repeated
+// tool-call output. Canonicalize them before validation so executors, traces,
+// saved calls, and legacy long-form callers keep one stable internal contract.
+function normalizeCompactSurfaceArgs(toolName, args) {
+    if (['grep', 'glob', 'find', 'list'].includes(toolName)
+        && !hasOwn(args, 'head_limit')
+        && hasOwn(args, 'limit')) {
+        args.head_limit = args.limit;
+        delete args.limit;
+    }
+    if (toolName === 'grep'
+        && !hasOwn(args, 'output_mode')
+        && typeof args.mode === 'string') {
+        const mode = args.mode.trim();
+        const canonical = {
+            content: 'content_with_context',
+            files: 'files_with_matches',
+            count: 'count',
+        }[mode];
+        if (canonical) {
+            args.output_mode = canonical;
+            delete args.mode;
+        }
+    }
+}
+
 // string | string[] arguments arrive nested ([["a","b"]] from a batching
 // wrapper), padded with null/empty entries, or empty. The intent is
 // unambiguous, so flatten one level, drop the blanks, and remove a key that
@@ -866,9 +892,13 @@ const STRING_LIST_ARG_KEYS = [
     'pattern', 'patterns', 'query', 'regex', 'needle',
     'glob', 'file_pattern', 'include', 'type', 'symbols',
 ];
-function normalizeStringListArgs(args) {
+function normalizeStringListArgs(args, toolName) {
     for (const key of STRING_LIST_ARG_KEYS) {
         if (!hasOwn(args, key) || !Array.isArray(args[key])) continue;
+        // read.path may contain compact [path,offset,limit] tuples. Flattening
+        // here would destroy their boundaries before guardRead canonicalizes
+        // them through coerceReadFamilyPathArg().
+        if (toolName === 'read' && key === 'path' && args[key].some(Array.isArray)) continue;
         const source = args[key];
         // Flatten ONE nesting level and drop blank entries; every other entry
         // type is left untouched so the per-tool guards still see (and coerce
@@ -896,7 +926,8 @@ export function validateBuiltinArgs(toolName, args) {
         return `Error: ${toolName} arguments must be an object (got ${describeType(args)})`;
     }
     dropUndefinedArgs(args);
-    normalizeStringListArgs(args);
+    normalizeCompactSurfaceArgs(toolName, args);
+    normalizeStringListArgs(args, toolName);
     if (toolName === 'grep') applyGrepContextLeadPolicy(args);
     try {
         return guard(args) || null;

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -498,7 +498,10 @@ export async function executeBashTool(args, workDir, options = {}) {
     const promotedTimeoutMs = hasExplicitTimeout && backgroundOnTimeout
         ? Math.max(0, totalTimeout - timeout)
         : 0;
-    const mergeStderr = args.merge_stderr === true;
+    // Provider schema intentionally omits this low-value toggle; all observed
+    // live calls requested merged output, which is also the useful default for
+    // in-turn diagnostics. Internal callers may still opt out explicitly.
+    const mergeStderr = args.merge_stderr !== false;
     const longForegroundHint = foregroundLongCommandHint(
         command,
         timeout,

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -46,24 +46,28 @@ export const BUILTIN_TOOLS = [
                             items: {
                                 anyOf: [
                                     { type: 'string' },
+                                    { type: 'number' },
                                     {
-                                        type: 'object',
-                                        properties: {
-                                            path: { type: 'string' },
-                                            offset: { type: 'number', minimum: 0 },
-                                            limit: { type: 'number', minimum: 1 },
+                                        type: 'array',
+                                        items: {
+                                            anyOf: [
+                                                { type: 'string' },
+                                                { type: 'number' },
+                                            ],
                                         },
-                                        required: ['path'],
+                                        minItems: 2,
+                                        maxItems: 3,
+                                        description: '[path,offset,limit?].',
                                     },
                                 ],
                             },
                             minItems: 1,
                         },
                     ],
-                    description: 'File path, or {path,offset,limit}[] regions. Pass real arrays, not JSON strings.',
+                    description: 'Project-relative file path, string[] files, [path,offset,limit?] range, or range[]; absolute only outside the project.',
                 },
                 offset: { type: 'number', minimum: 0, description: 'Lines to skip.' },
-                limit: { type: 'number', minimum: 1, description: 'Max lines after offset. Defaults to 2000.' },
+                limit: { type: 'number', minimum: 1, description: 'Max lines; default 2000.' },
             },
             required: ['path'],
             additionalProperties: false,
@@ -78,14 +82,11 @@ export const BUILTIN_TOOLS = [
             type: 'object',
             properties: {
                 command: { type: 'string', description: `Command.${_shellSyntaxCheat}` },
-                cwd: { type: 'string', description: 'Working directory; persists. Omit to reuse; an absolute path changes it.' },
+                cwd: { type: 'string', description: 'Omit for current directory; use a project-relative subdir or explicit external path.' },
                 timeout: {
                     type: 'number',
-                    description: `Timeout ms; default ${_shellDefaultTimeoutMs()}. `
-                        + 'Sync timeout may return task_id; an explicit value is its deadline. '
-                        + 'Sleeps are killed, not promoted.',
+                    description: `Timeout ms; default ${_shellDefaultTimeoutMs()}. Explicit values are deadlines; sync may return task_id.`,
                 },
-                merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell.' },
             },
@@ -101,9 +102,9 @@ export const BUILTIN_TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
-                task_id: { type: 'string', description: 'shell async task_id.' },
-                action: { type: 'string', enum: ['list', 'status', 'read', 'wait', 'cancel'], description: 'Default list; with task_id, default wait.' },
-                timeout_ms: { type: 'number', description: 'Wait timeout ms.' },
+                task_id: { type: 'string', description: 'Shell task_id.' },
+                action: { type: 'string', enum: ['list', 'status', 'read', 'wait', 'cancel'], description: 'Default list; with task_id: wait.' },
+                timeout_ms: { type: 'number', description: 'Wait timeout (ms).' },
             },
             required: [],
             additionalProperties: false,
@@ -122,14 +123,14 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Text/regex; pattern[] batches exact query literals and identifier variants in one call.',
+                    description: 'Text/regex; pattern[] batches exact query literals and identifier variants.',
                 },
                 path: {
                     anyOf: [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'File/dir scope(s).',
+                    description: 'Project-relative file/dir scope(s); omit for project root; absolute only outside.',
                 },
                 glob: {
                     anyOf: [
@@ -138,10 +139,10 @@ export const BUILTIN_TOOLS = [
                     ],
                     description: 'Glob filter.',
                 },
-                output_mode: { type: 'string', enum: ['content_with_context', 'files_with_matches', 'count'], description: 'content_with_context (default); files_with_matches/count for existence.' },
-                head_limit: { type: 'number', minimum: 0, description: 'Max results. Defaults to 250; 0 = unlimited.' },
-                offset: { type: 'number', minimum: 0, description: 'Skip results for paging.' },
-                context: { type: 'number', minimum: 0, description: 'Minimum surrounding lines; runtime expands within its call budget. Omit for automatic context; 0 for matches only.' },
+                mode: { type: 'string', enum: ['content', 'files', 'count'], description: 'content default; files/count for existence.' },
+                limit: { type: 'number', minimum: 0, description: 'Max results; default 250; 0 unlimited.' },
+                offset: { type: 'number', minimum: 0, description: 'Result offset.' },
+                context: { type: 'number', minimum: 0, description: 'Omit for automatic context; 0 for matches only.' },
             },
             anyOf: [
                 { required: ['pattern'] },
@@ -163,17 +164,16 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Glob pattern(s); pattern[] batches.',
+                    description: 'Glob(s); pattern[] batches.',
                 },
                 path: {
                     anyOf: [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Base directory(ies); path[] batches.',
+                    description: 'Project-relative base dir(s); omit for project root; path[] batches; absolute only outside.',
                 },
-                head_limit: { type: 'number', description: 'Max entries. Defaults to 100; 0 = unlimited.' },
-                offset: { type: 'number', description: 'Skip entries.' },
+                limit: { type: 'number', description: 'Max entries; default 100; 0 unlimited.' },
             },
             required: ['pattern'],
             additionalProperties: false,
@@ -194,8 +194,8 @@ export const BUILTIN_TOOLS = [
                     ],
                     description: 'Filename or directory path fragments matched against path strings; query[] batches.',
                 },
-                path: { type: 'string', description: 'Base directory.' },
-                head_limit: { type: 'number', description: 'Max paths across the call. Defaults to 25.' },
+                path: { type: 'string', description: 'Project-relative base; omit for project root; absolute only outside.' },
+                limit: { type: 'number', description: 'Max paths across the call. Defaults to 25.' },
             },
             required: ['query'],
             additionalProperties: false,
@@ -214,12 +214,12 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Directory; path[] batches.',
+                    description: 'Project-relative directory; omit for project root; path[] batches; absolute only outside.',
                 },
                 hidden: { type: 'boolean', description: 'Include dotfiles.' },
                 meta: { type: 'boolean', description: 'Per-entry size bytes, UTC mtime, octal mode.' },
-                head_limit: { type: 'number', description: 'Max entries. Defaults to 200; 0 = no cap.' },
-                offset: { type: 'number', description: 'Skip N entries for paging.' },
+                limit: { type: 'number', description: 'Max entries; default 200; 0 unlimited.' },
+                offset: { type: 'number', description: 'Entry offset.' },
             },
             required: [],
             additionalProperties: false,

package/src/runtime/agent/orchestrator/tools/builtin/path-utils.mjs

@@ -110,6 +110,10 @@ export const GREP_AUTO_CONTEXT_LINES = 25;
 
 export function normalizeGrepArgs(args) {
     if (!args || typeof args !== 'object') return args;
+    if ((args.head_limit === undefined || args.head_limit === null) && args.limit !== undefined) {
+        args.head_limit = args.limit;
+        delete args.limit;
+    }
     if (args.pattern === undefined || args.pattern === null || args.pattern === '') {
         const alias = firstPresentArg(args, ['query', 'regex', 'regexp', 'needle', 'search', 'literal']);
         if (alias !== undefined) args.pattern = alias;
@@ -124,13 +128,24 @@ export function normalizeGrepArgs(args) {
     }
     if ((args.output_mode === undefined || args.output_mode === null || args.output_mode === '') && typeof args.mode === 'string') {
         const mode = args.mode.trim();
-        if (['files_with_matches', 'content', 'content_with_context', 'count'].includes(mode)) args.output_mode = mode;
+        const canonical = {
+            content: 'content_with_context',
+            files: 'files_with_matches',
+            count: 'count',
+            content_with_context: 'content_with_context',
+            files_with_matches: 'files_with_matches',
+        }[mode];
+        if (canonical) args.output_mode = canonical;
     }
     return args;
 }
 
 export function normalizeGlobArgs(args) {
     if (!args || typeof args !== 'object') return args;
+    if ((args.head_limit === undefined || args.head_limit === null) && args.limit !== undefined) {
+        args.head_limit = args.limit;
+        delete args.limit;
+    }
     if (args.pattern === undefined || args.pattern === null || args.pattern === '') {
         const alias = firstPresentArg(args, ['glob', 'file_pattern', 'filePattern', 'name', 'include', 'includes', 'files']);
         if (alias !== undefined) args.pattern = alias;
@@ -247,6 +262,20 @@ export function coerceShapeFlex(value) {
 // JSON-stringified path arrays (path:"[]") and empty arrays mean "search cwd".
 // Bracket-shaped strings that exist on disk (e.g. a literal `[x]` directory) are
 // left untouched — JSON reinterpretation only runs after a stat miss.
+function compactReadRangeTuple(value) {
+    if (!Array.isArray(value) || value.length < 2 || value.length > 3 || typeof value[0] !== 'string') return null;
+    const numeric = value.slice(1).every((part) => (
+        typeof part === 'number'
+        || (typeof part === 'string' && /^-?\d+(?:\.\d+)?$/.test(part.trim()))
+    ));
+    if (!numeric) return null;
+    return {
+        path: value[0],
+        offset: value[1],
+        ...(value.length === 3 ? { limit: value[2] } : {}),
+    };
+}
+
 export function coerceReadFamilyPathArg(path, workDir = null) {
     if (path === undefined || path === null || path === '') return path;
     if (typeof path === 'string' && typeof workDir === 'string' && workDir) {
@@ -305,10 +334,13 @@ export function coerceReadFamilyPathArg(path, workDir = null) {
     }
     const coerced = coerceShapeFlex(path);
     if (!Array.isArray(coerced)) return coerced;
+    const directRange = compactReadRangeTuple(coerced);
+    if (directRange) return [directRange];
     const list = coerced
-        // Region objects ({path,offset,limit}) must pass through untouched —
-        // read's batch dispatcher consumes them. Only strings are trimmed.
-        .map((p) => (typeof p === 'string' ? p.trim() : p))
+        // Provider-facing range tuples are compact; canonicalize them to the
+        // legacy region objects consumed by read's batch dispatcher. Existing
+        // object callers remain valid and pass through untouched.
+        .map((p) => compactReadRangeTuple(p) ?? (typeof p === 'string' ? p.trim() : p))
         .filter((p) => (typeof p === 'string' ? p.length > 0 : (p && typeof p === 'object')));
     if (list.length === 0) return '.';
     // Collapse to scalar only for a lone string; a lone region object must

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -8,13 +8,12 @@ export const CODE_GRAPH_TOOL_DEFS = [
       type: 'object',
       properties: {
         mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'], description: 'File modes: overview/imports/dependents/related/impact. symbols with files[] gives a file outline; others are symbol modes.' },
-        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Source file path(s); supported targets only.' },
+        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Project-relative source file path(s); absolute only outside the project; supported targets only.' },
         symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Exact identifiers or keywords (symbol-index terms); batch multiple in one symbols[] call.' },
         body: { type: 'boolean', description: 'Include body.' },
         limit: { type: 'number', minimum: 1, description: 'Max results.' },
         depth: { type: 'number', minimum: 1, maximum: 5, description: 'Caller depth.' },
-        page: { type: 'number', minimum: 1, description: 'Caller page.' },
-        cwd: { type: 'string', description: 'Explicit root.' },
+        cwd: { type: 'string', description: 'Explicit root outside the project; omit for project root.' },
       },
       required: ['mode'],
       additionalProperties: false,

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -680,6 +680,26 @@ function extractInlinePatchRoot(patchText) {
   };
 }
 
+export function expandCompactPatchInput(patchText) {
+  const text = String(patchText || '').replace(/^\uFEFF/, '');
+  if (/^\s*\*\*\* Begin Patch(?:\r?\n|$)/.test(text)) return text;
+  const lines = text.replace(/\r\n/g, '\n').split('\n');
+  while (lines.length && lines[0] === '') lines.shift();
+  while (lines.length && lines[lines.length - 1] === '') lines.pop();
+  if (!lines.length || !/^[RADU] /.test(lines[0])) return text;
+  const mapped = lines.map((line) => {
+    if (line.startsWith('R ')) return `*** Root: ${line.slice(2)}`;
+    if (line.startsWith('A ')) return `*** Add File: ${line.slice(2)}`;
+    if (line.startsWith('D ')) return `*** Delete File: ${line.slice(2)}`;
+    if (line.startsWith('U ')) return `*** Update File: ${line.slice(2)}`;
+    if (line.startsWith('M ')) return `*** Move to: ${line.slice(2)}`;
+    if (line === '@') return '@@';
+    if (line.startsWith('@ ')) return `@@ ${line.slice(2)}`;
+    return line;
+  });
+  return ['*** Begin Patch', ...mapped, '*** End Patch', ''].join('\n');
+}
+
 function isFilesystemRootSpecifier(value, cwd) {
   const raw = String(value || '').trim();
   if (!raw) return false;
@@ -692,7 +712,8 @@ function isFilesystemRootSpecifier(value, cwd) {
 
 async function apply_patch(args, cwd, options = {}) {
   args = salvageShatteredV4APatchArgs(args);
-  let patchStr = salvageV4AOpening((typeof args?.patch === 'string' ? args.patch : '').replace(/^\uFEFF/, ''));
+  let patchStr = expandCompactPatchInput(typeof args?.patch === 'string' ? args.patch : '');
+  patchStr = salvageV4AOpening(patchStr);
   const inlineRoot = extractInlinePatchRoot(patchStr);
   patchStr = inlineRoot.patch;
   if (inlineRoot.root) {

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -20,16 +20,41 @@ eof_line: "*** End of File" LF
 %import common.LF
 `;
 
+const COMPACT_PATCH_LARK_GRAMMAR = `start: root_line? hunk+
+root_line: "R " filename LF
+
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "A " filename LF add_line+
+delete_hunk: "D " filename LF
+update_hunk: "U " filename LF change_move? change
+
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+
+change_move: "M " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@" | "@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+
+%import common.LF
+`;
+
+const USE_COMPACT_PATCH_FORMAT = process.env.MIXDOG_COMPACT_PATCH_GRAMMAR !== '0';
+
 // Public contract: apply_patch is the PRIMARY edit tool and takes
 // a raw freeform V4A patch (no JSON envelope) on providers that support custom
 // grammar tools. No prior `read` is required or implied — send the patch as
 // soon as the target and content are known. The JSON schema below is only the
 // fallback for providers that cannot carry freeform/custom tools, so it exposes
-// the patch string alone; runtime-only knobs stay off the model surface.
+// the patch string and an optional explicit base; runtime-only knobs stay off
+// the model surface.
 // Batching stays a rules-level policy: every new edit goes in one patch, with
 // one file block per target.
 const APPLY_PATCH_FREEFORM_DESCRIPTION =
   'Edit files with `apply_patch`. FREEFORM input; do not wrap the patch in JSON.';
+const COMPACT_PATCH_FREEFORM_DESCRIPTION =
+  'Compact patch: U/A/D path, optional M rename or R root, @ hunks, then space/-/+ lines.';
 
 // JSON-schema fallback providers (Anthropic and other non-grammar surfaces)
 // get the full V4A instructions inline: without a grammar the model has
@@ -40,12 +65,20 @@ const APPLY_PATCH_FREEFORM_DESCRIPTION =
 const APPLY_PATCH_JSON_DESCRIPTION = [
   'Edit files with this V4A patch:',
   '*** Begin Patch',
+  '[optional *** Root: <path> for out-of-session writes]',
   '[file sections]',
   '*** End Patch',
   'Each section starts with exactly one: *** Add File: <path> (+ lines), *** Delete File: <path> (header only), or *** Update File: <path> (optional *** Move to: <new path>).',
   'Hunks start with @@ or @@ <symbol>; lines start space, -, or +; optional *** End of File.',
   'Use 3 verbatim context lines from newest output (post-patch body after edits); avoid overlap; stack @@ only if ambiguous.',
-  'Relative or explicit absolute paths; + every added line. Never send compacted-history markers; re-read first.',
+  'Project-relative paths; explicit absolute paths only outside the project; + every added line. Never send compacted-history markers; re-read first.',
+].join('\n');
+
+const COMPACT_PATCH_JSON_DESCRIPTION = [
+  'Edit with a compact patch.',
+  'Sections: A <path> (+ lines), D <path>, or U <path> (optional M <new path>).',
+  'Optional first line R <root>. Update hunks start @ or @ <symbol>; lines start space, -, or +; optional *** End of File.',
+  'Use 3 verbatim context lines. Project-relative paths; absolute only outside the project.',
 ].join('\n');
 
 export const PATCH_TOOL_DEFS = [
@@ -53,21 +86,18 @@ export const PATCH_TOOL_DEFS = [
     name: 'apply_patch',
     title: 'Mixdog Apply Patch',
     annotations: { title: 'Mixdog Apply Patch', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: APPLY_PATCH_JSON_DESCRIPTION,
-    freeformDescription: APPLY_PATCH_FREEFORM_DESCRIPTION,
+    description: USE_COMPACT_PATCH_FORMAT ? COMPACT_PATCH_JSON_DESCRIPTION : APPLY_PATCH_JSON_DESCRIPTION,
+    freeformDescription: USE_COMPACT_PATCH_FORMAT ? COMPACT_PATCH_FREEFORM_DESCRIPTION : APPLY_PATCH_FREEFORM_DESCRIPTION,
     freeform: {
       type: 'grammar',
       syntax: 'lark',
-      definition: APPLY_PATCH_LARK_GRAMMAR,
+      definition: USE_COMPACT_PATCH_FORMAT ? COMPACT_PATCH_LARK_GRAMMAR : APPLY_PATCH_LARK_GRAMMAR,
     },
     inputSchema: {
       type: 'object',
       properties: {
-        patch: { type: 'string', description: 'V4A patch; format above.' },
-        root: {
-          type: 'string',
-          description: 'Write root only outside the session directory.',
-        },
+        patch: { type: 'string', description: USE_COMPACT_PATCH_FORMAT ? 'Compact patch.' : 'V4A patch.' },
+        root: { type: 'string', description: 'Explicit patch base directory.' },
       },
       required: ['patch'],
       additionalProperties: false,

package/src/session-runtime/context-status.mjs

@@ -11,6 +11,7 @@ import {
 import { SUMMARY_PREFIX } from '../runtime/agent/orchestrator/session/compact.mjs';
 import { hasUserConversationMessage } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import {
+  resolveCurrentContextTokens,
   resolveCompactionPressureTokens,
   resolveWorkerCompactPolicy,
 } from '../runtime/agent/orchestrator/session/loop/compact-policy.mjs';
@@ -268,15 +269,18 @@ export function createContextStatus({
         ...resolveSessionCompactPolicy(session || {}, compactBoundaryTokens),
         tokenCalibration: providerTokenCalibration(session?.provider || route.provider),
       };
-    // Match the pre-provider-send auto-compact check exactly: the gauge uses
-    // the same provider-baseline-or-estimate pressure, including request and
-    // configured reserves, rather than a separate transcript-only estimate.
+    // Keep the user-facing gauge aligned to provider-visible context. The
+    // compaction branch retains its stricter pressure numerator separately.
     const compactionPressureTokens = resolveCompactionPressureTokens(
       messageSummary.estimatedTokens,
       compactPolicy,
       { messages, sessionRef: session },
     );
-    const usedTokens = compactionPressureTokens;
+    const usedTokens = resolveCurrentContextTokens(
+      messageSummary.estimatedTokens,
+      compactPolicy,
+      { messages, sessionRef: session },
+    );
     const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
     const compactTriggerTokens = compactPolicy.triggerTokens || 0;
     const compactBufferTokens = Number.isFinite(Number(compactPolicy.bufferTokens))
@@ -297,7 +301,7 @@ export function createContextStatus({
       effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
       usedTokens,
       usedSource: 'estimated',
-      currentEstimatedTokens: compactionPressureTokens,
+      currentEstimatedTokens: usedTokens,
       lastApiRequestTokens: lastContextTokens || 0,
       lastApiRequestStale: lastUsageStale,
       freeTokens,
@@ -308,6 +312,8 @@ export function createContextStatus({
         bufferTokens: Number.isFinite(compactBufferTokens) ? compactBufferTokens : null,
         bufferRatio: compactBufferRatio,
         currentEstimatedTokens: compactionPressureTokens,
+        pressureTokens: compactionPressureTokens,
+        reserveTokens: Math.max(0, Number(compactPolicy.configuredReserveTokens) || 0),
         lastApiRequestTokens: lastContextTokens || 0,
         lastApiRequestStale: lastUsageStale,
       },

package/src/standalone/explore-tool.mjs

@@ -24,10 +24,9 @@ export const EXPLORE_TOOL = {
     type: 'object',
     properties: {
         query: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'One concrete unknown target per query; return its minimal complete direct path:line set. Never a topic list; array = independent targets fanned out.' },
-      cwd: { type: 'string', description: 'Project/root directory.' },
       roots: {
         anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }],
-        description: 'Search root(s); defaults to cwd. Use multiple roots for cross-project or machine lookup.',
+        description: 'Project-relative or absolute external search root(s); omit for the caller project; use multiple roots for cross-project or machine lookup.',
       },
     },
     required: [],

package/src/tui/app/usage-context-panels.mjs

@@ -157,6 +157,8 @@ export function createUsageContextPanels({
     const compactDescription = compactDuration
       ? `${compactState} · ${compactDuration}`
       : compactState;
+    const compactPressure = Number(compaction.pressureTokens || compaction.currentEstimatedTokens || 0);
+    const compactReserve = Number(compaction.reserveTokens || 0);
     const contextRows = [
       {
         value: 'summary',
@@ -167,7 +169,7 @@ export function createUsageContextPanels({
       {
         value: 'compaction',
         label: 'Compaction',
-        description: compactDescription,
+        description: `${compactDescription} · ${fmt(compactPressure)} pressure · ${fmt(compactReserve)} reserve`,
         _action: 'compaction',
       },
       {
@@ -249,7 +251,8 @@ export function createUsageContextPanels({
             if (compactBoundary && compactTrigger) return Math.max(0, compactBoundary - compactTrigger);
             return null;
           })(),
-          pressureTokens: Number(compaction.lastPressureTokens || compaction.currentEstimatedTokens || 0) || null,
+          pressureTokens: Number(compaction.lastPressureTokens || compaction.pressureTokens || compaction.currentEstimatedTokens || 0) || null,
+          reserveTokens: Number(compaction.reserveTokens || 0) || null,
           lastChanged: compaction.lastChanged === true,
         },
         messages: {

package/src/tui/components/ContextPanel.jsx

@@ -176,6 +176,8 @@ function ContextUsageView({ detail, columns }) {
     compaction.type ? `type ${compaction.type}` : '',
     compaction.triggerTokens ? `trigger ${formatTokens(compaction.triggerTokens)}` : '',
     compaction.boundaryTokens ? `boundary ${formatTokens(compaction.boundaryTokens)}` : '',
+    compaction.pressureTokens ? `pressure ${formatTokens(compaction.pressureTokens)}` : '',
+    compaction.reserveTokens ? `reserve ${formatTokens(compaction.reserveTokens)}` : '',
   ]);
   const sourceLine = metricValue([
     usage.effective ? `effective ${formatTokens(windowTokens)}` : `window ${formatTokens(windowTokens)}`,

package/src/tui/dist/index.mjs

@@ -7626,7 +7626,9 @@ function ContextUsageView({ detail, columns }) {
     compaction.state,
     compaction.type ? `type ${compaction.type}` : "",
     compaction.triggerTokens ? `trigger ${formatTokens(compaction.triggerTokens)}` : "",
-    compaction.boundaryTokens ? `boundary ${formatTokens(compaction.boundaryTokens)}` : ""
+    compaction.boundaryTokens ? `boundary ${formatTokens(compaction.boundaryTokens)}` : "",
+    compaction.pressureTokens ? `pressure ${formatTokens(compaction.pressureTokens)}` : "",
+    compaction.reserveTokens ? `reserve ${formatTokens(compaction.reserveTokens)}` : ""
   ]);
   const sourceLine = metricValue([
     usage.effective ? `effective ${formatTokens(windowTokens)}` : `window ${formatTokens(windowTokens)}`,
@@ -13797,6 +13799,8 @@ function createUsageContextPanels({
     const compactReactive = String(compaction.lastTrigger || "").toLowerCase() === "reactive";
     const compactState = compactRunning ? "Compacting conversation" : compactInterrupted ? "Compact interrupted" : autoClearFailed ? `auto-clear skipped${compaction.lastClearCompactError ? `: ${compaction.lastClearCompactError}` : ""}` : autoClearStage ? "Auto-clear complete" : compaction.lastChanged ? compactReactive ? "Compact complete (overflow recovery)" : "Compact complete" : "Compact checked";
     const compactDescription = compactDuration ? `${compactState} \xB7 ${compactDuration}` : compactState;
+    const compactPressure = Number(compaction.pressureTokens || compaction.currentEstimatedTokens || 0);
+    const compactReserve = Number(compaction.reserveTokens || 0);
     const contextRows = [
       {
         value: "summary",
@@ -13807,7 +13811,7 @@ function createUsageContextPanels({
       {
         value: "compaction",
         label: "Compaction",
-        description: compactDescription,
+        description: `${compactDescription} \xB7 ${fmt(compactPressure)} pressure \xB7 ${fmt(compactReserve)} reserve`,
         _action: "compaction"
       },
       {
@@ -13889,7 +13893,8 @@ function createUsageContextPanels({
             if (compactBoundary && compactTrigger) return Math.max(0, compactBoundary - compactTrigger);
             return null;
           })(),
-          pressureTokens: Number(compaction.lastPressureTokens || compaction.currentEstimatedTokens || 0) || null,
+          pressureTokens: Number(compaction.lastPressureTokens || compaction.pressureTokens || compaction.currentEstimatedTokens || 0) || null,
+          reserveTokens: Number(compaction.reserveTokens || 0) || null,
           lastChanged: compaction.lastChanged === true
         },
         messages: {