codemini-cli 0.4.1 → 0.4.3

package/src/core/chat-runtime.js

@@ -1,6 +1,7 @@
 import { parseInput } from './input-parser.js';
 import { loadCommandsAndSkills, renderCommandPrompt } from './command-loader.js';
-import { runAgentLoop, setResultDir, clearResultStore } from './agent-loop.js';
+import { runAgentLoop } from './agent-loop.js';
+import { setResultDir, clearResultStore } from './tool-result-store.js';
 import { trimInline, normalizePath } from './string-utils.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -29,6 +30,12 @@ import { forgetMemory, listMemories, rememberMemory, searchMemories, captureToIn
 import { runDreamConsolidation } from './dream-consolidate.js';
 import { normalizePlanState } from './plan-state.js';
 import { countActiveTodos, normalizeTodos } from './todo-state.js';
+import {
+  attachReflectTargets,
+  buildReflectSkillDraft,
+  parseReflectScope,
+  writeReflectSkillDraft
+} from './reflect-skill.js';
 
 const STREAM_SAVE_DEBOUNCE_MS = 120;
 
@@ -103,6 +110,7 @@ function getCompletionCopy(language = 'zh') {
         'context.tool_result_max_chars': '工具结果字符上限',
         'context.read_file_default_lines': 'read_file 默认行数窗口',
         'context.read_file_max_chars': 'read_file 字符上限',
+        'context.prompt_budget_audit': 'Prompt 预算审计开关',
         'sessions.max_sessions': '会话保留上限',
         'sessions.retention_days': '会话保留天数',
         'shell.default': '默认 shell',
@@ -120,7 +128,8 @@ function getCompletionCopy(language = 'zh') {
         'execution.mode': '可选：auto | normal | plan',
         'shell.default': '常用：bash | powershell',
         'policy.safe_mode': '可选：true | false',
-        'policy.allow_dangerous_commands': '可选：true | false'
+        'policy.allow_dangerous_commands': '可选：true | false',
+        'context.prompt_budget_audit': '可选：true | false'
       },
       describeSet: (label, hint) => `设置${label}${hint ? `（${hint}）` : ''}`,
       describeGet: (label, hint) => `查看${label}${hint ? `（${hint}）` : ''}`,
@@ -153,12 +162,14 @@ function getCompletionCopy(language = 'zh') {
         config: '设置/读取/列出/重置配置',
         memory: '查看/搜索/删除持久记忆',
         dream: '整理记忆收件箱（dream consolidation）',
+        reflect: '复盘成功链路并生成可审阅 skill 草稿',
         history: '查看/恢复会话',
         debug: '运行时调试开关',
         retry: '重试上一条用户请求',
         stop: '中止当前回答',
         new: '开始新会话',
         yes: '确认当前待审批计划并开始执行',
+        no: '放弃当前待审批事项',
         edit: '修改当前待审批计划',
         reject: '拒绝当前待审批计划'
       },
@@ -172,6 +183,7 @@ function getCompletionCopy(language = 'zh') {
         agentCommand: '子代理命令',
         memoryCommand: '记忆命令',
         dreamCommand: '记忆整理命令',
+        reflectCommand: '复盘生成 skill 草稿',
         debugCommand: '调试命令',
         keyboardDebugCommand: '键盘调试命令',
         compactCommand: '上下文压缩命令',
@@ -200,6 +212,7 @@ function getCompletionCopy(language = 'zh') {
         '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',
+        'context.prompt_budget_audit': 'prompt budget audit switch',
         'sessions.max_sessions': 'stored session limit',
         'sessions.retention_days': 'session retention days',
         'shell.default': 'default shell',
@@ -217,7 +230,8 @@ function getCompletionCopy(language = 'zh') {
         'execution.mode': 'options: auto | normal | plan',
         'shell.default': 'common: bash | powershell',
         'policy.safe_mode': 'options: true | false',
-        'policy.allow_dangerous_commands': 'options: true | false'
+        'policy.allow_dangerous_commands': 'options: true | false',
+        'context.prompt_budget_audit': 'options: true | false'
       },
       describeSet: (label, hint) => `set the ${label}${hint ? ` (${hint})` : ''}`,
       describeGet: (label, hint) => `show the ${label}${hint ? ` (${hint})` : ''}`,
@@ -250,12 +264,14 @@ function getCompletionCopy(language = 'zh') {
         config: 'set/get/list/reset config values',
         memory: 'list/search/delete persistent memories',
         dream: 'consolidate memory inbox (dream)',
+        reflect: 'reflect on a successful workflow and draft a reusable skill',
         history: 'list/resume sessions',
         debug: 'runtime debug switches',
         retry: 'retry the last user request',
         stop: 'stop the current response',
         new: 'start a new session',
         yes: 'approve the pending plan and start execution',
+        no: 'discard the pending item',
         edit: 'revise the pending plan',
         reject: 'reject the pending plan'
       },
@@ -269,6 +285,7 @@ function getCompletionCopy(language = 'zh') {
         agentCommand: 'sub-agent command',
         memoryCommand: 'memory command',
         dreamCommand: 'dream consolidation command',
+        reflectCommand: 'reflect skill draft command',
         debugCommand: 'debug command',
         keyboardDebugCommand: 'keyboard debug command',
         compactCommand: 'context compaction command',
@@ -288,9 +305,10 @@ function describeConfigKey(key, mode = 'set', language = 'zh') {
   return mode === 'get' ? copy.describeGet(label, hint) : copy.describeSet(label, hint);
 }
 
-const SUB_AGENT_ROLES = ['planner', 'coder', 'reviewer', 'tester', 'summarizer'];
+const SUB_AGENT_ROLES = ['planner', 'advisor', 'coder', 'reviewer', 'tester', 'summarizer'];
 export const ROLE_TOOL_POLICY = {
   planner: ['read', 'grep', 'list', 'query_project_index', 'tool_search', 'glob', 'ast_query', 'read_ast_node', 'web_fetch', 'web_search', 'read_plan', 'update_plan'],
+  advisor: ['read', 'grep', 'list', 'query_project_index', 'tool_search', 'read_plan'],
   coder: ['read', 'grep', 'list', 'edit', 'write', 'delete', 'run', 'ast_query', 'read_ast_node', 'glob', 'tool_search', 'web_fetch', 'web_search', 'update_todos', 'read_plan', 'update_plan'],
   reviewer: ['read', 'grep', 'list', 'glob', 'tool_search', 'ast_query', 'read_ast_node', 'read_plan'],
   tester: ['read', 'grep', 'list', 'run', 'glob', 'tool_search', 'read_plan'],
@@ -338,6 +356,25 @@ export function getSubAgentRolePrompt(role) {
       'Do not add a closing summary or "Next Action" — the pipeline handles what comes next.'
     ].join('\n');
   }
+  if (role === 'advisor') {
+    return [
+      'You are the advisor in a multi-step agent pipeline.',
+      'Your job: analyze the handed-off context and produce recommendations, tradeoffs, and evidence.',
+      'Do not edit files, write code, delete files, or run commands.',
+      'Output format — keep it short and direct:',
+      'Findings:',
+      '- <important observation, constraint, or "none">',
+      'Recommendations:',
+      '- <prioritized recommendation or "none">',
+      'Tradeoffs:',
+      '- <important tradeoff or "none">',
+      'Evidence:',
+      '- <files, docs, or observations checked>',
+      'Open Questions:',
+      '- <blocking uncertainty or "none">',
+      'Do not summarize your own work or add closing remarks — just deliver the structured advisory handoff and stop.'
+    ].join('\n');
+  }
   if (role === 'tester') {
     return [
       'You are the tester in a multi-step agent pipeline.',
@@ -413,7 +450,10 @@ function buildPipelineStepGuidance({ role, stepIndex, totalSteps, isFirst, isLas
   lines.push('- If you discover something new, record it under the requested headings instead of burying it in prose.');
   lines.push('- Continue the established direction unless you have concrete contradictory evidence.');
   lines.push('- Output only what the next step needs to know. Skip obvious observations.');
-  if (isLast) {
+  if (role !== 'summarizer') {
+    lines.push('- Do not produce a final overall summary; the final summarizer step owns synthesis.');
+  }
+  if (isLast && role === 'summarizer') {
     lines.push('- Since you are the final step, give a concise overall verdict the user can act on.');
   }
   return lines.join('\n');
@@ -704,6 +744,9 @@ function buildGoalRequirementPacket(goal, role) {
     lines.push('Verify the implementation against the original goal, not just syntax or smoke checks.');
     lines.push('Check each acceptance item explicitly before calling the work verified.');
     lines.push('If any requested behavior is unverified or contradicted by evidence, list it under Not Verified or Failures.');
+  } else if (role === 'advisor') {
+    lines.push('Advise against the acceptance checklist and original goal, not generic best practices.');
+    lines.push('Prioritize concrete recommendations, evidence, and tradeoffs. Do not implement changes.');
   } else if (role === 'coder') {
     lines.push('Implement against the acceptance checklist, not only the broad wording of the goal.');
   }
@@ -719,10 +762,11 @@ 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.',
-    '- Available sub-agent roles are planner, coder, reviewer, tester, and summarizer. Use only the roles the task actually needs.',
-    '- The summarizer role reads accumulated step results from the plan file and synthesizes a final summary. It does NOT re-analyze the codebase. Prefer summarizer as the final step for multi-step plans.',
+    '- Available sub-agent roles are planner, advisor, coder, reviewer, tester, and summarizer. Use only the non-summary roles the task actually needs.',
+    '- Always include a summarizer as the final step. The summarizer reads accumulated step results from the plan file and synthesizes the final summary. It does NOT re-analyze the codebase.',
+    '- Do not ask planner, advisor, coder, reviewer, or tester steps to produce the final summary. They should write detailed step results for the summarizer.',
     '- 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.',
+    '- For analysis, recommendation, optimization, architecture feedback, or planning-only goals, prefer advisor over coder and 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');
@@ -740,6 +784,9 @@ function buildAutoPlanExecutionGuidance(role) {
   if (role === 'coder') {
     common.push('- Keep edits tightly scoped to the chosen plan direction.');
     common.push('- Avoid speculative cleanup or unrelated improvements.');
+  } else if (role === 'advisor') {
+    common.push('- Produce advisory findings and recommendations only; do not modify files or run commands.');
+    common.push('- Ground every recommendation in inspected evidence or mark it as an assumption.');
   } else if (role === 'reviewer') {
     common.push('- Review against the chosen plan direction and the acceptance checklist.');
     common.push('- Call out missing requested behavior, regression risk, and unverified claims.');
@@ -1040,7 +1087,12 @@ async function buildTesterVerificationPacket(focusPaths = []) {
   return lines.join('\n');
 }
 
-function isSkillEnabled(config, name) {
+function isBundledSkillCommand(command) {
+  return command?.metadata?.type === 'skill' && command?.source === 'bundled-skill';
+}
+
+function isSkillEnabled(config, name, command = null) {
+  if (isBundledSkillCommand(command)) return true;
   return config.skills?.enabled?.[name] !== false;
 }
 
@@ -1048,6 +1100,10 @@ function selectAutoSkillNames(text = '') {
   const input = String(text || '').toLowerCase();
   const selected = ['superpowers-lite'];
 
+  const explicitGrillMe =
+    /\bgr+ill\s+me\b|\bpressure[- ]?test\b|\bstress[- ]?test\b|\bchallenge\s+(?:this|my|me)\b|\btear\s+(?:this|my)\s+.*apart\b/i.test(
+      input
+    ) || /(拷问|质询|压力测试|挑战一下|挑刺|狠狠审|喷一下|怼一下)/i.test(input);
   const explicitBrainstorm =
     /(brainstorm|头脑风暴|方案|思路|设计一下|设计方案|怎么做|如何做|approach|options?)/i.test(input);
   const ambiguitySignals =
@@ -1066,6 +1122,9 @@ function selectAutoSkillNames(text = '') {
   if (explicitBrainstorm || (ambiguitySignals && featureRequest) || greenfieldBuildRequest) {
     selected.push('brainstorm');
   }
+  if (explicitGrillMe) {
+    selected.push('grill-me');
+  }
   return selected;
 }
 
@@ -1165,7 +1224,7 @@ function buildMediumTaskSystemPrompt(systemPrompt) {
 }
 
 function buildAutoSkillSystemPrompt(baseSystemPrompt, commands, config, text) {
-  const selected = classifyAutoRoute(text).selectedSkills.filter((name) => isSkillEnabled(config, name));
+  const selected = classifyAutoRoute(text).selectedSkills.filter((name) => isSkillEnabled(config, name, commands.get(name)));
   if (selected.length === 0) return baseSystemPrompt;
 
   const blocks = [];
@@ -1244,13 +1303,34 @@ function summarizeGoalForStepTitle(goal, fallback = 'requested change') {
 function buildFallbackAutoPlan(goal) {
   const requirements = deriveGoalRequirements(goal);
   const lightweightGoal = isLightweightAutoPlanGoal(goal, requirements);
+  const taskClass = classifyPlanTaskClass(goal);
   const focus = summarizeGoalForStepTitle(goal);
   const summary =
     requirements.length > 0
       ? `Auto fallback plan for: ${requirements.join('; ')}`
       : `Auto fallback plan for: ${goal}`;
 
+  if (taskClass === 'advisory') {
+    return {
+      summary,
+      steps: [
+        {
+          title: 'Inspect the target area',
+          role: 'planner',
+          task: `Inspect the relevant project context for: ${goal}. Identify constraints, evidence, and likely high-value advisory areas.`
+        },
+        {
+          title: `Advise on ${focus}`,
+          role: 'advisor',
+          task: `Analyze the findings for: ${goal}. Produce prioritized recommendations, tradeoffs, evidence, and open questions without implementing changes.`
+        },
+        buildDefaultSummarizerStep(goal)
+      ]
+    };
+  }
+
   if (lightweightGoal) {
+    const summarizerStep = buildDefaultSummarizerStep(goal);
     return {
       summary,
       steps: [
@@ -1263,7 +1343,8 @@ function buildFallbackAutoPlan(goal) {
           title: 'Verify the change',
           role: 'tester',
           task: `Verify the completed change for: ${goal}. Run the most relevant focused checks available and report concrete evidence plus anything still unverified.`
-        }
+        },
+        summarizerStep
       ]
     };
   }
@@ -1308,6 +1389,13 @@ function buildFallbackAutoPlan(goal) {
 function buildDefaultSummarizerStep(goal, source = []) {
   const existing = (Array.isArray(source) ? source : []).find((step) => step.role === 'summarizer');
   if (existing?.title && existing?.task) return existing;
+  if (classifyPlanTaskClass(goal) === 'advisory') {
+    return {
+      title: 'Synthesize final findings',
+      role: 'summarizer',
+      task: `Synthesize the advisory findings for: ${goal}. Read the accumulated observations, recommendations, tradeoffs, evidence, and open questions from earlier steps, then produce a concise final summary with the single best next action.`
+    };
+  }
   return {
     title: 'Synthesize final implementation status',
     role: 'summarizer',
@@ -1320,7 +1408,7 @@ function enforceAutoPlanGuardrailSteps(plan, goal) {
   const requirements = deriveGoalRequirements(goal);
   const lightweightGoal = isLightweightAutoPlanGoal(goal, requirements);
   const taskClass = classifyPlanTaskClass(goal);
-  const implementationSteps = source.filter((step) => step.role !== 'reviewer' && step.role !== 'tester' && step.role !== 'summarizer');
+  const implementationSteps = source.filter((step) => step.role !== 'advisor' && step.role !== 'reviewer' && step.role !== 'tester' && step.role !== 'summarizer');
   const primaryImplementationStep =
     implementationSteps.find((step) => step.role === 'coder') ||
     implementationSteps[0] || {
@@ -1343,17 +1431,49 @@ function enforceAutoPlanGuardrailSteps(plan, goal) {
   const hasTester = source.some((step) => step.role === 'tester');
 
   if (taskClass === 'advisory') {
-    const advisorySteps = source.filter((step) => step.role === 'planner' || step.role === 'coder');
+    const advisorySteps = source
+      .filter((step) => step.role === 'planner' || step.role === 'advisor' || step.role === 'coder')
+      .map((step) =>
+        step.role === 'coder'
+          ? {
+              ...step,
+              role: 'advisor',
+              title: /^implement\b/i.test(String(step.title || '')) ? 'Advise on requested goal' : step.title
+            }
+          : step
+      );
+    const hasAdvisor = advisorySteps.some((step) => step.role === 'advisor');
+    const baseSteps =
+      advisorySteps.length > 0
+        ? advisorySteps.slice(0, 6)
+        : [
+            {
+              title: 'Advise on requested goal',
+              role: 'advisor',
+              task: `Analyze the goal and recommend the highest-value next steps for: ${goal}`
+            }
+          ];
+    const finalSteps = hasAdvisor
+      ? baseSteps
+      : [
+          ...baseSteps,
+          {
+            title: 'Advise on requested goal',
+            role: 'advisor',
+            task: `Analyze the goal and recommend the highest-value next steps for: ${goal}`
+          }
+        ];
     return {
       summary: String(plan?.summary || `Auto plan for: ${goal}`).trim(),
-      steps: advisorySteps.length > 0 ? advisorySteps.slice(0, 6) : [primaryImplementationStep]
+      steps: [...finalSteps, summarizerStep]
     };
   }
 
   if (lightweightGoal) {
+    const baseSteps = hasTester ? [primaryImplementationStep, testerStep] : [primaryImplementationStep];
     return {
       summary: String(plan?.summary || `Auto plan for: ${goal}`).trim(),
-      steps: hasTester ? [primaryImplementationStep, testerStep] : [primaryImplementationStep]
+      steps: [...baseSteps, summarizerStep]
     };
   }
 
@@ -1362,11 +1482,9 @@ function enforceAutoPlanGuardrailSteps(plan, goal) {
     ...(hasReviewer ? [reviewerStep] : []),
     ...(testerStep ? [testerStep] : [])
   ];
-  const needsSummarizer = executionSteps.length >= 3;
-
   return {
     summary: String(plan?.summary || `Auto plan for: ${goal}`).trim(),
-    steps: needsSummarizer ? [...executionSteps, summarizerStep] : executionSteps
+    steps: [...executionSteps, summarizerStep]
   };
 }
 
@@ -1618,7 +1736,7 @@ async function buildAutoPlanFinalSummary({
           content: buildAutoPlanFinalSummaryUserPrompt({ goal, autoPlan, runItems, planningError })
         }
       ],
-      timeoutMs: config.gateway.timeout_ms || 90000,
+      timeoutMs: config.gateway.timeout_ms || 1800000,
       maxRetries: config.gateway.max_retries ?? 2
     });
     return trimInline(result.text || '', 600) || fallbackSummary;
@@ -1656,35 +1774,51 @@ async function removePlanFileIfPresent(planState) {
 
 function buildSpecTemplate(topic) {
   return `
-# Spec: ${topic}
+# ${topic} Design
 
-## 1. Background
-- Why this work is needed
-- Existing pain points
+## Summary
+- Problem statement
+- Desired outcome
+- Why this is worth doing
 
-## 2. Goals
+## Goals
 - Primary goal
-- Non-goals
+- Secondary goals
+
+## Non-Goals
+- Out-of-scope behavior
+- Explicitly rejected approaches
 
-## 3. Scope
-- In scope
-- Out of scope
+## User Experience / Command Behavior
+- User-facing commands or flows
+- Review or approval behavior
+- Expected outputs
 
-## 4. Requirements
+## Architecture
+- Main modules and responsibilities
+- Data flow
+- Integration points
+
+## Data / State Model
+- New or changed state
+- Persistence locations
+- Lifecycle and cleanup behavior
+
+## Safety Rules
+- Guardrails
+- Permission or approval requirements
+- Failure behavior
+
+## Requirements
 - Functional requirements
 - Non-functional requirements
 - Win10 compatibility requirements
 
-## 5. Design
-- Architecture sketch
-- Data flow
-- Key interfaces/commands
-
-## 6. Risks and Mitigations
+## Risks and Mitigations
 - Risk
 - Mitigation
 
-## 7. Validation
+## Testing / Validation
 - Test strategy
 - Acceptance checklist
 `;
@@ -1703,17 +1837,20 @@ async function buildSpecWithModel({
   systemPrompt
 }) {
   const prompt = [
-    'Write a practical engineering spec in markdown.',
+    'Write a practical engineering spec in markdown, like an implementation-ready design document.',
     'Use these sections exactly:',
-    '# Spec: <title>',
-    '## 1. Background',
-    '## 2. Goals',
-    '## 3. Scope',
-    '## 4. Requirements',
-    '## 5. Design',
-    '## 6. Risks and Mitigations',
-    '## 7. Validation',
-    'Make it implementation-oriented and suitable for a Win10-first internal coding CLI.'
+    '# <Feature> Design',
+    '## Summary',
+    '## Goals',
+    '## Non-Goals',
+    '## User Experience / Command Behavior',
+    '## Architecture',
+    '## Data / State Model',
+    '## Safety Rules',
+    '## Requirements',
+    '## Risks and Mitigations',
+    '## Testing / Validation',
+    'Make it concrete, scoped, and suitable for turning into a sub-agent implementation plan.'
   ].join('\n');
 
   const result = await createChatCompletion({
@@ -1725,7 +1862,7 @@ async function buildSpecWithModel({
       { role: 'system', content: `${systemPrompt}\n${prompt}` },
       { role: 'user', content: `Topic: ${topic}` }
     ],
-    timeoutMs: config.gateway.timeout_ms || 90000,
+    timeoutMs: config.gateway.timeout_ms || 1800000,
     maxRetries: config.gateway.max_retries ?? 2
   });
   return String(result.text || '').trim();
@@ -1788,7 +1925,7 @@ async function buildPlanFromSpecWithModel({
         content: `Spec path: ${specPath || '(inline)'}\n\nProject implementation constraints:\n${projectConstraints}\n\n${specText}`
       }
     ],
-    timeoutMs: config.gateway.timeout_ms || 90000,
+    timeoutMs: config.gateway.timeout_ms || 1800000,
     maxRetries: config.gateway.max_retries ?? 2
   });
   return String(result.text || '').trim();
@@ -1886,6 +2023,72 @@ function effectiveMaxContextTokens(config) {
   return 32000;
 }
 
+function estimateTextTokens(role, content) {
+  const text = String(content || '');
+  if (!text) return 0;
+  return estimateMessagesTokens([{ role, content: text }]);
+}
+
+function makePromptBudgetComponent(name, role, content) {
+  const text = String(content || '');
+  return {
+    name,
+    chars: text.length,
+    estimated_tokens: estimateTextTokens(role, text)
+  };
+}
+
+function buildPromptBudgetAudit({
+  systemPrompt = '',
+  projectContextSnippet = '',
+  projectContextGuidance = '',
+  messages = [],
+  toolDefinitions = [],
+  config = {}
+}) {
+  const toolSchemaText = JSON.stringify(toolDefinitions || []);
+  const messageTexts = (Array.isArray(messages) ? messages : []).map((message) => ({
+    role: message?.role || 'user',
+    content: message?.content || ''
+  }));
+  const components = [
+    makePromptBudgetComponent('system_prompt', 'system', systemPrompt),
+    makePromptBudgetComponent('project_context', 'system', projectContextSnippet),
+    makePromptBudgetComponent('project_context_guidance', 'system', projectContextGuidance),
+    {
+      name: 'message_history',
+      chars: messageTexts.reduce((total, message) => total + String(message.content || '').length, 0),
+      estimated_tokens: estimateMessagesTokens(messageTexts)
+    },
+    makePromptBudgetComponent('tool_schemas', 'system', toolSchemaText)
+  ];
+  const totalChars = components.reduce((total, component) => total + component.chars, 0);
+  const totalTokens = components.reduce((total, component) => total + component.estimated_tokens, 0);
+  const maxContextTokens = effectiveMaxContextTokens(config);
+  const contextUsagePct =
+    maxContextTokens > 0 ? Math.min(100, Math.max(0, (totalTokens / maxContextTokens) * 100)) : 0;
+  return {
+    components,
+    total: {
+      chars: totalChars,
+      estimated_tokens: totalTokens
+    },
+    max_context_tokens: maxContextTokens,
+    context_usage_pct: contextUsagePct
+  };
+}
+
+function summarizePromptBudgetAudit(audit) {
+  const totalTokens = audit?.total?.estimated_tokens || 0;
+  const maxContextTokens = audit?.max_context_tokens || 0;
+  const pct = Number(audit?.context_usage_pct || 0).toFixed(1);
+  const components = (audit?.components || [])
+    .filter((component) => component.estimated_tokens > 0)
+    .map((component) => `${component.name}=${component.estimated_tokens}`)
+    .join(', ');
+  return `prompt budget: ${totalTokens}/${maxContextTokens} est tokens (${pct}%)${components ? `; ${components}` : ''}`;
+}
+
 function buildRuntimeStateSnapshot({ currentSession, config, model, executionMode, extraSession }) {
   const parentTokens = estimateMessagesTokens(currentSession?.messages || []);
   const subTokens = extraSession ? estimateMessagesTokens(extraSession.messages || []) : 0;
@@ -1896,6 +2099,7 @@ function buildRuntimeStateSnapshot({ currentSession, config, model, executionMod
     sessionId: currentSession?.id || '',
     mode: executionMode || config.execution?.mode || 'auto',
     sdkProvider: config.sdk?.provider || 'openai-compatible',
+    agentRole: 'general',
     model: model || config.model?.name || '',
     maxContextTokens
   };
@@ -1914,6 +2118,11 @@ function buildRuntimeStateSnapshot({ currentSession, config, model, executionMod
       value: currentSession?.planState?.status === 'pending_approval',
       enumerable: false,
       writable: false
+    },
+    pendingReflectSkill: {
+      value: currentSession?.planState?.status === 'pending_reflect_skill',
+      enumerable: false,
+      writable: false
     }
   });
   return snapshot;
@@ -1940,6 +2149,10 @@ function hasPendingPlanApproval(session) {
   return session?.planState?.status === 'pending_approval';
 }
 
+function hasPendingReflectSkill(session) {
+  return session?.planState?.status === 'pending_reflect_skill';
+}
+
 function isApprovalText(text = '') {
   const value = String(text || '').trim().toLowerCase();
   if (!value) return false;
@@ -1976,6 +2189,28 @@ function buildPendingPlanApprovalMessage(planState) {
   return lines.join('\n');
 }
 
+function buildPendingReflectSkillMessage(reflectState) {
+  const candidates = Array.isArray(reflectState?.candidates) ? reflectState.candidates : [];
+  if (candidates.length === 0) {
+    return 'Reflect found no reusable skill candidate.';
+  }
+  const lines = [
+    'Reflect skill draft pending.',
+    `Scope: ${reflectState?.targetScope || 'project'}`
+  ];
+  for (const candidate of candidates) {
+    lines.push('');
+    lines.push(`[${candidate.id || 1}] ${candidate.name}`);
+    lines.push(`Confidence: ${Number(candidate.confidence ?? 0.75).toFixed(2)}`);
+    lines.push(`Target: ${candidate.targetPath || '-'}`);
+    lines.push('');
+    lines.push(String(candidate.content || '').trim());
+  }
+  lines.push('');
+  lines.push('Use /yes to write this skill, /edit <feedback> to revise it, or /no to discard it.');
+  return lines.join('\n');
+}
+
 function buildApprovedPlanExecutionPrompt(planState, approvalText = '') {
   const requirementPacket = buildGoalRequirementPacket(planState?.goal || '', 'coder');
   const lines = [
@@ -2167,8 +2402,10 @@ async function askModel({
   }
 
   const projectContextSnippet = await buildProjectContextSnippet(process.cwd(), text).catch(() => '');
+  const projectContextGuidance =
+    'Use this project context as lightweight guidance and verify important details with fresh reads when needed.';
   const effectiveSystemPrompt = projectContextSnippet
-    ? `${systemPrompt}\n\n${projectContextSnippet}\n\nUse this project context as lightweight guidance and verify important details with fresh reads when needed.`
+    ? `${systemPrompt}\n\n${projectContextSnippet}\n\n${projectContextGuidance}`
     : systemPrompt;
 
   const { definitions, handlers, formatters, deferredDefinitions, dispose: disposeTools } = getBuiltinTools({
@@ -2198,6 +2435,31 @@ async function askModel({
     ? Object.fromEntries(Object.entries(deferredDefinitions).filter(([name]) => allowedTools.includes(name)))
     : deferredDefinitions;
 
+  if (config.context?.prompt_budget_audit === true && onAgentEvent) {
+    const auditId = `prompt-budget-${Date.now()}`;
+    const audit = buildPromptBudgetAudit({
+      systemPrompt,
+      projectContextSnippet,
+      projectContextGuidance: projectContextSnippet ? projectContextGuidance : '',
+      messages: session.messages.filter((m) => m.role !== 'system'),
+      toolDefinitions: filteredDefinitions,
+      config
+    });
+    onAgentEvent({
+      type: 'system_tool:start',
+      id: auditId,
+      name: 'prompt_budget',
+      summary: 'calculating prompt budget'
+    });
+    onAgentEvent({
+      type: 'system_tool:end',
+      id: auditId,
+      name: 'prompt_budget',
+      summary: summarizePromptBudgetAudit(audit),
+      details: audit
+    });
+  }
+
   let activeAssistantIndex = -1;
   const wrappedAgentEvent = (event) => {
     // Always accumulate messages in session (for token tracking), only save when persisting
@@ -2277,7 +2539,7 @@ async function askModel({
         model: selectedModel,
         messages,
         tools,
-        timeoutMs: config.gateway.timeout_ms || 90000,
+        timeoutMs: config.gateway.timeout_ms || 1800000,
         maxRetries: config.gateway.max_retries ?? 2,
         signal,
         onTextDelta: (delta) => {
@@ -2375,6 +2637,12 @@ async function runSubAgentTask({
         }
       } catch {}
     }
+    if (
+      role !== 'summarizer' &&
+      ['assistant:start', 'assistant:delta', 'assistant:response', 'assistant:tool_call_delta'].includes(String(evt?.type || ''))
+    ) {
+      return;
+    }
     if (onAgentEvent) onAgentEvent(evt);
   };
   const roleAllowedTools = ROLE_TOOL_POLICY[role];
@@ -2503,7 +2771,14 @@ async function executePlanWithSubAgents({
       );
     }
 
-    if (stepRecord.failed && i < steps.length - 1) break;
+    if (stepRecord.failed && i < steps.length - 1) {
+      const summarizerIndex = steps.findIndex((candidate, index) => index > i && candidate.role === 'summarizer');
+      if (summarizerIndex > i) {
+        i = summarizerIndex - 1;
+        continue;
+      }
+      break;
+    }
   }
 
   const summaryLines = [];
@@ -2557,14 +2832,15 @@ async function buildAutoPlanAndRun({
     '- 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, prefer planner and advisor roles. Do not use coder unless the plan will actually modify code or files.',
+    '- For advisory goals, 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 advisory roles: planner -> inspect project shape, advisor -> 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|summarizer","task":"..."}]}. No markdown.'
+    'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|advisor|coder|reviewer|tester|summarizer","task":"..."}]}. No markdown.'
   ].join('\n');
   let autoPlan = {
     summary: `Auto plan for: ${goal}`,
@@ -2589,14 +2865,15 @@ async function buildAutoPlanAndRun({
           role: 'user',
           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|summarizer","task":"..."}]}. No markdown.',
-            'The available roles are planner, coder, reviewer, tester, and summarizer. Use only the roles the task actually needs.',
-            'The summarizer role synthesizes prior step results without re-analyzing. Use it as the final step for plans with 3+ steps.',
+            'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|advisor|coder|reviewer|tester|summarizer","task":"..."}]}. No markdown.',
+            'The available roles are planner, advisor, coder, reviewer, tester, and summarizer. Use only the non-summary roles the task actually needs.',
+            'Always include a summarizer as the final step. The summarizer synthesizes prior step results without re-analyzing.',
+            'Planner, advisor, coder, reviewer, and tester steps should write detailed step results, not final summaries.',
             `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.',
-            'For analysis, recommendation, optimization, audit, or project-review goals, keep the plan lean and usually limit it to planner/coder.',
+            'For analysis, recommendation, optimization, audit, or project-review goals, keep the plan lean and usually limit it to planner/advisor.',
             '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.',
@@ -2606,7 +2883,7 @@ async function buildAutoPlanAndRun({
             .join('\n')
         }
       ],
-      timeoutMs: config.gateway.timeout_ms || 90000,
+      timeoutMs: config.gateway.timeout_ms || 1800000,
       maxRetries: config.gateway.max_retries ?? 2
     });
     const parsed = extractJsonBlock(planning.text || '');
@@ -2707,8 +2984,9 @@ async function revisePendingPlanWithModel({
   const prompt = [
     buildAutoPlanPlannerGuidance(),
     'You are revising an existing plan based on explicit user feedback.',
-    'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|coder|reviewer|tester|summarizer","task":"..."}]}. No markdown.',
-    'Keep roles minimal and only include steps that materially help the goal.'
+    'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|advisor|coder|reviewer|tester|summarizer","task":"..."}]}. No markdown.',
+    'Keep roles minimal and only include steps that materially help the goal.',
+    'Always keep a summarizer as the final step.'
   ].join('\n');
   const result = await createChatCompletion({
     sdkProvider: config.sdk?.provider,
@@ -2730,7 +3008,7 @@ async function revisePendingPlanWithModel({
         ].join('\n')
       }
     ],
-    timeoutMs: config.gateway.timeout_ms || 90000,
+    timeoutMs: config.gateway.timeout_ms || 1800000,
     maxRetries: config.gateway.max_retries ?? 2
   });
   const parsed = extractJsonBlock(result.text || '');
@@ -2782,6 +3060,44 @@ async function handleShellInput(shellText, config) {
   return { text: chunks.join('\n') };
 }
 
+function formatHistoryTimestamp(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return 'updated unknown';
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) return `updated ${raw}`;
+  return `updated ${parsed.toISOString().slice(0, 16).replace('T', ' ')}`;
+}
+
+function compactHistoryPreview(value, maxChars = 72) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '(no preview)';
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+
+function formatHistoryList({ currentSession, sessions }) {
+  const currentMessages = Array.isArray(currentSession?.messages) ? currentSession.messages.length : 0;
+  const lines = [
+    `Current session  ${currentSession.id}`,
+    `Messages         ${currentMessages}`,
+    '',
+    'Recent sessions'
+  ];
+
+  for (const [index, session] of sessions.entries()) {
+    const count = Number(session.messageCount || 0);
+    lines.push(
+      `${index + 1}. ${session.id}`,
+      `   ${count} ${count === 1 ? 'msg' : 'msgs'}  |  ${formatHistoryTimestamp(session.updatedAt)}`,
+      `   ${compactHistoryPreview(session.preview)}`,
+      `   resume: /history resume ${session.id}`
+    );
+  }
+
+  lines.push('', 'Tip: use /history resume <session_id>');
+  return lines.join('\n');
+}
+
 export async function createChatRuntime({
   session,
   config: initialConfig,
@@ -2830,6 +3146,13 @@ export async function createChatRuntime({
     executionMode = 'plan';
   }
   const commands = await loadCommandsAndSkills();
+  const reloadCommandsAndSkills = async () => {
+    const next = await loadCommandsAndSkills();
+    commands.clear();
+    for (const [name, command] of next.entries()) {
+      commands.set(name, command);
+    }
+  };
 
   // Set up tool result store under session directory
   const sessionResultsDir = path.join(getSessionsDir(), String(currentSession.id));
@@ -2940,6 +3263,7 @@ export async function createChatRuntime({
       { name: 'config', description: completionCopy.commands.config },
       { name: 'memory', description: completionCopy.commands.memory },
       { name: 'dream', description: completionCopy.commands.dream },
+      { name: 'reflect', description: completionCopy.commands.reflect },
       { name: 'history', description: completionCopy.commands.history },
       { name: 'debug', description: completionCopy.commands.debug },
       { name: 'retry', description: completionCopy.commands.retry },
@@ -2948,7 +3272,7 @@ export async function createChatRuntime({
     ];
     const out = [];
     for (const cmd of commands.values()) {
-      if (cmd.metadata.type === 'skill' && config.skills?.enabled?.[cmd.name] === false) {
+      if (cmd.metadata.type === 'skill' && !isSkillEnabled(config, cmd.name, cmd)) {
         continue;
       }
       out.push({
@@ -2988,9 +3312,10 @@ export async function createChatRuntime({
   ];
   const specTemplates = ['/spec <topic>'];
   const planTemplates = ['/plan <goal>', '/plan auto <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>', '/agents run summarizer <task>'];
+  const agentTemplates = ['/agents list', '/agents run planner <task>', '/agents run advisor <task>', '/agents run coder <task>', '/agents run reviewer <task>', '/agents run tester <task>', '/agents run summarizer <task>'];
   const debugTemplates = ['/debug keys on', '/debug keys off', '/debug keys status'];
   const dreamTemplates = ['/dream', '/dream --dry-run', '/dream --scope=project', '/dream --scope=global'];
+  const reflectTemplates = ['/reflect', '/reflect --scope=global <request>', '/reflect <request>'];
   const compactTemplates = compactOptions.map((opt) => `/compact ${opt}`);
   const slashTemplates = [
     ...configTemplates,
@@ -3003,6 +3328,7 @@ export async function createChatRuntime({
     ...agentTemplates,
     ...debugTemplates,
     ...dreamTemplates,
+    ...reflectTemplates,
     ...compactTemplates,
     '/retry',
     '/status'
@@ -3070,6 +3396,7 @@ export async function createChatRuntime({
     for (const template of agentTemplates) registerSuggestion(template, completionCopy.generic.agentCommand);
     for (const template of debugTemplates) registerSuggestion(template, completionCopy.generic.debugCommand);
     for (const template of dreamTemplates) registerSuggestion(template, completionCopy.generic.dreamCommand);
+    for (const template of reflectTemplates) registerSuggestion(template, completionCopy.generic.reflectCommand);
     for (const template of compactTemplates) registerSuggestion(template, completionCopy.generic.compactCommand);
     registerSuggestion('/retry', completionCopy.generic.retryCommand);
     registerSuggestion('/status', completionCopy.generic.statusCommand);
@@ -3215,7 +3542,7 @@ export async function createChatRuntime({
       if (tokens.length === 1 || (tokens.length === 2 && !hasTrailingSpace)) {
         const sub = tokens[1] || '';
         if (sub === 'run') {
-          return ['planner', 'coder', 'reviewer', 'tester', 'summarizer']
+          return SUB_AGENT_ROLES
             .map((r) => registerSuggestion(`/agents run ${r} `, completionCopy.generic.agentCommand));
         }
         return ['list', 'run']
@@ -3224,7 +3551,7 @@ export async function createChatRuntime({
       }
       if (tokens[1] === 'run') {
         const rolePrefix = tokens[2] || '';
-        return ['planner', 'coder', 'reviewer', 'tester']
+        return SUB_AGENT_ROLES
           .filter((r) => r.startsWith(rolePrefix))
           .map((r) => registerSuggestion(`/agents run ${r} `, completionCopy.generic.agentCommand));
       }
@@ -3355,6 +3682,27 @@ export async function createChatRuntime({
   const saveDirectMemoryPrompt = async (text) => {
     const direct = classifyDirectMemoryPrompt(text);
     if (!direct) return null;
+    const existing = await listMemories({
+      scope: direct.scope,
+      workspaceRoot: process.cwd()
+    }).catch(() => []);
+    const directText = String(direct.content || '').toLowerCase();
+    const directTokens = new Set(directText.match(/[a-z0-9_\u4e00-\u9fa5]+/g) || []);
+    const directAsciiTokens = new Set(directText.match(/[a-z0-9_]{4,}/g) || []);
+    const overlapsExisting = existing.some((item) => {
+      const existingText = `${item.content || ''} ${item.summary || ''}`.toLowerCase();
+      for (const token of directAsciiTokens) {
+        if (existingText.includes(token)) return true;
+      }
+      let hits = 0;
+      for (const token of directTokens) {
+        if (token.length < 2) continue;
+        if (existingText.includes(token)) hits += 1;
+        if (hits >= 2) return true;
+      }
+      return false;
+    });
+    if (overlapsExisting) return null;
     return rememberMemory({
       scope: direct.scope,
       content: direct.content,
@@ -3495,14 +3843,14 @@ export async function createChatRuntime({
       if (parsedInput.command === 'help') {
         return {
           type: 'system',
-          text: 'Commands: /help /exit /new /stop /commands /status /mode /compact /checkpoint /spec /plan /yes /edit /reject /agents /config /memory /capture /inbox /dream /history /debug /retry /<custom> !<shell>'
+          text: 'Commands: /help /exit /new /stop /commands /status /mode /compact /checkpoint /spec /plan /yes /no /edit /reject /agents /config /memory /capture /inbox /dream /reflect /history /debug /retry /<custom> !<shell>'
         };
       }
       if (parsedInput.command === 'status') {
         const todoCount = countActiveTodos(currentSession.todos);
         return {
           type: 'system',
-          text: `mode=${executionMode} | model=${model || config.model.name} | max_ctx=${effectiveMaxContextTokens(config)} | session=${currentSession.id} | todos=${todoCount}`
+          text: `mode=${executionMode} | role=general | model=${model || config.model.name} | max_ctx=${effectiveMaxContextTokens(config)} | session=${currentSession.id} | todos=${todoCount}`
         };
       }
       if (parsedInput.command === 'mode') {
@@ -3521,6 +3869,27 @@ export async function createChatRuntime({
         return { type: 'system', text };
       }
       if (parsedInput.command === 'yes') {
+        if (hasPendingReflectSkill(currentSession)) {
+          const state = { ...currentSession.planState };
+          const candidate = Array.isArray(state.candidates) ? state.candidates[0] : null;
+          if (!candidate) {
+            currentSession.planState = null;
+            const text = 'No reflect skill draft to write.';
+            await persistLocalExchange(line, text, { includeUser: false });
+            return { type: 'system', text };
+          }
+          const written = await writeReflectSkillDraft({
+            draft: candidate,
+            scope: state.targetScope || 'project',
+            workspaceRoot: process.cwd()
+          });
+          currentSession.planState = null;
+          executionMode = 'auto';
+          await reloadCommandsAndSkills();
+          const text = `Reflect skill written and loaded: /${written.draft.name}\nPath: ${written.filePath}`;
+          await persistLocalExchange(line, text, { includeUser: false });
+          return { type: 'system', text };
+        }
         if (!hasPendingPlanApproval(currentSession)) {
           return { type: 'system', text: 'No pending plan approval. Use /plan auto <goal> first.' };
         }
@@ -3544,6 +3913,35 @@ export async function createChatRuntime({
         return { type: 'assistant', text: result.text, aborted: !!result.aborted };
       }
       if (parsedInput.command === 'edit') {
+        if (hasPendingReflectSkill(currentSession)) {
+          const feedback = parsedInput.args.join(' ').trim();
+          if (!feedback) {
+            return { type: 'system', text: 'Usage: /edit <feedback>' };
+          }
+          const state = { ...currentSession.planState };
+          const previousDraft = Array.isArray(state.candidates) ? state.candidates[0] : null;
+          const drafts = await buildReflectSkillDraft({
+            request: state.request || '',
+            scope: state.targetScope || 'project',
+            session: currentSession,
+            config,
+            model,
+            systemPrompt: activeReplySystemPrompt,
+            previousDraft,
+            feedback
+          });
+          currentSession.planState = {
+            ...state,
+            candidates: attachReflectTargets({
+              candidates: drafts,
+              scope: state.targetScope || 'project',
+              workspaceRoot: process.cwd()
+            })
+          };
+          const text = `Reflect skill draft revised.\n${buildPendingReflectSkillMessage(currentSession.planState)}`;
+          await persistLocalExchange(line, text);
+          return { type: 'system', text };
+        }
         if (!hasPendingPlanApproval(currentSession)) {
           return { type: 'system', text: 'No pending plan approval. Use /plan auto <goal> first.' };
         }
@@ -3564,6 +3962,23 @@ export async function createChatRuntime({
         await persistLocalExchange(line, text);
         return { type: 'system', text };
       }
+      if (parsedInput.command === 'no') {
+        if (hasPendingReflectSkill(currentSession)) {
+          currentSession.planState = null;
+          executionMode = 'auto';
+          const text = 'Reflect skill draft discarded.';
+          await persistLocalExchange(line, text, { includeUser: false });
+          return { type: 'system', text };
+        }
+        if (hasPendingPlanApproval(currentSession)) {
+          currentSession.planState = null;
+          executionMode = 'auto';
+          const text = 'Pending plan rejected and cleared.';
+          await persistLocalExchange(line, text, { includeUser: false });
+          return { type: 'system', text };
+        }
+        return { type: 'system', text: 'No pending reflect skill draft.' };
+      }
       if (parsedInput.command === 'reject') {
         if (!hasPendingPlanApproval(currentSession)) {
           return { type: 'system', text: 'No pending plan approval.' };
@@ -3776,7 +4191,7 @@ export async function createChatRuntime({
         if (sub === 'list') {
           return {
             type: 'system',
-            text: 'Sub-agent roles: planner, coder, reviewer, tester, summarizer\nUse: /agents run <role> <task>'
+            text: 'Sub-agent roles: planner, advisor, coder, reviewer, tester, summarizer\nUse: /agents run <role> <task>'
           };
         }
         if (sub === 'run') {
@@ -3784,7 +4199,7 @@ export async function createChatRuntime({
           const task = parsedInput.args.slice(2).join(' ').trim();
           if (!role || !task) return { type: 'system', text: 'Usage: /agents run <role> <task>' };
           if (!SUB_AGENT_ROLES.includes(role)) {
-            return { type: 'system', text: 'Unknown role. Allowed: planner|coder|reviewer|tester|summarizer' };
+            return { type: 'system', text: 'Unknown role. Allowed: planner|advisor|coder|reviewer|tester|summarizer' };
           }
           const output = await runSubAgentTask({
             role,
@@ -3822,13 +4237,9 @@ export async function createChatRuntime({
             messageCount: Number(s.messageCount || 0)
           }));
           if (sessions.length === 0) return { type: 'system', text: 'No sessions found' };
-          const rows = sessions.map(
-            (s, idx) =>
-              `${idx + 1}. ${s.id} | msgs:${s.messageCount} | updated:${s.updatedAt || '-'}${s.preview ? ` | ${s.preview}` : ''}`
-          );
           return {
             type: 'system',
-            text: `Current: ${currentSession.id}\n${rows.join('\n')}\nUse /history resume <session_id>`
+            text: formatHistoryList({ currentSession, sessions })
           };
         }
         if (sub === 'current') {
@@ -3971,6 +4382,37 @@ export async function createChatRuntime({
           return { type: 'system', text: `Dream failed: ${err.message}` };
         }
       }
+      if (parsedInput.command === 'reflect') {
+        const parsedReflect = parseReflectScope(parsedInput.args);
+        const drafts = await buildReflectSkillDraft({
+          request: parsedReflect.request,
+          scope: parsedReflect.scope,
+          session: currentSession,
+          config,
+          model,
+          systemPrompt: activeReplySystemPrompt
+        });
+        const candidates = attachReflectTargets({
+          candidates: drafts,
+          scope: parsedReflect.scope,
+          workspaceRoot: process.cwd()
+        });
+        if (candidates.length === 0) {
+          const text = 'Reflect found no reusable skill candidate.';
+          await persistLocalExchange(line, text);
+          return { type: 'system', text };
+        }
+        currentSession.planState = {
+          status: 'pending_reflect_skill',
+          source: 'reflect',
+          targetScope: parsedReflect.scope,
+          request: parsedReflect.request,
+          candidates
+        };
+        const text = buildPendingReflectSkillMessage(currentSession.planState);
+        await persistLocalExchange(line, text);
+        return { type: 'system', text };
+      }
       if (parsedInput.command === 'retry') {
         const lastUser = [...currentSession.messages].reverse().find((m) => m.role === 'user');
         if (!lastUser?.content) {
@@ -4096,7 +4538,7 @@ export async function createChatRuntime({
       if (!custom) {
         return { type: 'system', text: `Unknown slash command: /${parsedInput.command}` };
       }
-      if (custom.metadata.type === 'skill' && config.skills?.enabled?.[custom.name] === false) {
+      if (custom.metadata.type === 'skill' && !isSkillEnabled(config, custom.name, custom)) {
         return { type: 'system', text: `Skill is disabled: ${custom.name}` };
       }
 
@@ -4218,7 +4660,6 @@ export async function createChatRuntime({
     }
 
     const expandedText = await expandFileMentions(parsedInput.text, process.cwd());
-    await saveDirectMemoryPrompt(expandedText);
     const autoRoute = classifyAutoRoute(expandedText);
     if (autoRoute.autoPlan) {
       await maybeAutoDreamFromRuntime();
@@ -4247,7 +4688,7 @@ export async function createChatRuntime({
       return { type: 'system', text };
     }
 
-    const selectedAutoSkills = autoRoute.selectedSkills.filter((name) => isSkillEnabled(config, name));
+    const selectedAutoSkills = autoRoute.selectedSkills.filter((name) => isSkillEnabled(config, name, commands.get(name)));
     if (selectedAutoSkills.length > 0 && onAgentEvent) {
       onAgentEvent({
         type: 'skill:auto',
@@ -4270,6 +4711,7 @@ export async function createChatRuntime({
       executionMode,
       signal
     });
+    await saveDirectMemoryPrompt(expandedText);
     await captureUserPromptForDream(expandedText);
     return { type: 'assistant', text: result.text, aborted: !!result.aborted };
   };