mixdog 0.9.93 → 0.9.94

package/package.json

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

package/src/rules/agent/30-explorer.md

@@ -9,22 +9,28 @@ kind: retrieval
 Return only WHERE (`path:line`), never WHY. You ARE `explore`; never call it.
 Use only grep/find/glob/code_graph; `read` and `list` are forbidden.
 
-Turn 1 (`turn 1/3`) is the whole search. Split broad/uncertain input into every
-known facet and send one batch under the shared one-route contract. Use
-`pattern[]` with 4–8 code-token variants for concept facets, `code_graph`
-`symbol_search` for symbol facets, and `find` `query[]` for unknown/broad
-targets or unverified path/name fragments. For a symptom/behavior query, add
-the upstream producer/derivation layer of the reported surface as extra facets
-in the SAME batch (more `pattern[]` variants or `code_graph` `symbol_search`),
-never as a later turn. Follow-up turns batch every unresolved facet in
-parallel; a single-tool turn is allowed only when exactly one
-pre-anchor/zero-hit facet remains.
-
-For broad grep use `output_mode:"files_with_matches"`. Use
-`content_with_context` with `head_limit` only on paths returned this session.
-Each pattern is one identifier, camel/snake variant, or concept synonym; never
-a prose phrase. Spaces and non-ASCII are allowed only in verbatim quoted
-error/log literals. Translate other non-English queries to English identifiers.
+Turn 1 (`turn 1/3`) is the whole search and should already mint anchors. Split
+broad/uncertain input into every known facet and send one batch under the
+shared one-route contract. Route each facet to the cheapest anchor source:
+`code_graph` `symbol_search` whenever the facet names a plausible
+symbol/identifier; grep `content_with_context` with `pattern[]` of 4–8
+code-token variants for concept facets — its hits carry `path:line`, cite them
+directly instead of re-mining; `find` `query[]` ONLY when the target is itself
+a file/dir name or an unverified path fragment, never as a default extra
+facet. For a symptom/behavior query, add the upstream producer/derivation
+layer of the reported surface as extra facets in the SAME batch, never as a
+later turn. Follow-up turns batch every unresolved facet in parallel; a
+single-tool turn is allowed only when exactly one pre-anchor/zero-hit facet
+remains.
+
+Grep defaults to `output_mode:"content_with_context"` with `context:0`
+(matches only — the match line already carries its citable `path:line`) and a
+tight `head_limit` (≤20); never request surrounding context lines. Use
+`files_with_matches` only as a cheap existence probe when a facet must be
+scoped before searching. Each pattern is one identifier, camel/snake variant,
+or concept synonym; never a prose phrase. Spaces and non-ASCII are allowed
+only in verbatim quoted error/log literals. Translate other non-English
+queries to English identifiers.
 
 Scope is session cwd; `path` may be omitted. For unverified `src` paths, use
 `find` first; never guess or invent directories or pair `path:"."` with guessed

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

@@ -1,28 +1,33 @@
 # Tool Use
 
 - Before the first call, gather every known facet — environment, capability,
-  artifact, and failure checks — in one bounded tool message. Use one shortest
-  route per facet: broad/uncertain→`explore` (roles without it: `find`);
-  partial path/name→`find`; verified root+wildcard→`glob`;
-  quoted/non-identifier literal or regex→`grep`; exact code
-  identifier/relation→`code_graph` before grep; known file/span→`read`
-  directly without `grep`; verified directory→`list`; known
-  edit→`apply_patch`; program/state change→`shell`; web/current external
-  info→`search`.
-- Shortest total calls, maximum batching — every turn: every determined call
-  in one concurrent message (mix `shell` in), merged per tool — one `shell`
-  chain, one `read`, one `apply_patch` carrying full verification in
-  `post_shell`; a later turn only for steps needing unseen output.
+  artifact, failure checks — in one bounded tool message, one shortest route
+  per facet: broad/uncertain→`explore` (roles without it: `find`); known
+  name fragment→`find`; verified root+wildcard→`glob`; text/code→`grep`;
+  symbol body/relation→`code_graph`; known file/span→`read`, not `grep`;
+  verified directory→`list`; known edit→`apply_patch`; program/state
+  change→`shell`; web/current info→`search`.
+- A turn is a plan, not a step: emit every already-determined call in one
+  concurrent message, merged per tool — one `shell` chain (`&&`/`;`), one
+  `read`, one `apply_patch` with verification in `post_shell`. In-message
+  order is guaranteed — edits land before the shell that checks them — so
+  produce and its check always ride one message, never a follow-up turn.
+  Distinct facets only — never two routes per facet. The archetype is two
+  turns — one message observes through the dedicated tools (`shell` beside
+  them, not instead of them), one chain produces and proves itself; a new
+  turn exists only at a true data dependency.
 - Verified paths: project root, session cwd, user-provided, tool-returned.
   `find` first for guessed path/name fragments; on ENOENT, find the basename.
   Retry `EXPLORATION_FAILED` once with changed tokens.
 - Stop when evidence covers the deliverable: a returned `path:line` or
