mixdog 0.9.2 → 0.9.4

package/src/output-styles/default.md

@@ -7,21 +7,46 @@ keep-coding-instructions: true
 
 # Output Style
 
-Mixdog default — the most detailed of the three styles, but only as long as the
-task warrants.
+Mixdog default — the most detailed style, but always summary-form, never
+essay-form. Depth comes from picking the right facts, not from explaining more.
 
-- Lead with the outcome, then add the supporting detail that matters: what
-  changed, key evidence (paths, commands, errors, verification), and important
-  context. Include trade-offs or follow-up only when they actually matter.
-- Use a few bullets or short paragraphs when they add signal; this style may run
-  longer than Simple, but match length to the work — do not pad a small change
-  into a full report. Cut anything that does not earn its place.
+Content
+- Lead with the outcome in one short sentence, then only the detail that
+  matters: what changed, key evidence (paths, commands, errors, verification).
+- Summarize at the concept level: name the problem/behavior and the direction,
+  not the code path. Cite a symbol or path only as an anchor, never as the
+  explanation.
+- Compress by cutting content (filler, hedging, connective padding, restated
+  facts), not by clipping grammar: keep natural, complete sentences in the
+  user's language — never telegraph-style stub endings. Technical terms and
+  code stay exact.
+- State conclusions, not reasoning: no mechanism walkthroughs, background, or
+  chained qualifiers unless the user asks. One decisive fact beats three
+  hedges.
+- Say each point once: problem and fix in ONE compact statement, not a
+  restated pair. Prefer fewer, denser items over full coverage of every
+  nuance.
+- Size budget: roughly TWICE the Simple style — per point about 2 rendered
+  lines, whole report ~10–15 lines. Spend the extra room on evidence and
+  context Simple would drop, not on longer sentences.
 - Use labels such as `바뀐 점`, `확인한 것`, and `남은 리스크/다음 단계`
   in final reports to structure the summary; skip labels on interim progress.
 - Collapse trivial tasks to a couple of sentences instead of forcing sections.
 - Synthesize agent or retrieval results; never forward raw reports, long file
   lists, tool traces, or session metadata.
 - Do not hide blockers, failed verification, or required follow-up; surface them
-  explicitly rather than omitting them.
+  in one short clause.
 - Keep paths, commands, symbols, API names, code, and exact errors verbatim.
+
+Layout (hard rules)
+- One bullet or numbered item = one idea, at most 2 rendered lines including
+  its sub-bullet. If it needs more, cut the detail — do not add lines.
+- Open each list item with a short **bold key point**, then the brief
+  elaboration — never bury the point mid-sentence.
+- Insert a blank line between numbered items, and between any list items that
+  run past one line (loose list). Never emit a wall of consecutive multi-line
+  items.
+- Keep paragraphs to ~3 lines max, with a blank line between paragraphs,
+  lists, and code blocks.
+- Nest at most one sub-level; deeper detail means you are over-explaining.
 - Never name this style unless asked.

package/src/output-styles/{oneline.md → extreme-minimal.md}

@@ -1,14 +1,15 @@
 ---
-name: oneline
-title: Oneline
+name: extreme-minimal
+title: Extreme Minimal
 description: Single sentence under 100 characters
-aliases: one-line, one line, mono
+aliases: extreme, oneline, one-line, one line, mono
 keep-coding-instructions: true
 ---
 
 # Output Style
 
-Oneline — the most minimal style: exactly one sentence, under 100 characters.
+Extreme minimal — the most compressed style: exactly one sentence, under 100
+characters.
 
 - Reply with a SINGLE sentence, always under 100 characters. Never a second
   sentence, clause pile-up, or run-on that smuggles in extra facts.

package/src/output-styles/minimal.md

@@ -2,7 +2,6 @@
 name: minimal
 title: Minimal
 description: One- or two-sentence summary
-aliases: extreme, extreme-simple
 keep-coding-instructions: true
 ---
 
