codemini-cli 0.5.1 → 0.5.3

package/src/core/chat-runtime.js

@@ -20,13 +20,13 @@ import { createCheckpoint, listCheckpoints, loadCheckpoint } from './checkpoint-
 import {
   compactMessagesLocally,
   estimateMessagesTokens,
+  microCompactMessages,
   parseCompactArgs
 } from './context-compact.js';
-import { buildSystemPromptWithReplyLanguage, getReplyLanguage, getReplyLanguageName } from './reply-language.js';
-import { buildSystemPromptWithSoul } from './soul.js';
+import { getReplyLanguage, getReplyLanguageName } from './reply-language.js';
+import { composeSystemPrompt } from './system-prompt-composer.js';
 import { getProjectPlansDir, getProjectSpecsDir, getProjectWorkspaceDir, getSessionsDir } from './paths.js';
 import { buildProjectContextSnippet, initializeProjectIndex } from './project-index.js';
-import { buildMemorySnapshot } from './memory-prompt.js';
 import { forgetMemory, listMemories, rememberMemory, searchMemories, captureToInbox, listInbox } from './memory-store.js';
 import { runDreamConsolidation } from './dream-consolidate.js';
 import { normalizePlanState } from './plan-state.js';
@@ -115,6 +115,8 @@ function getCompletionCopy(language = 'zh') {
         'context.read_file_default_lines': 'read_file 默认行数窗口',
         'context.read_file_max_chars': 'read_file 字符上限',
         'context.prompt_budget_audit': 'Prompt 预算审计开关',
+        'context.microcompact_enabled': '微压缩(micro-compact)开关',
+        'context.microcompact_keep_recent': '微压缩保留最近工具结果数',
         'sessions.max_sessions': '会话保留上限',
         'sessions.retention_days': '会话保留天数',
         'shell.default': '默认 shell',
@@ -220,6 +222,8 @@ function getCompletionCopy(language = 'zh') {
         'context.read_file_default_lines': 'default read_file line window',
         'context.read_file_max_chars': 'read_file character limit',
         'context.prompt_budget_audit': 'prompt budget audit switch',
+        'context.microcompact_enabled': 'micro-compact enabled',
+        'context.microcompact_keep_recent': 'micro-compact keep recent tool results',
         'sessions.max_sessions': 'stored session limit',
         'sessions.retention_days': 'session retention days',
         'shell.default': 'default shell',
@@ -581,16 +585,52 @@ function buildPipelineStepGuidance({ role, stepIndex, totalSteps, isFirst, isLas
   return lines.join('\n');
 }
 
-function buildSubAgentContextPacket(session) {
+function extractTaskKeywords(task) {
+  const text = String(task || '').toLowerCase();
+  const tokens = text.match(/[a-z0-9_./:-]{3,}|[\u4e00-\u9fa5]{2,}/g) || [];
+  const stop = new Set([
+    'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'task',
+    'please', 'update', 'change', 'fix', 'implement', 'review', 'test'
+  ]);
+  return [...new Set(tokens.filter((token) => !stop.has(token)))].slice(0, 24);
+}
+
+function scoreMessageForTask(message, keywords) {
+  if (!keywords.length) return 0;
+  const text = String(message?.content || '').toLowerCase();
+  if (!text) return 0;
+  let score = 0;
+  for (const keyword of keywords) {
+    if (text.includes(keyword)) score += keyword.includes('/') || keyword.includes('.') ? 3 : 1;
+  }
+  return score;
+}
+
+function buildSubAgentContextPacket(session, task = '') {
   const source = Array.isArray(session?.messages) ? session.messages : [];
-  const recent = source
+  const candidates = source
     .filter((msg) => msg && (msg.role === 'user' || msg.role === 'assistant'))
-    .slice(-SUB_AGENT_CONTEXT_MAX_MESSAGES);
-  if (recent.length === 0) return '';
+    .map((msg, index) => ({ msg, index }));
+  if (candidates.length === 0) return '';
+  const keywords = extractTaskKeywords(task);
+  const recentStart = Math.max(0, candidates.length - SUB_AGENT_CONTEXT_MAX_MESSAGES);
+  const ranked = candidates
+    .map((item, order) => ({
+      ...item,
+      score: scoreMessageForTask(item.msg, keywords),
+      recentScore: order >= recentStart ? 1 : 0
+    }))
+    .sort((a, b) => {
+      const scoreDelta = (b.score + b.recentScore) - (a.score + a.recentScore);
+      if (scoreDelta !== 0) return scoreDelta;
+      return b.index - a.index;
+    })
+    .slice(0, SUB_AGENT_CONTEXT_MAX_MESSAGES)
+    .sort((a, b) => a.index - b.index);
 
   const lines = [];
   let usedChars = 0;
-  for (const msg of recent) {
+  for (const { msg } of ranked) {
     const role = msg.role === 'assistant' ? 'assistant' : 'user';
     const text = trimInline(msg.content, 260);
     if (!text) continue;
@@ -601,7 +641,7 @@ function buildSubAgentContextPacket(session) {
   }
   if (lines.length === 0) return '';
   return [
-    'Scoped parent context (recent only, not full history):',
+    'Scoped parent context (task-relevant snippets, not full history):',
     ...lines,
     'Use this context only if it helps the current task.'
   ].join('\n');
@@ -1332,8 +1372,8 @@ function classifyAutoRoute(text = '') {
   };
 }
 
-function buildMediumTaskSystemPrompt(systemPrompt) {
-  const guidance = [
+function buildMediumTaskPromptBlock() {
+  return [
     'Task Mode: medium',
     'Execution guidance:',
     '- Give a brief execution outline before coding.',
@@ -1342,12 +1382,11 @@ function buildMediumTaskSystemPrompt(systemPrompt) {
     '- Verify the changed behavior before finishing.',
     '- If major ambiguity appears mid-task, say so clearly and ask for a plan instead of guessing.'
   ].join('\n');
-  return `${systemPrompt}\n\n${guidance}`;
 }
 
-function buildAutoSkillSystemPrompt(baseSystemPrompt, commands, config, text) {
+function buildAutoSkillPromptBlock(commands, config, text) {
   const selected = classifyAutoRoute(text).selectedSkills.filter((name) => isSkillEnabled(config, name, commands.get(name)));
-  if (selected.length === 0) return baseSystemPrompt;
+  if (selected.length === 0) return '';
 
   const blocks = [];
   for (const name of selected) {
@@ -1355,8 +1394,7 @@ function buildAutoSkillSystemPrompt(baseSystemPrompt, commands, config, text) {
     if (!skill || skill.metadata?.type !== 'skill') continue;
     blocks.push(`[Auto skill: ${name}]\n${skill.content}`);
   }
-  if (blocks.length === 0) return baseSystemPrompt;
-  return `${baseSystemPrompt}\n\n${blocks.join('\n\n')}`;
+  return blocks.join('\n\n');
 }
 
 function extractJsonBlock(text) {
@@ -1843,6 +1881,13 @@ async function buildAutoPlanFinalSummary({
   }
 
   try {
+    const summarySystemPrompt = await composeSystemPrompt({
+      shellRulesPrompt: systemPrompt,
+      config,
+      skillsPrompt: 'You are writing the final execution summary for a completed auto plan. Focus on closure, verification status, and the next action.',
+      includeSoul: false,
+      includeMemory: false
+    });
     const result = await createChatCompletion({
       sdkProvider: config.sdk?.provider,
       baseUrl: config.gateway.base_url,
@@ -1851,7 +1896,7 @@ async function buildAutoPlanFinalSummary({
       messages: [
         {
           role: 'system',
-          content: `${systemPrompt}\nYou are writing the final execution summary for a completed auto plan. Focus on closure, verification status, and the next action.`
+          content: summarySystemPrompt
         },
         {
           role: 'user',
@@ -1974,6 +2019,13 @@ async function buildSpecWithModel({
     '## Testing / Validation',
     'Make it concrete, scoped, and suitable for turning into a sub-agent implementation plan.'
   ].join('\n');
+  const specSystemPrompt = await composeSystemPrompt({
+    shellRulesPrompt: systemPrompt,
+    config,
+    skillsPrompt: prompt,
+    includeSoul: false,
+    includeMemory: false
+  });
 
   const result = await createChatCompletion({
     sdkProvider: config.sdk?.provider,
@@ -1981,7 +2033,7 @@ async function buildSpecWithModel({
     apiKey: config.gateway.api_key,
     model: model || config.model.name,
     messages: [
-      { role: 'system', content: `${systemPrompt}\n${prompt}` },
+      { role: 'system', content: specSystemPrompt },
       { role: 'user', content: `Topic: ${topic}` }
     ],
     timeoutMs: config.gateway.timeout_ms || 1800000,
@@ -2034,6 +2086,13 @@ async function buildPlanFromSpecWithModel({
     '## Task Breakdown',
     'Make the plan concrete and ordered for a coding agent.'
   ].join('\n');
+  const planSystemPrompt = await composeSystemPrompt({
+    shellRulesPrompt: systemPrompt,
+    config,
+    skillsPrompt: prompt,
+    includeSoul: false,
+    includeMemory: false
+  });
 
   const result = await createChatCompletion({
     sdkProvider: config.sdk?.provider,
@@ -2041,7 +2100,7 @@ async function buildPlanFromSpecWithModel({
     apiKey: config.gateway.api_key,
     model: model || config.model.name,
     messages: [
-      { role: 'system', content: `${systemPrompt}\n${prompt}` },
+      { role: 'system', content: planSystemPrompt },
       {
         role: 'user',
         content: `Spec path: ${specPath || '(inline)'}\n\nProject implementation constraints:\n${projectConstraints}\n\n${specText}`
@@ -2253,6 +2312,17 @@ function buildRuntimeStateSnapshot({ currentSession, config, model, executionMod
       value: getReplyLanguage(config),
       enumerable: false,
       writable: false
+    },
+    toJSON: {
+      value: () => ({
+        ...snapshot,
+        currentContextTokens,
+        contextUsagePct,
+        pendingReflectSkill: currentSession?.planState?.status === 'pending_reflect_skill',
+        replyLanguage: getReplyLanguage(config)
+      }),
+      enumerable: false,
+      writable: false
     }
   });
   return snapshot;
@@ -2520,28 +2590,61 @@ async function askModel({
   signal,
   allowedTools,
   maxSteps: maxStepsOverride,
-  skipAnalysisNudge = false
+  skipAnalysisNudge = false,
+  compactedForModel: compactedInput = null,
+  onCompactedUpdate = null
 }) {
+  let compacted = compactedInput;
   const modelInputText = typeof modelText === 'string' && modelText ? modelText : text;
   const maxContextTokens = effectiveMaxContextTokens(config);
-  const triggerPct = Number(config.context?.preflight_trigger_pct || 92);
+  const triggerPct = Number(config.context?.preflight_trigger_pct || 60);
   const hardPct = Number(config.context?.hard_limit_pct || 98);
-  const preflightTokens = estimatePromptTokensForRequest(session.messages, modelInputText);
+  const messagesForEstimate = compacted ?? session.messages;
+  const preflightTokens = estimatePromptTokensForRequest(messagesForEstimate, modelInputText);
   const preflightPct = (preflightTokens / maxContextTokens) * 100;
 
   if (persistSession && preflightPct >= triggerPct) {
-    const auto = compactMessagesLocally(session.messages, {
-      mode: preflightPct >= hardPct ? 'aggressive' : 'conservative'
-    });
-    if (auto.changed) {
-      session.messages = auto.compacted.map((m) => ({ ...m, at: new Date().toISOString() }));
-      await saveSession(session);
-      if (onAgentEvent) {
-        onAgentEvent({
-          type: 'compact:auto',
-          mode: preflightPct >= hardPct ? 'aggressive' : 'conservative',
-          threshold: Math.round(preflightPct)
-        });
+    const compactSource = compacted ?? session.messages;
+    // Phase 0: try micro-compact first (in-place tool result clearing)
+    const microEnabled = config.context?.microcompact_enabled !== false;
+    const microKeep = Number(config.context?.microcompact_keep_recent || 5);
+    let needsMacro = true;
+    if (microEnabled) {
+      const micro = microCompactMessages(compactSource, { keepRecent: microKeep, enabled: true });
+      if (micro.changed) {
+        compacted = micro.messages.map((m) => ({ ...m, at: new Date().toISOString() }));
+        if (onCompactedUpdate) onCompactedUpdate(compacted);
+        const afterMicroTokens = estimateMessagesTokens(compacted);
+        const afterMicroPct = (afterMicroTokens / maxContextTokens) * 100;
+        if (onAgentEvent) {
+          onAgentEvent({
+            type: 'compact:auto',
+            mode: 'micro',
+            threshold: Math.round(preflightPct),
+            tokensSaved: micro.tokensSaved
+          });
+        }
+        if (afterMicroPct < triggerPct) {
+          needsMacro = false;
+        }
+      }
+    }
+    if (needsMacro) {
+      const macroSource = compacted ?? compactSource;
+      const auto = compactMessagesLocally(macroSource, {
+        mode: preflightPct >= hardPct ? 'aggressive' : 'conservative',
+        force: true
+      });
+      if (auto.changed) {
+        compacted = auto.compacted.map((m) => ({ ...m, at: new Date().toISOString() }));
+        if (onCompactedUpdate) onCompactedUpdate(compacted, { boundaryIndex: auto.boundaryIndex, mode: preflightPct >= hardPct ? 'aggressive' : 'conservative' });
+        if (onAgentEvent) {
+          onAgentEvent({
+            type: 'compact:auto',
+            mode: preflightPct >= hardPct ? 'aggressive' : 'conservative',
+            threshold: Math.round(preflightPct)
+          });
+        }
       }
     }
   }
@@ -2608,9 +2711,15 @@ async function askModel({
   const projectContextSnippet = await buildProjectContextSnippet(process.cwd(), modelInputText).catch(() => '');
   const projectContextGuidance =
     'Use this project context as lightweight guidance and verify important details with fresh reads when needed.';
-  const effectiveSystemPrompt = projectContextSnippet
-    ? `${systemPrompt}\n\n${projectContextSnippet}\n\n${projectContextGuidance}`
-    : systemPrompt;
+  const effectiveSystemPrompt = await composeSystemPrompt({
+    shellRulesPrompt: systemPrompt,
+    config,
+    workspaceRoot: process.cwd(),
+    includeSoul: false,
+    includeMemory: false,
+    projectContextSnippet,
+    projectContextGuidance
+  });
 
   const { definitions, handlers, formatters, deferredDefinitions, dispose: disposeTools } = getBuiltinTools({
     workspaceRoot: process.cwd(),
@@ -2745,6 +2854,7 @@ async function askModel({
     if (onAgentEvent) onAgentEvent(event);
   };
 
+  const sessionLenBeforeLoop = session.messages.length;
   const loopUserPrompt = persistSession ? '' : modelInputText;
   const expectedModelText = typeof modelText === 'string' && modelText && modelText !== text ? modelText : '';
   const loopResult = await runAgentLoop({
@@ -2754,7 +2864,7 @@ async function askModel({
     maxSteps: maxStepsOverride ?? Number(config.execution?.max_steps || 16),
     toolDefinitions: filteredDefinitions,
     toolHandlers: filteredHandlers,
-    initialMessages: toOpenAIMessages(session.messages),
+    initialMessages: toOpenAIMessages(compacted ?? session.messages),
     onEvent: wrappedAgentEvent,
     executionMode: executionMode || config.execution?.mode || 'normal',
     alwaysAllowTools:
@@ -2804,9 +2914,15 @@ async function askModel({
   });
 
   if (persistSession) {
-    session.messages = loopResult.messages
-      .filter((m) => m.role !== 'system')
-      .map((m) => ({ ...m, at: new Date().toISOString() }));
+    // Sync new messages to compacted view
+    if (compacted) {
+      const newMsgs = session.messages.slice(sessionLenBeforeLoop);
+      for (const msg of newMsgs) {
+        compacted.push({ ...msg });
+      }
+      if (onCompactedUpdate) onCompactedUpdate(compacted);
+    }
+    // Handle model_content rewrite on the new user message
     if (expectedModelText) {
       for (let i = session.messages.length - 1; i >= 0; i -= 1) {
         const message = session.messages[i];
@@ -2855,7 +2971,7 @@ async function runSubAgentTask({
 }) {
   const subSession = { id: `sub-${Date.now()}`, messages: [] };
   const rolePrompt = getSubAgentRolePrompt(role);
-  const contextPacket = buildSubAgentContextPacket(parentSession);
+  const contextPacket = buildSubAgentContextPacket(parentSession, task || goal);
   const evidencePacket = buildSubAgentEvidencePacket(parentSession);
   const handoffPacket = buildStepArtifactPacket(priorSteps, role);
   const handoffFocusPaths = collectStepArtifacts(priorSteps, role)?.focusPaths || [];
@@ -2910,12 +3026,19 @@ async function runSubAgentTask({
   };
   const roleAllowedTools = ROLE_TOOL_POLICY[role];
   if (onSessionActive) onSessionActive(subSession);
+  const subSystemPrompt = await composeSystemPrompt({
+    shellRulesPrompt: systemPrompt,
+    config,
+    skillsPrompt: [rolePrompt, extraRolePrompt].filter(Boolean).join('\n\n'),
+    includeSoul: false,
+    includeMemory: false
+  });
   const subResult = await askModel({
     text: scopedTask,
     session: subSession,
     config,
     model,
-    systemPrompt: `${systemPrompt}\n${rolePrompt}${extraRolePrompt ? `\n${extraRolePrompt}` : ''}`,
+    systemPrompt: subSystemPrompt,
     onAgentEvent: wrappedOnAgentEvent,
     persistSession: false,
     executionMode: 'auto',
@@ -3225,13 +3348,20 @@ async function buildAutoPlanAndRun({
   };
   let planningError = '';
   try {
+    const plannerSystemPrompt = await composeSystemPrompt({
+      shellRulesPrompt: systemPrompt,
+      config,
+      skillsPrompt: plannerPrompt,
+      includeSoul: false,
+      includeMemory: false
+    });
     const planning = await createChatCompletion({
       sdkProvider: config.sdk?.provider,
       baseUrl: config.gateway.base_url,
       apiKey: config.gateway.api_key,
       model: model || config.model.name,
       messages: [
-        { role: 'system', content: `${systemPrompt}\n${plannerPrompt}` },
+        { role: 'system', content: plannerSystemPrompt },
         {
           role: 'user',
           content: [
@@ -3864,13 +3994,20 @@ async function revisePendingPlanWithModel({
     'Keep roles minimal and only include steps that materially help the goal.',
     'Always keep a summarizer as the final step.'
   ].join('\n');
+  const revisionSystemPrompt = await composeSystemPrompt({
+    shellRulesPrompt: systemPrompt,
+    config,
+    skillsPrompt: prompt,
+    includeSoul: false,
+    includeMemory: false
+  });
   const result = await createChatCompletion({
     sdkProvider: config.sdk?.provider,
     baseUrl: config.gateway.base_url,
     apiKey: config.gateway.api_key,
     model: model || config.model.name,
     messages: [
-      { role: 'system', content: `${systemPrompt}\n${prompt}` },
+      { role: 'system', content: revisionSystemPrompt },
       {
         role: 'user',
         content: [
@@ -4048,6 +4185,13 @@ export async function createChatRuntime({
     threshold: 60,
     mode: 'conservative'
   };
+  let compactedForModel = currentSession.compact?.view || null;
+  const setCompactedView = (view, meta = {}) => {
+    compactedForModel = view;
+    currentSession.compact = view
+      ? { view, timestamp: new Date().toISOString(), ...meta }
+      : null;
+  };
   let historyIdCache = [currentSession.id];
   let historySessionCache = [
     {
@@ -4106,6 +4250,8 @@ export async function createChatRuntime({
     'context.tool_result_max_chars',
     'context.read_file_default_lines',
     'context.read_file_max_chars',
+    'context.microcompact_enabled',
+    'context.microcompact_keep_recent',
     'sessions.max_sessions',
     'sessions.retention_days',
     'shell.timeout_ms',
@@ -4177,6 +4323,7 @@ export async function createChatRuntime({
   const compactOptions = [
     '--preview',
     '--restore',
+    '--micro',
     '--aggressive',
     '--conservative',
     '--default',
@@ -4653,14 +4800,14 @@ export async function createChatRuntime({
   };
 
   const buildActiveSystemPrompt = async () => {
-    const soulPrompt = await buildSystemPromptWithSoul(baseSystemPrompt, config);
-    const memorySnapshot = await buildMemorySnapshot({
-      config,
-      workspaceRoot: process.cwd()
-    }).catch(() => '');
     const memoryGuide =
       'Persistent memory stores durable preferences and stable workflow knowledge. Verify changeable details from files, and only write memory for future-useful, non-sensitive facts.';
-    return [soulPrompt, memorySnapshot, memoryGuide].filter(Boolean).join('\n\n');
+    return composeSystemPrompt({
+      shellRulesPrompt: baseSystemPrompt,
+      config,
+      workspaceRoot: process.cwd(),
+      extraPrompts: [memoryGuide]
+    });
   };
 
   const isImmediateLocalInput = (line) => {
@@ -5434,7 +5581,9 @@ export async function createChatRuntime({
           onAgentEvent,
           requestToolApproval: activeRequestToolApproval,
           executionMode,
-          signal
+          signal,
+          compactedForModel,
+          onCompactedUpdate: setCompactedView
         });
         return { type: 'assistant', text: result.text, aborted: !!result.aborted };
       }
@@ -5498,18 +5647,35 @@ export async function createChatRuntime({
         if (cargs.mode) compactState.mode = cargs.mode;
 
         if (cargs.restore) {
-          if (!compactState.backupMessages) {
-            return { type: 'system', text: 'No backup available to restore' };
-          }
-          currentSession.messages = structuredClone(compactState.backupMessages);
-          await saveSession(currentSession);
-          const text = 'Context restored from backup';
+          setCompactedView(null);
+          const text = 'Context restored to full view';
           await persistLocalExchange(line, text, { includeUser: false });
           return { type: 'system', text };
         }
 
-        const beforeTokens = estimateMessagesTokens(currentSession.messages);
-        const result = compactMessagesLocally(currentSession.messages, { mode: compactState.mode });
+        const compactSource = compactedForModel ?? currentSession.messages;
+        const beforeTokens = estimateMessagesTokens(compactSource);
+
+        // --micro: only do micro-compact (in-place tool result clearing)
+        if (cargs.micro) {
+          const microKeep = Number(config.context?.microcompact_keep_recent || 5);
+          const micro = microCompactMessages(compactSource, { keepRecent: microKeep, enabled: true });
+          if (!micro.changed) {
+            return { type: 'system', text: 'Micro-compact: nothing to clear' };
+          }
+          const afterTokens = estimateMessagesTokens(micro.messages);
+          const report = `Micro-compact ${cargs.preview ? 'preview' : 'applied'}: ${beforeTokens} -> ${afterTokens} tokens (saved ${micro.tokensSaved})`;
+
+          if (cargs.preview) {
+            return { type: 'system', text: report };
+          }
+
+          setCompactedView(micro.messages.map((m) => ({ ...m, at: new Date().toISOString() })));
+          await persistLocalExchange(line, report, { includeUser: false });
+          return { type: 'system', text: report };
+        }
+
+        const result = compactMessagesLocally(compactSource, { mode: compactState.mode, force: true });
         if (!result.changed) {
           return { type: 'system', text: 'Nothing to compact yet' };
         }
@@ -5520,9 +5686,10 @@ export async function createChatRuntime({
           return { type: 'system', text: `${report}\n\n${result.summary}` };
         }
 
-        compactState.backupMessages = structuredClone(currentSession.messages);
-        currentSession.messages = result.compacted.map((m) => ({ ...m, at: new Date().toISOString() }));
-        await saveSession(currentSession);
+        setCompactedView(
+          result.compacted.map((m) => ({ ...m, at: new Date().toISOString() })),
+          { boundaryIndex: result.boundaryIndex, mode: compactState.mode }
+        );
         await captureCompactSummary({
           summary: result.summary,
           mode: compactState.mode,
@@ -5596,7 +5763,9 @@ export async function createChatRuntime({
           onAgentEvent,
           requestToolApproval: activeRequestToolApproval,
           executionMode,
-          signal
+          signal,
+          compactedForModel,
+          onCompactedUpdate: setCompactedView
         });
       } catch (error) {
         if (custom.metadata.type === 'skill' && onAgentEvent) {
@@ -5699,32 +5868,71 @@ export async function createChatRuntime({
     }
 
     if (compactState.autoEnabled) {
-      const currentTokens = estimateMessagesTokens(currentSession.messages);
+      const compactSource = compactedForModel ?? currentSession.messages;
+      const currentTokens = estimateMessagesTokens(compactSource);
       const maxTokens = effectiveMaxContextTokens(config);
       const usagePct = (currentTokens / maxTokens) * 100;
       if (usagePct >= compactState.threshold) {
-        const autoResult = compactMessagesLocally(currentSession.messages, {
-          mode: compactState.mode
-        });
-        if (autoResult.changed) {
-          compactState.backupMessages = structuredClone(currentSession.messages);
-          currentSession.messages = autoResult.compacted.map((m) => ({
-            ...m,
-            at: new Date().toISOString()
-          }));
-          await saveSession(currentSession);
-          await captureCompactSummary({
-            summary: autoResult.summary,
+        // Phase 0: try micro-compact first
+        const microEnabled = config.context?.microcompact_enabled !== false;
+        const microKeep = Number(config.context?.microcompact_keep_recent || 5);
+        let needsMacro = true;
+        if (microEnabled) {
+          const micro = microCompactMessages(compactSource, { keepRecent: microKeep, enabled: true });
+          if (micro.changed) {
+            setCompactedView(micro.messages.map((m) => ({
+              ...m,
+              at: new Date().toISOString()
+            })));
+            const afterMicroTokens = estimateMessagesTokens(compactedForModel);
+            const afterMicroPct = (afterMicroTokens / maxTokens) * 100;
+            if (onAgentEvent) {
+              onAgentEvent({
+                type: 'compact:auto',
+                mode: 'micro',
+                threshold: compactState.threshold,
+                tokensSaved: micro.tokensSaved
+              });
+            }
+            if (afterMicroPct < compactState.threshold) {
+              needsMacro = false;
+              await captureCompactSummary({
+                summary: `Micro-compact saved ${micro.tokensSaved} tokens`,
+                mode: 'micro',
+                beforeTokens: currentTokens,
+                afterTokens: afterMicroTokens
+              });
+            }
+          }
+        }
+        // Phase 1: macro compact if still over threshold
+        if (needsMacro) {
+          const macroSource = compactedForModel ?? compactSource;
+          const autoResult = compactMessagesLocally(macroSource, {
             mode: compactState.mode,
-            beforeTokens: currentTokens,
-            afterTokens: estimateMessagesTokens(currentSession.messages)
+            force: true
           });
-          if (onAgentEvent) {
-            onAgentEvent({
-              type: 'compact:auto',
+          if (autoResult.changed) {
+            setCompactedView(
+              autoResult.compacted.map((m) => ({
+                ...m,
+                at: new Date().toISOString()
+              })),
+              { boundaryIndex: autoResult.boundaryIndex, mode: compactState.mode }
+            );
+            await captureCompactSummary({
+              summary: autoResult.summary,
               mode: compactState.mode,
-              threshold: compactState.threshold
+              beforeTokens: currentTokens,
+              afterTokens: estimateMessagesTokens(compactedForModel)
             });
+            if (onAgentEvent) {
+              onAgentEvent({
+                type: 'compact:auto',
+                mode: compactState.mode,
+                threshold: compactState.threshold
+              });
+            }
           }
         }
       }
@@ -5766,10 +5974,27 @@ export async function createChatRuntime({
         names: selectedAutoSkills
       });
     }
-    const skillPrompt = buildAutoSkillSystemPrompt(activeReplySystemPrompt, commands, config, expandedText);
+    const autoSkillPrompt = buildAutoSkillPromptBlock(commands, config, expandedText);
+    const skillPrompt = autoSkillPrompt
+      ? await composeSystemPrompt({
+          shellRulesPrompt: activeReplySystemPrompt,
+          config,
+          workspaceRoot: process.cwd(),
+          skillsPrompt: autoSkillPrompt,
+          includeSoul: false,
+          includeMemory: false
+          })
+        : activeReplySystemPrompt;
     const routedSystemPrompt =
       autoRoute.mode === 'direct_medium'
-        ? buildMediumTaskSystemPrompt(skillPrompt)
+        ? await composeSystemPrompt({
+            shellRulesPrompt: skillPrompt,
+            config,
+            workspaceRoot: process.cwd(),
+            skillsPrompt: buildMediumTaskPromptBlock(),
+            includeSoul: false,
+            includeMemory: false
+          })
         : skillPrompt;
     const result = await askModel({
       text: expandedText,
@@ -5780,7 +6005,9 @@ export async function createChatRuntime({
       onAgentEvent,
       requestToolApproval: activeRequestToolApproval,
       executionMode,
-      signal
+      signal,
+      compactedForModel,
+      onCompactedUpdate: setCompactedView
     });
     await saveDirectMemoryPrompt(expandedText);
     await captureUserPromptForDream(expandedText);
@@ -5803,6 +6030,7 @@ export async function createChatRuntime({
     getInputHistory: () => loadInputHistory(),
     getCurrentSessionId: () => currentSession.id,
     getSessionMessages: () => currentSession.messages || [],
+    getSessionCompact: () => currentSession.compact || null,
     reloadConfig: async () => {
       config = await loadConfig();
       return config;