mixdog 0.9.149 → 0.9.151

package/README.md

@@ -150,18 +150,34 @@ npm run dev
 
 ## Terminal-Bench 2.1
 
-Controlled single-model runs on the same 89 tasks produced:
-
-- **78/89** with Claude Opus 5 vs Claude Code's **77/89**
-- **75/89** with GPT-5.6 Sol xhigh, matching Codex CLI
-- **1.43×** faster vs Claude Code and **1.27×** faster vs Codex CLI
-- **40–47%** smaller median final context
-- **29%** lower priced cost vs Claude Code and at least **39.7%** lower vs
-  Codex CLI
-
-These are self-reported single runs (`k=1`, 2026-08), not leaderboard
-submissions. Raw artifacts, commands, comparison charts, and metric scripts
-live under [`benchmarks/terminal-bench-2.1/`](benchmarks/terminal-bench-2.1/).
+Head-to-head runs against other agent CLIs on the same 89 tasks, holding the
+model fixed and changing only the harness. Every run uses the official Harbor
+verifier, fast mode off, a 272k context window, and zero retries.
+
+**GPT-5.6 Sol xhigh — Mixdog vs Codex CLI**
+
+- Score: **86.5%** (385/445) vs Codex CLI's **84.3%** (75/89)
+- **1.11×** faster per trial (339s vs 378s)
+- **42%** lower priced cost ($0.641 vs $1.096 per trial)
+- **45%** smaller median final context (18.5k vs 33.5k tokens)
+
+**Claude Opus 5 — Mixdog vs Claude Code**
+
+- Score: **79/89** vs Claude Code's **77/89**
+- **1.15×** faster and **19%** lower priced cost ($104.29 vs $129.21 per run)
+- **28%** smaller median final context (27.6k vs 38.2k tokens)
+
+Measurement: the Mixdog Sol run follows the same protocol the official
+Terminal-Bench leaderboard requires — all 89 tasks repeated five times
+(`k=5`, 445 trials), scored by the official Harbor verifier. The Codex CLI
+baseline and both Opus-side runs are single passes (`k=1`, 89 trials each).
+
+The official leaderboard is not accepting community submissions, so every run
+here ships its raw artifacts instead — Harbor verdicts, official verifier
+output, pinned task checksums, and the usage snapshots behind every cost
+figure — alongside the harness, presets, and metric scripts that recompute
+each number above:
+[`benchmarks/terminal-bench-2.1/`](benchmarks/terminal-bench-2.1/).
 
 ## Data and configuration
 

package/package.json

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

package/src/headless-exec.mjs

