perf: stop busting the prompt cache and slim per-turn context

src/constants/prompts.doingTasks.test.ts

@@ -0,0 +1,35 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { withMockMacro } from 'src/test/mockMacro.js'
+import { getSystemPrompt } from './prompts.js'
+
+// getSystemPrompt returns a minimal prompt without the doing-tasks section
+// when CLAUDE_CODE_SIMPLE is truthy — unset it so the test always exercises
+// the full prompt path regardless of process-level state.
+let originalSimple: string | undefined
+
+beforeEach(() => {
+  originalSimple = process.env.CLAUDE_CODE_SIMPLE
+  delete process.env.CLAUDE_CODE_SIMPLE
+})
+
+afterEach(() => {
+  if (originalSimple === undefined) {
+    delete process.env.CLAUDE_CODE_SIMPLE
+  } else {
+    process.env.CLAUDE_CODE_SIMPLE = originalSimple
+  }
+})
+
+test('coding system prompt includes the timing and wiring robustness guidance', async () => {
+  const prompt = await withMockMacro(
+    { ISSUES_EXPLAINER: 'report the issue at the tracker', VERSION: '0.0.0-test' },
+    async () => (await getSystemPrompt([], 'test-model')).join('\n'),
+  )
+
+  // Focused assertions on the new "Doing tasks" guidance — not a full-prompt
+  // snapshot, so unrelated prompt edits don't churn this test.
+  expect(prompt).toContain(
+    'derive timing-sensitive logic (animation, physics, timers) from actual elapsed time',
+  )
+  expect(prompt).toContain('Every element you introduce must be wired up')
+})

src/constants/prompts.ts

@@ -226,6 +226,7 @@ function getSimpleDoingTasksSection(): string {
     `Avoid giving time estimates or predictions for how long tasks will take, whether for your own work or for users planning projects. Focus on what needs to be done, not how long it might take.`,
     `If an approach fails, diagnose why before switching tactics—read the error, check your assumptions, try a focused fix. Don't retry the identical action blindly, but don't abandon a viable approach after a single failure either. Escalate to the user with ${ASK_USER_QUESTION_TOOL_NAME} only when you're genuinely stuck after investigation, not as a first response to friction.`,
     `Be careful not to introduce security vulnerabilities such as command injection, XSS, SQL injection, and other OWASP top 10 vulnerabilities. If you notice that you wrote insecure code, immediately fix it. Prioritize writing safe, secure, and correct code.`,
+    `Make behavior explicit rather than environment-dependent: derive timing-sensitive logic (animation, physics, timers) from actual elapsed time instead of assuming a fixed frame or tick rate. Every element you introduce must be wired up — a UI element, state variable, or parameter that nothing ever updates or reads is a bug, not a placeholder.`,
     ...codeStyleSubitems,
     `Avoid backwards-compatibility hacks like renaming unused _vars, re-exporting types, adding // removed comments for removed code, etc. If you are certain that something is unused, you can delete it completely.`,
     // @[MODEL LAUNCH]: False-claims mitigation for Capybara v8 (29-30% FC rate vs v4's 16.7%)

src/memdir/paths.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, beforeEach, expect, test, mock } from 'bun:test'
-import { setAllowedSettingSources } from '../bootstrap/state.js'
+import {
+  getIsInteractive,
+  setAllowedSettingSources,
+  setIsInteractive,
+} from '../bootstrap/state.js'
 import { SETTING_SOURCES } from '../utils/settings/constants.js'
 import { isAutoMemoryEnabled } from './paths.ts'
 
