mixdog 0.9.8 → 0.9.10

package/package.json

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

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

@@ -6,29 +6,27 @@ kind: retrieval
 
 # Role: explorer
 
-You are a one-shot locator, not a researcher. You find WHERE, never WHY or
-HOW: no reading code to understand it, no explaining behaviour, no tracing
-logic across files. Coordinates are the entire deliverable.
+You are a one-shot locator, not a researcher. You find WHERE, never WHY —
+no understanding code, explaining behaviour, or tracing logic. Coordinates
+are the entire deliverable.
 
-Default shape: ONE tool turn, then the answer. Turn 1 is ONE maximal batch:
-a single `grep` carrying ALL literal strings/errors/identifier guesses
-(content mode, small `-C`), plus `code_graph`/`find`/`glob` in the same
-turn. Fire everything at once; never probe one tool at a time. Any second
-turn means turn 1 under-batched.
+Default shape: ONE maximal-batch turn, then the answer. Fire everything at
+once: a single `grep` whose pattern[] carries ALL literal strings/errors/
+identifier guesses — synonyms, casings, variants — plus `code_graph`/`find`/
+`glob` in the SAME turn when useful. Width is free, turns are not.
 
-Answer straight from search output: grep/code_graph hits already carry
-`path:line` — NEVER spend a turn on `read` just to confirm or polish an
-anchor you already have. Prefer user-visible strings and identifiers.
-`dist`/generated hits are leads, not answers: trace them back to source.
+Answer straight from search output: hits already carry `path:line` — never
+spend a turn on `read` to confirm or polish an anchor. `dist`/generated
+hits are leads, not answers: trace them to source.
 
-Budget: 5 tool turns; coordinates only, zero analysis. The FIRST
-credible `path:line` ends the search — answer in that same turn; do not
-verify, refine, or collect extras. A plausible anchor now beats a perfect
-anchor later: mark weak ones `?` instead of checking them. Turns 2-5 exist
-ONLY for a zero-anchor turn 1: derive new tokens from returned paths/names
-or widen scope (no repeated synonyms), batching ALL remaining candidates in
-one shot. Past turn 5 you are wasting the caller's time: answer with
-best-so-far anchors or `EXPLORATION_FAILED`.
+Budget: 5 turns of maximal batches. Credible `path:line` on screen means the
+search is OVER — answer in that turn; no verifying or collecting extras;
+mark weak anchors `?`. Turns 2-5 exist ONLY for a zero-anchor turn 1: derive
+new tokens from returned paths/names or widen scope, packing ALL candidates
+into the next batch. Concept queries: grep implementation vocabulary
+(file/dir names, symbol fragments, config keys). `EXPLORATION_FAILED` only
+after all 5 turns found zero anchors — giving up early is as wrong as
+over-searching; at turn 5 answer best-so-far.
 
 Answer format, nothing else:
 - up to 5 lines: `path:line — symbol/name — short reason` (append `?` if weak)

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