@@ -14,6 +14,7 @@ import {
 import { hasActiveBackgroundTasks } from './runtime/shared/background-tasks.mjs';
 import { installProcessSignalCleanup } from './runtime/shared/process-shutdown.mjs';
 import { stopStandaloneMemoryRuntimesForProcess } from './standalone/memory-runtime-proxy.mjs';
+import { shutdownDaemonForRuntimeRoot } from './standalone/session-client.mjs';
 import { applyUsageDelta, createSessionStats } from './ui/session-stats.mjs';
 
 function clean(value) {
@@ -558,6 +559,7 @@ export async function runHeadlessExec({
   boundaryFactory = createPristineExecutionBoundary,
   runtimeFactory = null,
   memoryRuntimeCleanup = stopStandaloneMemoryRuntimesForProcess,
+  daemonRuntimeCleanup = shutdownDaemonForRuntimeRoot,
   hasActiveTasks = hasActiveBackgroundTasks,
   installSignalCleanupFn = installProcessSignalCleanup,
 } = {}) {
@@ -616,17 +618,28 @@ export async function runHeadlessExec({
       } catch (error) {
         errors.push(error);
       }
-      let memoryCleanupFailed = false;
+      let resourceCleanupFailed = false;
+      if (boundary?.runtimeRoot) {
+        try {
+          await daemonRuntimeCleanup(boundary.runtimeRoot, {
+            waitForExit: true,
+            timeoutMs: 8_000,
+          });
+        } catch (error) {
+          resourceCleanupFailed = true;
+          errors.push(error);
+        }
+      }
       if (boundary) {
         try {
           await memoryRuntimeCleanup({ waitForExit: true, timeoutMs: 10_000 });
         } catch (error) {
-          memoryCleanupFailed = true;
+          resourceCleanupFailed = true;
           errors.push(error);
         }
       }
       try {
-        const cleanupResult = boundary?.cleanup(memoryCleanupFailed
+        const cleanupResult = boundary?.cleanup(resourceCleanupFailed
           ? { preserveRoot: true }
           : { tolerateRootRemovalFailure: true });
         if (cleanupResult?.rootRemovalError) {
@@ -672,7 +685,10 @@ export async function runHeadlessExec({
       approvalMode: 'implicit',
       disallowDelegation: true,
       autoWakeCompletions: false,
-      initialConfig: boundary.loadConfig(),
+      initialConfig: {
+        ...boundary.loadConfig(),
+        workflow: { active: 'headless' },
+      },
     });
     if (lifecycle && !clean(runtime?.id) && typeof runtime?.reserveSessionId === 'function') {
       runtime.reserveSessionId(lifecycle.threadId);
@@ -689,6 +705,25 @@ export async function runHeadlessExec({
         },
       );
     }
+    // Rewrite the usage snapshot after every model response, not only on the
+    // way out. A session killed mid-run — agent timeout, SIGKILL — never
+    // reaches the exit path, and used to leave no usage document at all while
+    // its token spend was already real. The file is a few hundred bytes and
+    // the write is atomic, so the cost is negligible and a live run stays
+    // readable from outside.
+    const flushUsageDocument = () => {
+      try {
+        writeUsageDocument(
+          usageLogPath,
+          stats,
+          runtime,
+          lifecycle?.toolCallCount || 0,
+          observedModels,
+        );
+      } catch {
+        // Telemetry must never break the session; the exit path reports.
+      }
+    };
     const askOptions = {
       onTextReset: () => true,
       onUsageDelta: (delta) => {
@@ -696,6 +731,7 @@ export async function runHeadlessExec({
         if (observedModel) observedModels.add(observedModel);
         applyUsageDelta(stats, delta);
         lifecycle?.onUsageDelta(delta);
+        flushUsageDocument();
       },
       ...(lifecycle ? {
         onProviderSendStarted: () => lifecycle.onProviderSendStarted(),

package/src/headless-exec.test.mjs

@@ -62,6 +62,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
   let activeChecks = 0;
   let boundaryCleaned = false;
   let runtimeClosed = false;
+  const daemonCleanupCalls = [];
   const cleanupOrder = [];
   try {
     const code = await runHeadlessExec({
@@ -75,6 +76,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
       write: (text) => output.push(text),
       writeErr: (text) => errors.push(text),
       boundaryFactory: () => ({
+        runtimeRoot: join(root, 'runtime-root'),
         loadConfig: () => ({ providers: { 'openai-oauth': { enabled: true } } }),
         cleanup: () => {
           boundaryCleaned = true;
@@ -106,6 +108,10 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
       memoryRuntimeCleanup: async () => {
         cleanupOrder.push('memory');
       },
+      daemonRuntimeCleanup: async (runtimeRoot, options) => {
+        daemonCleanupCalls.push({ runtimeRoot, options });
+        cleanupOrder.push('daemon');
+      },
       hasActiveTasks: (scope) => {
         activeScopes.push(scope);
         activeChecks += 1;
@@ -119,6 +125,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
     assert.deepEqual(errors, []);
     assert.equal(runtimeOptions[0].approvalMode, 'implicit');
     assert.equal(runtimeOptions[0].disallowDelegation, true);
+    assert.deepEqual(runtimeOptions[0].initialConfig.workflow, { active: 'headless' });
     assert.equal(runtimeOptions[0].autoWakeCompletions, false);
     assert.equal(runtimeOptions[0].toolMode, 'full');
     assert.deepEqual(activeScopes[0], {
@@ -127,7 +134,11 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
     });
     assert.equal(boundaryCleaned, true);
     assert.equal(runtimeClosed, true);
-    assert.deepEqual(cleanupOrder, ['runtime', 'memory', 'boundary']);
+    assert.deepEqual(cleanupOrder, ['runtime', 'daemon', 'memory', 'boundary']);
+    assert.deepEqual(daemonCleanupCalls, [{
+      runtimeRoot: join(root, 'runtime-root'),
+      options: { waitForExit: true, timeoutMs: 8_000 },
+    }]);
     const usage = JSON.parse(readFileSync(usageLogPath, 'utf8'));
     assert.deepEqual(usage.sessions[0].models, ['gpt-test', 'gpt-fallback']);
     assert.deepEqual(usage.totals, {
@@ -142,6 +153,98 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
   }
 });
 
+test('headless exec preserves the pristine root when isolated daemon shutdown fails', async () => {
+  const errors = [];
+  let cleanupOptions = null;
+  const code = await runHeadlessExec({
+    message: 'done',
+    provider: 'openai-oauth',
+    model: 'gpt-test',
+    usageLogPath: '',
+    write() {},
+    writeErr: (text) => errors.push(text),
+    boundaryFactory: () => ({
+      runtimeRoot: '/isolated/runtime',
+      loadConfig: () => ({ providers: { 'openai-oauth': { enabled: true } } }),
+      cleanup: (options) => { cleanupOptions = options; },
+    }),
+    runtimeFactory: async () => ({
+      id: 'sess_cleanup_failure',
+      model: 'gpt-test',
+      clientHostPid: 123,
+      async ask() { return { result: { content: 'done' } }; },
+      async close() {},
+    }),
+    daemonRuntimeCleanup: async () => { throw new Error('daemon stuck'); },
+    memoryRuntimeCleanup: async () => {},
+    hasActiveTasks: () => false,
+    installSignalCleanupFn: () => ({ uninstall() {} }),
+  });
+
+  assert.equal(code, 1);
+  assert.deepEqual(cleanupOptions, { preserveRoot: true });
+  assert.ok(errors.some((line) => line.includes('shutdown failed: daemon stuck')));
+});
+
+test('headless exec flushes the usage snapshot mid-session, before any exit path', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-headless-usage-flush-test-'));
+  const usageLogPath = join(root, 'usage.json');
+  // What a killed run would have left behind: read the file while `ask` is
+  // still running. Before the per-response flush this was always absent, so
+  // an agent-timeout trial reported no token spend at all.
+  let midSession = null;
+  try {
+    const code = await runHeadlessExec({
+      message: 'fix it',
+      provider: 'openai-oauth',
+      model: 'gpt-test',
+      effort: 'high',
+      fast: true,
+      usageLogPath,
+      idlePollMs: 1,
+      write: () => {},
+      writeErr: () => {},
+      boundaryFactory: () => ({
+        loadConfig: () => ({ providers: { 'openai-oauth': { enabled: true } } }),
+        cleanup: () => {},
+      }),
+      runtimeFactory: async () => ({
+        id: 'sess_flush_test',
+        model: 'gpt-test',
+        clientHostPid: 123,
+        ask: async (_prompt, options) => {
+          options.onUsageDelta({
+            deltaInput: 9,
+            deltaCachedRead: 4,
+            deltaCacheWrite: 2,
+            deltaOutput: 6,
+          });
+          try {
+            midSession = JSON.parse(readFileSync(usageLogPath, 'utf8'));
+          } catch (error) {
+            midSession = { error: error?.message ?? String(error) };
+          }
+          return { result: { content: 'done' } };
+        },
+        close: async () => {},
+      }),
+      hasActiveTasks: () => false,
+      installSignalCleanupFn: () => ({ uninstall() {} }),
+    });
+
+    assert.equal(code, 0);
+    assert.deepEqual(midSession?.totals, {
+      inputTokens: 9,
+      cacheTokens: 4,
+      cacheWriteTokens: 2,
+      outputTokens: 6,
+      toolCallCountApprox: 0,
+    });
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('headless exec answers an arrived completion and exits without waiting on live work', async () => {
   const output = [];
   const errors = [];
@@ -427,3 +530,15 @@ test('--json is accepted for exec and rejected for the interactive command', ()
   assert.equal(interactive.kind, 'error');
   assert.equal(interactive.error, 'option --json is only supported for mixdog exec');
 });
+
+test('headless exec rejects workflow selection', () => {
+  const invocation = classifyCliInvocation([
+    'exec',
+    '--provider', 'openai-oauth',
+    '--model', 'gpt-test',
+    '--workflow', 'solo',
+    'fix it',
+  ]);
+  assert.equal(invocation.kind, 'error');
+  assert.equal(invocation.error, 'option --workflow is not supported for mixdog exec');
+});

package/src/rules/lead/01-general.md

@@ -10,8 +10,9 @@
   recoverability.
 - Mid-task: replacement supersedes; addition folds in; status gets a brief
   answer while work continues. After compaction, resume the summary.
-- Periodic task reports stay in-turn: after each update, call `task wait` for
-  the requested interval again until the task settles or the request changes.
+- Periodic task reports stay in-turn: when `task wait` returns still-running,
+  write the user-facing report first, then call `task wait` for the next
+  interval; repeat until the task settles or the request changes.
 - Auto-compact owns context management: never propose stopping work to the
   user and never stop on your own judgment; resume and continue the work
   after every compaction.

package/src/rules/shared/00-general.md

@@ -2,3 +2,4 @@
 
 - When an internal Mixdog rule conflicts with the user's latest explicit
   request, follow the user's request.
+- Drive the user's request yourself.

package/src/rules/shared/10-tool-workflow.md

@@ -1,16 +1,16 @@
 # Tool Workflow
 
-- Determine the required outcome and its gaps — requirements are not evidence —
-  gather only what is missing, act, then verify the affected facets.
-- Investigate, build, and verify only what the requested outcome requires, at
-  the level it requires; internal and framework guarantees are trusted.
-- Minimize tool turns through maximal useful parallelism. Cost is counted in
-  rounds, not calls: a batch is one round, so a call-count saving never
-  justifies a worse-routed call.
-- In each round, issue every necessary non-overlapping call whose inputs are
-  already known; defer a call only when its target or arguments require an
-  earlier result. Respect tool/schema limits, never omit required fanout, and
-  apply one analysis to many targets as one parameterized call when supported.
+- Determine the required outcome and missing evidence; requirements are not
+  evidence. Trust internal and framework guarantees.
+- Before exploration or implementation, consult prior work, current external
+  information, or repository state only when needed to choose the next action.
+  Start with the source most likely to decide it; consult another only if the
+  result leaves the decision unresolved.
+- Minimize tool turns by batching only calls that are independently necessary
+  before the batch begins. A call whose necessity or scope can change after
+  another result waits for that result.
+- Respect tool/schema limits, never omit required fanout, and apply one analysis
+  to many targets as one parameterized call when supported.
 - Route each evidence facet once to its primary owner, preferring the operation
   that directly returns the evidence needed for the next decision. A summary,
   overview, or enumeration is not a prerequisite to an operation whose complete
@@ -26,7 +26,6 @@
 - Mine each returned result fully before opening the next round; a follow-up is
   valid only for evidence a result omitted, invalidated, or newly made
   necessary.
-- Evidence that determines the answer, edit, or deliverable ends retrieval.
 - Treat failure as new evidence and re-enter that loop only for the affected
   facets. Do not abandon a viable approach after one failure or leave the
   required deliverable half-finished. Report a blocker when no deterministic

package/src/rules/shared/30-exploration.md

@@ -2,6 +2,8 @@
 
 - Use read-only means for inspection; never mutate to clear an obstacle or
   unexpected state. Preserve evidence before a required mutation can destroy it.
+- Stop exploring once sufficient evidence determines the next action required
+  by the request.
 - Ownership is exclusive: each evidence type has one owner;
   a successful owner result closes that facet.
 - Route the missing evidence to its primary owner:
@@ -19,9 +21,8 @@
 - Use a path locator only when the owner's required target is unknown. Paths
   reachable by expanding an environment variable or the home directory are
   resolved locations, not unknowns.
-- Enumerate sibling directories or same-kind files with one wildcard call
-  (`glob`, or `read` with a glob for content sampling), never a
-  directory-by-directory `list` walk or one `read` per file.
+- Enumerate sibling directories or same-kind files with one `glob` call, never
+  a directory-by-directory `list` walk or one `read` per file.
 - Treat supplied target locations as resolved; access them directly without
   locator searches. Within the current project, pass project-relative paths and
   omit optional scopes equal to its root; explicit paths may be outside cwd

package/src/rules/shared/60-verification.md

@@ -1,9 +1,10 @@
 # Verification
 
 - Enter Verification only after all planned work is complete.
-- Run only checks that directly cover the changed behavior or essential
-  invariants; use an umbrella suite only when the user explicitly requests it
-  or a documented project or release process requires it.
+- Verify the essential behaviors and invariants required to complete the
+  requested work.
+- Use an umbrella suite only when explicitly requested or required by the
+  documented project or release process.
 - Blocking checks cover only essential integrity, security, compatibility, and
   buildability invariants. Treat mutable behavior, UX, exact text, snapshots,
   and implementation shape as advisory specifications; update them when the

package/src/runtime/agent/orchestrator/providers/openai-codex-identity.test.mjs

@@ -90,7 +90,6 @@ test('Codex cache key and every wire session identity use the same UUIDv7', () =
         poolKey: session.id,
         model: 'gpt-5.6-sol',
         handshake: true,
-        useResponsesLite: true,
         sendOpts: {
             codexSessionId: sessionId,
             codexThreadId: sessionId,
@@ -102,7 +101,6 @@ test('Codex cache key and every wire session identity use the same UUIDv7', () =
     assert.equal(prewarmHeaders['thread-id'], sessionId);
     assert.equal(prewarmHeaders['x-client-request-id'], sessionId);
     assert.equal('x-codex-installation-id' in prewarmHeaders, false);
-    assert.equal('x-openai-internal-codex-responses-lite' in prewarmHeaders, false);
     const prewarmMetadata = JSON.parse(prewarmHeaders['x-codex-turn-metadata']);
     assert.equal(prewarmMetadata.request_kind, 'prewarm');
     assert.equal(prewarmMetadata.turn_id, '');

package/src/runtime/agent/orchestrator/providers/openai-codex-metadata.mjs

@@ -172,7 +172,7 @@ export function _metadataTrace(metadata) {
 }
 
 // The WebSocket handshake carries compatibility identity and routing fields.
-// Installation and Responses Lite data stay in per-request client_metadata.
+// Installation data stays in per-request client_metadata.
 export function _codexWsCompatibilityHeaders(context = {}) {
     const metadata = _codexMetadataBase(null, context);
     const headers = {};
@@ -211,9 +211,6 @@ export function _withCodexWsClientMetadata(frame, entry, enabled, context = {})
     const metadata = {
         ...base,
         ...(frame.client_metadata && typeof frame.client_metadata === 'object' ? frame.client_metadata : {}),
-        ...(context?.useResponsesLite === true
-            ? { ws_request_header_x_openai_internal_codex_responses_lite: 'true' }
-            : {}),
         'x-codex-ws-stream-request-start-ms': String(Date.now()),
     };
     if (entry && typeof entry === 'object') {

package/src/runtime/agent/orchestrator/providers/openai-codex-model.mjs

@@ -7,23 +7,6 @@
  * _displayCodexModel for existing importers.
  */
 
-const CODEX_RESPONSES_LITE_CAPABILITY = Object.freeze({
-    'gpt-5.6-sol': true,
-    'gpt-5.6-terra': true,
-    'gpt-5.6-luna': true,
-    'gpt-5.5': false,
-    'gpt-5.4': false,
-    'gpt-5.4-mini': false,
-    'gpt-5.2': false,
-    'codex-auto-review': false,
-});
-
-export function _codexUsesResponsesLite(id, modelInfo = null) {
-    const explicit = modelInfo?.useResponsesLite ?? modelInfo?.use_responses_lite;
-    if (typeof explicit === 'boolean') return explicit;
-    return CODEX_RESPONSES_LITE_CAPABILITY[String(id || '').trim()] === true;
-}
-
 // OAuth catalog returns dated ids (gpt-5.4-mini-2026-03-17). Strip the trailing
 // -YYYY-MM-DD to get the version alias (gpt-5.4-mini). Unknown shapes pass
 // through unchanged.
@@ -101,7 +84,6 @@ export function _normalizeCodexModel(m) {
         reasoningLevels: (m?.supported_reasoning_levels || []).map(r => r.effort),
         supportVerbosity: m?.support_verbosity === true,
         defaultVerbosity: m?.default_verbosity || null,
-        useResponsesLite: m?.use_responses_lite === true,
         supportsReasoningSummaries: m?.supports_reasoning_summaries === true,
         serviceTiers,
         defaultServiceTier: m?.default_service_tier || null,

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

@@ -251,9 +251,6 @@ export async function sendViaHttpSse({
     const statelessConversation = opts?.statelessConversation === true
         || _envFlag('MIXDOG_OAI_STATELESS_HTTP', false);
     const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey, statelessConversation });
-    if (auth?.type !== 'openai-direct' && body?.input?.[0]?.type === 'additional_tools') {
-        headers['x-openai-internal-codex-responses-lite'] = 'true';
-    }
     const fetchStartedAt = Date.now();
     const responsesUrl = auth?.type === 'openai-direct'
         ? OPENAI_DIRECT_RESPONSES_URL

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

@@ -584,7 +584,6 @@ export async function sendViaWebSocket({
         sendOpts,
         model: useModel,
         serviceTier: body?.service_tier || '',
-        useResponsesLite: body?.input?.[0]?.type === 'additional_tools',
     };
     const codexHandshakeHeaders = useCodexWsClientMetadata
         ? _codexWsCompatibilityHeaders({ ...codexMetadataContext, handshake: true })

package/src/runtime/agent/orchestrator/providers/openai-responses-payload.mjs

@@ -71,7 +71,6 @@ import {
     _compareVersion,
     _isMainCodexFamily,
     _markLatestCodex,
-    _codexUsesResponsesLite,
 } from './openai-codex-model.mjs';
 
 // Public test/integration entry retained alongside the transport module export.
@@ -253,53 +252,8 @@ function _codexModelSupportsReasoningSummaries(id) {
     return true;
 }
 
-function _codexModelUsesResponsesLite(id, opts = {}) {
-    if (typeof opts.useResponsesLite === 'boolean') return opts.useResponsesLite;
-    const override = String(process.env.MIXDOG_OAI_RESPONSES_LITE || '').trim().toLowerCase();
-    if (['1', 'true', 'yes', 'on'].includes(override)) return true;
-    if (['0', 'false', 'no', 'off'].includes(override)) return false;
-    const info = _findCachedCodexModel(id);
-    return _codexUsesResponsesLite(id, info);
-}
-
-function _responsesLiteTools(tools) {
-    const out = [];
-    const functions = [];
-    let functionsIndex = null;
-    for (const tool of Array.isArray(tools) ? tools : []) {
-        if (tool?.type === 'function' || tool?.type === 'custom') {
-            if (functionsIndex == null) functionsIndex = out.length;
-            functions.push(tool);
-            continue;
-        }
-        if (tool?.type === 'namespace' && tool?.name === 'functions') {
-            if (functionsIndex == null) functionsIndex = out.length;
-            if (Array.isArray(tool.tools)) functions.push(...tool.tools);
-            continue;
-        }
-        out.push(tool);
-    }
-    if (functions.length) {
-        out.splice(functionsIndex, 0, {
-            type: 'namespace',
-            name: 'functions',
-            description: '',
-            tools: functions,
-        });
-    }
-    return out;
-}
-
 export function buildCodexStartupPrewarmBody(body) {
-    const input = Array.isArray(body?.input) ? body.input : [];
-    const stableInput = [];
-    if (input[0]?.type === 'additional_tools' && input[0]?.role === 'developer') {
-        stableInput.push(input[0]);
-        if (input[1]?.type === 'message' && input[1]?.role === 'developer') {
-            stableInput.push(input[1]);
-        }
-    }
-    return { ...body, input: stableInput, generate: false };
+    return { ...body, input: [], generate: false };
 }
 
 // Effort normalization: `ultra` collapses to
@@ -340,8 +294,6 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         .join('\n\n---\n\n');
     const opts = sendOpts || {};
     const promptCacheProvider = opts.promptCacheProvider || 'openai-oauth';
-    const useResponsesLite = promptCacheProvider === 'openai-oauth'
-        && _codexModelUsesResponsesLite(model, opts);
     // Recovery-only encrypted-reasoning replay is DEFAULT ON for the OAuth
     // backend (validated 2026-08-11: smoke wire parity on normal chains +
     // live full-frame acceptance + full-run A/B). The per-socket policy in
@@ -421,7 +373,6 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         reasoning: {
             effort: _normalizeReasoningEffort(opts.effort),
             ...(supportsReasoningSummary ? { summary: 'auto' } : {}),
-            ...(useResponsesLite ? { context: 'all_turns' } : {}),
         },
         store: process.env.MIXDOG_OAI_STORE === 'true' ? true : false,
         stream: true,
@@ -461,25 +412,6 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     const toolsList = (functionTools.length || nativeTools.length)
         ? [...nativeTools, ...functionTools]
         : null;
-    const liteTools = useResponsesLite ? _responsesLiteTools(toolsList || []) : null;
-    const wireInput = useResponsesLite
-        ? [
-            {
-                type: 'additional_tools',
-                role: 'developer',
-                tools: liteTools,
-            },
-            ...(instructions
-                ? [{
-                    type: 'message',
-                    role: 'developer',
-                    content: [{ type: 'input_text', text: instructions }],
-                }]
-                : []),
-            ...input,
-        ]
-        : input;
-    if (useResponsesLite) body.parallel_tool_calls = false;
     const promptCacheLane = opts.promptCacheLane || resolveProviderPromptCacheLane(promptCacheProvider, opts);
     const promptCacheKey = buildStableProviderPromptCacheKey(promptCacheProvider, opts, {
         model,
@@ -506,9 +438,9 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     // fast set it.
     const ordered = {
         model: body.model,
-        ...(!useResponsesLite ? { instructions: body.instructions } : {}),
-        input: wireInput,
-        ...(!useResponsesLite && toolsList ? { tools: toolsList } : {}),
+        instructions: body.instructions,
+        input: body.input,
+        ...(toolsList ? { tools: toolsList } : {}),
         tool_choice: body.tool_choice,
         parallel_tool_calls: body.parallel_tool_calls,
         reasoning: body.reasoning,

package/src/runtime/agent/orchestrator/session/approval-mode.mjs

@@ -1,9 +1 @@
 export const IMPLICIT_APPROVAL_MODE = 'implicit';
-export const IMPLICIT_APPROVAL_CONTEXT =
-    'Non-interactive execution: treat the initial user request as the approved plan and proceed without requesting approval.';
-
-export function workflowContextForApprovalMode(workflowContext, approvalMode) {
-    if (approvalMode !== IMPLICIT_APPROVAL_MODE) return workflowContext || null;
-    const workflow = typeof workflowContext === 'string' ? workflowContext.trim() : '';
-    return [workflow, IMPLICIT_APPROVAL_CONTEXT].filter(Boolean).join('\n\n');
-}

package/src/runtime/agent/orchestrator/session/compact/handoff.mjs

@@ -1,6 +1,5 @@
 import { estimateTokens } from '../context-utils.mjs';
 
-const CONVERSATION_LINE_CHARS = 800;
 const TOOL_OUTCOME_CHARS = 80;
 
 function textOf(m) {
@@ -339,7 +338,7 @@ export function conversationLinesFromMemoryText(text) {
             .replace(/\s+#\d+\s*$/, '')
             .trim();
         if (body && body !== '.' && body !== '…') {
-            rows.push(`${current.role}: ${body.slice(0, CONVERSATION_LINE_CHARS)}`);
+            rows.push(`${current.role}: ${body}`);
         }
         current = null;
     };
@@ -372,8 +371,7 @@ export function excludeTailFromConversation(lines, tailMessages) {
         if (m?.role !== 'user' && m?.role !== 'assistant') continue;
         const body = String(typeof m.content === 'string' ? m.content : '')
             .replace(/\s+/g, ' ')
-            .trim()
-            .slice(0, CONVERSATION_LINE_CHARS);
+            .trim();
         if (body) tails.push(body);
     }
     if (!tails.length) return Array.isArray(lines) ? lines : [];