mixdog 0.9.38 → 0.9.39

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

@@ -1,5 +1,6 @@
 import { createHash } from 'crypto';
 import { countJsonNextCalls } from './tools/next-call-utils.mjs';
+import { splitGrepLinePrefix } from './tools/builtin/grep-formatting.mjs';
 import {
     appendAgentTrace,
     normalizeSessionId,
@@ -108,7 +109,7 @@ const TOOL_ARG_KEYS = {
     recall: ['query', 'limit', 'session_id', 'cwd'],
     search: ['query', 'limit', 'cwd'],
     explore: ['query', 'queries', 'limit', 'cwd'],
-    code_graph: ['mode', 'file', 'symbol', 'symbols', 'body', 'language', 'limit', 'depth', 'page', 'cwd'],
+    code_graph: ['mode', 'file', 'files', 'symbol', 'symbols', 'body', 'language', 'limit', 'depth', 'page', 'cwd'],
     shell: ['command', 'cwd', 'timeout', 'mode', 'run_in_background', 'persistent', 'session_id'],
     task: ['task_id', 'action', 'timeout_ms', 'poll_ms'],
     edit: ['path', 'replace_all', 'edits'],
@@ -211,6 +212,38 @@ function _redactLogText(text) {
     return out;
 }
 
+const GREP_COVERAGE_MAX = 512;
+export function parseGrepCoverage(resultText, toolName, toolArgs, resultKind) {
+    if (toolName !== 'grep' || resultKind === 'error' || (toolArgs?.output_mode && toolArgs.output_mode !== 'content_with_context')) return null;
+    const out = [];
+    const seen = new Set();
+    let sectionPath = null;
+    for (const line of String(resultText ?? '').split(/\r?\n/)) {
+        const section = line.match(/^# grep (.+)$/);
+        if (section) {
+            if (!section[1].startsWith('pattern:')) sectionPath = section[1];
+            continue;
+        }
+        const split = splitGrepLinePrefix(line);
+        const omitted = !split && typeof toolArgs?.path === 'string'
+            ? String(line).match(/^(\d+)(?::|-)/)
+            : null;
+        const sectionOmitted = !split && sectionPath
+            ? String(line).match(/^(\d+)(?::|-)/)
+            : null;
+        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 });
+        if (out.length >= GREP_COVERAGE_MAX) break;
+    }
+    return out.length ? out : null;
+}
+
 function classifyToolFailure(resultText, toolName) {
     const text = String(resultText ?? '').toLowerCase();
     if (/\[shell-tool-failed\]/i.test(String(resultText ?? ''))) return 'tool-call/failure';
@@ -264,6 +297,7 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
     const resultLinesEst = typeof resultText === 'string' && resultText.length > 0 ? resultText.split('\n').length : 0;
     const numericToolMs = Number(toolMs);
     const summarizedArgs = summarizeToolArgs(toolName, toolArgs);
+    const grepCoverage = parseGrepCoverage(resultText, toolName, toolArgs, resultKind);
     // Hash the FULL args, not the summary: summaries drop payload fields
     // (e.g. apply_patch keeps only base_path), which made every patch in a
     // session collide to one hash and broke duplicate/retry detection.
@@ -297,6 +331,8 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
         result_next_call_count: nextCallCount,
         result_bytes_est: resultBytesEst,
         result_lines_est: resultLinesEst,
+        grep_coverage: grepCoverage,
+        cwd: cwd || null,
     });
     if (
         Number.isFinite(numericToolMs)

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

@@ -26,6 +26,7 @@ let _localTracePath = null;
 let _localTraceBuffer = [];
 let _localTraceTimer = null;
 let _localTraceFlushInFlight = false;
+let _localTraceFlushPromise = null;
 let _toolFailurePath = null;
 let _toolFailureBuffer = [];
 let _toolFailureTimer = null;
@@ -132,12 +133,10 @@ function _flushLocalTrace() {
         clearTimeout(_localTraceTimer);
         _localTraceTimer = null;
     }
-    if (_localTraceBuffer.length === 0) return;
     if (_localTraceFlushInFlight) {
-        _localTraceTimer = setTimeout(_flushLocalTrace, 25);
-        _localTraceTimer.unref?.();
-        return;
+        return _localTraceFlushPromise;
     }
+    if (_localTraceBuffer.length === 0) return null;
     const path = _resolveLocalTracePath();
     if (!path) return;
     const chunk = _localTraceBuffer.join('');
@@ -157,17 +156,20 @@ function _flushLocalTrace() {
     // mode only applies on file creation; existing files keep their mode.
     // Windows ignores POSIX bits — ACL governs there.
     _localTraceFlushInFlight = true;
-    appendFile(path, chunk, { encoding: 'utf8', mode: 0o600 })
+    const pending = appendFile(path, chunk, { encoding: 'utf8', mode: 0o600 })
         .catch((err) => {
             warnAgentOnce('agent-trace:local-spool', `[agent-trace] local spool failed (${err?.message})`);
         })
         .finally(() => {
             _localTraceFlushInFlight = false;
+            _localTraceFlushPromise = null;
             if (_localTraceBuffer.length > 0) {
                 _localTraceTimer = setTimeout(_flushLocalTrace, 0);
                 _localTraceTimer.unref?.();
             }
         });
+    _localTraceFlushPromise = pending;
+    return pending;
 }
 
 function _flushLocalTraceSync() {
@@ -294,7 +296,20 @@ function _scheduleFlush(immediate = false) {
     }
 }
 
+async function _drainLocalTrace() {
+    if (!_resolveLocalTracePath()) return;
+    if (_localTraceTimer) {
+        clearTimeout(_localTraceTimer);
+        _localTraceTimer = null;
+    }
+    while (_localTraceBuffer.length > 0 || _localTraceFlushInFlight) {
+        const pending = _flushLocalTrace();
+        if (pending) await pending;
+    }
+}
+
 async function drainAgentTrace() {
+    await _drainLocalTrace();
     if (!_resolveServiceUrl()) return;
     if (_flushTimer) { clearTimeout(_flushTimer); _flushTimer = null; }
     for (let i = 0; i < 10 && _buffer.length > 0; i++) {

package/src/runtime/agent/orchestrator/providers/codex-client-meta.mjs

@@ -16,7 +16,10 @@
 import os from 'node:os';
 
 // Offline fallback only; live value refreshes from npm (24h TTL, in-process).
-export const CODEX_CLIENT_VERSION_FLOOR = '0.142.5';
+// The backend gates model exposure AND per-request model access on the client
+// version (gpt-5.6-* require >= 0.144.0 per codex models-manager/models.json,
+// verified 2026-07-09), so keep this at the current release when bumping.
+export const CODEX_CLIENT_VERSION_FLOOR = '0.144.1';
 const VERSION_TTL_MS = 24 * 60 * 60_000;
 let _cache = { value: null, fetchedAt: 0 };
 let _refreshInFlight = null;
@@ -52,6 +55,23 @@ export function codexClientVersionSync() {
     return _cache.value || CODEX_CLIENT_VERSION_FLOOR;
 }
 
+/**
+ * Awaitable warmup for cold-start paths: resolves the live npm version (or
+ * floor on failure) and fills the shared cache so codexClientVersionSync()
+ * and codexVersionHeader() stop reporting the floor. Never rejects; dedupes
+ * with the in-flight background refresh. First turns await this so the
+ * backend's minimal_client_version gate never sees a stale floor.
+ */
+export function warmCodexClientVersion() {
+    if (_cache.value && Date.now() - _cache.fetchedAt < VERSION_TTL_MS) {
+        return Promise.resolve(_cache.value);
+    }
+    if (!_refreshInFlight) {
+        _refreshInFlight = _refresh().finally(() => { _refreshInFlight = null; });
+    }
+    return _refreshInFlight;
+}
+
 function _osType() {
     // codex os_info reports "Windows"/"Mac OS"/"Linux"; node os.type() gives
     // Windows_NT/Darwin/Linux. Map to codex's vocabulary.

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

@@ -59,6 +59,7 @@ import {
     _shouldUseOpenAIHttpFallback,
 } from './openai-oauth-http-sse.mjs';
 import { createOpenAIOAuthLogin } from './openai-oauth-login.mjs';
+import { warmCodexClientVersion } from './codex-client-meta.mjs';
 import {
     _displayCodexModel,
     _codexFamily,
@@ -77,42 +78,13 @@ const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 export const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const TOKEN_URL = 'https://auth.openai.com/oauth/token';
 export const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
-// Version string baked into the models endpoint query — the OAuth backend
-// rejects the request without it, and gates new model exposures (e.g.
-// gpt-5.5 only on >= 0.130.0) on this client_version header; older versions
-// trigger a visibility-filtered catalog (e.g. only rollout models). Resolved
-// dynamically from npm so newly-shipped models surface within a day instead
-// of waiting on a hardcoded bump here. Cached 24h in-process; npm failure
-// falls back to the floor below.
-// Offline fallback only — _resolveCodexClientVersion() fetches the live
-// @openai/codex latest from npm first. Bumped to the current release
-// (0.142.5, verified 2026-07-03) so the offline path stays close to what the
-// backend expects for client-version gating.
-const CODEX_CLIENT_VERSION_FLOOR = '0.142.5';
-const CODEX_VERSION_CACHE_TTL_MS = 24 * 60 * 60_000;
-let _codexVersionCache = { value: null, fetchedAt: 0 };
-
-async function _resolveCodexClientVersion() {
-    const now = Date.now();
-    if (_codexVersionCache.value && now - _codexVersionCache.fetchedAt < CODEX_VERSION_CACHE_TTL_MS) {
-        return _codexVersionCache.value;
-    }
-    try {
-        const res = await fetch('https://registry.npmjs.org/@openai/codex/latest', {
-            signal: AbortSignal.timeout(5_000),
-        });
-        if (res.ok) {
-            const j = await res.json();
-            const v = String(j?.version || '').trim();
-            if (/^\d+\.\d+\.\d+/.test(v)) {
-                _codexVersionCache = { value: v, fetchedAt: now };
-                return v;
-            }
-        }
-    } catch { /* network down / npm rejects — use floor */ }
-    _codexVersionCache = { value: CODEX_CLIENT_VERSION_FLOOR, fetchedAt: now };
-    return CODEX_CLIENT_VERSION_FLOOR;
-}
+// Client version for the models endpoint query and the `version`/User-Agent
+// request headers — the OAuth backend rejects requests without it, gates new
+// model exposures on it (gpt-5.6-* require >= 0.144.0), and rejects turns on
+// gated models when the reported version is below the model's
+// minimal_client_version. Resolution is unified in codex-client-meta.mjs
+// (live npm @openai/codex latest, 24h in-process cache, offline floor) so the
+// catalog query and the transport headers can never disagree.
 const CODEX_MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
 const CODEX_MODEL_CACHE_SCHEMA_VERSION = 3;
 const TOKEN_REFRESH_SKEW_MS = 5 * 60_000;
@@ -784,7 +756,14 @@ export class OpenAIOAuthProvider {
             ? Promise.resolve(opts._prebuiltBody)
             : Promise.resolve().then(() => buildRequestBody(messages, useModel, tools, bodyOpts));
         const _authP = this.ensureAuth();
+        // Cold-start guard: the WS/SSE transports read the client version via
+        // the SYNC accessor for the `version` header + User-Agent. Await the
+        // shared resolver (parallel with auth; never rejects; no-op once
+        // cached) so the first turn after boot doesn't report the offline
+        // floor and trip the backend's minimal_client_version gate.
+        const _verP = warmCodexClientVersion();
         let auth = await _authP;
+        await _verP;
         const body = await _bodyP;
         // poolKey != cacheKey by design (see openai-oauth-ws.mjs header note).
         // poolKey is per-session so parallel reviewer/worker callers each get
@@ -1038,7 +1017,7 @@ export class OpenAIOAuthProvider {
         }
         try {
             const auth = await this.ensureAuth();
-            const clientVersion = await _resolveCodexClientVersion();
+            const clientVersion = await warmCodexClientVersion();
             const url = `https://chatgpt.com/backend-api/codex/models?client_version=${clientVersion}`;
             const res = await fetch(url, {
                 signal: AbortSignal.timeout(10_000),
@@ -1076,7 +1055,7 @@ export class OpenAIOAuthProvider {
         _codexRefreshInFlight = (async () => {
             try {
                 const auth = await this.ensureAuth();
-                const clientVersion = await _resolveCodexClientVersion();
+                const clientVersion = await warmCodexClientVersion();
                 const url = `https://chatgpt.com/backend-api/codex/models?client_version=${clientVersion}`;
                 const res = await fetch(url, {
                     signal: AbortSignal.timeout(10_000),

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

@@ -305,11 +305,18 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // cut off early. Other runaway protection is behavior-based (steering
     // ladder hints, REPEAT_FAIL_LIMIT), never a lower iteration count.
     let _iterWarnStage = 0;
-    const _iterWarnAt = [
-        Math.floor(maxLoopIterations * 0.5),
-        Math.floor(maxLoopIterations * 0.75),
-        Math.floor(maxLoopIterations * 0.9),
-    ];
+    // Tiny-cap loops (e.g. explorer cap=3) can't afford staged 50/75/90%
+    // steers — the 50% stage lands on iteration 1 in every session, spamming
+    // the normal batch→answer path. For caps < 10 emit ONE wrap-up warning at
+    // the penultimate iteration instead; caps >= 10 keep staged behavior.
+    const _singleWarn = maxLoopIterations < 10;
+    const _iterWarnAt = _singleWarn
+        ? [Math.max(1, maxLoopIterations - 1)]
+        : [
+            Math.floor(maxLoopIterations * 0.5),
+            Math.floor(maxLoopIterations * 0.75),
+            Math.floor(maxLoopIterations * 0.9),
+        ];
     while (true) {
         throwIfAborted();
         if (iterations >= maxLoopIterations) {
@@ -341,9 +348,11 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         if (_iterWarnStage < _iterWarnAt.length && iterations >= _iterWarnAt[_iterWarnStage]) {
             _iterWarnStage += 1;
             const warnAt = _iterWarnAt[_iterWarnStage - 1];
-            const stageMsg = _iterWarnStage === 1
-                ? `Iteration budget notice: ${warnAt} of ${maxLoopIterations} iterations used. Converge on a conclusion: prefer finishing the current objective over opening new exploration.`
-                : `Iteration budget warning (stage ${_iterWarnStage}): ${warnAt} of ${maxLoopIterations} iterations used — the loop hard-stops at ${maxLoopIterations}. Wrap up now: summarize progress, state what remains, and finish with your best current result.`;
+            const stageMsg = _singleWarn
+                ? `Iteration budget nearly spent: ${warnAt} of ${maxLoopIterations} iterations used — answer NOW with the best anchors you already hold.`
+                : _iterWarnStage === 1
+                    ? `Iteration budget notice: ${warnAt} of ${maxLoopIterations} iterations used. Converge on a conclusion: prefer finishing the current objective over opening new exploration.`
+                    : `Iteration budget warning (stage ${_iterWarnStage}): ${warnAt} of ${maxLoopIterations} iterations used — the loop hard-stops at ${maxLoopIterations}. Wrap up now: summarize progress, state what remains, and finish with your best current result.`;
             messages.push({ role: 'user', content: `<system-reminder>\n${stageMsg}\n</system-reminder>`, meta: 'hook' });
             process.stderr.write(`[loop] iteration warning stage ${_iterWarnStage} at ${iterations} (sess=${sessionId || 'unknown'}); continuing with steer.\n`);
             try {