@@ -15,6 +19,7 @@ const realSettings = (await import(
 // opt-out can't be silently re-enabled by a narrower scope flipping the key.
 
 let _originalEnv: Record<string, string | undefined> = {}
+let _originalInteractive = false
 
 type SourceFixture = { source: string; settings: Record<string, unknown> }
 let _sources: SourceFixture[] = []
@@ -41,6 +46,10 @@ beforeEach(() => {
   delete process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR
 
   _sources = []
+  // Auto-memory defaults off for non-interactive (-p) sessions; these tests
+  // exercise the interactive default unless a test overrides this.
+  _originalInteractive = getIsInteractive()
+  setIsInteractive(true)
   // Enable every source so getEnabledSettingSources() returns the full set in
   // priority order; the fixtures decide which of them carry a value.
   setAllowedSettingSources([...SETTING_SOURCES])
@@ -61,6 +70,7 @@ afterEach(() => {
       process.env[k] = v
     }
   }
+  setIsInteractive(_originalInteractive)
   setAllowedSettingSources([...SETTING_SOURCES])
   // mock.restore() undoes spies but NOT mock.module() registrations, which
   // otherwise leak into later test files in the same (serial) run. Re-register
@@ -74,6 +84,20 @@ test('defaults to enabled when no source sets the key and no env override', () =
   expect(isAutoMemoryEnabled()).toBe(true)
 })
 
+test('defaults to disabled in non-interactive (-p) sessions', () => {
+  setIsInteractive(false)
+  mockSources([{ source: 'userSettings', settings: {} }])
+  expect(isAutoMemoryEnabled()).toBe(false)
+})
+
+test('an explicit settings opt-in overrides the non-interactive default', () => {
+  setIsInteractive(false)
+  mockSources([
+    { source: 'userSettings', settings: { memory: { autoWrite: true } } },
+  ])
+  expect(isAutoMemoryEnabled()).toBe(true)
+})
+
 test('memory.autoWrite: false opts out via the new discoverable alias (#1326)', () => {
   mockSources([
     { source: 'projectSettings', settings: { memory: { autoWrite: false } } },

src/memdir/paths.ts

@@ -57,6 +57,7 @@ export function isAutoMemoryEnabled(): boolean {
   // a parent-scope opt-out cannot be re-enabled by a narrower scope (#1326).
   // Per-source reads are cached (getSettingsForSource), so this stays cheap on
   // the hot path.
+  let explicitOptIn = false
   for (const source of getEnabledSettingSources()) {
     const sourceSettings = getSettingsForSource(source)
     if (
@@ -65,6 +66,26 @@ export function isAutoMemoryEnabled(): boolean {
     ) {
       return false
     }
+    if (
+      sourceSettings?.autoMemoryEnabled === true ||
+      sourceSettings?.memory?.autoWrite === true
+    ) {
+      explicitOptIn = true
+    }
+  }
+  // One-shot non-interactive (-p) runs have no future session to build memory
+  // for: default off to skip the ~3.2k-token memory protocol section, the
+  // per-request arc/RAG system-prompt append (which busts the prompt cache),
+  // and turn-end extraction forks. Still enabled by any explicit provisioning:
+  // a settings opt-in, CLAUDE_CODE_DISABLE_AUTO_MEMORY=0 (handled above), a
+  // Cowork memory-path override, or a mounted remote memory dir — those
+  // sessions are non-interactive but deliberately memory-backed.
+  const envProvisionedMemory =
+    hasAutoMemPathOverride() ||
+    (isEnvTruthy(process.env.CLAUDE_CODE_REMOTE) &&
+      Boolean(process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR))
+  if (!explicitOptIn && !envProvisionedMemory && getIsNonInteractiveSession()) {
+    return false
   }
   return true
 }

src/query.conversationArc.test.ts

@@ -16,6 +16,11 @@ import {
   updateGoalStatus,
 } from './utils/conversationArc.js'
 import { resetGlobalGraph } from './utils/knowledgeGraph.js'
+import {
+  addToolCallToTurn,
+  resetMultiTurnState,
+  startNewTurn,
+} from './utils/multiTurnContext.js'
 import { setClaudeConfigHomeDirForTesting } from './utils/envUtils.js'
 import { getAutoMemPath } from './memdir/paths.js'
 import { setGovernancePolicySettingsForSourceForTesting } from './utils/governancePolicy.js'
@@ -38,11 +43,13 @@ beforeEach(async () => {
     memory: { requireApprovalBeforeWrite: false },
   }))
   resetArc()
+  resetMultiTurnState()
 })
 
 afterEach(() => {
   try {
     resetArc()
+    resetMultiTurnState()
     resetGlobalGraph()
     setGovernancePolicySettingsForSourceForTesting(null)
     setClaudeConfigHomeDirForTesting(undefined)
@@ -109,6 +116,18 @@ productionArcTest('query appends arc memory to the model system prompt without m
   updateGoalStatus(goal.id, 'completed')
   await finalizeArcTurn()
 
+  // Seed a prior COMPLETED turn: the multi-turn tracking block renders only
+  // completed turns (the in-progress turn's tool-call list grows between
+  // model requests and would bust the prompt cache). query() starts a fresh
+  // turn, which completes this one.
+  startNewTurn()
+  addToolCallToTurn({
+    id: 'call_prior',
+    name: 'read_file',
+    input: { path: '/prior.ts' },
+    timestamp: Date.now(),
+  })
+
   const userMessage = createUserMessage({ content: 'review query integration' })
   let observedSystemPrompt: readonly string[] = []
   const deps: QueryDeps = {
@@ -141,5 +160,10 @@ productionArcTest('query appends arc memory to the model system prompt without m
   expect(prompt).toContain('PERSISTENT PROJECT MEMORY')
   expect(prompt).toContain('Ship query integration')
   expect(prompt).toContain('MULTI-TURN CONTEXT TRACKING')
+  expect(prompt).toContain('read_file')
+  // No per-request-varying content: wall-clock durations and running token
+  // totals would rewrite the system prompt every request and bust the cache.
+  expect(prompt).not.toContain('Duration:')
+  expect(prompt).not.toContain('Total Tokens:')
   expect(userMessage.message.content).toBe('review query integration')
 })

src/services/api/codexShim.test.ts

@@ -782,7 +782,11 @@ describe('Codex request translation', () => {
     expect(output?.output).toBe('first block\nsecond block')
   })
 
-  test('compresses structured tool results with the Codex Responses separator', async () => {
+  test('keeps tool history uncompressed on the Codex transport (implicit prefix caching)', async () => {
+    // Codex talks to OpenAI Responses backends, which do implicit prefix
+    // caching: compressToolHistory's end-relative window would rewrite
+    // already-sent tool results each turn and bust the cache, so the Codex
+    // path must send history verbatim even with compression enabled.
     setToolHistoryCompressionEnabledOverrideForTest(true)
     try {
       mock.restore()
@@ -828,8 +832,12 @@ describe('Codex request translation', () => {
       const outputs = (body?.input as Array<{ type?: string; output?: string }>)
         .filter(item => item.type === 'function_call_output')
       expect(outputs[16]?.output).toBe(
-        `${'a'.repeat(1_000)}\n${'b'.repeat(999)}\n[…truncated 501 chars from tool history]`,
+        `${'a'.repeat(1_000)}\n${'b'.repeat(1_500)}`,
       )
+      for (const item of outputs) {
+        expect(item.output).not.toContain('truncated')
+        expect(item.output).not.toContain('chars omitted')
+      }
     } finally {
       setToolHistoryCompressionEnabledOverrideForTest(undefined)
     }

src/services/api/codexShim.ts

@@ -1,6 +1,5 @@
 import { APIError } from '@anthropic-ai/sdk'
 import { buildAnthropicUsageFromRawUsage } from './cacheMetrics.js'
-import { compressToolHistory } from './compressToolHistory.js'
 import { fetchWithProxyRetry } from './fetchWithProxyRetry.js'
 import { stableStringifyJson } from '../../utils/stableStringify.js'
 import type {
@@ -578,18 +577,20 @@ export async function performCodexRequest(options: {
   signal?: AbortSignal
   fetcher?: typeof fetchWithProxyRetry
 }): Promise<Response> {
-  const compressedMessages = compressToolHistory(
-    options.params.messages as Array<{
-      role?: string
-      message?: { role?: string; content?: unknown }
-      content?: unknown
-    }>,
-    options.request.resolvedModel,
-    // Codex Responses flattens structured tool-result text with a single
-    // newline, unlike Chat's double-newline message serialization.
-    { textBlockSeparator: '\n' },
-  )
-  const input = convertAnthropicMessagesToResponsesInput(compressedMessages)
+  // No tool-history compression on the Codex transport: Codex talks to
+  // OpenAI Responses backends, which do implicit prefix caching, and
+  // compressToolHistory's end-relative window rewrites already-sent tool
+  // results each turn — mutating the request prefix and forfeiting the
+  // cache, which costs more than the compression saves. This mirrors the
+  // prefix-caching skip in openaiShim/requestPreparation.ts; context
+  // pressure is handled by the compaction machinery, as on the native
+  // Anthropic transport.
+  const rawMessages = options.params.messages as Array<{
+    role?: string
+    message?: { role?: string; content?: unknown }
+    content?: unknown
+  }>
+  const input = convertAnthropicMessagesToResponsesInput(rawMessages)
   const body: Record<string, unknown> = {
     model: options.request.resolvedModel,
     input: input.length > 0

src/services/api/openaiShim.compression.test.ts

@@ -485,7 +485,7 @@ test('FIX: 1M context model with 30 exchanges → only first 5 mid-truncated', a
   }
 })
 
-test('Kimi K3 256K selection uses its own compression window while sending the k3 API name', async () => {
+test('Kimi K3 256K selection keeps history uncompressed (implicit prefix caching) while sending the k3 API name', async () => {
   mockState.enabled = true
   process.env.OPENAI_BASE_URL = 'https://api.kimi.com/coding/v1'
   const messages = buildLongConversation(50, 5_000)
@@ -497,9 +497,65 @@ test('Kimi K3 256K selection uses its own compression window while sending the k
 
   expect(body.model).toBe('k3')
   expect(toolMessages).toHaveLength(50)
+  // api.kimi.com does implicit prefix caching: compressToolHistory's
+  // end-relative window would rewrite already-sent tool results each turn
+  // and bust the cache, so compression is skipped for this host.
+  for (const m of toolMessages) {
+    expect(m.content).not.toContain('chars omitted')
+    expect(m.content).not.toContain('[…truncated')
+  }
+})
+
+test('implicit-prefix-caching host (api.deepseek.com) skips tool-history compression', async () => {
+  mockState.enabled = true
+  mockState.effectiveWindow = 100_000 // small window: would compress on a custom endpoint
+  process.env.OPENAI_BASE_URL = 'https://api.deepseek.com/v1'
+  const messages = buildLongConversation(30, 5_000)
+
+  const body = await captureRequestBody(messages, 'deepseek-chat')
+  const toolMessages = getToolMessages(body)
+
+  expect(toolMessages).toHaveLength(30)
+  for (const m of toolMessages) {
+    expect(m.content.length).toBe(5_000)
+    expect(m.content).not.toContain('chars omitted')
+    expect(m.content).not.toContain('[…truncated')
+  }
+})
+
+test('non-caching custom endpoint still compresses tool history', async () => {
+  // Guard against the inverse regression: the prefix-caching skip must not
+  // disable compression for endpoints with no implicit caching. The default
+  // harness base URL (http://example.test/v1) is such an endpoint.
+  mockState.enabled = true
+  mockState.effectiveWindow = 100_000 // recent=12, mid=25
+  const messages = buildLongConversation(30, 5_000)
+
+  const body = await captureRequestBody(messages, 'gpt-4o')
+  const toolMessages = getToolMessages(body)
+
+  expect(toolMessages).toHaveLength(30)
   expect(toolMessages[0].content).toContain('chars omitted')
 })
 
+test('implicit-prefix-caching host skips compression on the Responses path too', async () => {
+  mockState.enabled = true
+  mockState.effectiveWindow = 100_000
+  const messages = buildLongConversation(30, 5_000)
+
+  const body = await captureResponsesRequestBody(messages, 'gpt-4o', {
+    baseUrl: 'https://api.openai.com/v1',
+  })
+  const outputs = (body.input as Array<{ type?: string; output?: string }>)
+    .filter(item => item.type === 'function_call_output')
+
+  expect(outputs).toHaveLength(30)
+  for (const item of outputs) {
+    expect(item.output).not.toContain('chars omitted')
+    expect(item.output).not.toContain('[…truncated')
+  }
+})
+
 // ============================================================================
 // FIX: stub preserves tool name and args — model can re-invoke if needed
 // ============================================================================