@miphamai/cli 0.16.5 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.16.5",
+  "version": "0.17.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/agent-context.ts

@@ -5,6 +5,7 @@ import { homedir } from 'node:os'
 import { ContextManager } from '../core/context'
 import type { ToolDefinition } from '../shared/index.ts'
 import type { AgentDefinition } from './types'
+import { AgentExperience } from './agent-experience'
 
 export interface AgentContextResult {
   context: ContextManager
@@ -31,28 +32,96 @@ function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local')
       break
   }
 
-  if (!existsSync(memoryDir)) return ''
+  // Load static memory files
+  let staticMemory = ''
+  if (existsSync(memoryDir)) {
+    try {
+      const files = readdirSync(memoryDir).filter((f) => f.endsWith('.md'))
+      if (files.length > 0) {
+        const contents: string[] = []
+        for (const file of files.slice(0, 10)) {
+          try {
+            const content = readFileSync(join(memoryDir, file), 'utf-8').trim()
+            if (content) contents.push(content)
+          } catch {
+            // skip unreadable
+          }
+        }
+        if (contents.length > 0) {
+          staticMemory = [`[Agent Memory — ${scope} scope]`, ...contents].join('\n\n')
+        }
+      }
+    } catch {
+      // memory dir unreadable
+    }
+  }
 