-  nonzero `content_with_context` result is final — act on it (inspecting it
-  via read/code_graph is valid); only zero/error results justify changed
-  tokens or scope. Don't re-locate, re-verify, or reread returned spans.
-- Verify changes in proportion to risk with one decisive batched boundary
-  probe. A pass is final; on failure, fix and rerun only what failed. Keep
-  optional diagnostics non-fatal; report verified vs assumed.
+  nonzero `content_with_context` result is final for its returned range. Read
+  is allowed for new/uncovered lines; do not call read when grep/read already
+  fully covers the requested range. Only zero/error results justify new scope.
+- Verify in proportion to risk, appended to the producing chain (`shell`
+  tail or `post_shell`) — one decisive boundary probe covering its failure
+  modes. A pass is final — observed matching output IS the verification,
+  never re-checked in a later turn; on failure fix and rerun only what
+  failed. Optional diagnostics non-fatal; report verified vs assumed.
 - `apply_patch` is the primary edit tool: once target path and new content are
   known, include the patch in the current tool batch, hunk context verbatim
   from the newest tool output of that span (post-patch content after edits).

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -1,6 +1,6 @@
 import { createHash } from 'crypto';
 import { countJsonNextCalls } from './tools/next-call-utils.mjs';
-import { splitGrepLinePrefix } from './tools/builtin/grep-formatting.mjs';
+import { parseGrepContextHeader, splitGrepLinePrefix } from './tools/builtin/grep-formatting.mjs';
 import {
     appendAgentTrace,
     normalizeSessionId,
@@ -236,7 +236,27 @@ export function parseGrepCoverage(resultText, toolName, toolArgs, resultKind) {
     const out = [];
     const seen = new Set();
     let sectionPath = null;
+    let rawSourceLinesRemaining = 0;
+    const addLine = (path, lineNo) => {
+        if (!path || !Number.isInteger(lineNo) || lineNo < 1 || out.length >= GREP_COVERAGE_MAX) return;
+        const key = `${path}\0${lineNo}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        out.push({ path: String(path).replace(/\\/g, '/'), line: lineNo });
+    };
     for (const line of String(resultText ?? '').split(/\r?\n/)) {
+        if (rawSourceLinesRemaining > 0) {
+            rawSourceLinesRemaining--;
+            continue;
+        }
+        const header = parseGrepContextHeader(line);
+        if (header) {
+            for (let lineNo = header.startLine; lineNo <= header.endLine && out.length < GREP_COVERAGE_MAX; lineNo++) {
+                addLine(header.path, lineNo);
+            }
+            rawSourceLinesRemaining = header.sourceLineCount;
+            continue;
+        }
         const section = line.match(/^# grep (.+)$/);
         if (section) {
             if (!section[1].startsWith('pattern:')) sectionPath = section[1];
@@ -252,11 +272,7 @@ export function parseGrepCoverage(resultText, toolName, toolArgs, resultKind) {
         const path = split?.path || (omitted ? toolArgs.path : null) || (sectionOmitted ? sectionPath : null);
         const lineNo = split?.lineNo || (omitted ? Number(omitted[1]) : null)
             || (sectionOmitted ? Number(sectionOmitted[1]) : null);
-        if (!path || !Number.isInteger(lineNo) || lineNo < 1) continue;
-        const key = `${path}\0${lineNo}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        out.push({ path: String(path).replace(/\\/g, '/'), line: lineNo });
+        addLine(path, lineNo);
         if (out.length >= GREP_COVERAGE_MAX) break;
     }
     return out.length ? out : null;

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -374,6 +374,11 @@ function sanitizeMcpInstructionText(text, max = MCP_INSTRUCTION_MAX_CHARS) {
 /**
  * Per-server MCP initialize instructions for deferred-pool tools only.
  * Empty when no instructions or no matching deferred MCP tools → omit block.
+ * Emits ONLY the server heading + instruction body: the per-server tool names
+ * are deliberately NOT repeated here — every pool tool is already listed once
+ * (with its description) in <available-deferred-tools>, and re-listing ~30
+ * names per server doubled the MCP share of the BP1 prefix (2026-08-05 audit).
+ * Server membership stays evident from the mcp__<server>__ name prefix.
  */
 function buildMcpInstructionsManifest(mcpServerInstructions, poolNames) {
     const map = mcpServerInstructions && typeof mcpServerInstructions === 'object'
@@ -400,8 +405,7 @@ function buildMcpInstructionsManifest(mcpServerInstructions, poolNames) {
     for (const server of servers) {
         const safeServer = sanitizeMcpManifestServerName(server);
         const body = sanitizeMcpInstructionText(map[server]);
-        const tools = [...toolsByServer.get(server)].sort((a, b) => a.localeCompare(b));
-        lines.push(`## ${safeServer}`, body, ...tools.map((tool) => `- ${tool}`));
+        lines.push(`## ${safeServer}`, body);
     }
     lines.push('</mcp-instructions>');
     return lines.join('\n');

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -18,6 +18,10 @@ const FETCH_TIMEOUT_MS = 4500;
 const WARN_TTL_MS = 5 * 60_000;
 const CODEX_RESET_CREDITS_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
 const CODEX_RESET_CONSUME_URL = `${CODEX_RESET_CREDITS_URL}/consume`;
+// Redeeming a reset credit is an explicit user action, not a poll: it gets the
+// generous budget the orca client uses (REDEEM_BACKEND_TIMEOUT_MS) so a slow
+// backend cannot abort a request the server is already applying.
+const CODEX_REDEEM_TIMEOUT_MS = 30_000;
 
 const memoryCache = new Map();
 const inflight = new Map();
@@ -99,6 +103,38 @@ try {
   // Embedded runtimes may not expose process lifecycle hooks.
 }
 
+/** Drops every cached usage snapshot of one provider (memory, queued disk
+ *  writes and the persisted routes). A mutation that changes quota state
+ *  server-side — redeeming a Codex reset credit — must not keep serving the
+ *  pre-mutation meters from a 60s/10min cache. */
+export function invalidateOAuthUsageSnapshots(provider) {
+  const providerOnly = String(provider || '').toLowerCase();
+  if (!providerOnly) return;
+  const routePrefix = `${providerOnly}\u0001`;
+  const owned = (key) => key === providerOnly || String(key).startsWith(routePrefix);
+  for (const key of [...memoryCache.keys()]) {
+    if (owned(key)) memoryCache.delete(key);
+  }
+  for (const key of [...pendingDiskSnapshots.keys()]) {
+    if (owned(key)) pendingDiskSnapshots.delete(key);
+  }
+  try {
+    updateJsonAtomicSync(cachePath(), (curRaw) => {
+      const cur = curRaw && typeof curRaw === 'object' ? curRaw : {};
+      const routes = cur.routes && typeof cur.routes === 'object' ? cur.routes : {};
+      return {
+        version: 1,
+        updatedAt: Date.now(),
+        routes: Object.fromEntries(
+          Object.entries(routes).filter(([key]) => !owned(key)),
+        ),
+      };
+    }, { compact: true, fsync: false, fsyncDir: false });
+  } catch {
+    // Usage display must never break the reset path.
+  }
+}
+
 function isContentfulSnapshot(snapshot) {
   return !!snapshot
     && typeof snapshot === 'object'
@@ -253,11 +289,15 @@ function normalizeOpenAICodexResetCredits(data, accountId = '') {
     .filter((value) => Number.isFinite(value) && value > 0);
   const nextExpiresAt = resetAtMs(data.next_expires_at ?? data.nextExpiresAt)
     || (expiryCandidates.length ? Math.min(...expiryCandidates) : null);
+  // Identity of the OFFER, not of one payload shape: the detail endpoint and
+  // the counts embedded in /wham/usage describe the same credits with
+  // different fields, so hashing the raw rows made the same offer produce two
+  // revisions — and the desktop scopes its durable idempotency key by
+  // revision. Count + soonest expiry is what a user is offered.
   const offerRevision = `v1:${createHash('sha256').update(JSON.stringify({
     accountId,
     availableCount,
     nextExpiresAt,
-    credits,
   })).digest('hex')}`;
   return {
     availableCount,
@@ -290,6 +330,32 @@ function codexResetOutcome(code) {
   throw new Error(`Unknown Codex reset outcome: ${cleanString(code) || 'missing'}`);
 }
 
+async function postOpenAICodexResetConsume(auth, idempotencyKey) {
+  return await fetch(CODEX_RESET_CONSUME_URL, {
+    ...fetchOptions({
+      ...codexHeaders(auth),
+      'Content-Type': 'application/json',
+    }, CODEX_REDEEM_TIMEOUT_MS),
+    method: 'POST',
+    body: JSON.stringify({ redeem_request_id: idempotencyKey }),
+  });
+}
+
+async function redeemOpenAICodexResetCredit(auth, idempotencyKey) {
+  // A transport failure (abort, dropped socket) leaves the outcome unknown
+  // while the credit may already be spent. redeem_request_id makes the request
+  // idempotent, so ONE replay turns that unknown into the server's real answer
+  // instead of reporting "could not be confirmed" over a consumed credit.
+  let response;
+  try {
+    response = await postOpenAICodexResetConsume(auth, idempotencyKey);
+  } catch {
+    response = await postOpenAICodexResetConsume(auth, idempotencyKey);
+  }
+  if (!response.ok) throw new Error(`Codex reset failed: HTTP ${response.status}`);
+  return codexResetOutcome((await response.json())?.code);
+}
+
 export async function consumeOpenAICodexResetCredit(providerObj, options = {}) {
   const expectedOfferRevision = cleanString(options?.expectedOfferRevision);
   const idempotencyKey = cleanString(options?.idempotencyKey);
@@ -301,20 +367,14 @@ export async function consumeOpenAICodexResetCredit(providerObj, options = {}) {
   }
   const auth = await resolveOpenAICodexAuth(providerObj);
   if (!auth) throw new Error('Codex is not signed in');
-  const current = await fetchOpenAICodexResetCreditsWithAuth(auth);
-  if (!current || current.availableCount < 1 || current.offerRevision !== expectedOfferRevision) {
-    return { status: 'offerChanged', resetCredits: current };
-  }
-  const response = await fetch(CODEX_RESET_CONSUME_URL, {
-    ...fetchOptions({
-      ...codexHeaders(auth),
-      'Content-Type': 'application/json',
-    }, 15_000),
-    method: 'POST',
-    body: JSON.stringify({ redeem_request_id: idempotencyKey }),
-  });
-  if (!response.ok) throw new Error(`Codex reset failed: HTTP ${response.status}`);
-  const outcome = codexResetOutcome((await response.json())?.code);
+  // The SERVER decides the outcome (orca parity): redeem_request_id makes the
+  // call idempotent and `already_redeemed`/`no_credit` are real answers. The
+  // old client-side offer gate ran before every attempt, so retrying an
+  // unconfirmed redeem — whose credit was already spent, hence a changed
+  // revision — could only ever report "offer changed" and never the truth.
+  const outcome = await redeemOpenAICodexResetCredit(auth, idempotencyKey);
+  // Quota meters just changed server-side; cached snapshots are now wrong.
+  invalidateOAuthUsageSnapshots('openai-oauth');
   const resetCredits = await fetchOpenAICodexResetCreditsWithAuth(auth).catch(() => null);
   return { outcome, resetCredits };
 }

package/src/runtime/agent/orchestrator/session/cache/scoped-cache.mjs

@@ -5,6 +5,7 @@
 import { join, resolve as _pathResolve, isAbsolute as _pathIsAbs, normalize as _pathNorm } from 'node:path';
 import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
 import { _normalizeCacheKey } from './util.mjs';
+import { GREP_AUTO_CONTEXT_LINES } from '../../tools/builtin/path-utils.mjs';
 
 const MAX_PER_SESSION = 100;
 
@@ -43,6 +44,22 @@ function _firstArg(args, names) {
     return undefined;
 }
 
+const _GREP_CONTEXT_GROUPS = [
+    ['-A', ['-A', 'A', 'after', 'after_context', 'afterContext', '--after-context', 'after-context', 'afterLines', 'after_lines']],
+    ['-B', ['-B', 'B', 'before', 'before_context', 'beforeContext', '--before-context', 'before-context', 'beforeLines', 'before_lines']],
+    ['context', ['context', '-C', 'C', 'context_lines', 'contextLines', '--context', 'contextN', 'around', 'surrounding']],
+];
+
+function _canonicalizeGrepContextArgs(args) {
+    for (const [canonical, aliases] of _GREP_CONTEXT_GROUPS) {
+        const value = _firstArg(args, aliases);
+        for (const alias of aliases) delete args[alias];
+        if (value === undefined) continue;
+        const numeric = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+        args[canonical] = Number.isFinite(numeric) && Number.isInteger(numeric) ? numeric : value;
+    }
+}
+
 function _canonicalToolArgs(toolName, args) {
     if (!args || typeof args !== 'object') return args;
     const next = { ...args };
@@ -59,12 +76,35 @@ function _canonicalToolArgs(toolName, args) {
             const alias = _firstArg(next, ['root', 'directory', 'dir']);
             if (alias !== undefined) next.path = alias;
         }
+        _canonicalizeGrepContextArgs(next);
         if ((next.output_mode === undefined || next.output_mode === null || next.output_mode === '') && typeof next.mode === 'string') {
             const mode = next.mode.trim();
-            if (['files_with_matches', 'content', 'count'].includes(mode)) next.output_mode = mode;
+            if (['files_with_matches', 'content', 'content_with_context', 'count'].includes(mode)) next.output_mode = mode;
         }
         for (const k of ['query', 'regex', 'regexp', 'needle', 'search', 'literal', 'file_pattern', 'filePattern', 'include', 'includes', 'files', 'root', 'directory', 'dir']) delete next[k];
-        if (next.output_mode && next.mode === next.output_mode) delete next.mode;
+        delete next.mode;
+
+        // Canonicalize by execution semantics, not caller spelling:
+        // omitted/content_with_context => content + automatic 25-line context;
+        // context:0 => bare content; context flags are ignored in count/files.
+        const requestedMode = typeof next.output_mode === 'string' ? next.output_mode.trim() : '';
+        if (requestedMode === 'files_with_matches' || requestedMode === 'count') {
+            next.output_mode = requestedMode;
+            delete next['-A'];
+            delete next['-B'];
+            delete next.context;
+        } else {
+            const hasExplicitContext = ['-A', '-B', 'context']
+                .some((key) => Object.prototype.hasOwnProperty.call(next, key));
+            next.output_mode = 'content';
+            if ((requestedMode === '' || requestedMode === 'content_with_context') && !hasExplicitContext) {
+                next.context = GREP_AUTO_CONTEXT_LINES;
+            }
+            if (next.context === 0 && !Object.prototype.hasOwnProperty.call(next, '-A')
+                && !Object.prototype.hasOwnProperty.call(next, '-B')) {
+                delete next.context;
+            }
+        }
     } else if (toolName === 'glob') {
         if (next.pattern === undefined || next.pattern === null || next.pattern === '') {
             const alias = _firstArg(next, ['glob', 'file_pattern', 'filePattern', 'name', 'include', 'includes', 'files']);