mixdog 0.9.149 → 0.9.151

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

@@ -45,7 +45,6 @@ import {
     enforceSemanticSummarySchema,
     fitSemanticSummaryMessage,
     fitRecallFastTrackSummaryMessage,
-    stripNestedSummaryHeaderLines,
     RECALL_TAIL_TRUNCATION_MARKER,
     RECALL_TAIL_SHORT_TRUNCATION_MARKER,
 } from './summary.mjs';
@@ -57,7 +56,6 @@ import {
     fitRecallHandoffText,
     conversationLinesFromMemoryText,
     excludeTailFromConversation,
-    stripWorkingFileSections,
 } from './handoff.mjs';
 
 // Post-compact file re-attachment: re-inject fresh reads
@@ -555,12 +553,12 @@ export function recallFastTrackCompactMessages(messages, budgetTokens, opts = {}
 //
 // Turns are anchored on user-role boundaries: each turn = a user message plus
 // the assistant/tool/system/developer messages that follow it. Recall-fasttrack
-// keeps the newest live turn verbatim. Older conversation comes from memory.
+// keeps the newest five live turns verbatim. Older conversation comes from memory.
 //
 // Partial tool_call/tool_result pairs that truncation might leave behind are
 // repaired by sanitizeToolPairs/reconcileDedupStubs in the caller, so pairing
 // stays valid even after trimming.
-const RECALL_TAIL_USER_MAX = 1;
+const RECALL_TAIL_USER_MAX = 5;
 const RECALL_TAIL_TOKEN_CAP = DEFAULT_COMPACTION_KEEP_TOKENS; // 8k
 // A caller may request a cap smaller than one structurally valid message. Keep
 // the cap strict above this unavoidable floor while retaining a real anchor.
@@ -695,10 +693,10 @@ function truncateTailToCap(messages, cap) {
     return estimateMessagesTokens(sanitized) <= cap ? sanitized : [];
 }
 
-function splitRecallFitInputs(recallText, previousSummary) {
+function splitRecallFitInputs(recallText) {
     return {
         recall: String(recallText || '').trim(),
-        prior: previousSummary ? stripNestedSummaryHeaderLines(previousSummary) : '',
+        prior: '',
     };
 }
 
@@ -799,7 +797,7 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
     }
     const sanitized = redactToolCallSecretsInMessages(baseSanitized);
 
-    const { system: safeSystem, live, previousSummary } = splitLiveCompactionContext(sanitized);
+    const { system: safeSystem, live } = splitLiveCompactionContext(sanitized);
     const recallTailOpts = {
         maxUsers: opts.recallTailMaxUsers ?? opts.tailTurns ?? RECALL_TAIL_USER_MAX,
         tokenCap: (() => {
@@ -815,8 +813,8 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
         head: recallHead,
         lastTurnStartIdx = recallHead.length,
     } = selectRecallPreservedTail(live, recallTailOpts);
-    const recallFit = splitRecallFitInputs(opts.recallText, previousSummary);
-    if (recallHead.length === 0 && !previousSummary
+    const recallFit = splitRecallFitInputs(opts.recallText);
+    if (recallHead.length === 0
         && !(recallFit.recall || recallFit.prior || opts.allowEmptyRecall === true)) {
         throw new Error('recallFastTrackCompactMessages: no compactable prior history before preserved tail');
     }
@@ -848,44 +846,31 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
     const recallRoom = (Number.isFinite(recallTokenCap) && recallTokenCap > 0)
         ? Math.min(recallRoomUncapped, Math.max(512, recallTokenCap - tailTokens))
         : recallRoomUncapped;
-    const priorWithoutWorkingFiles = stripWorkingFileSections(recallFit.prior);
-    const priorLines = new Set(
-        priorWithoutWorkingFiles
-            .split('\n')
-            .map((line) => line.trim())
-            .filter(Boolean),
-    );
-    const toolLines = collectToolOutcomeLines(live)
-        .filter((line) => !priorLines.has(String(line || '').trim()));
-    const workingFiles = collectWorkingFileGroups(live, undefined, {
+    const toolLines = collectToolOutcomeLines(recallHead)
+        .filter((line) => !recallFit.recall.includes(String(line || '').trim()));
+    const workingFiles = collectWorkingFileGroups(recallHead, undefined, {
         cwd: opts.cwd,
-        previousSummary: recallFit.prior,
+        previousSummary: '',
         now: Date.now(),
     });
     const conversationLines = excludeTailFromConversation(
         conversationLinesFromMemoryText(recallFit.recall),
         recallTail,
-    ).filter((line) => !priorLines.has(String(line || '').trim()));
+    );
     const composedRecall = composeRecallHandoff({
         sessionId: opts.sessionId || '',
         conversationLines,
         toolLines,
         workingFiles,
     });
-    const priorRoom = priorWithoutWorkingFiles
-        ? Math.max(256, Math.floor((recallRoom - 200) * 0.55))
-        : 0;
-    const currentRoom = Math.max(256, recallRoom - priorRoom - 200);
+    const currentRoom = Math.max(256, recallRoom - 200);
     const fittedRecall = fitRecallHandoffText(composedRecall, currentRoom);
-    const priorPart = priorWithoutWorkingFiles
-        ? fitRecallHandoffText(priorWithoutWorkingFiles, priorRoom)
-        : '';
     const summaryMessage = fitRecallFastTrackSummaryMessage(
         oldHistory,
         fittedRecall,
         recallRoom,
         recallMeta,
-        priorPart,
+        '',
     );
     if (!summaryMessage) {
         throw new Error(`recallFastTrackCompactMessages: summary cannot fit remaining budget=${recallRoom}`);
@@ -929,18 +914,18 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
         recallRoom,
         recallChars: recallFit.recall.length,
         recallBytes: textByteLength(recallFit.recall),
-        priorChars: recallFit.prior.length,
-        priorBytes: textByteLength(recallFit.prior),
+        priorChars: 0,
+        priorBytes: 0,
         summaryMessageChars: summaryContent.length,
         summaryMessageBytes: textByteLength(summaryContent),
         recallEmpty: !recallFit.recall,
         priorEmpty: !recallFit.prior,
         recallTruncatedInSummary: !!recallFit.recall && !summaryContent.includes(recallFit.recall),
-        priorTruncatedInSummary: !!priorPart && !summaryContent.includes(priorPart),
+        priorTruncatedInSummary: false,
         tailTruncated: recallTail.some((m) => messageContentHasMarker(m, RECALL_TAIL_TRUNCATION_MARKER) || messageContentHasMarker(m, RECALL_TAIL_SHORT_TRUNCATION_MARKER)),
         fileReattached: reattach.reattached,
         tailOptions: recallTailOpts,
-        previousSummary: !!previousSummary,
+        previousSummary: false,
         durationMs: Date.now() - startedAt,
     };
     compactDebugLog('recall-fasttrack result', diagnostics);

package/src/runtime/agent/orchestrator/session/loop/recall-fasttrack.mjs

@@ -19,43 +19,11 @@ import {
     compactDebugLog,
 } from './compact-debug.mjs';
 import { positiveTokenInt } from './env.mjs';
-import { TOOL_OUTPUT_MAX_BYTES } from '../../tools/builtin/tool-output-limit.mjs';
 
 // ── Digest injection ────────────────────────────────────────────────────────
-// Inject a small newest-first digest plus an instruction telling the model to
-// pull details lazily via recall(sessionId/query/period). The memory DB holds
-// the full session (ingest_session below), and raw rows are embedded
-// synchronously at ingest, so recall serves everything the old full-dump
-// injection used to carry.
-// Default digest cap = the SHARED tool-output limit (TOOL_OUTPUT_MAX_BYTES,
-// 50KB default, env MIXDOG_TOOL_OUTPUT_MAX_BYTES) — the digest injection is
-// budgeted like any other tool result, not a special context share.
-// compaction.recallDigestMaxKb still overrides per-session.
-export const DIGEST_DEFAULT_MAX_KB = Math.max(1, Math.floor(TOOL_OUTPUT_MAX_BYTES / 1024));
-
-// Byte-capped line-boundary truncation. Digest source is newest-first, so
-// keeping the HEAD keeps the newest turns.
-// Exported for manager/compaction-runner.mjs (manual//clear digest path) so
-// both digest producers share one cap implementation.
-export function truncateToKb(text, maxKb) {
-    const maxBytes = Math.max(1, maxKb) * 1024;
-    const s = String(text || '');
-    if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;
-    const lines = s.split('\n');
-    const marker = '[digest truncated at ' + maxKb + 'KB]';
-    const contentBudget = maxBytes - Buffer.byteLength(marker, 'utf8');
-    const out = [];
-    let used = 0;
-    for (const line of lines) {
-        const cost = Buffer.byteLength(line, 'utf8') + 1;
-        if (used + cost > contentBudget) break;
-        out.push(line);
-        used += cost;
-    }
-    return out.length ? out.join('\n') + '\n' + marker : marker;
-}
-
-function buildRecallDigestText(sessionId, digestBody, maxKb) {
+// Memory provides every available summary/raw row. Only the final compaction
+// budget is allowed to reduce the handoff.
+function buildRecallDigestText(sessionId, digestBody) {
     // No recall-usage instruction block here: the recall tool description
     // already carries the usage-pattern cheatsheet (tool-defs.mjs), so
     // repeating it per-compaction would be redundant injected tokens. The
@@ -64,7 +32,7 @@ function buildRecallDigestText(sessionId, digestBody, maxKb) {
     return [
         `[context compacted — session ${sessionId}]`,
         `Recent digest (newest first):`,
-        truncateToKb(digestBody, maxKb),
+        String(digestBody || '').trim(),
     ].join('\n');
 }
 
@@ -88,7 +56,17 @@ export function isUsableRecallDigestText(value) {
     return !!trimmed && !/^\((?:no results|no current session)\)$/i.test(trimmed);
 }
 
-export async function runRecallFastTrackCompact({ sessionRef, messages, compactBudgetTokens, compactPolicy, sessionId, signal }) {
+export const RECALL_FAST_TRACK_TAIL_TURNS = 5;
+
+export async function runRecallFastTrackCompact({
+    sessionRef,
+    messages,
+    compactBudgetTokens,
+    compactPolicy,
+    sessionId,
+    signal,
+    executeMemorySearch,
+}) {
     if (!sessionId) throw new Error('recall-fasttrack requires a session id');
     const startedAt = Date.now();
     const diagnostics = {
@@ -126,14 +104,15 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
     // watcher already persisted. Do not retransmit the live transcript through
     // the memory RPC: that duplicates canonical history and can exceed the
     // bounded HTTP request body before compaction gets a chance to run.
-    const digestMaxKb = positiveTokenInt(sessionRef?.compaction?.recallDigestMaxKb) || DIGEST_DEFAULT_MAX_KB;
     let digestBody = '';
     t0 = Date.now();
     try {
-        const browsed = await executeInternalTool('memory', {
+        const searchMemory = typeof executeMemorySearch === 'function'
+            ? executeMemorySearch
+            : (args, ctx) => executeInternalTool('memory', args, ctx);
+        const browsed = await searchMemory({
             action: 'search',
             sessionId,
-            limit: positiveTokenInt(sessionRef?.compaction?.recallDigestLimit) || 100,
             includeMembers: true,
             includeRaw: true,
             compactHandoff: true,
@@ -171,7 +150,7 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         try { process.stderr.write(`[loop] recall-fasttrack fail-safe abort (sess=${sessionId || 'unknown'}): stored session unavailable — keeping full history, no recall notice injected\n`); } catch {}
         throw new Error(`recall-fasttrack aborted: stored session memory unavailable; head preserved`);
     }
-    const digestText = buildRecallDigestText(sessionId, digestBody, digestMaxKb);
+    const digestText = buildRecallDigestText(sessionId, digestBody);
     diagnostics.finalRecallChars = digestText.length;
     diagnostics.finalRecallBytes = compactByteLength(digestText);
     const contextWindow = positiveTokenInt(compactPolicy?.contextWindow)
@@ -192,7 +171,7 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         // Empty/sentinel browse output was rejected above, so the handoff always
         // contains real stored session context.
         allowEmptyRecall: false,
-        tailTurns: compactPolicy.tailTurns,
+        tailTurns: RECALL_FAST_TRACK_TAIL_TURNS,
         keepTokens: compactPolicy.keepTokens,
         preserveRecentTokens: compactPolicy.preserveRecentTokens,
         recallTokenCap,

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -6,22 +6,17 @@
 import { createHash } from 'crypto';
 import { getProvider } from '../../providers/registry.mjs';
 import {
-    recallFastTrackCompactMessages,
     semanticCompactMessages,
     pruneToolOutputsUnanchored,
     effectiveBudget as compactEffectiveBudget,
     compactTypeIsRecallFastTrack,
     compactTypeIsSemantic,
     normalizeCompactType,
-    CONTEXT_SHARE_RATIO,
-    RECALL_TOKEN_CAP_FLOOR_TOKENS,
 } from '../compact.mjs';
 import { estimateMessagesTokens, estimateRequestReserveTokens, estimateTranscriptContextUsage, resolveCompactBufferRatio } from '../context-utils.mjs';
 import { executeInternalTool } from '../../internal-tools.mjs';
 import {
-    truncateToKb,
-    DIGEST_DEFAULT_MAX_KB,
-    isUsableRecallDigestText,
+    runRecallFastTrackCompact,
 } from '../loop/recall-fasttrack.mjs';
 import {
     positiveContextWindow,
@@ -159,58 +154,6 @@ async function callMemoryBounded(args, callerCtx, timeoutMs, executeMemory = exe
         try { outer?.removeEventListener?.('abort', onOuterAbort); } catch {}
     }
 }
-async function runRecallFastTrackForSession(session, sessionId, opts = {}) {
-    if (!sessionId) throw new Error('recall-fasttrack requires a session id');
-    const query = `session:${sessionId}:all-chunks`;
-    const querySha = createHash('sha256').update(query).digest('hex').slice(0, 16);
-    const callerCtx = {
-        callerSessionId: sessionId,
-        callerCwd: session?.cwd || undefined,
-        routingSessionId: sessionId,
-        clientHostPid: session?.clientHostPid,
-        signal: opts.signal || null,
-    };
-    const memoryTimeoutMs = recallMemoryTimeoutMs(session);
-    const executeMemory = typeof opts.executeInternalToolFn === 'function'
-        ? opts.executeInternalToolFn
-        : executeInternalTool;
-    // The transcript watcher already persists this session incrementally.
-    // Manual/clear compaction reads those rows directly instead of sending the
-    // entire live message array through the memory RPC again.
-    let recallText = '';
-    try {
-        const browsed = await callMemoryColdStart({
-            action: 'search',
-            sessionId,
-            limit: positiveContextWindow(session?.compaction?.recallDigestLimit) || 100,
-            includeMembers: true,
-            includeRaw: true,
-            compactHandoff: true,
-        }, callerCtx, memoryTimeoutMs, executeMemory);
-        recallText = typeof browsed === 'string' ? browsed : String(browsed?.text ?? browsed ?? '');
-        if (!isUsableRecallDigestText(recallText)) {
-            throw new Error('memory has no stored history for this session');
-        }
-    } catch (err) {
-        // Without real stored context we cannot safely replace the live head.
-        // Bail to the semantic fallback rather than injecting a false recall
-        // handoff.
-        try { process.stderr.write(`[session] recall-digest browse failed — bailing (sess=${sessionId}): ${err?.message || err}\n`); } catch {}
-        throw new Error(`recall-fasttrack search failed: ${err?.message || err}`);
-    }
-    return {
-        query,
-        querySha,
-        recallText: [
-            `session_id=${sessionId}`,
-            // Same byte cap as the loop digest path (recallDigestMaxKb,
-            // default = shared tool-output limit) — without it the memory
-            // renderer bounds the browse at ~200 rows × 1000 chars, letting a
-            // manual//clear compact process a far larger digest than loop's.
-            truncateToKb(recallText, positiveContextWindow(session?.compaction?.recallDigestMaxKb) || DIGEST_DEFAULT_MAX_KB),
-        ].map(v => String(v || '').trim()).filter(Boolean).join('\n\n'),
-    };
-}
 // Element-identity change detection (same approach as loop.mjs messagesArrayChanged): two
 // arrays are "unchanged" only when same length AND every slot is the same object
 // reference. Used to reject a no-op prune (which returns a fresh array whose
@@ -307,27 +250,27 @@ export async function runSessionCompaction(session, opts = {}) {
     let recallFastTrackError = null;
     if (compactTypeIsRecallFastTrack(compactType)) {
         try {
-            const recallPayload = await runRecallFastTrackForSession(session, resolvedSessionId, opts);
             const contextWindow = positiveContextWindow(session.contextWindow) || boundary;
-            const recallTokenCap = Math.max(
-                RECALL_TOKEN_CAP_FLOOR_TOKENS,
-                Math.floor(contextWindow * CONTEXT_SHARE_RATIO),
-            );
-            recallFastTrackResult = recallFastTrackCompactMessages(messages, budget, {
-                reserveTokens,
-                force: true,
-                recallText: recallPayload.recallText,
-                query: recallPayload.query,
-                querySha: recallPayload.querySha,
-                cwd: session.cwd,
-                // The stored-memory browse above returned real session context;
-                // empty/sentinel output already threw into semantic fallback.
-                allowEmptyRecall: false,
-                tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 1,
-                keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
-                preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
-                recallTokenCap,
+            const memoryTimeoutMs = recallMemoryTimeoutMs(session);
+            const executeMemory = typeof opts.executeInternalToolFn === 'function'
+                ? opts.executeInternalToolFn
+                : executeInternalTool;
+            recallFastTrackResult = await runRecallFastTrackCompact({
+                sessionRef: session,
+                messages,
+                compactBudgetTokens: budget,
+                compactPolicy: {
+                    reserveTokens,
+                    contextWindow,
+                    boundaryTokens: boundary,
+                    keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
+                    preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+                },
                 sessionId: resolvedSessionId,
+                signal: opts.signal || null,
+                executeMemorySearch: (args, callerCtx) => (
+                    callMemoryColdStart(args, callerCtx, memoryTimeoutMs, executeMemory)
+                ),
             });
             if (Array.isArray(recallFastTrackResult?.messages)) {
                 compacted = recallFastTrackResult.messages;
@@ -338,54 +281,6 @@ export async function runSessionCompaction(session, opts = {}) {
             try {
                 process.stderr.write(`[session] recall-fasttrack ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`);
             } catch { /* best-effort */ }
-            // Degraded-compact fallback: recall-fasttrack failed (empty recall,
-            // ingest error, fit failure). Before recording a hard failure, try
-            // the semantic path once so auto-clear/manual compaction still makes
-            // progress WITHOUT shipping an empty-recall summary. History is only
-            // replaced when the semantic summary actually succeeds.
-            if (semanticCompactionEnabledForSession(session)
-                && provider && typeof provider.send === 'function') {
-                try {
-                    semanticCompactResult = await semanticCompactMessages(
-                        provider,
-                        messages,
-                        opts.model || resolveSemanticSummaryModel(session, { budgetTokens: budget }) || session.model,
-                        budget,
-                        {
-                            reserveTokens,
-                            providerName: session.provider || provider?.name || null,
-                            sessionId: resolvedSessionId,
-                            cwd: session.cwd,
-                            signal: opts.signal || null,
-                            // Carries the session's wire identity so the
-                            // summary request stays on the session's own
-                            // prefix-cache slot instead of opening a second one.
-                            sendOpts: { session },
-                            promptCacheKey: session.promptCacheKey || null,
-                            providerCacheKey: session.promptCacheKey || null,
-                            timeoutMs: semanticCompactTimeoutMs(session, beforeMessageTokens),
-                            tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
-                            keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
-                            preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
-                            filterOldHistoryForIngest: opts.filterOldHistoryForIngest === true,
-                            force: true,
-                        },
-                    );
-                    if (Array.isArray(semanticCompactResult?.messages)) {
-                        compacted = semanticCompactResult.messages;
-                        compactError = null;
-                        addCompactUsageToSession(session, semanticCompactResult.usage);
-                        try {
-                            process.stderr.write(`[session] degraded compact: recall-fasttrack failed, semantic fallback succeeded (sess=${session.id || 'unknown'}, mode=${mode})\n`);
-                        } catch { /* best-effort */ }
-                    }
-                } catch (fallbackErr) {
-                    semanticCompactError = fallbackErr;
-                    try {
-                        process.stderr.write(`[session] degraded compact: semantic fallback also failed (sess=${session.id || 'unknown'}): ${fallbackErr?.message || fallbackErr}\n`);
-                    } catch { /* best-effort */ }
-                }
-            }
         }
     } else if (compactTypeIsSemantic(compactType)) {
         try {

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

@@ -40,11 +40,8 @@ import { getAgentRuntimeSync, warnAgentRuntimeResolveFailureOnce } from './agent
 import { ensureCodexWireSessionId, mintSessionId, mintUuidV7 } from './session-id.mjs';
 import { providerCacheKey } from './provider-cache-key.mjs';
 import { clearTurnCheckpoint, recoverTurnCheckpoint } from './turn-checkpoint.mjs';
-import {
-    IMPLICIT_APPROVAL_MODE,
-    workflowContextForApprovalMode,
-} from '../approval-mode.mjs';
-import { describeShellStartupPolicy } from '../../tools/builtin/runtime-capabilities.mjs';
+import { IMPLICIT_APPROVAL_MODE } from '../approval-mode.mjs';
+import { describeGitStartupState } from '../../tools/builtin/runtime-capabilities.mjs';
 import { captureOriginalUserCwd } from '../../../../shared/user-cwd.mjs';
 import { refreshSessionBp3Environment } from './prompt-utils.mjs';
 
@@ -314,6 +311,7 @@ export function createSession(opts) {
     // resolves explicit session signals first and never leaks the daemon's
     // install root (user-cwd.mjs safe fallback chain).
     const sessionCwdLine = opts.cwd || captureOriginalUserCwd();
+    const wantsGitStartupLine = toolsForRouting.some((tool) => tool?.name === 'git');
     const shellEnvironmentContext = [
         sessionCwdLine
             ? `- Cwd: ${sessionCwdLine} — the active Project root; relative paths and shell commands resolve here.`
@@ -321,8 +319,15 @@ export function createSession(opts) {
         !ownerIsAgent
             ? `- Shell: ${process.platform === 'win32' ? 'PowerShell' : 'Bash'}. Use ${process.platform === 'win32' ? 'PowerShell' : 'Bash'} syntax unless the user specifies otherwise.`
             : '',
-        toolsForRouting.some((tool) => tool?.name === 'shell')
-            ? describeShellStartupPolicy()
+        // A startup inventory of PATH binaries used to sit here; see
+        // runtime-capabilities.mjs for why it cannot be stated truthfully
+        // before a command has run. Whether the cwd is inside a repository is
+        // different: it is a property of this directory, true at startup and
+        // observable without spawning anything, and the git tool cannot infer
+        // it. Without it a session spends a call discovering `exited 128`, and
+        // repeats it per candidate path.
+        wantsGitStartupLine
+            ? describeGitStartupState(sessionCwdLine ? { cwd: sessionCwdLine } : {})
             : '',
     ].filter(Boolean).join('\n');
     const { baseRules, stableSystemContext, sessionMarkerCore, sessionEnvironment } = composeSystemPrompt({
@@ -333,7 +338,7 @@ export function createSession(opts) {
         skipRoleCatalog: !ownerIsAgent,
         profile: profile || undefined,
         agent: resolvedAgent,
-        workflowContext: workflowContextForApprovalMode(opts.workflowContext, opts.approvalMode),
+        workflowContext: opts.workflowContext || null,
         coreMemoryContext: opts.coreMemoryContext || null,
         skillManifest: buildSkillManifest(skills),
         environmentContext: shellEnvironmentContext,
@@ -493,6 +498,36 @@ export function contextSeedForRouteUpdate(session, routeChanged, selectedContext
         : {};
 }
 
+// The shared-rules block (BP1) renders tool-conditional variants against the
+// edit dialect the model actually receives (edit vs apply_patch). An
+// empty-session route change swaps the tool surface, so this block must
+// re-render too — otherwise a session created on a GPT default route and
+// switched to Claude keeps apply_patch placement guidance for a tool it can
+// no longer call (and vice versa). The block is identified by EXACT previous
+// content: the old variant is rebuilt from the same inputs and matched, so
+// only the true BP1 block is ever replaced; custom-prompt or agent layouts
+// without that block are left untouched, and a same-dialect switch is a no-op.
+export function _refreshSessionRuleVariantsForModel(session, previousModel) {
+    const deny = [
+        ...(Array.isArray(session?.disallowedTools) ? session.disallowedTools : []),
+        ...(getHiddenAgent(session?.agent || null) ? ['Skill'] : []),
+        ...(!isAgentOwner(session) && workflowDisallowsAgentTool(session?.workflow) ? ['agent'] : []),
+    ];
+    const previousRules = _buildSharedRules({ omitTools: [...deny, unusedModelEditToolName(previousModel)] });
+    const nextRules = _buildSharedRules({ omitTools: [...deny, unusedModelEditToolName(session?.model)] });
+    if (!previousRules || previousRules === nextRules) return false;
+    const messages = Array.isArray(session?.messages) ? session.messages : [];
+    const index = messages.findIndex((message) => (
+        message?.role === 'system' && !message.cacheTier && message.content === previousRules
+    ));
+    if (index < 0) return false;
+    // Replace, never mutate: session-store delta saves treat stable message
+    // references as an append-only prefix, so a fresh object forces the full
+    // snapshot that keeps the persisted transcript in sync.
+    messages[index] = { ...messages[index], content: nextRules };
+    return true;
+}
+
 export function updateSessionRoute(id, route = {}) {
     if (!id) return null;
     const session = loadSession(id);
@@ -576,8 +611,15 @@ export function updateSessionRoute(id, route = {}) {
         for (const key of ['deferredSelectedTools', 'deferredCallableTools', 'deferredDefaultTools', 'deferredDiscoveredTools']) {
             if (Array.isArray(session[key])) session[key] = filterModelEditToolNames(session[key], session.model);
         }
+        _refreshSessionRuleVariantsForModel(session, previousModel);
         _preparedResumes.delete(id);
     }
+    // Route fields feed the `# Session` prompt block (Model: … · EFFORT · FAST).
+    // Rebuild it here: createSession stamped the block with the creation-time
+    // route and set sessionStartMetaInjected, so the ask-time refresh guard
+    // skips it and an empty-session route change would otherwise keep the old
+    // model line in the system prompt (model self-identity confusion).
+    refreshSessionBp3Environment(session, session.cwd);
     session.updatedAt = Date.now();
     setLiveSession(session);
     void saveSessionAsync(session, { expectedGeneration: session.generation })

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

@@ -1,7 +1,8 @@
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { resolveSessionContextMeta } from './context-meta.mjs';
-import { contextSeedForRouteUpdate } from './session-lifecycle.mjs';
+import { contextSeedForRouteUpdate, _refreshSessionRuleVariantsForModel } from './session-lifecycle.mjs';
+import { _buildSharedRules } from './rules-cache.mjs';
 
 test('a cold Cursor route uses 200k instead of inheriting another model window', () => {
     const seed = contextSeedForRouteUpdate({
@@ -38,3 +39,32 @@ test('an explicitly selected context window survives a route update', () => {
         selectedContextWindow: 300_000,
     });
 });
+
+test('an empty-session route change re-renders the edit-dialect rule variants', () => {
+    const gptRules = _buildSharedRules({ omitTools: ['edit'] });
+    const claudeRules = _buildSharedRules({ omitTools: ['apply_patch'] });
+    assert.notEqual(gptRules, claudeRules);
+    const session = {
+        model: 'claude-fable-5',
+        messages: [
+            { role: 'system', content: gptRules },
+            { role: 'system', content: 'profile block' },
+            { role: 'system', content: 'core block', cacheTier: 'tier3' },
+        ],
+    };
+    // GPT-created session switched to Claude: BP1 flips to the edit variant.
+    assert.equal(_refreshSessionRuleVariantsForModel(session, 'gpt-5.6-sol'), true);
+    assert.equal(session.messages[0].content, claudeRules);
+    assert.match(session.messages[0].content, /`edit`/);
+    assert.doesNotMatch(session.messages[0].content, /apply_patch/);
+    // Untouched blocks keep their identity and content.
+    assert.equal(session.messages[1].content, 'profile block');
+    assert.equal(session.messages[2].cacheTier, 'tier3');
+    // Same edit dialect on both sides is a no-op.
+    assert.equal(_refreshSessionRuleVariantsForModel(session, 'claude-opus-5'), false);
+    // A layout without the expected BP1 content is left untouched.
+    assert.equal(_refreshSessionRuleVariantsForModel({
+        model: 'claude-fable-5',
+        messages: [{ role: 'system', content: 'custom prompt' }],
+    }, 'gpt-5.6-sol'), false);
+});

package/src/runtime/agent/orchestrator/session/store/serialize.mjs

@@ -30,22 +30,41 @@ export function _sessionForDisk(session) {
     //    persist a non-canonical message array).
     //  - toolApprovalHook: the askOpts.onToolApproval callback wired for the
     //    turn — a function that must never be serialized.
+    //  - _providerPrefixGuardState: hashes of the live provider projection.
+    //    Stored history intentionally omits inline media, so these hashes are
+    //    valid only for the current runtime and must not survive a reload.
     const hasTransient = session && typeof session === 'object'
         && (Object.prototype.hasOwnProperty.call(session, 'liveTurnMessages')
-            || Object.prototype.hasOwnProperty.call(session, 'toolApprovalHook'));
+            || Object.prototype.hasOwnProperty.call(session, 'toolApprovalHook')
+            || Object.prototype.hasOwnProperty.call(session, '_providerPrefixGuardState'));
     const messages = Array.isArray(session?.messages) ? session.messages : null;
     if (!messages || messages.length === 0) {
         if (!hasTransient) return session;
-        const { liveTurnMessages: _dropLTM, toolApprovalHook: _dropTAH, ...rest } = session;
+        const {
+            liveTurnMessages: _dropLTM,
+            toolApprovalHook: _dropTAH,
+            _providerPrefixGuardState: _dropPPGS,
+            ...rest
+        } = session;
         return rest;
     }
     const out = _messagesForDisk(messages);
     if (out === messages) {
         if (!hasTransient) return session;
-        const { liveTurnMessages: _dropLTM, toolApprovalHook: _dropTAH, ...rest } = session;
+        const {
+            liveTurnMessages: _dropLTM,
+            toolApprovalHook: _dropTAH,
+            _providerPrefixGuardState: _dropPPGS,
+            ...rest
+        } = session;
         return rest;
     }
-    const { liveTurnMessages: _dropLTM, toolApprovalHook: _dropTAH, ...rest } = session;
+    const {
+        liveTurnMessages: _dropLTM,
+        toolApprovalHook: _dropTAH,
+        _providerPrefixGuardState: _dropPPGS,
+        ...rest
+    } = session;
     return { ...rest, messages: out };
 }
 
@@ -95,6 +114,10 @@ export function _storedSessionFromFile(dir, filename, ensureLifecycle = true) {
         const record = readTopLevelLifecycleRecord(text);
         if (isLifecycleUnreadable(record) || record.id !== storageId) return null;
         const session = record.doc;
+        // Older builds persisted this runtime-local snapshot. Discard it at
+        // the reload boundary before sanitized history establishes a new
+        // provider prefix baseline.
+        delete session._providerPrefixGuardState;
         return ensureLifecycle ? _ensureLifecycleFields(session) : session;
     } catch {
         return null;