-  try {
-    const files = readdirSync(memoryDir).filter((f) => f.endsWith('.md'))
-    if (files.length === 0) return ''
+  // Load auto-accumulated experience (always from user scope)
+  const exp = new AgentExperience(agentName)
+  const experienceContent = exp.getExperience()
 
-    const contents: string[] = []
-    for (const file of files.slice(0, 10)) {
-      // max 10 files
-      try {
-        const content = readFileSync(join(memoryDir, file), 'utf-8').trim()
-        if (content) contents.push(content)
-      } catch {
-        // skip unreadable
-      }
+  let experienceMemory = ''
+  if (experienceContent) {
+    const lines = experienceContent.split('\n')
+    const statsIdx = lines.findIndex((l) => l.startsWith('## Stats'))
+    const successIdx = lines.findIndex((l) => l.startsWith('## Success Patterns'))
+    const failureIdx = lines.findIndex((l) => l.startsWith('## Failure Patterns'))
+
+    // Header: content before the first section
+    const firstSection = Math.min(
+      successIdx !== -1 ? successIdx : Infinity,
+      failureIdx !== -1 ? failureIdx : Infinity,
+      statsIdx !== -1 ? statsIdx : Infinity,
+    )
+    const header = lines.slice(0, firstSection === Infinity ? 3 : firstSection)
+
+    // Last 5 success entries (summary line only, not detail)
+    const successLines: string[] = []
+    if (successIdx !== -1) {
+      const endIdx = Math.min(
+        failureIdx !== -1 && failureIdx > successIdx ? failureIdx : Infinity,
+        statsIdx !== -1 && statsIdx > successIdx ? statsIdx : Infinity,
+      )
+      successLines.push(
+        ...lines
+          .slice(successIdx + 1, endIdx === Infinity ? undefined : endIdx)
+          .filter((l) => l.startsWith('- ['))
+          .slice(-5),
+      )
     }
 
-    if (contents.length === 0) return ''
-    return [`[Agent Memory — ${scope} scope]`, ...contents].join('\n\n')
-  } catch {
-    return ''
+    // Last 3 failure entries (summary line only, not detail)
+    const failureLines: string[] = []
+    if (failureIdx !== -1) {
+      const endIdx = statsIdx !== -1 && statsIdx > failureIdx ? statsIdx : Infinity
+      failureLines.push(
+        ...lines
+          .slice(failureIdx + 1, endIdx === Infinity ? undefined : endIdx)
+          .filter((l) => l.startsWith('- ['))
+          .slice(-3),
+      )
+    }
+
+    // Stats section (header + stat line)
+    const stats = statsIdx !== -1 ? lines.slice(statsIdx, statsIdx + 3) : []
+
+    if (successLines.length > 0 || failureLines.length > 0) {
+      experienceMemory = [
+        '## Agent Experience',
+        ...header.filter((l) => l.trim()),
+        ...successLines,
+        ...failureLines,
+        ...stats,
+      ].join('\n')
+    }
+  }
+
+  // Combine both memory sources
+  if (staticMemory && experienceMemory) {
+    return `${staticMemory}\n\n---\n\n${experienceMemory}`
   }
+  if (experienceMemory) return experienceMemory
+  return staticMemory
 }
 
 /**

package/src/agent/agent-experience.ts

@@ -0,0 +1,105 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+
+const MAX_EXPERIENCES = 20
+
+export class AgentExperience {
+  private readonly expFile: string
+  private readonly expDir: string
+
+  constructor(
+    private readonly agentName: string,
+    baseDir: string = join(process.env.HOME || '~', '.mipham', 'agent-memory'),
+  ) {
+    this.expDir = join(baseDir, agentName)
+    this.expFile = join(this.expDir, 'experience.md')
+  }
+
+  logSuccess(description: string, whenToApply: string): void {
+    const date = new Date().toISOString().slice(0, 10)
+    const entry = `- [${date}] ${description}\n  **When to apply:** ${whenToApply}\n`
+    this.appendToSection('## Success Patterns', entry, 'success')
+  }
+
+  logFailure(description: string, whenToAvoid: string): void {
+    const date = new Date().toISOString().slice(0, 10)
+    const entry = `- [${date}] ${description}\n  **When to avoid:** ${whenToAvoid}\n`
+    this.appendToSection('## Failure Patterns', entry, 'failure')
+  }
+
+  getExperience(): string {
+    if (!existsSync(this.expFile)) return ''
+    try {
+      return readFileSync(this.expFile, 'utf-8')
+    } catch {
+      return ''
+    }
+  }
+
+  reset(): void {
+    if (existsSync(this.expFile)) {
+      try {
+        unlinkSync(this.expFile)
+      } catch {
+        /* ok */
+      }
+    }
+  }
+
+  private appendToSection(section: string, entry: string, type: 'success' | 'failure'): void {
+    mkdirSync(this.expDir, { recursive: true })
+
+    let content = this.getExperience()
+    if (!content) {
+      content = `# Agent Experience — ${this.agentName}\n\n## Success Patterns\n\n## Failure Patterns\n\n## Stats\n- 总执行: 0 次 | 成功: 0 | 失败: 0\n`
+    }
+
+    // Find section and append entry
+    const sectionIndex = content.indexOf(section)
+    if (sectionIndex === -1) {
+      // Section missing — add before Stats
+      const statsIndex = content.indexOf('## Stats')
+      if (statsIndex !== -1) {
+        content =
+          content.slice(0, statsIndex) + `${section}\n${entry}\n` + content.slice(statsIndex)
+      } else {
+        content += `\n${section}\n${entry}\n`
+      }
+    } else {
+      // Find next section header after this one
+      const nextSection = content.indexOf('\n## ', sectionIndex + section.length)
+      const insertAt = nextSection !== -1 ? nextSection : content.length
+      content = content.slice(0, insertAt) + entry + content.slice(insertAt)
+    }
+
+    // Trim old entries if over limit
+    const lines = content.split('\n')
+    let finalEntries = lines.filter((l) => l.startsWith('- ['))
+    while (finalEntries.length > MAX_EXPERIENCES) {
+      // Remove oldest entry (first one found)
+      const firstEntryIdx = lines.findIndex((l) => l.startsWith('- ['))
+      if (firstEntryIdx !== -1) {
+        const nextEntryLine = lines[firstEntryIdx + 1]
+        const removeCount = nextEntryLine?.startsWith('  **') ? 2 : 1
+        lines.splice(firstEntryIdx, removeCount)
+        finalEntries = lines.filter((l) => l.startsWith('- ['))
+      } else {
+        break
+      }
+    }
+    content = lines.join('\n')
+
+    // Update stats (merged from incrementStat — single file write)
+    content = content.replace(
+      /- 总执行: (\d+) 次 \| 成功: (\d+) \| 失败: (\d+)/,
+      (_match, total: string, success: string, failure: string) => {
+        const newTotal = parseInt(total) + 1
+        const newSuccess = type === 'success' ? parseInt(success) + 1 : parseInt(success)
+        const newFailure = type === 'failure' ? parseInt(failure) + 1 : parseInt(failure)
+        return `- 总执行: ${newTotal} 次 | 成功: ${newSuccess} | 失败: ${newFailure}`
+      },
+    )
+
+    writeFileSync(this.expFile, content, 'utf-8')
+  }
+}

package/src/agent/sub-agent.ts

@@ -6,6 +6,7 @@ import { getBackgroundAgentRegistry } from './background-registry'
 import { getMessageBus } from './message-bus'
 import type { HookEngine } from '../core/hooks'
 import type { PermissionSystem } from '../core/permission'
+import { AgentExperience } from './agent-experience'
 
 const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
   general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
@@ -73,6 +74,17 @@ export class SubAgent {
             task.result || task.error,
           )
         }