@@ -254,6 +254,15 @@ function _codexMetadataBase(entry, { poolKey, cacheKey, sendOpts } = {}) {
         turn_id: turnId,
         window_id: windowId,
         request_kind: requestKind,
+        // Richer codex turn-metadata fields (responses_metadata.rs:264-280:
+        // thread_source "user" per protocol.rs:2751-2765, sandbox label).
+        // A/B 2026-07-04 (rvA/rvB interleaved, 24 sessions/arm): no effect
+        // (it2 full 3 vs 2, miss 2 vs 3 — noise). Default OFF; keep the knob
+        // for future probes if the backend starts gating on payload richness.
+        ...(process.env.MIXDOG_OAI_TURN_METADATA_RICH === '1' ? {
+            thread_source: 'user',
+            sandbox: 'read-only',
+        } : {}),
         turn_started_at_unix_ms: startedAt,
     };
     const metadata = {

package/src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs

@@ -54,6 +54,52 @@ const MAX_POOLED_SOCKETS_PER_KEY = 8;
 //          closing, ephemeral }
 const _wsPool = new Map();
 
+// --- Cache-route probe state (2026-07-04 hunt) -----------------------------
+// CF cookie stickiness (codex chatgpt_cloudflare_cookies.rs:22-55 persists
+// __cf_bm/_cfuvid across HTTP clients; our WS handshakes never echo them, so
+// Cloudflare may re-shard every fresh socket). Jar is per-process, keyed by
+// auth account. Env knobs (A/B):
+//   MIXDOG_OAI_CF_COOKIES=1        capture Set-Cookie from the 101 upgrade and
+//                                  send Cookie on subsequent handshakes
+//   MIXDOG_OAI_SESSION_AFFINITY=1  send x-session-affinity: <cacheKey>
+//                                  (opencode request.ts:187, ws-pool.ts:66)
+//   MIXDOG_OAI_WS_URL_SESSION=0    drop the ?session_id= URL query (codex/pi/
+//                                  opencode all use the bare WS URL)
+const _cfCookieJar = new Map(); // accountKey -> { name -> value }
+const _CF_COOKIE_ALLOWLIST = new Set(['__cf_bm', '_cfuvid']);
+
+function _envOn(name) {
+    const v = String(process.env[name] || '').trim().toLowerCase();
+    return ['1', 'true', 'yes', 'on'].includes(v);
+}
+
+function _cfCookieAccountKey(auth) {
+    return String(auth?.account_id || auth?.apiKey || 'default');
+}
+
+function _cfCookieHeader(auth) {
+    if (!_envOn('MIXDOG_OAI_CF_COOKIES')) return null;
+    const jar = _cfCookieJar.get(_cfCookieAccountKey(auth));
+    if (!jar || !jar.size) return null;
+    return [...jar.entries()].map(([k, v]) => `${k}=${v}`).join('; ');
+}
+
+function _cfCookieCapture(auth, setCookieHeaders) {
+    if (!_envOn('MIXDOG_OAI_CF_COOKIES')) return;
+    const list = Array.isArray(setCookieHeaders) ? setCookieHeaders : (setCookieHeaders ? [setCookieHeaders] : []);
+    if (!list.length) return;
+    const key = _cfCookieAccountKey(auth);
+    let jar = _cfCookieJar.get(key);
+    if (!jar) { jar = new Map(); _cfCookieJar.set(key, jar); }
+    for (const raw of list) {
+        const pair = String(raw || '').split(';', 1)[0];
+        const eq = pair.indexOf('=');
+        if (eq <= 0) continue;
+        const name = pair.slice(0, eq).trim();
+        if (_CF_COOKIE_ALLOWLIST.has(name)) jar.set(name, pair.slice(eq + 1).trim());
+    }
+}
+
 function _getPoolArr(poolKey) {
     if (!poolKey) return null;
     let arr = _wsPool.get(poolKey);
@@ -200,6 +246,14 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey: _cach
         headers['x-client-request-id'] = randomBytes(16).toString('hex');
     }
     if (turnState) headers['x-codex-turn-state'] = turnState;
+    // Probe knobs (cache-route hunt 2026-07-04): see jar block at top of file.
+    if (isOpenAiOauth) {
+        const jar = _cfCookieHeader(auth);
+        if (jar) headers['Cookie'] = jar;
+        if (_envOn('MIXDOG_OAI_SESSION_AFFINITY') && (_cacheKey || sessionToken)) {
+            headers['x-session-affinity'] = String(_cacheKey || sessionToken);
+        }
+    }
     return headers;
 }
 
