mixdog 0.9.148 → 0.9.149

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -461,6 +461,42 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 effectiveContextWindowPercent: contextMeta.effectiveContextWindowPercent,
                 autoCompactTokenLimit: contextMeta.autoCompactTokenLimit,
             };
+            const effectiveCwd = cwdOverride || session.cwd;
+            if (session.sessionStartMetaInjected !== true
+                && !hasUserConversationMessage(session.messages)) {
+                refreshSessionBp3Environment(session, effectiveCwd);
+            }
+            let _startupProviderPrewarm = null;
+            if (session.provider === 'openai-oauth'
+                && Number(session.totalInputTokens || 0) === 0
+                && !session.providerState
+                && typeof provider.prewarmWsTransportForSession === 'function') {
+                try {
+                    _startupProviderPrewarm = Promise.resolve(
+                        provider.prewarmWsTransportForSession({
+                            sessionId,
+                            session,
+                            messages: filterModelVisibleSessionMessages(session.messages),
+                            model: session.model,
+                            tools: session.tools,
+                            effort: session.effort || null,
+                            fast: session.fast === true,
+                            modelParameters: session.modelParameters || {},
+                            selectedContextWindow: session.selectedContextWindow || session.contextWindow || null,
+                            promptCacheKey: session.promptCacheKey || null,
+                            providerCacheKey: session.promptCacheKey || null,
+                            ...(session.providerCacheOpts || {}),
+                            ...(codexWireSendOpts(session, {
+                                requestKind: 'prewarm',
+                                turnId: _codexTurnId,
+                                startedAtMs: _turnCheckpointStartedAt,
+                            }) || {}),
+                        }),
+                    ).catch(() => false);
+                } catch {
+                    _startupProviderPrewarm = null;
+                }
+            }
             // Cap caller-supplied / prefetched context so an oversized
             // payload can't blow the session token budget before the
             // first model call. 32 KB ~ 8k tokens at the 4 B/tok
@@ -489,11 +525,6 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             if (explicitPrefetchResult) {
                 _contextBlock += `# Prefetch\n${_capCtx(explicitPrefetchResult)}\n\n`;
             }
-            const effectiveCwd = cwdOverride || session.cwd;
-            if (session.sessionStartMetaInjected !== true
-                && !hasUserConversationMessage(session.messages)) {
-                refreshSessionBp3Environment(session, effectiveCwd);
-            }
             const historyMessages = filterModelVisibleSessionMessages(session.messages);
             const beforeCount = historyMessages.length + 1;
             const promptTextForMetrics = promptContentText(prompt);
@@ -576,6 +607,13 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     },
                 });
             } catch { /* trace must never break the ask path */ }
+            if (_startupProviderPrewarm) {
+                try {
+                    await runAbortable(turnSignal, () => _startupProviderPrewarm);
+                } catch {
+                    throwIfAborted(turnSignal);
+                }
+            }
             const agentLoop = await runAbortable(turnSignal, () => _getAgentLoop());
             const _trackTextDelta = (chunk) => {
                 _turnInterruption.recordTextDelta(chunk);

package/src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs

@@ -46,6 +46,7 @@ import {
 } from '../approval-mode.mjs';
 import { describeShellStartupPolicy } from '../../tools/builtin/runtime-capabilities.mjs';
 import { captureOriginalUserCwd } from '../../../../shared/user-cwd.mjs';
+import { refreshSessionBp3Environment } from './prompt-utils.mjs';
 
 function buildSessionProviderCacheOpts(providerName, sessionId, agent = null) {
     // Keep this in sync with createSession's provider-cache policy: only
@@ -477,6 +478,7 @@ export function createSession(opts) {
         ownerSessionId: opts.ownerSessionId || null,
         clientHostPid: opts.clientHostPid || null,
     };
+    refreshSessionBp3Environment(session, opts.cwd);
     // In-process registry + async debounced save: same-process create → load
     // reads live memory; disk flush is for cross-process / restart durability.
     setLiveSession(session);

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

@@ -244,7 +244,7 @@ export const BUILTIN_TOOLS = [
                 },
                 hidden: { type: 'boolean', description: 'Include dotfiles.' },
                 meta: { type: 'boolean', description: 'Per-entry size bytes, UTC mtime, octal mode.' },
-                limit: { type: 'integer', minimum: 0, description: 'Max entries; default 200; 0 unlimited.' },
+                limit: { type: 'integer', minimum: 0, description: 'Max entries; default 100; 0 unlimited.' },
                 offset: { type: 'integer', minimum: 0, description: 'Entry offset.' },
             },
             required: [],

package/src/runtime/agent/orchestrator/tools/builtin/list-tool-integrity.test.mjs

@@ -32,6 +32,20 @@ test('aborted list work cannot poison the result cache', async () => {
     }
 });
 
