codemini-cli 0.3.0 → 0.3.2

package/src/core/chat-runtime.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import {
   createChatCompletion,
   createChatCompletionStream
-} from './provider/openai-compatible.js';
+} from './provider/index.js';
 import { isDangerousCommand, runShellCommand } from './shell.js';
 import { getBuiltinTools } from './tools.js';
 import { listSessions, loadSession, pruneSessions, saveSession } from './session-store.js';
@@ -30,6 +30,8 @@ import { buildSystemPromptWithReplyLanguage } from './reply-language.js';
 import { buildSystemPromptWithSoul } from './soul.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, searchMemories } from './memory-store.js';
 
 function toOpenAIMessages(sessionMessages) {
   const mapped = [];
@@ -74,35 +76,199 @@ function prioritizeByPreferredOrder(items, preferredOrder) {
   });
 }
 
-function describeConfigKey(key, mode = 'set') {
-  const labelMap = {
-    'gateway.base_url': 'gateway base URL',
-    'gateway.api_key': 'gateway API key',
-    'gateway.timeout_ms': 'gateway timeout in milliseconds',
-    'gateway.max_retries': 'gateway retry count',
-    'model.name': 'active model name',
-    'model.max_context_tokens': 'model context token limit',
-    'ui.reply_language': 'reply language',
-    'execution.mode': 'execution mode',
-    'execution.always_allow_tools': 'always-allowed tools',
-    'execution.max_steps': 'maximum tool steps',
-    'context.preflight_trigger_pct': 'preflight compact threshold',
-    'context.hard_limit_pct': 'hard compact threshold',
-    'context.tool_result_max_chars': 'tool result character limit',
-    'context.read_file_default_lines': 'default read_file line window',
-    'context.read_file_max_chars': 'read_file character limit',
-    'sessions.max_sessions': 'stored session limit',
-    'sessions.retention_days': 'session retention days',
-    'shell.default': 'default shell',
-    'shell.timeout_ms': 'shell timeout in milliseconds',
-    'context.max_tokens': 'context token budget',
-    'soul.preset': 'soul preset',
-    'soul.custom_path': 'custom soul prompt path',
-    'policy.safe_mode': 'safe mode switch',
-    'policy.allow_dangerous_commands': 'dangerous command allowance'
-  };
-  const label = labelMap[key] || key;
-  return mode === 'get' ? `show the ${label}` : `set the ${label}`;
+function normalizeUiLocale(value) {
+  return String(value || '').toLowerCase().startsWith('en') ? 'en' : 'zh';
+}
+
+function getCompletionCopy(language = 'zh') {
+  const lang = normalizeUiLocale(language);
+  return {
+    zh: {
+      configLabels: {
+        'gateway.base_url': '网关基础 URL',
+        'gateway.api_key': '网关 API Key',
+        'sdk.provider': 'SDK provider',
+        'gateway.timeout_ms': '网关超时时间（毫秒）',
+        'gateway.max_retries': '网关重试次数',
+        'model.name': '当前模型名称',
+        'model.max_context_tokens': '模型上下文 token 上限',
+        'ui.language': '界面语言',
+        'ui.reply_language': '回复语言',
+        'execution.mode': '执行模式',
+        'execution.always_allow_tools': '始终允许的工具列表',
+        'execution.max_steps': '最大工具步骤数',
+        'context.preflight_trigger_pct': '预压缩阈值',
+        'context.hard_limit_pct': '硬压缩阈值',
+        'context.tool_result_max_chars': '工具结果字符上限',
+        'context.read_file_default_lines': 'read_file 默认行数窗口',
+        'context.read_file_max_chars': 'read_file 字符上限',
+        'sessions.max_sessions': '会话保留上限',
+        'sessions.retention_days': '会话保留天数',
+        'shell.default': '默认 shell',
+        'shell.timeout_ms': 'shell 超时时间（毫秒）',
+        'context.max_tokens': '上下文 token 预算',
+        'soul.preset': 'soul 预设',
+        'soul.custom_path': '自定义 soul 路径',
+        'policy.safe_mode': '安全模式开关',
+        'policy.allow_dangerous_commands': '危险命令开关'
+      },
+      optionHints: {
+        'sdk.provider': '可选：openai-compatible | anthropic',
+        'ui.language': '可选：zh | en',
+        'ui.reply_language': '可选：zh | en',
+        'execution.mode': '可选：auto | normal | plan',
+        'shell.default': '常用：bash | powershell',
+        'policy.safe_mode': '可选：true | false',
+        'policy.allow_dangerous_commands': '可选：true | false'
+      },
+      describeSet: (label, hint) => `设置${label}${hint ? `（${hint}）` : ''}`,
+      describeGet: (label, hint) => `查看${label}${hint ? `（${hint}）` : ''}`,
+      configSubcommands: {
+        '/config set': '设置配置项',
+        '/config get': '查看配置项',
+        '/config list': '查看完整配置',
+        '/config reset': '重置为默认配置'
+      },
+      planSubcommands: {
+        '/plan <goal>': '创建一个人工审阅的实施计划',
+        '/plan auto <goal>': '自动生成计划并等待你确认执行',
+        '/plan auto run <goal>': '自动生成计划后立即继续执行',
+        '/plan approve': '批准当前待确认的计划并开始执行',
+        '/plan from-spec <spec-path?>': '从 spec 文件生成实施计划'
+      },
+      commands: {
+        help: '显示聊天帮助',
+        exit: '退出聊天',
+        commands: '列出 slash/自定义命令',
+        status: '查看运行状态（mode/model/session）',
+        mode: '设置执行模式：normal|auto|plan',
+        compact: '压缩消息上下文',
+        tasks: '任务面板管理',
+        checkpoint: '创建/查看/加载检查点',
+        spec: '在 .codemini/specs 中创建 spec',
+        plan: '在 .codemini/plans 中创建实施计划',
+        agents: '列出/运行子代理角色',
+        config: '设置/读取/列出/重置配置',
+        memory: '查看/搜索/删除持久记忆',
+        history: '查看/恢复会话',
+        debug: '运行时调试开关',
+        retry: '重试上一条用户请求'
+      },
+      generic: {
+        configCommand: '配置命令',
+        historyCommand: '历史会话命令',
+        modeCommand: '切换执行模式',
+        taskCommand: '任务面板命令',
+        checkpointCommand: '检查点命令',
+        specCommand: '创建 spec 文件',
+        planCommand: '规划命令',
+        agentCommand: '子代理命令',
+        memoryCommand: '记忆命令',
+        debugCommand: '调试命令',
+        keyboardDebugCommand: '键盘调试命令',
+        compactCommand: '上下文压缩命令',
+        retryCommand: '重试上一条用户请求',
+        statusCommand: '查看运行状态',
+        resumeSession: '恢复一个已保存的会话'
+      }
+    },
+    en: {
+      configLabels: {
+        'gateway.base_url': 'gateway base URL',
+        'gateway.api_key': 'gateway API key',
+        'sdk.provider': 'SDK provider',
+        'gateway.timeout_ms': 'gateway timeout in milliseconds',
+        'gateway.max_retries': 'gateway retry count',
+        'model.name': 'active model name',
+        'model.max_context_tokens': 'model context token limit',
+        'ui.language': 'UI language',
+        'ui.reply_language': 'reply language',
+        'execution.mode': 'execution mode',
+        'execution.always_allow_tools': 'always-allowed tools',
+        'execution.max_steps': 'maximum tool steps',
+        'context.preflight_trigger_pct': 'preflight compact threshold',
+        'context.hard_limit_pct': 'hard compact threshold',
+        'context.tool_result_max_chars': 'tool result character limit',
+        'context.read_file_default_lines': 'default read_file line window',
+        'context.read_file_max_chars': 'read_file character limit',
+        'sessions.max_sessions': 'stored session limit',
+        'sessions.retention_days': 'session retention days',
+        'shell.default': 'default shell',
+        'shell.timeout_ms': 'shell timeout in milliseconds',
+        'context.max_tokens': 'context token budget',
+        'soul.preset': 'soul preset',
+        'soul.custom_path': 'custom soul prompt path',
+        'policy.safe_mode': 'safe mode switch',
+        'policy.allow_dangerous_commands': 'dangerous command allowance'
+      },
+      optionHints: {
+        'sdk.provider': 'options: openai-compatible | anthropic',
+        'ui.language': 'options: zh | en',
+        'ui.reply_language': 'options: zh | en',
+        'execution.mode': 'options: auto | normal | plan',
+        'shell.default': 'common: bash | powershell',
+        'policy.safe_mode': 'options: true | false',
+        'policy.allow_dangerous_commands': 'options: true | false'
+      },
+      describeSet: (label, hint) => `set the ${label}${hint ? ` (${hint})` : ''}`,
+      describeGet: (label, hint) => `show the ${label}${hint ? ` (${hint})` : ''}`,
+      configSubcommands: {
+        '/config set': 'update a config value',
+        '/config get': 'show a config value',
+        '/config list': 'print the full config',
+        '/config reset': 'reset config to defaults'
+      },
+      planSubcommands: {
+        '/plan <goal>': 'create an implementation plan for manual review',
+        '/plan auto <goal>': 'generate a plan and wait for your approval',
+        '/plan auto run <goal>': 'generate a plan and continue execution immediately',
+        '/plan approve': 'approve the pending plan and start execution',
+        '/plan from-spec <spec-path?>': 'generate an implementation plan from a spec file'
+      },
+      commands: {
+        help: 'show chat help',
+        exit: 'exit chat',
+        commands: 'list slash/custom commands',
+        status: 'show runtime status (mode/model/session)',
+        mode: 'set execution mode: normal|auto|plan',
+        compact: 'compress message context',
+        tasks: 'task board management',
+        checkpoint: 'create/list/load conversation checkpoints',
+        spec: 'create a spec markdown file in .codemini/specs',
+        plan: 'create an implementation plan markdown file in .codemini/plans',
+        agents: 'run/list sub-agent roles',
+        config: 'set/get/list/reset config values',
+        memory: 'list/search/delete persistent memories',
+        history: 'list/resume sessions',
+        debug: 'runtime debug switches',
+        retry: 'retry the last user request'
+      },
+      generic: {
+        configCommand: 'config command',
+        historyCommand: 'history command',
+        modeCommand: 'switch execution mode',
+        taskCommand: 'task board command',
+        checkpointCommand: 'checkpoint command',
+        specCommand: 'create a spec file',
+        planCommand: 'planning command',
+        agentCommand: 'sub-agent command',
+        memoryCommand: 'memory command',
+        debugCommand: 'debug command',
+        keyboardDebugCommand: 'keyboard debug command',
+        compactCommand: 'context compaction command',
+        retryCommand: 'retry the last user request',
+        statusCommand: 'show runtime status',
+        resumeSession: 'resume a saved session'
+      }
+    }
+  }[lang];
+}
+
+function describeConfigKey(key, mode = 'set', language = 'zh') {
+  const copy = getCompletionCopy(language);
+  const label = copy.configLabels[key] || key;
+  const hint = copy.optionHints[key] || '';
+  return mode === 'get' ? copy.describeGet(label, hint) : copy.describeSet(label, hint);
 }
 
 const SUB_AGENT_ROLES = ['planner', 'coder', 'reviewer', 'tester'];
@@ -407,6 +573,24 @@ function isLightweightAutoPlanGoal(goal, requirements = []) {
   return /\b(add|update|fix|rename|trim|export|create|remove|change|implement)\b/i.test(text);
 }
 
+function classifyPlanTaskClass(goal = '') {
+  const text = String(goal || '').trim();
+  const lowerGoal = text.toLowerCase();
+  const advisory =
+    /\b(analyze|analysis|review|audit|inspect|assess|recommend|recommendation|optimization|optimize|improve|suggest|brainstorm|plan|feedback)\b/i.test(lowerGoal) ||
+    /(分析|审查|审计|检查|评估|建议|优化|优化点|优化建议|改进|改进点|规划|方案|看一下|看看|有哪些问题|有什么问题)/.test(text);
+  const implementation =
+    /\b(add|build|create|implement|support|introduce|refactor|rewrite|rework|migrate|change|update|fix)\b/i.test(lowerGoal) ||
+    /(新增|增加|实现|支持|重构|重写|改造|迁移|修改|更新|修复)/.test(text);
+  const verificationHeavy =
+    /\b(test|verify|validation|validate|prove|confirm|reproduce|check coverage)\b/i.test(lowerGoal) ||
+    /(测试|验证|校验|确认|复现|覆盖率)/.test(text);
+
+  if (verificationHeavy) return 'verification-heavy';
+  if (advisory && !implementation) return 'advisory';
+  return 'implementation';
+}
+
 function buildGoalRequirementPacket(goal, role) {
   const rawGoal = trimInlineText(goal, 800);
   if (!rawGoal) return '';
@@ -441,7 +625,9 @@ function buildAutoPlanPlannerGuidance() {
     '- Prefer the smallest local approach that satisfies the goal.',
     '- Do not output multiple alternative branches in the final plan.',
     '- Do not assume implementation should begin before the plan is coherent.',
-    '- Turn the chosen direction into concrete execution steps for planner, coder, reviewer, and tester.',
+    '- Available sub-agent roles are planner, coder, reviewer, and tester. Use only the roles the task actually needs.',
+    '- For implementation-heavy or risky changes, prefer adding review and/or verification steps.',
+    '- For analysis, recommendation, or planning-only goals, you may omit reviewer/tester if they do not add value.',
     '- Prefer 3-5 steps total unless the task is clearly larger.',
     '- Keep the plan ordered, implementation-oriented, and easy for small sub-agents to follow.'
   ].join('\n');
@@ -598,49 +784,56 @@ function selectAutoSkillNames(text = '') {
   return selected;
 }
 
-function shouldAutoPlan(text = '') {
+function classifyTaskComplexity(text = '') {
   const input = String(text || '').trim();
-  if (!input) return false;
+  if (!input) return 'simple';
 
   const lower = input.toLowerCase();
   const explicitPlanning =
     /(\/plan\b|plan first|make a plan|implementation plan|先做计划|先出方案|先规划|先计划)/i.test(lower);
-  if (explicitPlanning) return false;
+  if (explicitPlanning) return 'complex';
 
   const simpleSkip =
     /(typo|readme|console\.log|log this|rename\s+\w+|one line|small tweak|tiny fix|格式化|拼写|注释|文案|小改|微调)/i.test(
       lower
     );
-  if (simpleSkip) return false;
+  if (simpleSkip) return 'simple';
 
   const discussionFirst =
     /(brainstorm|头脑风暴|方案|思路|怎么做|如何做|which (?:approach|option|way)|best way|trade-?off|not sure|unsure|unclear|whether it should|要不要|不确定|先别写|先不要写|先讨论|先想一下)/i.test(
       lower
     );
-  if (discussionFirst) return false;
+  if (discussionFirst) return 'simple';
 
   const implementationRequest =
     /\b(add|build|create|implement|support|introduce|design|refactor|rework|migrate|change|update|rewrite|restructure)\b/i.test(
       lower
     ) ||
     /(新增|增加|实现|支持|设计|重构|改造|迁移|调整|重写|重做)/i.test(lower);
-  if (!implementationRequest) return false;
-
-  const nonTrivialSignals =
-    /\b(auth|authentication|workflow|flow|system|architecture|api|endpoint|state management|cache|caching|database|migration|service|shared helper|helper module|refactor|multi[- ]file|across files|with tests?|and tests?|with validation|error handling)\b/i.test(
-      lower
-    ) ||
-    /(架构|流程|系统|接口|缓存|数据库|迁移|服务|共享|模块|跨文件|测试|校验|错误处理)/i.test(lower);
+  if (!implementationRequest) return 'simple';
 
+  const broadSignalPattern =
+    /\b(auth|authentication|workflow|flow|system|architecture|api|endpoint|state management|session state|cache|caching|database|migration|service|integration|error handling|error recovery|shared helper|helper module)\b/gi;
+  const broadSignals = lower.match(broadSignalPattern) || [];
   const multipleActions = /\b(and|plus|also|while|along with)\b/i.test(lower) || /[，、；;].+/.test(input);
   const singleFileScoped =
     /\b(?:in|inside|within|only in)\s+[-_/.\w]+\.(?:[cm]?[jt]sx?|py|go|rb|java|rs|php|md)\b/i.test(lower) ||
     /\b(?:src|app|lib|tests?)\/[-_/.\w]+\.(?:[cm]?[jt]sx?|py|go|rb|java|rs|php|md)\b/i.test(lower);
-
-  if (singleFileScoped && !multipleActions) return false;
-  if (singleFileScoped && !nonTrivialSignals) return false;
-
-  return nonTrivialSignals || (multipleActions && !singleFileScoped);
+  const fileMentions = (lower.match(/[-_/.\w]+\.(?:[cm]?[jt]sx?|py|go|rb|java|rs|php|md)\b/g) || []).length;
+  const multiFileScope =
+    fileMentions >= 2 ||
+    /\b(across|multiple files?|cross-file|cross file)\b/i.test(lower) ||
+    /跨文件|多文件/.test(input);
+  const verificationHeavy = /\b(with tests?|and tests?|verify|validation|error handling|error recovery)\b/i.test(lower) || /测试|验证|校验|错误处理|错误恢复/.test(input);
+  const architectureHeavy =
+    broadSignals.length >= 3 ||
+    /\b(architecture|workflow|migration|state management|session state|integration)\b/i.test(lower) ||
+    /架构|流程|迁移|状态/.test(input);
+
+  if (singleFileScoped && !multipleActions && !verificationHeavy) return 'simple';
+  if (architectureHeavy && (multiFileScope || multipleActions || verificationHeavy)) return 'complex';
+  if (multiFileScope || verificationHeavy || multipleActions) return 'medium';
+  return 'simple';
 }
 
 function classifyAutoRoute(text = '') {
@@ -650,25 +843,42 @@ function classifyAutoRoute(text = '') {
     return {
       mode: 'brainstorm',
       autoPlan: false,
-      selectedSkills
+      selectedSkills,
+      complexity: 'discussion'
     };
   }
 
-  if (shouldAutoPlan(text)) {
+  const complexity = classifyTaskComplexity(text);
+  if (complexity === 'complex') {
     return {
       mode: 'auto_plan',
       autoPlan: true,
-      selectedSkills: ['superpowers-lite']
+      selectedSkills: ['superpowers-lite'],
+      complexity
     };
   }
 
   return {
-    mode: 'direct',
+    mode: complexity === 'medium' ? 'direct_medium' : 'direct',
     autoPlan: false,
-    selectedSkills
+    selectedSkills,
+    complexity
   };
 }
 
+function buildMediumTaskSystemPrompt(systemPrompt) {
+  const guidance = [
+    'Task Mode: medium',
+    'Execution guidance:',
+    '- Give a brief execution outline before coding.',
+    '- Keep the outline concise and focused on touched files/behaviors.',
+    '- Then implement directly instead of entering pending plan approval.',
+    '- 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) {
   const selected = classifyAutoRoute(text).selectedSkills.filter((name) => isSkillEnabled(config, name));
   if (selected.length === 0) return baseSystemPrompt;
@@ -809,6 +1019,7 @@ function enforceAutoPlanGuardrailSteps(plan, goal) {
   const source = Array.isArray(plan?.steps) ? plan.steps : [];
   const requirements = deriveGoalRequirements(goal);
   const lightweightGoal = isLightweightAutoPlanGoal(goal, requirements);
+  const taskClass = classifyPlanTaskClass(goal);
   const implementationSteps = source.filter((step) => step.role !== 'reviewer' && step.role !== 'tester');
   const primaryImplementationStep =
     implementationSteps.find((step) => step.role === 'coder') ||
@@ -827,17 +1038,31 @@ function enforceAutoPlanGuardrailSteps(plan, goal) {
     role: 'tester',
     task: `Test and verify the completed work for: ${goal}. Start with the artifacts produced by earlier implementation steps, run the most relevant checks available, report concrete evidence, and call out anything still unverified.`
   };
+  const hasReviewer = source.some((step) => step.role === 'reviewer');
+  const hasTester = source.some((step) => step.role === 'tester');
+
+  if (taskClass === 'advisory') {
+    const advisorySteps = source.filter((step) => step.role === 'planner' || step.role === 'coder');
+    return {
+      summary: String(plan?.summary || `Auto plan for: ${goal}`).trim(),
+      steps: advisorySteps.length > 0 ? advisorySteps.slice(0, 6) : [primaryImplementationStep]
+    };
+  }
 
   if (lightweightGoal) {
     return {
       summary: String(plan?.summary || `Auto plan for: ${goal}`).trim(),
-      steps: [primaryImplementationStep, testerStep]
+      steps: hasTester ? [primaryImplementationStep, testerStep] : [primaryImplementationStep]
     };
   }
 
   return {
     summary: String(plan?.summary || `Auto plan for: ${goal}`).trim(),
-    steps: [...implementationSteps.slice(0, 6), reviewerStep, testerStep]
+    steps: [
+      ...implementationSteps.slice(0, 6),
+      ...(hasReviewer ? [reviewerStep] : []),
+      ...(testerStep ? [testerStep] : [])
+    ]
   };
 }
 
@@ -906,19 +1131,23 @@ function extractAcceptanceStatusItems(text = '') {
 }
 
 function buildAutoPlanSystemSummary(auto) {
-  const statusTitle =
+  const baseStatusTitle =
     auto.failedCount > 0 ? 'Auto plan finished with failures' : auto.warningCount > 0 ? 'Auto plan finished with warnings' : 'Auto plan finished';
+  const statusTitle =
+    auto.approvalStatus === 'pending' ? `${baseStatusTitle} (waiting for /plan approve)` : baseStatusTitle;
   const lines = [
     statusTitle,
-    `File: ${auto.filePath}`,
+    `Plan File: ${auto.filePath}`,
     `Plan Summary: ${auto.summary || '-'}`,
     `Final Summary: ${auto.finalSummary || auto.summary || '-'}`,
-    `Approval: ${auto.approvalStatus || 'not_required'}`,
-    `Steps: ${auto.steps.length} total`,
-    `Completed: ${auto.completedCount}`,
-    `Warnings: ${auto.warningCount}`,
-    `Failed: ${auto.failedCount}`
+    `Approval: ${auto.approvalStatus || 'not_required'}`
   ];
+  if (auto.approvalStatus !== 'pending') {
+    lines.push(`Steps: ${auto.steps.length} total`);
+    lines.push(`Completed: ${auto.completedCount}`);
+    lines.push(`Warnings: ${auto.warningCount}`);
+    lines.push(`Failed: ${auto.failedCount}`);
+  }
   if (auto.warningTitles?.length) {
     lines.push(`Warning steps: ${auto.warningTitles.slice(0, 5).join(', ')}`);
   }
@@ -926,7 +1155,7 @@ function buildAutoPlanSystemSummary(auto) {
     lines.push(`Failed steps: ${auto.failedTitles.slice(0, 5).join(', ')}`);
   }
   if (auto.approvalStatus === 'pending') {
-    lines.push('Next: review the plan summary, then use /plan approve to start implementation or /plan stay to keep planning.');
+    lines.push('Next: review the plan summary, then use /plan approve to start implementation, /plan auto run <goal> to plan and run in one step next time, or /plan stay to keep planning.');
   }
   return lines.join('\n');
 }
@@ -1002,6 +1231,7 @@ async function buildAutoPlanFinalSummary({
 
   try {
     const result = await createChatCompletion({
+      sdkProvider: config.sdk?.provider,
       baseUrl: config.gateway.base_url,
       apiKey: config.gateway.api_key,
       model: model || config.model.name,
@@ -1102,6 +1332,7 @@ async function buildSpecWithModel({
   ].join('\n');
 
   const result = await createChatCompletion({
+    sdkProvider: config.sdk?.provider,
     baseUrl: config.gateway.base_url,
     apiKey: config.gateway.api_key,
     model: model || config.model.name,
@@ -1161,6 +1392,7 @@ async function buildPlanFromSpecWithModel({
   ].join('\n');
 
   const result = await createChatCompletion({
+    sdkProvider: config.sdk?.provider,
     baseUrl: config.gateway.base_url,
     apiKey: config.gateway.api_key,
     model: model || config.model.name,
@@ -1276,6 +1508,7 @@ function buildRuntimeStateSnapshot({ currentSession, config, model, executionMod
   const snapshot = {
     sessionId: currentSession?.id || '',
     mode: executionMode || config.execution?.mode || 'auto',
+    sdkProvider: config.sdk?.provider || 'openai-compatible',
     model: model || config.model?.name || '',
     maxContextTokens
   };
@@ -1336,7 +1569,7 @@ function buildPendingPlanApprovalMessage(planState) {
   const lines = [
     'Plan approval is still pending.',
     `Goal: ${planState?.goal || '-'}`,
-    `Plan file: ${planState?.filePath || '-'}`,
+    `Plan File: ${planState?.filePath || '-'}`,
     `Summary: ${planState?.finalSummary || planState?.summary || '-'}`,
     'Use /plan approve to start implementation, or /plan stay to keep refining the plan first.'
   ];
@@ -1344,6 +1577,7 @@ function buildPendingPlanApprovalMessage(planState) {
 }
 
 function buildApprovedPlanExecutionPrompt(planState, approvalText = '') {
+  const requirementPacket = buildGoalRequirementPacket(planState?.goal || '', 'coder');
   const lines = [
     'Approved implementation plan:',
     `Original goal: ${planState?.goal || '-'}`,
@@ -1351,6 +1585,7 @@ function buildApprovedPlanExecutionPrompt(planState, approvalText = '') {
     `Plan summary: ${planState?.summary || '-'}`,
     `Final planning summary: ${planState?.finalSummary || planState?.summary || '-'}`,
     `User approval: ${String(approvalText || '').trim() || 'approved'}`,
+    requirementPacket,
     Array.isArray(planState?.steps) && planState.steps.length > 0 ? 'Planned steps:' : '',
     ...(Array.isArray(planState?.steps)
       ? planState.steps.slice(0, 8).map((step, index) => `${index + 1}. [${step.role}] ${step.title} :: ${step.task}`)
@@ -1595,6 +1830,7 @@ async function askModel({
       };
 
       const result = await createChatCompletionStream({
+        sdkProvider: config.sdk?.provider,
         baseUrl: config.gateway.base_url,
         apiKey: config.gateway.api_key,
         model: selectedModel,
@@ -1719,12 +1955,26 @@ async function buildAutoPlanAndRun({
   model,
   systemPrompt,
   onAgentEvent,
-  sessionId
+  sessionId,
+  taskClass
 }) {
+  const normalizedTaskClass = taskClass || classifyPlanTaskClass(goal);
   const requirementPacket = buildGoalRequirementPacket(goal, 'planner');
   const plannerPrompt = [
     buildAutoPlanPlannerGuidance(),
-    'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|coder|reviewer|tester","task":"..."}]}. No markdown. Always include final reviewer and tester steps.'
+    'Planning policy:',
+    '- First classify the user goal as one of: advisory, implementation, or verification-heavy.',
+    '- advisory = analysis, review, audit, optimization suggestions, architecture feedback, brainstorming, planning, or recommendation requests.',
+    '- implementation = add/build/create/implement/refactor/fix/update/change behavior in code or files.',
+    '- verification-heavy = the user explicitly asks to run tests, verify findings, reproduce a bug, prove a claim, or validate a result.',
+    '- For advisory goals, prefer only planner and coder roles. Do not use reviewer or tester unless the user explicitly asks for verification or review as a separate deliverable.',
+    '- For advisory goals, do not emit generic filler steps such as "Test and verify", "Review recommendations", or other template-only steps.',
+    '- For implementation goals, reviewer and tester are optional support roles, not defaults. Only include them when they clearly add value.',
+    '- Every step title must be concrete and tied to the goal. Avoid vague titles like "Initial analysis", "Review recommendations", or "Test and verify" unless the user explicitly requested those activities.',
+    '- If the task is purely to inspect the current project and suggest improvements, a lean 2-step or 3-step plan is preferred.',
+    '- Example advisory roles: planner -> inspect project shape, coder -> synthesize findings and prioritized recommendations.',
+    '- Example implementation roles: planner -> inspect target area, coder -> implement change, tester -> verify changed behavior.',
+    'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|coder|reviewer|tester","task":"..."}]}. No markdown.'
   ].join('\n');
   let autoPlan = {
     summary: `Auto plan for: ${goal}`,
@@ -1739,6 +1989,7 @@ async function buildAutoPlanAndRun({
   let planningError = '';
   try {
     const planning = await createChatCompletion({
+      sdkProvider: config.sdk?.provider,
       baseUrl: config.gateway.base_url,
       apiKey: config.gateway.api_key,
       model: model || config.model.name,
@@ -1749,10 +2000,15 @@ async function buildAutoPlanAndRun({
           content: [
             'Create an execution plan and assign best sub-agent role for each step.',
             'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|coder|reviewer|tester","task":"..."}]}. No markdown.',
-            'Always include final reviewer and tester steps unless the task is explicitly tiny.',
+            'The available roles are planner, coder, reviewer, and tester. Use only the roles the task actually needs.',
+            `Task class: ${normalizedTaskClass}`,
+            'Before choosing roles, decide whether the request is advisory, implementation, or verification-heavy.',
             requirementPacket,
             'The first step should usually inspect or clarify the target area before implementation.',
-            'The final steps must include review and testing/verification unless the goal is a tiny single-change task, in which case you may keep only one implementation step plus one testing/verification step.',
+            'For analysis, recommendation, optimization, audit, or project-review goals, keep the plan lean and usually limit it to planner/coder.',
+            'Do not include reviewer/tester for advisory goals unless the user explicitly asks to validate, verify, or independently review the findings.',
+            'Avoid template-only titles like "Initial analysis", "Review recommendations", or "Test and verify" for advisory goals.',
+            'For implementation-heavy changes, prefer review and/or testing steps near the end only when they materially improve confidence.',
             'Prefer 3-5 steps total.'
           ]
             .filter(Boolean)
@@ -1891,14 +2147,43 @@ export async function createChatRuntime({
       messageCount: Array.isArray(currentSession.messages) ? currentSession.messages.length : 0
     }
   ];
+  try {
+    const initialSessions = await listSessions(100);
+    if (initialSessions.length > 0) {
+      const merged = [
+        {
+          id: currentSession.id,
+          messageCount: Array.isArray(currentSession.messages) ? currentSession.messages.length : 0
+        },
+        ...initialSessions.map((session) => ({
+          id: session.id,
+          messageCount: Number(session.messageCount || 0)
+        }))
+      ];
+      const deduped = [];
+      const seen = new Set();
+      for (const session of merged) {
+        const id = String(session.id || '').trim();
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        deduped.push(session);
+      }
+      historySessionCache = deduped;
+      historyIdCache = deduped.map((session) => session.id);
+    }
+  } catch {
+    // keep startup resilient even if historical sessions cannot be listed
+  }
 
   const configKeyHints = [
     'gateway.base_url',
     'gateway.api_key',
     'model.name',
+    'ui.language',
     'ui.reply_language',
     'execution.mode',
     'shell.default',
+    'sdk.provider',
     'gateway.timeout_ms',
     'gateway.max_retries',
     'model.max_context_tokens',
@@ -1923,6 +2208,7 @@ export async function createChatRuntime({
     '/help',
     '/status',
     '/config',
+    '/memory',
     '/mode',
     '/plan',
     '/tasks',
@@ -1934,30 +2220,26 @@ export async function createChatRuntime({
     '/retry'
   ];
   const configSubcommandPriority = ['/config set', '/config get', '/config list', '/config reset'];
-  const configSubcommandDescriptions = {
-    '/config set': 'update a config value',
-    '/config get': 'show a config value',
-    '/config list': 'print the full config',
-    '/config reset': 'reset config to defaults'
-  };
 
   const listCommandNames = () => {
+    const completionCopy = getCompletionCopy(config.ui?.language);
     const builtins = [
-      { name: 'help', description: 'show chat help' },
-      { name: 'exit', description: 'exit chat' },
-      { name: 'commands', description: 'list slash/custom commands' },
-      { name: 'status', description: 'show runtime status (mode/model/session)' },
-      { name: 'mode', description: 'set execution mode: normal|auto|plan' },
-      { name: 'compact', description: 'compress message context' },
-      { name: 'tasks', description: 'task board management' },
-      { name: 'checkpoint', description: 'create/list/load conversation checkpoints' },
-      { name: 'spec', description: 'create a spec markdown file in .codemini/specs' },
-      { name: 'plan', description: 'create an implementation plan markdown file in .codemini/plans' },
-      { name: 'agents', description: 'run/list sub-agent roles' },
-      { name: 'config', description: 'set/get/list/reset config values' },
-      { name: 'history', description: 'list/resume sessions' },
-      { name: 'debug', description: 'runtime debug switches' },
-      { name: 'retry', description: 'retry the last user request' }
+      { name: 'help', description: completionCopy.commands.help },
+      { name: 'exit', description: completionCopy.commands.exit },
+      { name: 'commands', description: completionCopy.commands.commands },
+      { name: 'status', description: completionCopy.commands.status },
+      { name: 'mode', description: completionCopy.commands.mode },
+      { name: 'compact', description: completionCopy.commands.compact },
+      { name: 'tasks', description: completionCopy.commands.tasks },
+      { name: 'checkpoint', description: completionCopy.commands.checkpoint },
+      { name: 'spec', description: completionCopy.commands.spec },
+      { name: 'plan', description: completionCopy.commands.plan },
+      { name: 'agents', description: completionCopy.commands.agents },
+      { name: 'config', description: completionCopy.commands.config },
+      { name: 'memory', description: completionCopy.commands.memory },
+      { name: 'history', description: completionCopy.commands.history },
+      { name: 'debug', description: completionCopy.commands.debug },
+      { name: 'retry', description: completionCopy.commands.retry }
     ];
     const out = [];
     for (const cmd of commands.values()) {
@@ -1991,6 +2273,7 @@ export async function createChatRuntime({
   ];
 
   const historyTemplates = ['/history list', '/history current', '/history resume <session_id>'];
+  const memoryTemplates = ['/memory list <scope>', '/memory search <scope> <query>', '/memory forget <scope> <id>'];
   const modeTemplates = ['/mode normal', '/mode auto', '/mode plan'];
   const taskTemplates = ['/tasks', '/tasks add <title>', '/tasks start <id>', '/tasks done <id>', '/tasks remove <id>', '/tasks clear'];
   const checkpointTemplates = [
@@ -2000,12 +2283,13 @@ export async function createChatRuntime({
     '/checkpoint load <id>'
   ];
   const specTemplates = ['/spec <topic>'];
-  const planTemplates = ['/plan <goal>', '/plan auto <goal>', '/plan from-spec <spec-path?>'];
+  const planTemplates = ['/plan <goal>', '/plan auto <goal>', '/plan auto run <goal>', '/plan approve', '/plan from-spec <spec-path?>'];
   const agentTemplates = ['/agents list', '/agents run planner <task>', '/agents run coder <task>', '/agents run reviewer <task>', '/agents run tester <task>'];
   const debugTemplates = ['/debug keys on', '/debug keys off', '/debug keys status'];
   const compactTemplates = compactOptions.map((opt) => `/compact ${opt}`);
   const slashTemplates = [
     ...configTemplates,
+    ...memoryTemplates,
     ...historyTemplates,
     ...modeTemplates,
     ...taskTemplates,
@@ -2041,6 +2325,9 @@ export async function createChatRuntime({
   const getCompletionOptions = (rawInput) => {
     const input = String(rawInput || '');
     if (!input.startsWith('/')) return [];
+    const completionCopy = getCompletionCopy(config.ui?.language);
+    const configSubcommandDescriptions = completionCopy.configSubcommands;
+    const planSubcommandDescriptions = completionCopy.planSubcommands || {};
 
     const hasTrailingSpace = /\s$/.test(input);
     const body = input.slice(1);
@@ -2048,6 +2335,7 @@ export async function createChatRuntime({
     const commandPart = tokens[0] || '';
     const commandHasSubcommands = new Set([
       'config',
+      'memory',
       'compact',
       'mode',
       'tasks',
@@ -2065,19 +2353,22 @@ export async function createChatRuntime({
       registerSuggestion(`/${entry.name}`, entry.description || '');
     }
     for (const template of configTemplates) {
-      registerSuggestion(template, configSubcommandDescriptions[template] || 'config command');
-    }
-    for (const template of historyTemplates) registerSuggestion(template, 'history command');
-    for (const template of modeTemplates) registerSuggestion(template, 'switch execution mode');
-    for (const template of taskTemplates) registerSuggestion(template, 'task board command');
-    for (const template of checkpointTemplates) registerSuggestion(template, 'checkpoint command');
-    for (const template of specTemplates) registerSuggestion(template, 'create a spec file');
-    for (const template of planTemplates) registerSuggestion(template, 'planning command');
-    for (const template of agentTemplates) registerSuggestion(template, 'sub-agent command');
-    for (const template of debugTemplates) registerSuggestion(template, 'debug command');
-    for (const template of compactTemplates) registerSuggestion(template, 'context compaction command');
-    registerSuggestion('/retry', 'retry the last user request');
-    registerSuggestion('/status', 'show runtime status');
+      registerSuggestion(template, configSubcommandDescriptions[template] || completionCopy.generic.configCommand);
+    }
+    for (const template of memoryTemplates) registerSuggestion(template, completionCopy.generic.memoryCommand);
+    for (const template of historyTemplates) registerSuggestion(template, completionCopy.generic.historyCommand);
+    for (const template of modeTemplates) registerSuggestion(template, completionCopy.generic.modeCommand);
+    for (const template of taskTemplates) registerSuggestion(template, completionCopy.generic.taskCommand);
+    for (const template of checkpointTemplates) registerSuggestion(template, completionCopy.generic.checkpointCommand);
+    for (const template of specTemplates) registerSuggestion(template, completionCopy.generic.specCommand);
+    for (const template of planTemplates) {
+      registerSuggestion(template, planSubcommandDescriptions[template] || completionCopy.generic.planCommand);
+    }
+    for (const template of agentTemplates) registerSuggestion(template, completionCopy.generic.agentCommand);
+    for (const template of debugTemplates) registerSuggestion(template, completionCopy.generic.debugCommand);
+    for (const template of compactTemplates) registerSuggestion(template, completionCopy.generic.compactCommand);
+    registerSuggestion('/retry', completionCopy.generic.retryCommand);
+    registerSuggestion('/status', completionCopy.generic.statusCommand);
 
     if (!commandPart) {
       return materializeSuggestions(prioritizeByPreferredOrder(
@@ -2105,7 +2396,7 @@ export async function createChatRuntime({
         return materializeSuggestions(prioritizeByPreferredOrder(
           ['set', 'get', 'list', 'reset']
             .filter((s) => s.startsWith(subcommand))
-            .map((s) => registerSuggestion(`/config ${s}`, configSubcommandDescriptions[`/config ${s}`] || 'config command').value),
+            .map((s) => registerSuggestion(`/config ${s}`, configSubcommandDescriptions[`/config ${s}`] || completionCopy.generic.configCommand).value),
           configSubcommandPriority
         ));
       }
@@ -2114,42 +2405,58 @@ export async function createChatRuntime({
         const keyPrefix = tokens.length >= 3 ? tokens[2] || '' : '';
         return configKeyHints
           .filter((k) => k.startsWith(keyPrefix))
-          .map((k) => registerSuggestion(`/config get ${k}`, describeConfigKey(k, 'get')));
+          .map((k) => registerSuggestion(`/config get ${k}`, describeConfigKey(k, 'get', config.ui?.language)));
       }
       if (subcommand === 'set') {
         const keyPrefix = tokens.length >= 3 ? tokens[2] || '' : '';
         return configKeyHints
           .filter((k) => k.startsWith(keyPrefix))
-          .map((k) => registerSuggestion(`/config set ${k} `, describeConfigKey(k, 'set')));
+          .map((k) => registerSuggestion(`/config set ${k} `, describeConfigKey(k, 'set', config.ui?.language)));
       }
 
       return materializeSuggestions(configTemplates);
     }
 
+    if (commandPart === 'memory') {
+      const sub = tokens[1] || '';
+      if (tokens.length === 1 || (tokens.length === 2 && !hasTrailingSpace)) {
+        return ['list', 'search', 'forget']
+          .filter((item) => item.startsWith(sub))
+          .map((item) => registerSuggestion(`/memory ${item}`, completionCopy.generic.memoryCommand));
+      }
+      const scope = tokens[2] || '';
+      if (['list', 'search', 'forget'].includes(sub) && (tokens.length === 2 || (tokens.length === 3 && !hasTrailingSpace))) {
+        return ['user', 'global', 'project']
+          .filter((item) => item.startsWith(scope))
+          .map((item) => registerSuggestion(`/memory ${sub} ${item}${sub === 'list' ? '' : ' '}`, completionCopy.generic.memoryCommand));
+      }
+      return materializeSuggestions(memoryTemplates);
+    }
+
     if (commandPart === 'compact') {
       const joined = tokens.slice(1).join(' ');
       if (tokens.length === 1 || (tokens.length === 2 && !hasTrailingSpace)) {
         return compactOptions
           .filter((opt) => opt.startsWith(joined) || joined === '')
-          .map((opt) => registerSuggestion(`/compact ${opt}`, 'context compaction command'));
+          .map((opt) => registerSuggestion(`/compact ${opt}`, completionCopy.generic.compactCommand));
       }
       return compactOptions
         .filter((opt) => opt.includes(joined) || joined === '')
-        .map((opt) => registerSuggestion(`/compact ${opt}`, 'context compaction command'));
+        .map((opt) => registerSuggestion(`/compact ${opt}`, completionCopy.generic.compactCommand));
     }
 
     if (commandPart === 'retry') {
-      return [registerSuggestion('/retry', 'retry the last user request')];
+      return [registerSuggestion('/retry', completionCopy.generic.retryCommand)];
     }
     if (commandPart === 'status') {
-      return [registerSuggestion('/status', 'show runtime status')];
+      return [registerSuggestion('/status', completionCopy.generic.statusCommand)];
     }
     if (commandPart === 'mode') {
       if (tokens.length === 1 || (tokens.length === 2 && !hasTrailingSpace)) {
         const sub = tokens[1] || '';
         return ['normal', 'auto', 'plan']
           .filter((m) => m.startsWith(sub))
-          .map((m) => registerSuggestion(`/mode ${m}`, 'switch execution mode'));
+          .map((m) => registerSuggestion(`/mode ${m}`, completionCopy.generic.modeCommand));
       }
       return materializeSuggestions(modeTemplates);
     }
@@ -2158,7 +2465,7 @@ export async function createChatRuntime({
         const sub = tokens[1] || '';
         return ['add', 'start', 'done', 'remove', 'rm', 'clear']
           .filter((s) => s.startsWith(sub))
-          .map((s) => registerSuggestion(`/tasks ${s}`, 'task board command'));
+          .map((s) => registerSuggestion(`/tasks ${s}`, completionCopy.generic.taskCommand));
       }
       return materializeSuggestions(taskTemplates);
     }
@@ -2167,24 +2474,24 @@ export async function createChatRuntime({
         const sub = tokens[1] || '';
         if (sub === 'list') {
           return ['--all']
-            .map((v) => registerSuggestion(`/checkpoint list ${v}`, 'checkpoint command'));
+            .map((v) => registerSuggestion(`/checkpoint list ${v}`, completionCopy.generic.checkpointCommand));
         }
         return ['create', 'list', 'load']
           .filter((s) => s.startsWith(sub))
-          .map((s) => registerSuggestion(`/checkpoint ${s}`, 'checkpoint command'));
+          .map((s) => registerSuggestion(`/checkpoint ${s}`, completionCopy.generic.checkpointCommand));
       }
       if (tokens[1] === 'list') {
         const hint = tokens[2] || '';
         return ['--all']
           .filter((v) => v.startsWith(hint))
-          .map((v) => registerSuggestion(`/checkpoint list ${v}`, 'checkpoint command'));
+          .map((v) => registerSuggestion(`/checkpoint list ${v}`, completionCopy.generic.checkpointCommand));
       }
       if (tokens[1] === 'load') {
         if (tokens.length >= 3) {
           const hint = tokens[3] || '';
           return ['--all']
             .filter((v) => v.startsWith(hint))
-            .map((v) => registerSuggestion(`/checkpoint load ${tokens[2]} ${v}`, 'checkpoint command'));
+            .map((v) => registerSuggestion(`/checkpoint load ${tokens[2]} ${v}`, completionCopy.generic.checkpointCommand));
         }
       }
       return materializeSuggestions(checkpointTemplates);
@@ -2193,11 +2500,25 @@ export async function createChatRuntime({
       return materializeSuggestions(specTemplates);
     }
     if (commandPart === 'plan') {
+      if (tokens[1] === 'auto' && (tokens.length === 2 || (tokens.length === 3 && !hasTrailingSpace))) {
+        const sub = tokens[2] || '';
+        return ['run']
+          .filter((s) => s.startsWith(sub))
+          .map((s) => registerSuggestion(`/plan auto ${s} `, planSubcommandDescriptions[`/plan auto ${s} <goal>`] || completionCopy.generic.planCommand));
+      }
       if (tokens.length === 1 || (tokens.length === 2 && !hasTrailingSpace)) {
         const sub = tokens[1] || '';
-        return ['auto', 'from-spec']
+        return ['auto', 'approve', 'from-spec']
           .filter((s) => s.startsWith(sub))
-          .map((s) => registerSuggestion(`/plan ${s}`, 'planning command'));
+          .map((s) =>
+            registerSuggestion(
+              `/plan ${s}`,
+              planSubcommandDescriptions[`/plan ${s}`] ||
+                planSubcommandDescriptions[`/plan ${s} <goal>`] ||
+                planSubcommandDescriptions[`/plan ${s} <spec-path?>`] ||
+                completionCopy.generic.planCommand
+            )
+          );
       }
       return materializeSuggestions(planTemplates);
     }
@@ -2206,17 +2527,17 @@ export async function createChatRuntime({
         const sub = tokens[1] || '';
         if (sub === 'run') {
           return ['planner', 'coder', 'reviewer', 'tester']
-            .map((r) => registerSuggestion(`/agents run ${r} `, 'sub-agent command'));
+            .map((r) => registerSuggestion(`/agents run ${r} `, completionCopy.generic.agentCommand));
         }
         return ['list', 'run']
           .filter((s) => s.startsWith(sub))
-          .map((s) => registerSuggestion(`/agents ${s}`, 'sub-agent command'));
+          .map((s) => registerSuggestion(`/agents ${s}`, completionCopy.generic.agentCommand));
       }
       if (tokens[1] === 'run') {
         const rolePrefix = tokens[2] || '';
         return ['planner', 'coder', 'reviewer', 'tester']
           .filter((r) => r.startsWith(rolePrefix))
-          .map((r) => registerSuggestion(`/agents run ${r} `, 'sub-agent command'));
+          .map((r) => registerSuggestion(`/agents run ${r} `, completionCopy.generic.agentCommand));
       }
       return materializeSuggestions(agentTemplates);
     }
@@ -2230,13 +2551,13 @@ export async function createChatRuntime({
             .map((session) => ({
               value: `/history resume ${session.id}`,
               display: `/history resume ${session.id}  ·  ${Number(session.messageCount || 0)} msgs`,
-              description: 'resume a saved session'
+              description: completionCopy.generic.resumeSession
             }));
           if (dynamic.length > 0) return dynamic;
         }
         return ['list', 'current', 'resume']
           .filter((s) => s.startsWith(sub))
-          .map((s) => registerSuggestion(`/history ${s}`, 'history command'));
+          .map((s) => registerSuggestion(`/history ${s}`, completionCopy.generic.historyCommand));
       }
       if (sub === 'resume') {
         const idPrefix = tokens[2] || '';
@@ -2245,7 +2566,7 @@ export async function createChatRuntime({
           .map((session) => ({
             value: `/history resume ${session.id}`,
             display: `/history resume ${session.id}  ·  ${Number(session.messageCount || 0)} msgs`,
-            description: 'resume a saved session'
+            description: completionCopy.generic.resumeSession
           }));
         if (dynamic.length > 0) return dynamic;
         return materializeSuggestions(historyTemplates);
@@ -2258,17 +2579,17 @@ export async function createChatRuntime({
       if (tokens.length === 1 || (tokens.length === 2 && !hasTrailingSpace)) {
         if (sub === 'keys') {
           return ['on', 'off', 'status']
-            .map((v) => registerSuggestion(`/debug keys ${v}`, 'keyboard debug command'));
+            .map((v) => registerSuggestion(`/debug keys ${v}`, completionCopy.generic.keyboardDebugCommand));
         }
         return ['keys']
           .filter((s) => s.startsWith(sub))
-          .map((s) => registerSuggestion(`/debug ${s}`, 'debug command'));
+          .map((s) => registerSuggestion(`/debug ${s}`, completionCopy.generic.debugCommand));
       }
       if (sub === 'keys') {
         const action = tokens[2] || '';
         return ['on', 'off', 'status']
           .filter((v) => v.startsWith(action))
-          .map((v) => registerSuggestion(`/debug keys ${v}`, 'keyboard debug command'));
+          .map((v) => registerSuggestion(`/debug keys ${v}`, completionCopy.generic.keyboardDebugCommand));
       }
       return materializeSuggestions(debugTemplates);
     }
@@ -2286,6 +2607,17 @@ export async function createChatRuntime({
     await saveSession(currentSession);
   };
 
+  const buildActiveSystemPrompt = async () => {
+    const soulPrompt = await buildSystemPromptWithSoul(baseSystemPrompt, config);
+    const memorySnapshot = await buildMemorySnapshot({
+      config,
+      workspaceRoot: process.cwd()
+    }).catch(() => '');
+    const memoryGuide =
+      'Persistent memory is for durable preferences, project conventions, and stable workflow knowledge. Use fresh file reads when the code can verify details. Only write memory when the fact is likely to matter in future sessions, is stable over time, and is not sensitive. Do not store temporary task details, speculative guesses, or secrets. Choose remember_user for user preferences, communication habits, and long-term constraints. Choose remember_global for reusable workflow knowledge that helps across many projects. Choose remember_project for repository-specific conventions, architecture notes, important modules, and local workflow expectations. When memory includes command names, file paths, identifiers, or exact wording, preserve those tokens exactly instead of paraphrasing them.';
+    return [soulPrompt, memorySnapshot, memoryGuide].filter(Boolean).join('\n\n');
+  };
+
   const isImmediateLocalInput = (line) => {
     const parsedInput = parseInput(line);
     if (parsedInput.type !== 'slash') return false;
@@ -2304,6 +2636,7 @@ export async function createChatRuntime({
       'tasks',
       'checkpoint',
       'history',
+      'memory',
       'config',
       'compact',
       'debug'
@@ -2312,8 +2645,7 @@ export async function createChatRuntime({
   };
 
   const submit = async (line, onAgentEvent) => {
-    const activeBaseSystemPrompt = buildSystemPromptWithReplyLanguage(baseSystemPrompt, config);
-    const activeReplySystemPrompt = await buildSystemPromptWithSoul(baseSystemPrompt, config);
+    const activeReplySystemPrompt = await buildActiveSystemPrompt();
     try {
       await appendInputHistory(line);
     } catch {
@@ -2332,7 +2664,7 @@ export async function createChatRuntime({
       if (parsedInput.command === 'help') {
         return {
           type: 'system',
-          text: 'Commands: /help /exit /commands /status /mode /compact /tasks /checkpoint /spec /plan /agents /config /history /debug /retry /<custom> !<shell>'
+          text: 'Commands: /help /exit /commands /status /mode /compact /tasks /checkpoint /spec /plan /agents /config /memory /history /debug /retry /<custom> !<shell>'
         };
       }
       if (parsedInput.command === 'status') {
@@ -2486,7 +2818,7 @@ export async function createChatRuntime({
             topic,
             config,
             model,
-            systemPrompt: activeBaseSystemPrompt
+            systemPrompt: activeReplySystemPrompt
           });
         } catch (err) {
           content = buildSpecTemplate(topic);
@@ -2506,17 +2838,45 @@ export async function createChatRuntime({
       if (parsedInput.command === 'plan') {
         const sub = (parsedInput.args[0] || '').trim().toLowerCase();
         if (sub === 'auto') {
-          const goal = parsedInput.args.slice(1).join(' ').trim();
-          if (!goal) return { type: 'system', text: 'Usage: /plan auto <goal>' };
+          const runImmediately = (parsedInput.args[1] || '').trim().toLowerCase() === 'run';
+          const goal = parsedInput.args.slice(runImmediately ? 2 : 1).join(' ').trim();
+          if (!goal) return { type: 'system', text: 'Usage: /plan auto <goal> | /plan auto run <goal>' };
           const auto = await buildAutoPlanAndRun({
             goal,
             session: currentSession,
             config,
             model,
-            systemPrompt: activeBaseSystemPrompt,
+            systemPrompt: activeReplySystemPrompt,
             onAgentEvent,
-            sessionId: currentSession.id
+            sessionId: currentSession.id,
+            taskClass: classifyPlanTaskClass(goal)
           });
+          if (runImmediately) {
+            const result = await askModel({
+              text: buildApprovedPlanExecutionPrompt(
+                {
+                  status: 'approved',
+                  source: 'auto',
+                  goal,
+                  filePath: auto.filePath,
+                  summary: auto.summary || '',
+                  finalSummary: auto.finalSummary || auto.summary || '',
+                  steps: Array.isArray(auto.steps) ? auto.steps : []
+                },
+                '/plan auto run'
+              ),
+              session: currentSession,
+              config,
+              model,
+              systemPrompt: activeReplySystemPrompt,
+              onAgentEvent,
+              executionMode: 'auto'
+            });
+            currentSession.planState = null;
+            executionMode = 'auto';
+            await saveSession(currentSession);
+            return { type: 'assistant', text: result.text };
+          }
           currentSession.planState = {
             status: 'pending_approval',
             source: 'auto',
@@ -2577,7 +2937,7 @@ export async function createChatRuntime({
               specPath,
               config,
               model,
-              systemPrompt: activeBaseSystemPrompt
+              systemPrompt: activeReplySystemPrompt
             });
           } catch (err) {
             planContent = buildPlanTemplate(specTitle);
@@ -2596,7 +2956,7 @@ export async function createChatRuntime({
         }
 
         const goal = parsedInput.args.join(' ').trim();
-        if (!goal) return { type: 'system', text: 'Usage: /plan <goal> | /plan auto <goal> | /plan from-spec <spec-path?>' };
+        if (!goal) return { type: 'system', text: 'Usage: /plan <goal> | /plan auto <goal> | /plan auto run <goal> | /plan from-spec <spec-path?>' };
         const content = buildPlanTemplate(goal);
         const filePath = await writeMarkdownInProjectDir(
           'plans',
@@ -2630,7 +2990,7 @@ export async function createChatRuntime({
             parentSession: currentSession,
             config,
             model,
-            systemPrompt: activeBaseSystemPrompt,
+            systemPrompt: activeReplySystemPrompt,
             onAgentEvent
           });
           const text = `[sub-agent:${role}]\n${output.text || output}`;
@@ -2691,11 +3051,55 @@ export async function createChatRuntime({
           ];
           return {
             type: 'system',
-            text: `Switched to session: ${targetId} (${loaded.messages.length} messages)`
+            text: `Switched to session: ${targetId} (${loaded.messages.length} messages)`,
+            restoredMessages: structuredClone(loaded.messages || [])
           };
         }
         return { type: 'system', text: `Unknown /history subcommand: ${sub}` };
       }
+      if (parsedInput.command === 'memory') {
+        const sub = String(parsedInput.args[0] || '').trim().toLowerCase();
+        if (!sub) {
+          return { type: 'system', text: 'Usage: /memory list <user|global|project> | /memory search <scope> <query> | /memory forget <scope> <id>' };
+        }
+        if (sub === 'list') {
+          const scope = String(parsedInput.args[1] || '').trim().toLowerCase();
+          if (!['user', 'global', 'project'].includes(scope)) {
+            return { type: 'system', text: 'Usage: /memory list <user|global|project>' };
+          }
+          const items = await listMemories({ scope, workspaceRoot: process.cwd() });
+          if (items.length === 0) return { type: 'system', text: `No ${scope} memories found.` };
+          return {
+            type: 'system',
+            text: items.map((item) => `${item.id} | ${item.kind} | ${item.content}`).join('\n')
+          };
+        }
+        if (sub === 'search') {
+          const scope = String(parsedInput.args[1] || '').trim().toLowerCase();
+          const query = parsedInput.args.slice(2).join(' ').trim();
+          if (!['user', 'global', 'project'].includes(scope) || !query) {
+            return { type: 'system', text: 'Usage: /memory search <user|global|project> <query>' };
+          }
+          const items = await searchMemories({ scope, query, workspaceRoot: process.cwd() });
+          if (items.length === 0) return { type: 'system', text: `No ${scope} memories matched: ${query}` };
+          return {
+            type: 'system',
+            text: items.map((item) => `${item.id} | ${item.kind} | ${item.content}`).join('\n')
+          };
+        }
+        if (sub === 'forget') {
+          const scope = String(parsedInput.args[1] || '').trim().toLowerCase();
+          const id = String(parsedInput.args[2] || '').trim();
+          if (!['user', 'global', 'project'].includes(scope) || !id) {
+            return { type: 'system', text: 'Usage: /memory forget <user|global|project> <id>' };
+          }
+          const result = await forgetMemory({ scope, id, workspaceRoot: process.cwd() });
+          const text = `Removed ${Number(result.removed || 0)} ${scope} memory item(s)`;
+          await persistLocalExchange(line, text, { includeUser: false });
+          return { type: 'system', text };
+        }
+        return { type: 'system', text: `Unknown /memory subcommand: ${sub}` };
+      }
       if (parsedInput.command === 'retry') {
         const lastUser = [...currentSession.messages].reverse().find((m) => m.role === 'user');
         if (!lastUser?.content) {
@@ -2842,7 +3246,7 @@ export async function createChatRuntime({
           session: currentSession,
           config,
           model,
-          systemPrompt: activeBaseSystemPrompt,
+          systemPrompt: activeReplySystemPrompt,
           onAgentEvent,
           executionMode
         });
@@ -2924,9 +3328,10 @@ export async function createChatRuntime({
         session: currentSession,
         config,
         model,
-        systemPrompt: activeBaseSystemPrompt,
+        systemPrompt: activeReplySystemPrompt,
         onAgentEvent,
-        sessionId: currentSession.id
+        sessionId: currentSession.id,
+        taskClass: classifyPlanTaskClass(expandedText)
       });
       currentSession.planState = {
         status: 'pending_approval',
@@ -2950,7 +3355,11 @@ export async function createChatRuntime({
         names: selectedAutoSkills
       });
     }
-    const routedSystemPrompt = buildAutoSkillSystemPrompt(activeReplySystemPrompt, commands, config, expandedText);
+    const skillPrompt = buildAutoSkillSystemPrompt(activeReplySystemPrompt, commands, config, expandedText);
+    const routedSystemPrompt =
+      autoRoute.mode === 'direct_medium'
+        ? buildMediumTaskSystemPrompt(skillPrompt)
+        : skillPrompt;
     const result = await askModel({
       text: expandedText,
       session: currentSession,