@@ -225,7 +279,17 @@ function _openSocket({ auth, sessionToken, turnState, externalSignal, cacheKey,
     if (process.env.MIXDOG_DEBUG_AGENT) {
         process.stderr.write(`[agent-trace] ws-open-start url=${baseUrl} tokenHash=${createHash('sha256').update(String(sessionToken)).digest('hex').slice(0, 8)} ts=${_wsOpenStart}\n`);
     }
-    const url = baseUrl + (sessionToken ? `?session_id=${encodeURIComponent(String(sessionToken))}` : '');
+    // Bare WS URL by default (codex/pi/opencode parity). Interleaved A/B
+    // (2026-07-04, ivA/ivB, 24 sessions each, alternating rounds to cancel
+    // server-time noise): dropping the ?session_id= query improved it1
+    // warmup-prefix hits 15/24 -> 22/24 and it2 full hits 11 -> 15 (miss
+    // 5 -> 4). The query string seeds CF/backend shard routing away from
+    // the header-affine cache node; session identity still rides on the
+    // session_id/session-id handshake headers. Re-enable the legacy query
+    // form with MIXDOG_OAI_WS_URL_SESSION=1.
+    const url = baseUrl + (sessionToken && process.env.MIXDOG_OAI_WS_URL_SESSION === '1'
+        ? `?session_id=${encodeURIComponent(String(sessionToken))}`
+        : '');
     return new Promise((resolve, reject) => {
         let settled = false;
         let abortListener = null;
@@ -260,6 +324,7 @@ function _openSocket({ auth, sessionToken, turnState, externalSignal, cacheKey,
             try {
                 const ts = res?.headers?.['x-codex-turn-state'];
                 if (typeof ts === 'string' && ts.length) capturedHeaders.turnState = ts;
+                _cfCookieCapture(auth, res?.headers?.['set-cookie']);
                 // Probe: dump the full 101-upgrade response header set so we can
                 // see what the server actually issues (turn-state investigation).
                 if (process.env.MIXDOG_WS_UPGRADE_HEADER_PROBE) {

package/src/standalone/explore-tool.mjs

@@ -15,7 +15,7 @@ export const EXPLORE_TOOL = {
   name: 'explore',
   title: 'Explore',
   annotations: { title: 'Explore', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-  description: 'Repo anchor locator. LLM-backed; broad/uncertain only. Array only for independent targets.',
+  description: 'Repo anchor locator: broad/uncertain targets, no known path. Array = independent targets.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -70,7 +70,7 @@ function escapeXml(str) {
 // reminder. The full no-verdict contract lives at system level
 // (rules/agent/30-explorer.md).
 export function buildExplorerPrompt(query) {
-  return `<query>${escapeXml(query)}</query>\nReminder: coordinates only — WHERE, never WHY. Finish within 5 tool turns, ideally 1. Turn 1 MUST be one maximal batch: fire EVERY candidate lookup at once (grep with all token variants + code_graph + find/glob in the same turn); never one tool at a time. Answer straight from search output — grep/code_graph hits already carry path:line; never spend a turn reading to confirm, polish, or understand. The FIRST credible anchor ends the search: STOP and answer in that same turn, marking weak anchors with ?. By turn 5 answer with best-so-far or EXPLORATION_FAILED. Output only anchor lines formatted as path:line — symbol/name — short reason, or EXPLORATION_FAILED. No preamble, bullets, numbering, headings, summary, code quotes, analysis, verdicts, ratings, or recommendations.`;
+  return `<query>${escapeXml(query)}</query>\nReminder: coordinates only — WHERE, never WHY. Budget: 5 turns of maximal batches, ideally 1. Turn 1 fires everything at once: one grep whose pattern[] packs ALL token variants, plus code_graph/find/glob in the SAME turn when useful — width is free, turns are not. Answer straight from search output — hits already carry path:line; never read to confirm, polish, or understand. Before every call ask: is a credible anchor already on screen? If yes STOP and answer now, marking weak anchors with ?. EXPLORATION_FAILED only after all 5 turns found zero anchors; at turn 5 answer with best-so-far. Output only anchor lines formatted as path:line — symbol/name — short reason, or EXPLORATION_FAILED. No preamble, bullets, numbering, headings, summary, code quotes, analysis, verdicts, ratings, or recommendations.`;
 }
 
 export function normalizeExploreQueries(rawQuery) {