@@ -13,6 +12,10 @@ Minimal — a very short summary: one or two sentences, nothing more.
 - Summarize only the net result in one short sentence; add a second short
   sentence only if a second fact (verification, blocker) genuinely needs it.
   Never cram unrelated facts into one run-on line just to stay at one sentence.
+- Size budget: roughly HALF the Simple style — 1–2 plain sentences, ~2–3
+  rendered lines at most, however large the task was.
+- Compress by cutting content, not grammar: natural, complete sentences only.
+  Concept-level only — never walk through code or mechanisms.
 - Summarize, never itemize: do not describe which files changed or how they were
   edited. State only what the change accomplishes.
 - No headings, bullets, numbered lists, labels, or sections — plain sentences

package/src/output-styles/simple.md

@@ -8,16 +8,31 @@ keep-coding-instructions: true
 
 # Output Style
 
-Practical concise — outcome-first handoffs for coding work: summarize the result,
-do not narrate the change.
+Practical concise — outcome-first handoffs for coding work: summarize the
+result, do not narrate or explain the change.
 
 - Open with the outcome in one sentence: done, blocked, or awaiting a decision.
+- Summarize at the concept level: name the behavior and the direction, not the
+  code path. Cite a symbol/path only as an anchor, never as the explanation.
+- Compress by cutting content (filler, hedging, pleasantries, restated facts),
+  not by clipping grammar: keep natural, complete sentences in the user's
+  language — never telegraph-style stub endings. Technical terms and code stay
+  exact.
 - Summarize what the change accomplishes rather than listing every file and how
   each was edited. Name a path (`file_path:line_number`) only when the reader
   truly needs it to navigate — not as a per-file changelog.
-- Keep controlled detail: usually 1–3 short bullets or 2–4 sentences total. No
-  step-by-step narration, no exhaustive file/line inventory. Expand only when the
-  user asks, scope is ambiguous, or a blocker needs concrete next steps.
+- Keep controlled detail: usually 1–3 short bullets or 2–3 sentences total.
+  State each point once — outcome or fix direction, not both restated. No
+  step-by-step narration or file/line inventory.
+- Size budget: roughly HALF the Default style and TWICE Minimal — per point
+  one rendered line, whole reply ~5–7 lines. Above that you are writing
+  Default; below ~3 lines consider whether prose (Minimal) reads better.
+- Layout: one idea per bullet, ONE line each (two only when a verbatim
+  path/error forces it). Lead each item with a short bold key phrase. Put a
+  blank line between multi-line list items — never emit a dense wall of text.
+- If a point runs past one line, cut the elaboration instead of wrapping;
+  detail beyond the key phrase + one clause belongs to the Default style, not
+  this one.
 - On final handoffs, optional labels such as `바뀐 점`, `확인한 것`, and
   `남은 리스크/다음 단계` fit Korean-facing profiles; use plain English labels
   when the thread is English. Do not label interim progress.
@@ -26,6 +41,6 @@ do not narrate the change.
 - Do not hide blockers, failed verification, or required follow-up; state them
   in one short clause.
 - Keep paths, commands, symbols, API names, code, and exact errors verbatim.
-- Skip filler, acknowledgments, and repeated conclusions; if verification was
-  not run, say so once.
+- Skip filler, acknowledgments, hedging, and repeated conclusions; if
+  verification was not run, say so once.
 - Never name this style unless asked.

package/src/repl.mjs

