codemini-cli 0.3.1 → 0.3.3

package/src/core/chat-runtime.js

@@ -6,20 +6,13 @@ 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';
 import { getConfigValue, loadConfig, resetConfig, setConfigValue } from './config-store.js';
 import { evaluateCommandPolicy } from './command-policy.js';
 import { appendInputHistory, loadInputHistory } from './input-history-store.js';
-import {
-  clearTasks,
-  createTasks,
-  deleteTasks,
-  loadTasks,
-  updateTask
-} from './task-store.js';
 import { createCheckpoint, listCheckpoints, loadCheckpoint } from './checkpoint-store.js';
 import {
   compactMessagesLocally,
@@ -30,6 +23,9 @@ 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';
+import { countActiveTodos, normalizeTodos } from './todo-state.js';
 
 function toOpenAIMessages(sessionMessages) {
   const mapped = [];
@@ -74,35 +70,195 @@ 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: '压缩消息上下文',
+        checkpoint: '创建/查看/加载检查点',
+        spec: '在 .codemini/specs 中创建 spec',
+        plan: '在 .codemini/plans 中创建实施计划',
+        agents: '列出/运行子代理角色',
+        config: '设置/读取/列出/重置配置',
+        memory: '查看/搜索/删除持久记忆',
+        history: '查看/恢复会话',
+        debug: '运行时调试开关',
+        retry: '重试上一条用户请求'
+      },
+      generic: {
+        configCommand: '配置命令',
+        historyCommand: '历史会话命令',
+        modeCommand: '切换执行模式',
+        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',
+        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',
+        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'];
@@ -110,7 +266,7 @@ const SUB_AGENT_CONTEXT_MAX_MESSAGES = 4;
 const SUB_AGENT_CONTEXT_MAX_CHARS = 1200;
 const SUB_AGENT_EVIDENCE_MAX_ITEMS = 3;
 const SUB_AGENT_HANDOFF_MAX_ITEMS = 6;
-function getSubAgentRolePrompt(role) {
+export function getSubAgentRolePrompt(role) {
   if (role === 'planner') {
     return 'You are a planning sub-agent. Produce a concrete implementation plan with risks and verification.';
   }
@@ -149,7 +305,11 @@ function getSubAgentRolePrompt(role) {
       '- <single best next step>'
     ].join('\n');
   }
-  return 'You are an execution sub-agent. Produce practical implementation guidance with code-level detail.';
+  return [
+    'You are an execution sub-agent. Produce practical implementation guidance with code-level detail.',
+    'Stop when: you have produced the code change and verified it compiles/passes basic checks.',
+    'If blocked: report what blocked you and what you tried, then stop.'
+  ].join('\n');
 }
 
 function trimInlineText(value, maxLen = 220) {
@@ -407,6 +567,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 +619,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 +778,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 +837,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 +1013,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 +1032,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 +1125,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 +1149,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 +1225,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 +1326,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 +1386,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 +1502,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 +1563,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 +1571,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 +1579,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}`)
@@ -1518,14 +1747,19 @@ async function askModel({
 
   const projectContextSnippet = await buildProjectContextSnippet(process.cwd(), text).catch(() => '');
   const effectiveSystemPrompt = projectContextSnippet
-    ? `${systemPrompt}\n\n${projectContextSnippet}\n\nUse this project context as lightweight guidance. Query the project index before broad globs or reading many files, then use targeted reads for fresh verification.`
+    ? `${systemPrompt}\n\n${projectContextSnippet}\n\nUse this project context as lightweight guidance and verify important details with fresh reads when needed.`
     : systemPrompt;
 
   const { definitions, handlers, formatters, deferredDefinitions } = getBuiltinTools({
     workspaceRoot: process.cwd(),
     config,
     sessionId: session.id,
-    onSystemEvent: onAgentEvent
+    onSystemEvent: onAgentEvent,
+    getTodos: () => normalizeTodos(session.todos),
+    onTodosUpdate: (todos) => {
+      session.todos = normalizeTodos(todos);
+      scheduleSessionSave();
+    }
   });
 
   let activeAssistantIndex = -1;
@@ -1595,6 +1829,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 +1954,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 +1988,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 +1999,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)
@@ -1866,6 +2121,17 @@ export async function createChatRuntime({
       summary: initialIndex.summary
     });
   }
+  const initialTodos = normalizeTodos(session?.todos);
+  if (initialTodos.length > 0) {
+    startupEvents.push({
+      type: 'tool',
+      id: `startup-todos-${String(session?.id || 'session')}`,
+      name: 'update_todos',
+      status: 'done',
+      arguments: { todos: initialTodos },
+      summary: `${initialTodos.length} todo item(s)`
+    });
+  }
   let currentSession = session;
   let config = initialConfig;
   const baseSystemPrompt = systemPrompt;
@@ -1891,14 +2157,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,9 +2218,9 @@ export async function createChatRuntime({
     '/help',
     '/status',
     '/config',
+    '/memory',
     '/mode',
     '/plan',
-    '/tasks',
     '/history',
     '/checkpoint',
     '/agents',
@@ -1934,30 +2229,25 @@ 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: '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,8 +2281,8 @@ 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 = [
     '/checkpoint create <name>',
     '/checkpoint list',
@@ -2000,15 +2290,15 @@ 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,
     ...checkpointTemplates,
     ...specTemplates,
     ...planTemplates,
@@ -2041,6 +2331,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,9 +2341,9 @@ export async function createChatRuntime({
     const commandPart = tokens[0] || '';
     const commandHasSubcommands = new Set([
       'config',
+      'memory',
       'compact',
       'mode',
-      'tasks',
       'checkpoint',
       'plan',
       'agents',
@@ -2065,19 +2358,21 @@ 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 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 +2400,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,77 +2409,84 @@ 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);
     }
-    if (commandPart === 'tasks') {
-      if (tokens.length <= 2 && !hasTrailingSpace) {
-        const sub = tokens[1] || '';
-        return ['add', 'start', 'done', 'remove', 'rm', 'clear']
-          .filter((s) => s.startsWith(sub))
-          .map((s) => registerSuggestion(`/tasks ${s}`, 'task board command'));
-      }
-      return materializeSuggestions(taskTemplates);
-    }
     if (commandPart === 'checkpoint') {
       if (tokens.length <= 2 && !hasTrailingSpace) {
         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 +2495,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 +2522,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 +2546,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 +2561,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 +2574,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 +2602,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 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');
+  };
+
   const isImmediateLocalInput = (line) => {
     const parsedInput = parseInput(line);
     if (parsedInput.type !== 'slash') return false;
@@ -2301,9 +2628,9 @@ export async function createChatRuntime({
       'commands',
       'status',
       'mode',
-      'tasks',
       'checkpoint',
       'history',
+      'memory',
       'config',
       'compact',
       'debug'
@@ -2312,7 +2639,7 @@ export async function createChatRuntime({
   };
 
   const submit = async (line, onAgentEvent) => {
-    const activeReplySystemPrompt = await buildSystemPromptWithSoul(baseSystemPrompt, config);
+    const activeReplySystemPrompt = await buildActiveSystemPrompt();
     try {
       await appendInputHistory(line);
     } catch {
@@ -2331,14 +2658,14 @@ 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 /checkpoint /spec /plan /agents /config /memory /history /debug /retry /<custom> !<shell>'
         };
       }
       if (parsedInput.command === 'status') {
-        const taskCount = (await loadTasks(process.cwd(), currentSession.id)).length;
+        const todoCount = countActiveTodos(currentSession.todos);
         return {
           type: 'system',
-          text: `mode=${executionMode} | model=${model || config.model.name} | max_ctx=${effectiveMaxContextTokens(config)} | session=${currentSession.id} | tasks=${taskCount}`
+          text: `mode=${executionMode} | model=${model || config.model.name} | max_ctx=${effectiveMaxContextTokens(config)} | session=${currentSession.id} | todos=${todoCount}`
         };
       }
       if (parsedInput.command === 'mode') {
@@ -2356,74 +2683,15 @@ export async function createChatRuntime({
         await persistLocalExchange(line, text);
         return { type: 'system', text };
       }
-      if (parsedInput.command === 'tasks') {
-        const sub = (parsedInput.args[0] || '').trim().toLowerCase();
-        if (!sub) {
-          const tasks = await loadTasks(process.cwd(), currentSession.id);
-          if (tasks.length === 0) return { type: 'system', text: 'No tasks' };
-          const rows = tasks.map((t, idx) => `${idx + 1}. ${t.id} | ${t.status} | ${t.title}`);
-          return { type: 'system', text: rows.join('\n') };
-        }
-        if (sub === 'add') {
-          const title = parsedInput.args.slice(1).join(' ').trim();
-          if (!title) return { type: 'system', text: 'Usage: /tasks add <title>' };
-          const created = await createTasks([{ title }], process.cwd(), currentSession.id);
-          const text = `Created task: ${created[0]?.id || '-'} | ${title}`;
-          await persistLocalExchange(line, text);
-          return { type: 'system', text };
-        }
-        if (sub === 'start') {
-          const id = parsedInput.args[1];
-          if (!id) return { type: 'system', text: 'Usage: /tasks start <id>' };
-          const updated = await updateTask(id, { status: 'in_progress' }, process.cwd(), currentSession.id);
-          if (!updated) return { type: 'system', text: `Task not found: ${id}` };
-          const text = `Task in progress: ${id}`;
-          await persistLocalExchange(line, text);
-          return { type: 'system', text };
-        }
-        if (sub === 'done') {
-          const id = parsedInput.args[1];
-          if (!id) return { type: 'system', text: 'Usage: /tasks done <id>' };
-          const updated = await updateTask(id, { status: 'completed' }, process.cwd(), currentSession.id);
-          if (!updated) return { type: 'system', text: `Task not found: ${id}` };
-          const text = `Task completed: ${id}`;
-          await persistLocalExchange(line, text);
-          return { type: 'system', text };
-        }
-        if (sub === 'remove' || sub === 'rm') {
-          const id = parsedInput.args[1];
-          if (!id) return { type: 'system', text: 'Usage: /tasks remove <id>' };
-          const result = await deleteTasks([id], process.cwd(), currentSession.id);
-          const text = `Removed=${result.removed}, Remaining=${result.remaining}`;
-          await persistLocalExchange(line, text);
-          return { type: 'system', text };
-        }
-        if (sub === 'clear') {
-          await clearTasks(process.cwd(), currentSession.id);
-          const text = 'All tasks cleared';
-          await persistLocalExchange(line, text);
-          return { type: 'system', text };
-        }
-        // shorthand: /tasks implement x
-        const title = parsedInput.args.join(' ').trim();
-        if (title) {
-          const created = await createTasks([{ title }], process.cwd(), currentSession.id);
-          const text = `Created task: ${created[0]?.id || '-'} | ${title}`;
-          await persistLocalExchange(line, text);
-          return { type: 'system', text };
-        }
-      }
       if (parsedInput.command === 'checkpoint') {
         const sub = (parsedInput.args[0] || 'list').trim().toLowerCase();
         if (sub === 'create') {
           const name = parsedInput.args.slice(1).join(' ').trim();
-          const tasks = await loadTasks(process.cwd(), currentSession.id);
           const cp = await createCheckpoint(
             {
               name,
               session: currentSession,
-              config,
-              tasks
+              config
             },
             process.cwd()
           );
@@ -2458,17 +2726,6 @@ export async function createChatRuntime({
             config = cp.config;
             executionMode = config.execution?.mode || executionMode;
           }
-          if (Array.isArray(cp?.tasks)) {
-            await clearTasks(process.cwd(), currentSession.id);
-            if (cp.tasks.length > 0) {
-              // restore with new ids to avoid stale references
-              await createTasks(
-                cp.tasks.map((t) => ({ title: t.title, description: t.description })),
-                process.cwd(),
-                currentSession.id
-              );
-            }
-          }
           const text = `Checkpoint loaded: ${id}`;
           await persistLocalExchange(line, text, { includeUser: false });
           return { type: 'system', text };
@@ -2505,8 +2762,9 @@ 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,
@@ -2514,8 +2772,35 @@ export async function createChatRuntime({
             model,
             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',
@@ -2595,7 +2880,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',
@@ -2690,11 +2975,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) {
@@ -2925,7 +3254,8 @@ export async function createChatRuntime({
         model,
         systemPrompt: activeReplySystemPrompt,
         onAgentEvent,
-        sessionId: currentSession.id
+        sessionId: currentSession.id,
+        taskClass: classifyPlanTaskClass(expandedText)
       });
       currentSession.planState = {
         status: 'pending_approval',
@@ -2949,7 +3279,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,