+        // Auto-log agent experience for background tasks
+        if (task.status === 'completed') {
+          this.logSuccessExperience(agentType, description, task.result || '', options.agentDef)
+        } else {
+          this.logFailureExperience(
+            agentType,
+            description,
+            task.error || 'Unknown error',
+            options.agentDef,
+          )
+        }
       })
 
       return `[background-task:${taskId}]`
@@ -84,6 +96,7 @@ export class SubAgent {
       if (this.hookEngine) {
         await this.hookEngine.executeSubagentStop(agentType, description, 'sub-agent', true, result)
       }
+      this.logSuccessExperience(agentType, description, result, options.agentDef)
       return result
     } catch (err) {
       if (this.hookEngine) {
@@ -95,6 +108,7 @@ export class SubAgent {
           String(err),
         )
       }
+      this.logFailureExperience(agentType, description, String(err), options.agentDef)
       throw err
     }
   }
@@ -314,4 +328,46 @@ export class SubAgent {
 
     return chunks.join('')
   }
+
+  /**
+   * Log a successful execution to AgentExperience.
+   * Wrapped in try/catch so it never breaks agent execution.
+   */
+  private logSuccessExperience(
+    agentType: SubAgentType,
+    description: string,
+    result: string,
+    agentDef?: AgentDefinition,
+  ): void {
+    try {
+      const name = agentDef?.name || agentType
+      const exp = new AgentExperience(name)
+      if (result && result.trim()) {
+        const firstLine = result.trim().split('\n')[0]?.slice(0, 150) || 'Task completed'
+        exp.logSuccess(firstLine, description)
+      }
+    } catch {
+      // Never let experience logging break execution
+    }
+  }
+
+  /**
+   * Log a failed execution to AgentExperience.
+   * Wrapped in try/catch so it never breaks agent execution.
+   */
+  private logFailureExperience(
+    agentType: SubAgentType,
+    description: string,
+    errMsg: string,
+    agentDef?: AgentDefinition,
+  ): void {
+    try {
+      const name = agentDef?.name || agentType
+      const exp = new AgentExperience(name)
+      const truncated = errMsg.slice(0, 200)
+      exp.logFailure(truncated, description)
+    } catch {
+      // Never let experience logging break execution
+    }
+  }
 }

package/src/core/memory/memory-manager.ts