+test('list defaults to a 100-entry page with an offset continuation', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'mixdog-list-default-page-'));
+    try {
+        await Promise.all(Array.from({ length: 101 }, (_, index) => (
+            writeFile(join(root, `entry-${String(index).padStart(3, '0')}.txt`), 'ok')
+        )));
+        const out = await executeListTool({ path: root, hidden: true }, process.cwd());
+        assert.equal(out.split('\n').filter((line) => line.endsWith('\tfile')).length, 100);
+        assert.match(out, /\[entries 1-100 of 101; pass offset:100 to continue\]/);
+    } finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+
 test('root readdir failures are errors, stay uncached, and mark a repeatedly failing runtime worker unhealthy', async () => {
     const originalRuntimeWorkerPid = process.env.MIXDOG_SESSION_RUNTIME_WORKER_PID;
     const roots = [];

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

@@ -100,7 +100,7 @@ function recordDirectoryWalkTelemetry(options, status, walkResult, warningCount
     };
 }
 
-// A/B override surface for the default result caps (stock: list/tree 200,
+// A/B override surface for the default result caps (stock: list 100, tree 200,
 // fuzzy find 25). Env-gated so bench variants can match competitor-style
 // generous caps without changing the shipped defaults.
 function _listDefaultHeadLimit(fallback) {
@@ -256,7 +256,7 @@ export async function executeListTool(args, workDir, options = {}) {
     const hidden = Boolean(args.hidden);
     const sort = ['name', 'mtime', 'size'].includes(args.sort) ? args.sort : 'name';
     const typeFilter = ['any', 'file', 'dir'].includes(args.type) ? args.type : 'any';
-    const headLimit = normalizeListHeadLimit(args.head_limit, _listDefaultHeadLimit(200));
+    const headLimit = normalizeListHeadLimit(args.head_limit, _listDefaultHeadLimit(100));
     const offset = typeof args.offset === 'number' && args.offset > 0 ? args.offset : 0;
     const needsGlobalStat = sort === 'mtime' || sort === 'size';
     const includeNoise = Boolean(args.include_noise);

package/src/runtime/shared/pristine-execution-contract.json

@@ -27,7 +27,6 @@
     "MIXDOG_CACHE_MESSAGES_TTL",
     "MIXDOG_OAI_TRANSPORT",
     "MIXDOG_OPENAI_OAUTH_WS_WARMUP",
-    "MIXDOG_OAI_CODEX_WIRE_PARITY",
     "MIXDOG_OAI_WS_DUMP_DIR",
     "MIXDOG_SESSION_TRANSCRIPT_LOG",
     "MIXDOG_USAGE_LOG"

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

@@ -333,6 +333,15 @@ export function createSessionLifecycle({
         throwIfAborted(signal);
         // best-effort: ordinary hook failure never breaks session create
       }
+      if (rt.session.provider === 'openai-oauth'
+        && Number(rt.session.totalInputTokens || 0) === 0
+        && !rt.session.providerState
+        && typeof providerImpl.prewarmWsTransportForSession === 'function') {
+        void Promise.resolve(providerImpl.prewarmWsTransportForSession({
+          sessionId: rt.session.id,
+          session: rt.session,
+        })).catch(() => {});
+      }
       throwIfAborted(signal);
       bootProfile('session:create:ready', {
         ms: (performance.now() - startedAt).toFixed(1),

package/src/standalone/agent-tool/spawn-flow.mjs

@@ -337,10 +337,10 @@ export function createSpawnFlow({
     const spec = spawnSessionSpec(plan, args, context);
     const { session, effectiveCwd } = prepareAgentSession(spec);
     bindSpawnedSession(session, plan);
-    // Spawn prewarm opens the worker's WebSocket now, in
-    // parallel with the remaining prep / first-prompt build, so the first
-    // request skips the handshake. Fire-and-forget: failures fall back to the
-    // lazy per-send handshake. MIXDOG_AGENT_SPAWN_WS_PREWARM=0 disables.
+    // Spawn prewarm builds the materialized stable prompt and keeps the
+    // resulting Codex-style client handle reserved for the first turn.
+    // Fire-and-forget: failures fall back to the lazy per-send handshake.
+    // MIXDOG_AGENT_SPAWN_WS_PREWARM=0 disables.
     maybePrewarmSpawnTransport(plan, session);
     return preparedSpawnResult(
       { ...plan, workerCwd: effectiveCwd || plan.workerCwd },