@@ -1,16 +1,16 @@
 /**
- * mixdog REPL — styled inline terminal loop over the ported mixdog brain.
+ * mixdog REPL — styled inline terminal loop over the mixdog session runtime.
  *
- * Drives the *ported mixdog brain* through mixdog-session-runtime.mjs:
+ * Drives the session runtime through mixdog-session-runtime.mjs:
  * createSession + askSession own agentLoop/provider/tools/compaction, while
  * this module stays presentation-only: markdown-rendered replies, tool-call
  * cards, a per-turn statusline footer, slash commands, and arrow-key history.
  *
  * Flow:  stdin line → runtime.ask(prompt) → onTextDelta streams tokens to
- *        stdout live → tool calls render as cards → on turn end we re-render
- *        the assistant text as markdown → statusline footer.
+ * stdout live → tool calls render as cards → on turn end we re-render
+ * the assistant text as markdown → statusline footer.
  *
- * STREAMING DECISION (approach (a) from the brief):
+ * STREAMING DECISION:
  *   Live token streaming via onTextDelta conflicts with post-hoc markdown
  *   rendering (you can't style a heading until you've seen the whole line).
  *   We choose: stream raw tokens live so the turn FEELS alive, then on turn

package/src/rules/agent/00-common.md

@@ -15,3 +15,5 @@
 - Banned as pure cost: report headings, markdown tables (unless requested),
   prose narration, raw logs/tool traces, speculative next-checks, restated
   brief, articles/politeness.
+- Exception: a runtime wrap-up directive (exploration budget reached)
+  overrides this — then summarize done/remaining/blocking as instructed.

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

@@ -6,16 +6,13 @@ kind: retrieval
 
 # Role: explorer
 
-Locator only: likely file/symbol/line anchors; no analysis, debugging, decisions,
-or recommendations.
+You are a one-shot locator, not a researcher.
 
-Output only:
-- `path:line — symbol/name — short reason`
-- or `EXPLORATION_FAILED`
-
-No preambles/tool-call preambles, bullets, headings, summaries, code quotes,
-verdicts, or invented coordinates. Weak anchors: `?`.
+Procedure: send ONE turn containing one `grep` (all synonyms in one
+`pattern:[...]`, output_mode content_with_context) plus one `code_graph`
+call. The results contain path:line — answer immediately from them.
+If both miss, answer `EXPLORATION_FAILED`. Do not send a second lookup turn.
 
-One batched lookup turn; first plausible anchor wins. No verification loop,
-synonym sweep, or proof-chasing. Hard stop after 5 tool calls; if uncertain,
-return best weak anchors with `?`.
+Answer format, nothing else:
+- up to 5 lines of `path:line — symbol/name — short reason` (append `?` if weak)
+- or `EXPLORATION_FAILED`

package/src/rules/lead/lead-brief.md

@@ -0,0 +1,12 @@
+# Lead Brief Contract
+
+- Brief = one-line fragments `Goal:` `Anchors:` `Allow/Forbid:` `Deliver:`
+  `Verify:` (+`Stop:` heavy-worker). No role-known rules, background, or
+  motivation — minimum characters, maximum information.
+- Full brief only on fresh spawn or `respawned: true` (dead-tag send =
+  cold session; re-supply anchors). Live-session follow-ups = delta only;
+  never restate Goal/rules.
+- Never `send` mid-run; batch all adjustments into ONE follow-up after
+  completion. Interrupt only to cancel.
+- All agent communication in English.
+- Referenced spec/test file beats its summary in the brief.

package/src/rules/lead/lead-tool.md

@@ -1,13 +1,6 @@
 # Lead Tool Use
 
-- Lead owns repo-local shell work: git, build, test, run, and verification commands.
+- Lead owns repo-local shell work: run git/build/test/verification commands via
+  `shell` directly; do not delegate them to agents.
 - Use the current project/workspace selected by the session. Only change the work project when the user asks for a different project or a tool call explicitly needs another project root.
-- Use `shell` directly for approved git/build/test/run work; do not delegate those commands to agents.
 - Use `agent` for scoped implementation, research, review, and debugging, not for git commit/push/stash or Ship.
-- Reuse the same agent tag/session for follow-up on the same scope (`send` or
-  `spawn` with the same tag reuses a live session). Spawn a new tag only for a
-  genuinely independent scope.
-- Briefs: minimum characters, maximum information. Fixed one-line fragment
-  fields — `Goal:` `Anchors:` `Allow/Forbid:` `Deliver:` `Verify:` (+`Stop:` for
-  heavy-worker). Omit role-known rules (git/preamble bans, output format),
-  background, motivation; non-actionable tokens are wasted cost.

package/src/rules/shared/01-tool.md

@@ -1,6 +1,8 @@
 # Tool Use
 
-- Independent lookups MUST batch in one turn; serialize only when a call needs a prior result.
+- Independent lookups MUST batch in one turn; serialize only when a call needs
+  a prior result. This includes edit loops: batch the post-edit verification
+  read with the next target's lookup instead of emitting single-call turns.
 - Target validity comes first: symbols/callers/deps → `code_graph`; exact text in
   a verified scope → `grep`; unknown path/name → `find`; structure → `glob`;
   dirs → `list`; verified file → `read`; broad unknown with no anchor →
@@ -10,10 +12,14 @@
   `code_graph symbols[]`). Refine from returned paths; do not repeat equivalent
   patterns or scopes.
 - On miss/error, normalize the target once and switch tool; on a plausible hit,
-  stop searching and answer from the framed context. Do not follow
-  `content_with_context` with `read` unless the needed span is not shown.
+  stop searching and answer from the framed context.
+- Lookup budget: retrieval exists to reach the NEXT action (edit, answer,
+  handoff), not to build certainty. One anchor is enough to act on; re-reading
+  or re-grepping an area you already saw this session is waste. When acting
+  and looking are both possible, act.
 - Avoid read fragmentation: `read` uses `offset`/`limit` only. If you need 2+
   spans from one or more known files, make one batched `read` call with
-  `{path,offset,limit}` region objects instead of serial reads.
-- `search`/`web_fetch` for external info; `recall` for history.
+  `{path,offset,limit}` region objects instead of serial reads. Adjacent spans
+  in the same file (within a few hundred lines) are ONE window, not repeated
+  reads.
 - Don't mix `apply_patch` with shell or other state-changing calls in one turn.

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

@@ -17,6 +17,31 @@ function envPositiveInt(name, fallback) {
 // to raise/lower the safety ceiling, never used as a per-agent task budget.
 export const LEAD_MAX_LOOP_ITERATIONS = envPositiveInt('MIXDOG_AGENT_MAX_LOOP', 200);
 
+// Worker soft cap — behavior-based ONLY. There is intentionally no fixed
+// iteration threshold: a legitimately long worker task (many edit/verify
+// rounds) must never be cut off by a count. The wrap-up is armed exclusively
+// by the steering ladder's early-cap signal (repeated ignored level-2 steers
+// with zero edits = confirmed read-only stall), after the ladder's own
+// warnings have gone out. The env knob remains as an opt-in count for
+// operators who want one; by default it is effectively disabled.
+export const WORKER_SOFT_CAP_ITERATIONS = envPositiveInt('MIXDOG_AGENT_SOFT_CAP', Number.MAX_SAFE_INTEGER);
+
+// Agents subject to the soft cap: implementation workers that should wrap up
+// once the exploration budget is spent. Reviewer and hidden long-runner agents
+// (explorer / cycle / scheduler / …) are legitimately read-only long-running
+// and are EXEMPT — capping them would truncate a valid long read pass.
+const SOFT_CAP_AGENTS = new Set(['worker', 'heavy-worker', 'maintainer', 'debugger']);
+
+/**
+ * Is this session a delegated worker subject to the soft cap?
+ * Only worker/heavy-worker/maintainer/debugger. Lead, TUI (no agent),
+ * reviewer, and hidden agents return false.
+ */
+export function isWorkerSoftCapSession(sessionRef) {
+    const agent = sessionRef?.agent;
+    return typeof agent === 'string' && SOFT_CAP_AGENTS.has(agent);
+}
+
 /**
  * Resolve the hard cap used by agentLoop for this session.
  *

package/src/runtime/agent/orchestrator/agent-runtime/cache-strategy.mjs

@@ -10,7 +10,8 @@
  *   BP_1  system#1  (1h)  — shared tool policy + compact skill manifest
  *   BP_2  system#2  (1h)  — role/system rules (Lead / agent / hidden role)
  *   BP_3  system#3  (1h)  — stable memory/meta marker (sessionMarker system block; tier3)
- *   BP_4  messages  (5m)  — sliding tool_result / prior user-text tail
+ *   BP_4  messages  (5m agents/hidden; Lead linked to autoClear — see below) —
+ *         sliding tool_result / prior user-text tail
  *
  * Tool schemas still sit before system in the provider prompt prefix. We do
  * not spend a separate cache_control slot on tools; the first system BP covers
@@ -51,10 +52,14 @@ import { getHiddenAgent } from '../internal-agents.mjs';
  */
 function isOneShotMaintenanceAgent(agent) {
     const hidden = getHiddenAgent(agent);
+    // Shipped cycle1/2/3 declare toolSchemaProfile:'none' (no tool schema at
+    // all); 'llm-only' is the legacy alias for the same one-shot LLM-only
+    // pattern. Multi-turn maintenance roles (scheduler-task/webhook-handler)
+    // are 'read-write-search' and stay excluded.
     return Boolean(
         hidden
         && hidden.kind === 'maintenance'
-        && hidden.toolSchemaProfile === 'llm-only',
+        && (hidden.toolSchemaProfile === 'llm-only' || hidden.toolSchemaProfile === 'none'),
     );
 }
 