@@ -5,12 +5,15 @@ import {
   writeFileSync,
   unlinkSync,
   existsSync,
+  statSync,
 } from 'node:fs'
 import { join, extname } from 'node:path'
 
 export interface MemoryMetadata {
   type: 'user' | 'feedback' | 'project' | 'reference'
   relevance: string[]
+  why?: string
+  howToApply?: string
 }
 
 export interface MemoryEntry {
@@ -26,6 +29,7 @@ const INDEX_FILE = 'MEMORY.md'
 
 export class MemoryManager {
   private memories = new Map<string, MemoryEntry>()
+  private linkGraph: Map<string, Set<string>> = new Map()
 
   constructor(private memoryDir: string) {
     mkdirSync(memoryDir, { recursive: true })
@@ -33,6 +37,7 @@ export class MemoryManager {
 
   loadAll(): void {
     this.memories.clear()
+    this.linkGraph.clear()
     if (!existsSync(this.memoryDir)) return
 
     let entries: string[] = []
@@ -55,9 +60,26 @@ export class MemoryManager {
         // skip unparseable
       }
     }
+    this.rebuildLinkGraph()
   }
 
   write(name: string, content: string, metadata: MemoryMetadata): void {
+    // Dedup: same name = update, don't create duplicate
+    const formattedBody = this.formatMemoryBody(metadata, content)
+    const existing = this.memories.get(name)
+    if (existing) {
+      existing.content = formattedBody
+      existing.metadata = metadata
+      existing.description = metadata.relevance.join(', ')
+      existing.updatedAt = new Date()
+      this.memories.set(name, existing)
+      const body = this.formatMemoryFile(name, metadata, content)
+      writeFileSync(existing.filePath, body, 'utf-8')
+      this.updateWikilinks(name, content)
+      this.updateIndex()
+      return
+    }
+
     const fileName = `${name}.md`
     const filePath = join(this.memoryDir, fileName)
 
@@ -68,18 +90,20 @@ export class MemoryManager {
       name,
       description: metadata.relevance.join(', '),
       metadata,
-      content,
+      content: formattedBody,
       filePath,
       updatedAt: new Date(),
     }
 
     this.memories.set(name, entry)
+    this.updateWikilinks(name, content)
     this.updateIndex()
   }
 
   recall(context: string, limit: number = 10): MemoryEntry[] {
     const contextLower = context.toLowerCase()
     const scored: Array<{ entry: MemoryEntry; score: number }> = []
+    const seen = new Set<string>()
 
     for (const entry of this.memories.values()) {
       let score = 0
@@ -95,6 +119,31 @@ export class MemoryManager {
       }
       if (score > 0) {
         scored.push({ entry, score })
+        seen.add(entry.name)
+      }
+    }
+
+    // Boost wikilink-connected memories with lower weight
+    for (const scoredItem of [...scored]) {
+      const linkedNames = this.linkGraph.get(scoredItem.entry.name)
+      if (!linkedNames) continue
+      for (const linkedName of linkedNames) {
+        if (seen.has(linkedName)) continue
+        const linkedEntry = this.memories.get(linkedName)
+        if (linkedEntry) {
+          scored.push({ entry: linkedEntry, score: 1 })
+          seen.add(linkedName)
+        }
+      }
+    }
+
+    // Apply time decay: memories older than 30 days get 50% weight
+    const now = Date.now()
+    const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000
+    for (const item of scored) {
+      const age = now - item.entry.updatedAt.getTime()
+      if (age > THIRTY_DAYS_MS) {
+        item.score *= 0.5
       }
     }
 
@@ -102,6 +151,17 @@ export class MemoryManager {
     return scored.slice(0, limit).map((s) => s.entry)
   }
 
+  getLinkedMemories(name: string): MemoryEntry[] {
+    const targets = this.linkGraph.get(name)
+    if (!targets || targets.size === 0) return []
+    const results: MemoryEntry[] = []
+    for (const target of targets) {
+      const entry = this.memories.get(target)
+      if (entry) results.push(entry)
+    }
+    return results
+  }
+
   delete(name: string): void {
     const entry = this.memories.get(name)
     if (!entry) return
@@ -134,6 +194,84 @@ export class MemoryManager {
     return lines.join('\n')
   }
 
+  distillFromSession(summary: string, sessionId: string): MemoryEntry[] {
+    const results: MemoryEntry[] = []
+    // Split on bullet points (both - and *)
+    const bullets = summary.split(/\n\s*[-*]\s+/).filter((b) => b.trim().length > 20)
+
+    for (const bullet of bullets) {
+      // Extract Why / How to apply if present
+      const whyMatch = bullet.match(/\*\*Why:\*\*\s*(.+?)(?:\s*\*\*How to apply:|$)/)
+      const howMatch = bullet.match(/\*\*How to apply:\*\*\s*(.+)$/)
+
+      // Strip Why/How markers from content — they're passed as metadata fields
+      // and formatMemoryBody appends them, so leaving them in duplicates the text
+      const stripped = bullet
+        .trim()
+        .replace(/\s*\*\*Why:\*\*.*/, '')
+        .replace(/\s*\*\*How to apply:\*\*.*/, '')
+        .trim()
+      const slug = `auto-${sessionId}-${results.length}`
+
+      this.write(slug, stripped, {
+        type: 'feedback',
+        relevance: this.extractKeywords(stripped),
+        why: whyMatch?.[1]?.trim(),
+        howToApply: howMatch?.[1]?.trim(),
+      })
+
+      const entry = this.memories.get(slug)
+      if (entry) results.push(entry)
+    }
+    return results
+  }
+
+  private extractKeywords(content: string): string[] {
+    const words = content
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, '')
+      .split(/\s+/)
+    const stopWords = new Set([
+      'the',
+      'a',
+      'an',
+      'is',
+      'are',
+      'was',
+      'were',
+      'in',
+      'on',
+      'at',
+      'to',
+      'for',
+      'of',
+      'and',
+      'or',
+      'but',
+      'not',
+      'this',
+      'that',
+      'with',
+      'from',
+      'by',
+      'as',
+      'be',
+      'has',
+      'have',
+      'it',
+      'its',
+    ])
+    const seen = new Set<string>()
+    const result: string[] = []
+    for (const word of words) {
+      if (word.length > 3 && !stopWords.has(word) && !seen.has(word)) {
+        seen.add(word)
+        result.push(word)
+      }
+    }
+    return result.slice(0, 10)
+  }
+
   private updateIndex(): void {
     const lines: string[] = [
       '# Memory Index',
@@ -149,6 +287,62 @@ export class MemoryManager {
     writeFileSync(join(this.memoryDir, INDEX_FILE), lines.join('\n') + '\n', 'utf-8')
   }
 
+  private extractWikilinks(content: string): string[] {
+    const re = /\[\[([^\]]+)\]\]/g
+    const links: string[] = []
+    let match: RegExpExecArray | null
+    while ((match = re.exec(content)) !== null) {
+      if (links.length >= 10) break // hard cap
+      links.push(match[1]!)
+    }
+    return links
+  }
+
+  private updateWikilinks(name: string, content: string): void {
+    // Clear stale outbound links for this memory
+    this.linkGraph.delete(name)
+
+    // Extract outbound wikilinks from content
+    const links = this.extractWikilinks(content)
+    if (links.length > 0) {
+      this.linkGraph.set(name, new Set(links))
+    }
+
+    // Update reverse links: other memories that link to this one
+    for (const [otherName, otherEntry] of this.memories) {
+      if (otherName === name) continue
+      const otherLinks = this.extractWikilinks(otherEntry.content)
+      if (otherLinks.includes(name)) {
+        const otherSet = this.linkGraph.get(otherName) || new Set()
+        otherSet.add(name)
+        this.linkGraph.set(otherName, otherSet)
+      }
+    }
+  }
+
+  private rebuildLinkGraph(): void {
+    this.linkGraph.clear()
+    for (const [name, entry] of this.memories) {
+      const links = this.extractWikilinks(entry.content)
+      if (links.length > 0) {
+        this.linkGraph.set(name, new Set(links))
+      }
+    }
+    // Compute reverse links: other memories that link to each memory
+    for (const [name, entry] of this.memories) {
+      const linked = this.extractWikilinks(entry.content)
+      for (const target of linked) {
+        if (target === name) continue
+        const targetSet = this.linkGraph.get(target)
+        if (targetSet) {
+          targetSet.add(name)
+        } else {
+          this.linkGraph.set(target, new Set([name]))
+        }
+      }
+    }
+  }
+
   private parseMemoryFile(raw: string, filePath: string): MemoryEntry | null {
     const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
     if (!match) return null
@@ -173,11 +367,12 @@ export class MemoryManager {
       },
       content,
       filePath,
-      updatedAt: new Date(),
+      updatedAt: statSync(filePath).mtime,
     }
   }
 
   private formatMemoryFile(name: string, metadata: MemoryMetadata, content: string): string {
+    const body = this.formatMemoryBody(metadata, content)
     return `---
 name: ${name}
 description: ${metadata.relevance.join(', ')}
@@ -186,7 +381,20 @@ metadata:
   relevance: [${metadata.relevance.join(', ')}]
 ---
 
-${content}
+${body}
 `
   }
+
+  private formatMemoryBody(metadata: MemoryMetadata, content: string): string {
+    let body = content
+
+    if (metadata.why) {
+      body += `\n\n**Why:** ${metadata.why}`
+    }
+    if (metadata.howToApply) {
+      body += `\n\n**How to apply:** ${metadata.howToApply}`
+    }
+
+    return body
+  }
 }

package/src/core/session-store.ts

@@ -27,6 +27,21 @@ export interface StoredSession {
 
 const HOME = process.env.HOME || '~'
 const SESSIONS_DIR = join(HOME, '.mipham', 'sessions')
+const INDEX_FILE = join(SESSIONS_DIR, '.index.json')
+const SUMMARIES_DIR = join(SESSIONS_DIR, '.summaries')
+
+export interface SessionIndexEntry {
+  name: string
+  createdAt: string
+  updatedAt: string
+  provider: string
+  model: string
+  messageCount: number
+  tokenCount: number
+  cwd?: string
+  summary?: string
+  tags?: string[]
+}
 
 function ensureDir(): void {
   mkdirSync(SESSIONS_DIR, { recursive: true })
@@ -67,6 +82,9 @@ export class SessionStore {
     const tmp = path + '.tmp'
     writeFileSync(tmp, JSON.stringify(session) + '\n', 'utf-8')
     renameSync(tmp, path)
+
+    // Incremental index update — only touch this session's entry
+    SessionStore.updateIndexEntry(name, session.metadata)
   }
 
   /**
@@ -142,4 +160,119 @@ export class SessionStore {
     SessionStore.save(name, messages, metadata)
     return name
   }
+
+  /**
+   * Write .index.json with all session metadata, merging existing summary/tags.
+   */
+  static updateIndex(): void {
+    ensureDir()
+    const sessions = SessionStore.list()
+    const index: SessionIndexEntry[] = sessions.map((s) => ({
+      name: s.name,
+      createdAt: s.createdAt,
+      updatedAt: s.updatedAt,
+      provider: s.provider,
+      model: s.model,
+      messageCount: s.messageCount,
+      tokenCount: 0,
+      cwd: s.cwd,
+    }))
+
+    // Merge with existing summaries and tags from prior index
+    const existing = SessionStore.loadIndexRaw()
+    for (const entry of index) {
+      const prev = existing.find((e) => e.name === entry.name)
+      if (prev) {
+        entry.summary = prev.summary
+        entry.tags = prev.tags
+        entry.tokenCount = prev.tokenCount || 0
+      }
+    }
+
+    writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), 'utf-8')
+  }
+
+  /**
+   * Incrementally update a single session's entry in the index.
+   * Only modifies one entry — faster than full rebuild. Used by save().
+   */
+  static updateIndexEntry(name: string, metadata: SessionMetadata): void {
+    ensureDir()
+    const index = SessionStore.loadIndexRaw()
+    const existing = index.find((e) => e.name === name)
+    const entry: SessionIndexEntry = {
+      name,
+      createdAt: metadata.createdAt,
+      updatedAt: metadata.updatedAt,
+      provider: metadata.provider,
+      model: metadata.model,
+      messageCount: metadata.messageCount,
+      tokenCount: existing?.tokenCount || 0,
+      cwd: metadata.cwd,
+      summary: existing?.summary,
+      tags: existing?.tags,
+    }
+    if (existing) {
+      Object.assign(existing, entry)
+    } else {
+      index.push(entry)
+    }
+    writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), 'utf-8')
+  }
+
+  /**
+   * Persist an LLM-generated summary for a session.
+   * Writes a markdown file to .summaries/ and updates the index entry.
+   */
+  static saveSummary(name: string, summary: string, tags: string[]): void {
+    ensureDir()
+    mkdirSync(SUMMARIES_DIR, { recursive: true })
+
+    const safe = name.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 100)
+    const summaryPath = join(SUMMARIES_DIR, `${safe}.md`)
+    writeFileSync(summaryPath, `# ${name}\n\n${summary}\n\nTags: ${tags.join(', ')}\n`, 'utf-8')
+
+    // Update index entry — create minimal one if not present
+    const index = SessionStore.loadIndexRaw()
+    const entry = index.find((e) => e.name === name)
+    if (entry) {
+      entry.summary = summary
+      entry.tags = tags
+    } else {
+      index.push({
+        name,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        provider: 'unknown',
+        model: 'unknown',
+        messageCount: 0,
+        tokenCount: 0,
+        summary,
+        tags,
+      })
+    }
+    writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), 'utf-8')
+  }
+
+  /**
+   * Return the most recent session from the index, or null if none exist.
+   */
+  static getLatest(): SessionIndexEntry | null {
+    const index = SessionStore.loadIndexRaw()
+    if (index.length === 0) return null
+    index.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+    return index[0]!
+  }
+
+  /**
+   * Read the raw index file, returning empty array if missing or corrupt.
+   */
+  private static loadIndexRaw(): SessionIndexEntry[] {
+    if (!existsSync(INDEX_FILE)) return []
+    try {
+      return JSON.parse(readFileSync(INDEX_FILE, 'utf-8'))
+    } catch {
+      return []
+    }
+  }
 }

package/src/index.tsx

@@ -5,7 +5,7 @@ import { App } from './ui/app'
 import { loadConfig, loadInferenceHookConfig, loadCredentialMaskingConfig } from './config/loader'
 import { bootstrapProviders } from './providers/bootstrap'
 import { InstructionsLoader } from './core/instructions'
-import { loadSessionMemories } from './core/memory/memory-loader'
+import { loadSessionMemories, getMemoryManager } from './core/memory/memory-loader'
 import { ContextManager } from './core/context'
 import { QueryEngine } from './core/engine'
 import { SessionStore } from './core/session-store'
@@ -143,7 +143,17 @@ export async function runApp(options: RunOptions): Promise<void> {
   if (context.getMessageCount() === 0) {
     const basePrompt = instructions.buildSystemPrompt()
     const memoryReminder = loadSessionMemories(basePrompt)
-    context.setSystemPrompt(memoryReminder ? `${basePrompt}\n\n${memoryReminder}` : basePrompt)
+
+    // Inject previous session summary for AI continuity
+    let prompt = basePrompt
+    if (memoryReminder) {
+      prompt = `${prompt}\n\n${memoryReminder}`
+    }
+    const latestSession = SessionStore.getLatest()
+    if (latestSession?.summary) {
+      prompt = `${prompt}\n\n<system-context name="previous-session">\n# Previous Session Summary\n${latestSession.summary}\n</system-context>`
+    }
+    context.setSystemPrompt(prompt)
   }
 
   // Create tool registry with all built-in tools
@@ -234,7 +244,9 @@ export async function runApp(options: RunOptions): Promise<void> {
   engine.setupContextSummarizer()
 
   // Auto-save session on exit
+  let saved = false
   const saveAndExit = () => {
+    saved = true
     artifactServer.stop()
     if (context.getMessageCount() > 0) {
       SessionStore.save(sessionName, context.getMessages(), {
@@ -249,6 +261,28 @@ export async function runApp(options: RunOptions): Promise<void> {
   process.on('SIGINT', saveAndExit)
   process.on('SIGTERM', saveAndExit)
 
+  // Safety net: auto-save on exit for paths that bypass saveAndExit
+  process.on('exit', () => {
+    if (!saved && context.getMessageCount() > 0) {
+      SessionStore.autoSave(context.getMessages(), {
+        provider: defaultProvider,
+        model: defaultModel,
+        cwd: process.cwd(),
+      })
+      // Distill learnings from the last 5 user messages into memory
+      const allMessages = context.getMessages()
+      const userMessages = allMessages
+        .filter((m) => m.role === 'user')
+        .slice(-5)
+        .map((m) => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content)))
+        .join('\n- ')
+      if (userMessages) {
+        const summary = `Session highlights:\n- ${userMessages}`
+        getMemoryManager().distillFromSession(summary, sessionName)
+      }
+    }
+  })
+
   const { waitUntilExit } = render(
     <App
       engine={engine}

package/src/ui/app.tsx

@@ -313,6 +313,13 @@ export function App({
           if (result.nextProvider) setProviderId(result.nextProvider)
           if (result.nextModel) setModelId(result.nextModel)
           if (result.exit) process.exit(0)
+          if (result.forwardedMessages && result.forwardedMessages.length > 0) {
+            const restored: ChatMessage[] = result.forwardedMessages.map((msg) => ({
+              role: msg.role,
+              content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            }))
+            setMessages((prev) => [...prev, ...restored])
+          }
           if (result.copyContent) {
             // Copy to clipboard via pbcopy (macOS) or clip (Windows)
             try {
@@ -364,10 +371,7 @@ export function App({
             if (isNewTurn) {
               turnContent = chunk.content
               isNewTurn = false
-              setMessages((prev) => [
-                ...prev,
-                { role: 'assistant', content: turnContent },
-              ])
+              setMessages((prev) => [...prev, { role: 'assistant', content: turnContent }])
             } else {
               turnContent += chunk.content
               setMessages((prev) => {

package/src/ui/chat.tsx

@@ -95,9 +95,7 @@ const MessageRow = React.memo(
 export function ChatPanel({ messages, focusMode }: ChatPanelProps) {
   // Group consecutive tool calls into compact summaries to reduce visual noise.
   // In focus mode, use the more aggressive compactForFocus.
-  const displayMessages = focusMode
-    ? compactForFocus(messages)
-    : compactToolGroups(messages)
+  const displayMessages = focusMode ? compactForFocus(messages) : compactToolGroups(messages)
 
   return (
     <Box flexDirection="column" marginY={1} flexGrow={1}>

package/src/ui/commands.ts

@@ -8,6 +8,7 @@ import type { QueryEngine } from '../core/engine'
 import type { MiphamConfig } from '../shared/index.ts'
 import type { SkillsLoader } from '../skills/loader'
 import type { PluginManager } from '../plugin/plugin-manager'
+import type { Message } from '../shared/types.js'
 import { McpClient } from '../mcp/client'
 import { NPM_INSTALL_COMMAND, NPM_UPDATE_COMMAND, PACKAGE_VERSION } from '../shared/index.ts'
 import { getPreference } from '../config/preferences'
@@ -58,6 +59,8 @@ export interface CommandResult {
   /** If set, route this message to the AI engine — bridges slash commands → skill/agent invocation.
    *  The app layer replaces the user input with this string and falls through to AI processing. */
   forwardToAI?: string
+  /** If set, restored messages to load into the session (used by /resume last). */
+  forwardedMessages?: Message[]
 }
 
 export type CommandHandler = (
@@ -98,6 +101,8 @@ const helpCmd: CommandHandler = (ctx) => {
       /export        Export conversation to file
       /doctor        System diagnostics
       /resume        List saved sessions
+      /resume last   Restore most recent session
+      /resume delete <name>   Delete a saved session
       /branch <name> Fork conversation
 
       ── History ─────────────────────────
@@ -1967,7 +1972,70 @@ const prCommentsCmd: CommandHandler = async () => {
 // Resume
 // ═══════════════════════════════════════════════════════════════
 
+const resumeLastCmd: CommandHandler = async () => {
+  const { SessionStore } = await import('../core/session-store')
+
+  const latest = SessionStore.getLatest()
+  if (!latest) {
+    return {
+      content:
+        '─ Resume Session ─\n\nNo saved sessions found.\n\nSessions are auto-saved to ~/.mipham/sessions/ when Mipham Code exits.',
+    }
+  }
+
+  const session = SessionStore.load(latest.name)
+  if (!session) {
+    return {
+      content: `─ Load Failed ─\n\nCould not load session "${latest.name}". The file may have been removed.`,
+    }
+  }
+
+  const date = new Date(latest.updatedAt).toLocaleString()
+  return {
+    content: [
+      '─ Session Restored ─',
+      '',
+      `Name:      ${latest.name}`,
+      `Messages:  ${session.messages.length}`,
+      `Provider:  ${latest.provider} / ${latest.model}`,
+      `Updated:   ${date}`,
+      '',
+      `${session.messages.length} messages loaded. Context has been restored.`,
+    ].join('\n'),
+    forwardedMessages: session.messages,
+  }
+}
+
+const resumeDeleteCmd: CommandHandler = async (_ctx, args) => {
+  const name = args.join(' ').trim()
+  if (!name) {
+    return {
+      content:
+        'Usage: /resume delete <session-name>\n\nDelete a saved session. Use /resume to list all sessions.',
+    }
+  }
+
+  const { SessionStore } = await import('../core/session-store')
+  const deleted = SessionStore.delete(name)
+
+  return deleted
+    ? { content: `✓ Session "${name}" deleted.` }
+    : { content: `✗ Session "${name}" not found. Use /resume to list all sessions.` }
+}
+
 const resumeCmd: CommandHandler = async (_ctx, args) => {
+  const sub = args[0]?.toLowerCase()
+
+  // Sub-command: /resume last
+  if (sub === 'last') {
+    return resumeLastCmd(_ctx, args.slice(1))
+  }
+
+  // Sub-command: /resume delete <name>
+  if (sub === 'delete') {
+    return resumeDeleteCmd(_ctx, args.slice(1))
+  }
+
   const { SessionStore } = await import('../core/session-store')
 
   // If a name is provided, show load instructions
@@ -1985,6 +2053,7 @@ const resumeCmd: CommandHandler = async (_ctx, args) => {
           `Updated:   ${session.metadata.updatedAt}`,
           '',
           'To resume this session:',
+          `  /resume last    — restore the most recent session`,
           `  mipham --resume "${targetName}"`,
           '',
           'Or restart Mipham Code — the most recent session loads automatically.',
@@ -2017,8 +2086,10 @@ const resumeCmd: CommandHandler = async (_ctx, args) => {
     '',
     `Total: ${sessions.length} session(s) • Location: ~/.mipham/sessions/`,
     '',
-    'To resume a session: /resume <name>',
-    'To resume from CLI:    mipham --resume "<name>"',
+    'To resume a session:   /resume <name>',
+    'To resume most recent:  /resume last',
+    'To delete a session:    /resume delete <name>',
+    'To resume from CLI:     mipham --resume "<name>"',
     '',
     'Sessions are auto-saved on exit. The most recent session loads automatically on restart.',
   ]
@@ -2993,6 +3064,8 @@ const commandsListCmd: CommandHandler = () => {
     '/export': 'Session & Identity',
     '/doctor': 'Session & Identity',
     '/resume': 'Session & Identity',
+    '/resume last': 'Session & Identity',
+    '/resume delete': 'Session & Identity',
     '/branch': 'Session & Identity',
     '/rewind': 'History',
     '/undo': 'History',
@@ -3175,6 +3248,8 @@ registry.set('/pr-comments', prCommentsCmd)
 registry.set('/doctor', doctorCmd)
 registry.set('/export', exportCmd)
 registry.set('/resume', resumeCmd)
+registry.set('/resume last', resumeLastCmd)
+registry.set('/resume delete', resumeDeleteCmd)
 registry.set('/memory', memoryCmd)
 registry.set('/upgrade', upgradeCmd)
 
@@ -3266,6 +3341,8 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/export': 'Export conversation to file',
   '/doctor': 'System diagnostics',
   '/resume': 'List saved sessions',
+  '/resume last': 'Restore the most recent saved session',
+  '/resume delete': 'Delete a saved session',
   '/branch': 'Fork conversation',
   '/rewind': 'Undo last AI turn',
   '/undo': 'Same as /rewind',