@@ -71,8 +76,16 @@ function isOneShotMaintenanceAgent(agent) {
  * warm window survives per-session gaps. The volatile message tail (BP4) is
  * per-session and trace data (2026-06) shows request gaps are p99 ≈ 4.5min —
  * 5m+ gaps mean a cold tail anyway, and the smart-compact path rebuilds the
- * history at that boundary. So every session's tail uses the cheaper 5m TTL
- * (1.25x write vs 2x), aligned with the 5m terminal-reap window for agents.
+ * history at that boundary. So hidden-agent and public-agent sessions keep
+ * the cheaper 5m tail TTL (1.25x write vs 2x), aligned with the 5m
+ * terminal-reap window for agents.
+ *
+ * Lead sessions are linked to the user's autoClear idle-sweep config
+ * instead of the fixed 5m default (see resolveLeadMessagesTtl): a Lead
+ * session that autoClear will only reap after a long/never idle window
+ * benefits from the 1h tail TTL (fewer writes over a long-lived session),
+ * while a short idle-sweep window means the tail is going cold anyway and
+ * 5m is cheaper to write.
  * (Tail TTL only affects explicit-breakpoint providers — Anthropic; no-op
  * elsewhere.)
  *
@@ -84,15 +97,41 @@ function isOneShotMaintenanceAgent(agent) {
  * the 1h TTL expiry (writes every run, 0 reads). All layers go 'none' for
  * these roles — single-iteration calls pay the write premium with no reuse.
  */
-export function resolveCacheStrategy(agent) {
+
+/**
+ * Lead-session BP4 (messages tail) TTL, linked to the autoClear idle-sweep
+ * config (config.mjs `autoClear: { enabled, idleMs }`, normalized via
+ * session-runtime/config-helpers.mjs normalizeAutoClearConfig):
+ *   - autoClear disabled                → '1h' (session may live indefinitely;
+ *     amortize the 2x write premium over a long-lived tail)
+ *   - idleMs >= 1h (3_600_000ms)        → '1h' (idle-sweep window is at least
+ *     as long as the 1h TTL, so the longer TTL is never wasted)
+ *   - otherwise (shorter idle-sweep)    → '5m' (session reaps before a 1h
+ *     write would ever be re-read; cheaper 5m write wins)
+ */
+export function resolveLeadMessagesTtl(autoClear) {
+    if (autoClear && autoClear.enabled === false) return '1h';
+    const idleMs = Number(autoClear?.idleMs);
+    if (Number.isFinite(idleMs) && idleMs >= 3_600_000) return '1h';
+    return '5m';
+}
+
+export function resolveCacheStrategy(agent, { autoClear } = {}) {
     if (isOneShotMaintenanceAgent(agent)) {
         return { tools: 'none', system: 'none', tier3: 'none', messages: 'none' };
     }
     if (getHiddenAgent(agent)) {
         return { tools: 'none', system: '1h', tier3: '1h', messages: '5m' };
     }
-    // Lead + public agents: per-session volatile tail -> 5m (see doc above).
-    return { tools: 'none', system: '1h', tier3: '1h', messages: '5m' };
+    if (agent && agent !== 'lead') {
+        // Public (non-hidden, non-lead) agents keep the flat 5m tail — only
+        // the Lead session's tail is linked to autoClear.
+        return { tools: 'none', system: '1h', tier3: '1h', messages: '5m' };
+    }
+    // Lead session (agent === 'lead', or no agent — raw/CLI callers default
+    // to Lead behavior): message tail TTL is linked to autoClear (see
+    // resolveLeadMessagesTtl).
+    return { tools: 'none', system: '1h', tier3: '1h', messages: resolveLeadMessagesTtl(autoClear) };
 }
 
 /**
@@ -200,6 +239,25 @@ function normalizePromptCacheNamespace(value) {
     return s.replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'mixdog-shared';
 }
 
+function fitPromptCacheKey(value, fallback = 'mixdog-shared') {
+    const s = normalizePromptCacheNamespace(value || fallback);
+    if (s.length <= 64) return s;
+    const hash = shortHash(s, 12);
+    const head = s.slice(0, Math.max(1, 64 - hash.length - 1));
+    return `${head}-${hash}`;
+}
+
+function codexThreadPromptCacheKey(opts, namespace) {
+    const explicit = cleanString(opts?.providerCacheKey)
+        || cleanString(opts?.promptCacheKey)
+        || cleanString(opts?.session?.promptCacheKey);
+    if (process.env.MIXDOG_OAI_CACHE_KEY_SHARED === '1') {
+        return fitPromptCacheKey(explicit || namespace, 'mixdog-codex');
+    }
+    const sessionKey = cleanString(opts?.sessionId || opts?.session?.id);
+    return fitPromptCacheKey(sessionKey || explicit || namespace, namespace);
+}
+
 function summarizePromptCacheTools(tools) {
     return (tools || []).map(t => ({
         type: cleanString(t?.type) || 'function',
@@ -211,13 +269,19 @@ function summarizePromptCacheTools(tools) {
 
 /**
  * Build a stable, prefix-scoped prompt_cache_key for OpenAI-style key-prefix
- * providers. The base namespace still comes from resolveProviderCacheKey()
- * (so overrides keep working), but a model/system/tools hash is appended so
- * unrelated main/worker prefixes do not evict each other inside one shared
- * provider lane.
+ * providers. OpenAI OAuth follows Codex's thread-scoped key by default:
+ * prompt_cache_key is the session/thread identity, clamped to the backend's
+ * 64-character limit. Other OpenAI-style providers keep the older
+ * namespace+prefix-hash key shape, but no longer get a shard suffix unless an
+ * explicit cache-lane override opts into it.
  */
 export function buildStableProviderPromptCacheKey(provider, opts, prefix = {}) {
     const namespace = normalizePromptCacheNamespace(resolveProviderCacheKey(opts, provider));
+    if (provider === 'openai-oauth'
+        && process.env.MIXDOG_OAI_CODEX_THREAD_CACHE_KEY !== '0'
+        && String(process.env.MIXDOG_OAI_CODEX_THREAD_CACHE_KEY || '').toLowerCase() !== 'false') {
+        return codexThreadPromptCacheKey(opts, namespace);
+    }
     const rawShards = prefix.cacheLaneShards ?? opts?.promptCacheLane?.shards ?? opts?.cacheLaneShards;
     const rawShardMode = String(rawShards ?? '').trim().toLowerCase();
     const autoLane = prefix.cacheLaneAuto === true
@@ -243,6 +307,16 @@ export function buildStableProviderPromptCacheKey(provider, opts, prefix = {}) {
         parallelToolCalls: prefix.parallelToolCalls === false ? false : true,
         cacheLaneSlot: laneEnabled ? shardSlot : null,
         cacheLaneShards: autoLane ? 'auto' : shardCount > 1 ? shardCount : null,
+        // Per-session cache-key isolation. R8 A/B (2026-07-03) showed parallel
+        // sessions sharing one prompt_cache_key evict each other's transcript
+        // body on the server cache node (same key -> same node; bodies differ),
+        // producing 8-23% genuine mid-session misses at tens of thousands of
+        // uncached tokens each. Mixing sessionId in costs only the small static
+        // prefix hit (~2-4k tokens) on a session's FIRST call — every later
+        // call's body cache is protected. Opt out: MIXDOG_OAI_CACHE_KEY_SHARED=1.
+        session: process.env.MIXDOG_OAI_CACHE_KEY_SHARED === '1'
+            ? null
+            : cleanString(opts?.sessionId || opts?.session?.id || '') || null,
     };
     const hash = shortHash(seed);
     const head = namespace.slice(0, Math.max(1, 64 - hash.length - laneSuffix.length - 1));
@@ -255,7 +329,7 @@ function providerEnvKey(provider) {
 
 const providerPromptCacheLaneAssignments = new Map();
 const PROVIDER_PROMPT_CACHE_LANE_MAX_ASSIGNMENTS = 4096;
-const DEFAULT_PROVIDER_PROMPT_CACHE_LANE_SHARDS = 12;
+const DEFAULT_PROVIDER_PROMPT_CACHE_LANE_SHARDS = 1;
 
 function promptCacheLaneGroupKey(provider, opts) {
     return [
@@ -282,6 +356,10 @@ function parsePromptCacheLaneLimit(raw, fallback = DEFAULT_PROVIDER_PROMPT_CACHE
     return Math.floor(n);
 }
 
+function defaultPromptCacheLaneShards(_provider) {
+    return DEFAULT_PROVIDER_PROMPT_CACHE_LANE_SHARDS;
+}
+
 function assignPromptCacheLaneSlot(provider, opts, shards, seed, { auto = false } = {}) {
     const explicit = opts?.promptCacheLaneSlot ?? opts?.cacheLaneSlot;
     const explicitSlot = Number(explicit);
@@ -308,14 +386,9 @@ function assignPromptCacheLaneSlot(provider, opts, shards, seed, { auto = false
 }
 
 /**
- * Resolve a stable cache-lane slot for OpenAI-style prompt cache sharding.
- * The shard count is the maximum same-prefix parallelism; each final shard key
- * is still internally queued and rate-shaped by the transport for stable server
- * cache hits. OpenAI's prompt caching guide says one prefix+prompt_cache_key
- * combination can overflow around 15 RPM, so transport owns that timing gate.
- * Default to the safer 12-lane pool. Explicit 0/auto/unbounded keeps the
- * no-cap execution mode for callers that prefer throughput over stricter
- * same-key serialization.
+ * Resolve an optional cache-lane slot for OpenAI-style prompt cache sharding.
+ * Codex does not shard prompt_cache_key by default, so every provider now gets
+ * one un-suffixed key unless an env/config override opts into shards.
  */
 export function resolveProviderPromptCacheLane(provider, opts = {}, config = {}) {
     const envKey = providerEnvKey(provider);
@@ -338,7 +411,7 @@ export function resolveProviderPromptCacheLane(provider, opts = {}, config = {})
             ?? env[`MIXDOG_${envKey}_CACHE_MAX_PARALLEL`]
             ?? env.MIXDOG_OPENAI_CACHE_LANE_SHARDS
             ?? env.MIXDOG_OPENAI_CACHE_MAX_PARALLEL);
-    const shards = parsePromptCacheLaneLimit(rawLimit, DEFAULT_PROVIDER_PROMPT_CACHE_LANE_SHARDS);
+    const shards = parsePromptCacheLaneLimit(rawLimit, defaultPromptCacheLaneShards(provider));
     const auto = shards <= 0;
     const seed = cleanString(
         opts?.promptCacheLaneSeed
@@ -359,8 +432,8 @@ export function resolveProviderPromptCacheLane(provider, opts = {}, config = {})
     };
 }
 
-export function buildProviderCacheOpts(provider, sessionId, agent) {
-    const ttls = resolveCacheStrategy(agent);
+export function buildProviderCacheOpts(provider, sessionId, agent, options = {}) {
+    const ttls = resolveCacheStrategy(agent, options);
     const capability = cacheCapabilityForProvider(provider);
     if (capability === 'explicit-breakpoint') {
         // 2026-03-06 Anthropic dropped default TTL 1h→5m. We send
@@ -368,6 +441,10 @@ export function buildProviderCacheOpts(provider, sessionId, agent) {
         // Verified 2026-04-17 (ephemeral_1h_input_tokens=4722).
         return { cacheStrategy: ttls };
     }
+    // NOTE: createSession's direct-call site (manager.mjs) only invokes this
+    // for explicit-breakpoint (Anthropic-family) providers, so this branch
+    // stays reachable only from other callers (none in-tree today) — keeping
+    // it here preserves the documented public API/behavior of this function.
     if (provider === 'openai') {
         // Public OpenAI API: prompt_cache_retention extends prefix retention.
         // openai-oauth rejects the header — falls through to default.

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

@@ -24,28 +24,21 @@ import { loadConfig } from '../config.mjs';
 import { AGENT_OWNER } from '../agent-owner.mjs';
 
 import {
-    COMPACT_TYPE_RECALL_FASTTRACK,
     COMPACT_TYPE_SEMANTIC,
     normalizeCompactType,
 } from '../session/compact.mjs';
 
-function memoryModuleEnabled(config) {
-    const entry = config?.modules?.memory;
-    if (entry && typeof entry === 'object' && entry.enabled === false) return false;
-    return true;
-}
-
 function normalizeAgentCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
     const raw = value && typeof value === 'object' ? value : {};
     let compactType = normalizeCompactType(
         raw.compactType ?? raw.compact_type ?? raw.type,
         COMPACT_TYPE_SEMANTIC,
     );
-    // recall-fasttrack depends on memory ingest/recall; fall back to semantic when
-    // the memory module is disabled (same rule as Lead session runtime).
-    if (compactType === COMPACT_TYPE_RECALL_FASTTRACK && memoryEnabled === false) {
-        compactType = COMPACT_TYPE_SEMANTIC;
-    }
+    // Memory is now always-on, so recall-fasttrack no longer downgrades to
+    // semantic. `memoryEnabled` is retained as a param for API compatibility
+    // but is intentionally ignored (fasttrack drains run on-demand regardless
+    // of the recap/background-cycle toggle) — mirrors config-helpers.mjs.
+    void memoryEnabled;
     return {
         ...raw,
         auto: raw.auto !== false && raw.enabled !== false,
@@ -109,9 +102,7 @@ export function prepareAgentSession({
     try {
         const cfg = loadConfig({ secrets: false });
         if (cfg?.compaction && typeof cfg.compaction === 'object') {
-            compaction = normalizeAgentCompactionConfig(cfg.compaction, {
-                memoryEnabled: memoryModuleEnabled(cfg),
-            });
+            compaction = normalizeAgentCompactionConfig(cfg.compaction);
         }
     } catch { /* config is best-effort for agent compaction policy */ }
     const sessionOpts = {