@miphamai/cli 0.55.0 → 0.56.0

package/bin/mipham.ts

@@ -87,7 +87,9 @@ async function runWorkflowCLI(): Promise<boolean> {
     })
 
   // Commander will handle --help, unknown commands, etc.
-  await program.parseAsync(process.argv)
+  // Skip node + script + the leading `workflow` keyword (already matched by the
+  // caller); `from: 'user'` stops commander from stripping two more elements.
+  await program.parseAsync(process.argv.slice(3), { from: 'user' })
   return true
 }
 
@@ -185,7 +187,9 @@ async function runPluginCLI(): Promise<boolean> {
       process.exit(result.success ? 0 : 1)
     })
 
-  await program.parseAsync(process.argv)
+  // Skip node + script + the leading `plugin` keyword (already matched by the
+  // caller); `from: 'user'` stops commander from stripping two more elements.
+  await program.parseAsync(process.argv.slice(3), { from: 'user' })
   return true
 }
 
@@ -1054,6 +1058,21 @@ async function runTokenCLI(): Promise<boolean> {
 }
 
 async function main() {
+  // ── Deleted-cwd guard ──────────────────────────────────────────────────
+  // `process.cwd()` throws ENOENT when the directory the process was launched
+  // from no longer exists (e.g. a removed git worktree). Print a clear message
+  // instead of a raw crash dump (matches Claude Code 2.1.239).
+  const { isDeletedCwdError, deletedCwdMessage } = await import('../src/shared/deleted-cwd')
+  try {
+    process.cwd()
+  } catch (err) {
+    if (isDeletedCwdError(err)) {
+      console.error(deletedCwdMessage())
+      process.exit(1)
+    }
+    throw err
+  }
+
   // ── Disable terminal special characters ──────────────────────────────────
   // Terminal intercepts Ctrl+S (XOFF), Ctrl+T (SIGINFO/status), Ctrl+R (rprnt)
   // before the app sees them. Disable these so Agent Dashboard shortcuts work.

package/package.json

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

package/src/core/engine.ts

@@ -38,6 +38,7 @@ import { UsageTracker } from './usage-tracker'
 import { getMetrics } from './metrics'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
+import { accumulateGraftSavings } from '../shared/graft-savings'
 import { getMessageBus, type AgentMessage } from '../agent/message-bus'
 import { createT } from '../i18n-core/t'
 import enUS from '../i18n-core/locales/en-US.json'
@@ -1127,6 +1128,9 @@ export class QueryEngine {
         tracker.persist()
       }
 
+      // Accumulate graft token savings from "[graft] tokens saved ≈ N" footers
+      accumulateGraftSavings(result.content)
+
       return result
     } catch (err) {
       // P1-3: Trigger PostToolUseFailure hook on tool execution errors

package/src/index.tsx

@@ -396,7 +396,7 @@ export async function runApp(options: RunOptions): Promise<void> {
   if (context.getMessageCount() === 0) {
     const basePrompt = instructions.buildSystemPrompt(config.permission as string)
     const memoryReminder = loadSessionMemories(basePrompt)
-    const skillsReminder = skillsLoader.buildSystemReminder(basePrompt)
+    const skillsReminder = skillsLoader.buildSystemReminder()
 
     // Inject previous session summary for AI continuity
     let prompt = basePrompt

package/src/plugin/claude-plugin.ts

@@ -0,0 +1,174 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import type { SkillsLoader } from '../skills/loader'
+import type { AgentRegistry } from '../agent/agent-registry'
+import type { McpClient } from '../mcp/client'
+import type { McpServerConfig, ToolDefinition } from '../shared/types'
+import { registerMcpServerTools } from '../mcp/registry'
+
+/**
+ * Claude marketplace plugin adapter — loads the portable content of a Claude
+ * plugin (`.claude-plugin/plugin.json` + skills/agents/MCP) into Mipham Code's
+ * own subsystems. Commands (`commands/*.md`) and hooks (`hooks/hooks.json`) are
+ * not mapped here: Mipham Code has no file-based slash-command system, and the
+ * hook matcher semantics differ.
+ */
+
+interface ClaudeManifest {
+  name: string
+  version?: string
+  mcpServers?: Record<string, unknown> | string
+  [key: string]: unknown
+}
+
+/** Read the Claude manifest at `<dir>/.claude-plugin/plugin.json`. */
+export function readClaudeManifest(dir: string): ClaudeManifest | null {
+  const path = join(dir, '.claude-plugin', 'plugin.json')
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8')) as ClaudeManifest
+  } catch {
+    return null
+  }
+}
+
+/** Expand `${CLAUDE_PLUGIN_ROOT}` (Claude's plugin-root placeholder). */
+function expandPluginRoot(value: string, pluginRoot: string): string {
+  return value.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginRoot)
+}
+
+/** Load Claude skills — `skills/<name>/SKILL.md` (no leading dot on SKILL.md). */
+function loadClaudeSkills(dir: string, skillsLoader: SkillsLoader): void {
+  const skillsDir = join(dir, 'skills')
+  if (!existsSync(skillsDir)) return
+  let entries: string[] = []
+  try {
+    entries = readdirSync(skillsDir)
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    let skillFile: string | null = null
+    try {
+      const full = join(skillsDir, entry)
+      if (statSync(full).isDirectory()) {
+        const candidate = join(full, 'SKILL.md')
+        if (existsSync(candidate)) skillFile = candidate
+      } else if (entry === 'SKILL.md') {
+        skillFile = full
+      }
+    } catch {
+      continue
+    }
+    if (skillFile) skillsLoader.loadSkillFile(skillFile, 'standard')
+  }
+}
+
+/** Map a Claude MCP server entry to a Mipham `McpServerConfig`. */
+function toMcpServerConfig(name: string, raw: Record<string, unknown>): McpServerConfig | null {
+  const command = typeof raw.command === 'string' ? raw.command : undefined
+  const url = typeof raw.url === 'string' ? raw.url : undefined
+  if (!command && !url) return null
+
+  const cfg: McpServerConfig = { name }
+  if (command) {
+    cfg.command = command
+    cfg.args = Array.isArray(raw.args) ? raw.args.map(String) : undefined
+  } else {
+    cfg.url = url
+  }
+  if (raw.env && typeof raw.env === 'object') {
+    cfg.env = raw.env as Record<string, string>
+  }
+  if (raw.headers && typeof raw.headers === 'object') {
+    cfg.headers = raw.headers as Record<string, string>
+  }
+  return cfg
+}
+
+/** Load Claude MCP servers (`.mcp.json` + inline `mcpServers`) into the client. */
+function loadClaudeMcp(
+  dir: string,
+  manifest: ClaudeManifest,
+  mcpClient: Pick<McpClient, 'connect'>,
+  toolsMap: Map<string, ToolDefinition>,
+): string[] {
+  const servers: McpServerConfig[] = []
+
+  const collect = (obj: unknown): void => {
+    if (!obj || typeof obj !== 'object') return
+    for (const [name, raw] of Object.entries(obj as Record<string, Record<string, unknown>>)) {
+      const cfg = toMcpServerConfig(name, raw)
+      if (cfg) servers.push(cfg)
+    }
+  }
+
+  // 1. `.mcp.json` at the plugin root
+  const mcpJsonPath = join(dir, '.mcp.json')
+  if (existsSync(mcpJsonPath)) {
+    try {
+      collect(JSON.parse(readFileSync(mcpJsonPath, 'utf-8')).mcpServers)
+    } catch {
+      /* skip unparseable .mcp.json */
+    }
+  }
+  // 2. Inline `mcpServers` field in the manifest
+  collect(manifest.mcpServers)
+
+  for (const cfg of servers) {
+    if (cfg.command) cfg.command = expandPluginRoot(cfg.command, dir)
+    if (cfg.args) cfg.args = cfg.args.map((a) => expandPluginRoot(a, dir))
+    if (cfg.env) {
+      for (const key of Object.keys(cfg.env)) cfg.env[key] = expandPluginRoot(cfg.env[key]!, dir)
+    }
+
+    mcpClient
+      .connect(cfg)
+      .then(() => {
+        const count = registerMcpServerTools(cfg.name, toolsMap)
+        if (count > 0) {
+          process.stderr.write(
+            `[plugin] "${manifest.name}": registered ${count} MCP tools from "${cfg.name}"\n`,
+          )
+        }
+      })
+      .catch((err: unknown) => {
+        process.stderr.write(
+          `[plugin] Failed to connect MCP "${cfg.name}" from "${manifest.name}": ${String(err)}\n`,
+        )
+      })
+  }
+
+  return servers.map((s) => s.name)
+}
+
+/** Load a Claude plugin's portable content (skills + agents + MCP) into Mipham Code.
+ *  Returns the names of the connected MCP servers so the caller can wire cleanup. */
+export function loadClaudePlugin(
+  dir: string,
+  deps: {
+    skillsLoader: SkillsLoader
+    agentRegistry: AgentRegistry
+    mcpClient: Pick<McpClient, 'connect'>
+    toolsMap: Map<string, ToolDefinition>
+  },
+): string[] {
+  const manifest = readClaudeManifest(dir)
+  if (!manifest) return []
+
+  loadClaudeSkills(dir, deps.skillsLoader)
+
+  // Claude agents use `.md` + frontmatter; largely compatible with Mipham's AgentDefinition.
+  const agentsDir = join(dir, 'agents')
+  if (existsSync(agentsDir)) {
+    try {
+      deps.agentRegistry.loadDirectory(agentsDir, 'user')
+    } catch (err) {
+      process.stderr.write(
+        `[plugin] Failed to load agents from "${manifest.name}": ${String(err)}\n`,
+      )
+    }
+  }
+
+  return loadClaudeMcp(dir, manifest, deps.mcpClient, deps.toolsMap)
+}

package/src/plugin/plugin-loader.ts

@@ -7,6 +7,8 @@ import type { HookEngine } from '../core/hooks'
 import type { McpClient } from '../mcp/client'
 import { registerMcpServerTools } from '../mcp/registry'
 import { executeHook } from '../core/hooks-executor'
+import { detectPluginFormat } from './plugin-validator'
+import { loadClaudePlugin } from './claude-plugin'
 import type { McpServerConfig, ToolDefinition, HookConfig, HookEvent } from '../shared/types'
 
 /**
@@ -24,6 +26,29 @@ export function loadPlugins(
   toolsMap: Map<string, ToolDefinition>,
 ): void {
   for (const plugin of pluginManager.getEnabled()) {
+    // Claude marketplace plugins: load their portable content via the adapter.
+    if (detectPluginFormat(plugin.path) === 'claude') {
+      const claudeMcpServers = loadClaudePlugin(plugin.path, {
+        skillsLoader,
+        agentRegistry,
+        mcpClient,
+        toolsMap,
+      })
+      pluginManager.onRemove(plugin.name, () => {
+        for (const serverName of claudeMcpServers) {
+          try {
+            const toolNames = mcpClient.disconnect(serverName)
+            for (const toolName of toolNames) {
+              toolsMap.delete(`mcp__${serverName}__${toolName}`)
+            }
+          } catch {
+            /* best effort */
+          }
+        }
+      })
+      continue
+    }
+
     const mcpServers: string[] = []
     const hookEvents: HookEvent[] = []
 

package/src/plugin/plugin-manager.ts

@@ -1,4 +1,12 @@
-import { mkdirSync, existsSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs'
+import {
+  mkdirSync,
+  existsSync,
+  writeFileSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  renameSync,
+} from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { execSync } from 'node:child_process'
@@ -48,7 +56,7 @@ export class PluginManager {
     const similarWarning = this.findSimilarWarning(validation.manifest.name)
     this.plugins.push({
       name: validation.manifest.name,
-      version: validation.manifest.version,
+      version: validation.manifest.version || '0.0.0',
       path: destDir,
       enabled: true,
       installedAt: new Date().toISOString(),
@@ -78,44 +86,65 @@ export class PluginManager {
       return { success: false, message: `Invalid package name: "${packageName}"` }
     }
 
-    // Derive plugin name from npm package name (strip scope prefix)
-    const pluginName = packageName.replace(/^@.+\//, '').replace(/^mipham-plugin-/, '')
+    // Staging dir name derived from the npm package name (scope stripped). The
+    // final directory is renamed to the manifest `name` once validated — the two
+    // can differ (e.g. a scoped package whose manifest declares a shorter name).
+    const stagingName = packageName.replace(/^@.+\//, '').replace(/^mipham-plugin-/, '')
 
-    const destDir = join(this.pluginDir, pluginName)
-    if (existsSync(destDir)) {
+    const stagingDir = join(this.pluginDir, stagingName)
+    if (existsSync(stagingDir)) {
       return {
         success: false,
-        message: `Plugin "${pluginName}" is already installed`,
+        message: `Plugin "${stagingName}" is already installed`,
       }
     }
 
     try {
       // Install the npm package into the plugins directory
-      mkdirSync(destDir, { recursive: true })
+      mkdirSync(stagingDir, { recursive: true })
 
       // Create a minimal package.json so npm install works in a subdirectory
       writeFileSync(
-        join(destDir, 'package.json'),
+        join(stagingDir, 'package.json'),
         JSON.stringify({ private: true }, null, 2),
         'utf-8',
       )
 
-      execSync(`npm install ${packageName} --prefix "${destDir}" --no-save`, {
+      execSync(`npm install ${packageName} --prefix "${stagingDir}" --no-save`, {
         encoding: 'utf-8',
         stdio: 'pipe',
         timeout: 60_000,
       })
 
-      // Validate the installed plugin
-      const validation = validatePlugin(destDir)
+      // npm installs the package into <stagingDir>/node_modules/<packageName>/ —
+      // validate there, then flatten it to the plugin dir root so its layout
+      // matches `install(sourcePath)`.
+      const pkgDir = join(stagingDir, 'node_modules', packageName)
+      const validation = validatePlugin(pkgDir)
       if (!validation.valid) {
         // Clean up on invalid plugin
-        rmSync(destDir, { recursive: true, force: true })
+        rmSync(stagingDir, { recursive: true, force: true })
         return { success: false, message: validation.errors.join('; ') }
       }
 
+      this.copyDir(pkgDir, stagingDir)
+      rmSync(join(stagingDir, 'node_modules'), { recursive: true, force: true })
+
+      // Use the manifest `name` for the final directory + record + message so
+      // they all agree (npm package name is only the staging key).
+      const manifestName = validation.manifest?.name || stagingName
+      let destDir = stagingDir
+      if (manifestName !== stagingName) {
+        destDir = join(this.pluginDir, manifestName)
+        if (existsSync(destDir)) {
+          rmSync(stagingDir, { recursive: true, force: true })
+          return { success: false, message: `Plugin "${manifestName}" is already installed` }
+        }
+        renameSync(stagingDir, destDir)
+      }
+
       this.plugins.push({
-        name: validation.manifest?.name || pluginName,
+        name: manifestName,
         version: validation.manifest?.version || '0.0.0',
         path: destDir,
         enabled: true,
@@ -123,18 +152,18 @@ export class PluginManager {
       })
 
       this.saveState()
-      const similarWarning = this.findSimilarWarning(pluginName)
+      const similarWarning = this.findSimilarWarning(manifestName)
       return {
         success: true,
         message:
-          `Plugin "${pluginName}" installed from npm` +
+          `Plugin "${manifestName}" installed from npm` +
           (similarWarning ? `\n⚠ ${similarWarning}` : ''),
       }
     } catch (err: unknown) {
       const msg = err instanceof Error ? err.message : String(err)
       // Clean up on failure
       try {
-        rmSync(destDir, { recursive: true, force: true })
+        rmSync(stagingDir, { recursive: true, force: true })
       } catch {
         /* ok */
       }

package/src/plugin/plugin-validator.ts

@@ -1,32 +1,67 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 
 export interface PluginManifest {
   name: string
-  version: string
+  version?: string
   miphamVersion?: string
   hooks?: Record<string, unknown>
+  /** Claude manifest fields (commands/agents/skills/mcpServers/…) — read by the Claude loader. */
+  [key: string]: unknown
 }
 
-export function validatePlugin(dir: string): {
+/** Which manifest convention a plugin uses. */
+export type PluginFormat = 'mipham' | 'claude'
+
+export interface PluginValidation {
   valid: boolean
   errors: string[]
   manifest?: PluginManifest
-} {
-  const errors: string[] = []
+  format: PluginFormat
+  /** Resolved manifest path (empty when no manifest found). */
+  manifestPath: string
+}
+
+/**
+ * Resolve a plugin's manifest. Mipham plugins use `plugin.json` at the plugin
+ * root; Claude marketplace plugins use `.claude-plugin/plugin.json`.
+ */
+function resolveManifestPath(dir: string): { path: string; format: PluginFormat } | null {
+  const mipham = join(dir, 'plugin.json')
+  if (existsSync(mipham)) return { path: mipham, format: 'mipham' }
+  const claude = join(dir, '.claude-plugin', 'plugin.json')
+  if (existsSync(claude)) return { path: claude, format: 'claude' }
+  return null
+}
+
+/** Detect a plugin's manifest convention (defaults to Mipham when absent). */
+export function detectPluginFormat(dir: string): PluginFormat {
+  return resolveManifestPath(dir)?.format ?? 'mipham'
+}
 
+export function validatePlugin(dir: string): PluginValidation {
+  const resolved = resolveManifestPath(dir)
+  if (!resolved) {
+    return {
+      valid: false,
+      errors: ['No plugin manifest found (expected plugin.json or .claude-plugin/plugin.json)'],
+      format: 'mipham',
+      manifestPath: '',
+    }
+  }
+
+  const errors: string[] = []
   try {
-    const raw = readFileSync(join(dir, 'plugin.json'), 'utf-8')
+    const raw = readFileSync(resolved.path, 'utf-8')
     const manifest = JSON.parse(raw) as PluginManifest
 
     if (!manifest.name || !/^[a-z0-9-]+$/.test(manifest.name)) {
       errors.push('Invalid plugin name: must be lowercase alphanumeric with hyphens')
     }
-    if (!manifest.version) {
+    // Mipham plugins require a version; Claude plugins only require `name`.
+    if (resolved.format === 'mipham' && !manifest.version) {
       errors.push('Missing required field: version')
     }
-
-    // Check for suspicious hooks
     if (manifest.hooks) {
       const hooksStr = JSON.stringify(manifest.hooks)
       if (hooksStr.includes('rm -rf') || hooksStr.includes('curl') || hooksStr.includes('eval')) {
@@ -34,8 +69,20 @@ export function validatePlugin(dir: string): {
       }
     }
 
-    return { valid: errors.length === 0, errors, manifest }
+    return {
+      valid: errors.length === 0,
+      errors,
+      manifest,
+      format: resolved.format,
+      manifestPath: resolved.path,
+    }
   } catch (err) {
-    return { valid: false, errors: [`Failed to read plugin.json: ${String(err)}`] }
+    const label = resolved.format === 'claude' ? '.claude-plugin/plugin.json' : 'plugin.json'
+    return {
+      valid: false,
+      errors: [`Failed to read ${label}: ${String(err)}`],
+      format: resolved.format,
+      manifestPath: resolved.path,
+    }
   }
 }

package/src/shared/deleted-cwd.ts

@@ -0,0 +1,26 @@
+/**
+ * Detection and messaging for the "current working directory was deleted"
+ * startup failure.
+ *
+ * `process.cwd()` throws `ENOENT` when the directory the process was launched
+ * from no longer exists (e.g. a removed git worktree). The CLI entry checks
+ * this up front and prints a clear, actionable message instead of letting the
+ * error surface as a raw crash dump (matches Claude Code 2.1.239).
+ */
+
+/** True when `err` is the ENOENT thrown by `process.cwd()` on a deleted cwd. */
+export function isDeletedCwdError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false
+  // Node sets `code = 'ENOENT'` with a message ending in `, uv_cwd`. Bun and
+  // other runtimes may omit the code but still name `getcwd`/`uv_cwd`.
+  return (err as NodeJS.ErrnoException).code === 'ENOENT' || /uv_cwd|getcwd/i.test(err.message)
+}
+
+/** Human-readable guidance shown when the launch directory was deleted. */
+export function deletedCwdMessage(): string {
+  return (
+    `Mipham Code can't start: the current working directory no longer exists.\n\n` +
+    `The directory you launched from was deleted (for example, a removed git worktree).\n` +
+    `Change to a valid directory and run \`mipham\` again.`
+  )
+}

package/src/shared/graft-savings.ts

@@ -0,0 +1,34 @@
+/**
+ * Session-scoped accumulator for graft's token savings. Graft tools emit a
+ * "[graft] tokens saved ≈ N" footer on their output; the engine parses that
+ * footer after each tool result and adds it here, so the statusline can show
+ * "~N tok saved" (mirroring graft's own hooks.js `handleToolSavings`).
+ */
+
+/** Sum the "[graft] tokens saved ≈ N" footers in a tool output. */
+export function parseGraftSavings(text: string): number {
+  let total = 0
+  for (const m of text.matchAll(/\[graft\] tokens saved ≈ ([\d,]+)/g)) {
+    const digits = m[1]
+    if (digits) total += Number(digits.replace(/,/g, '')) || 0
+  }
+  return total
+}
+
+let savings = 0
+
+/** Add a tool result's graft savings to the session running total. */
+export function accumulateGraftSavings(text: string): void {
+  if (!text) return
+  savings += parseGraftSavings(text)
+}
+
+/** The session's running graft token savings. */
+export function getGraftSavings(): number {
+  return savings
+}
+
+/** Reset the running total (e.g. on session reset). */
+export function resetGraftSavings(): void {
+  savings = 0
+}

package/src/shared/graft-stats.ts

@@ -0,0 +1,36 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+/** Graft's hook-maintained stats cache (`graft/.cache/stats.json`). */
+export interface GraftStats {
+  nodeCount: number
+  edgeCount: number
+  staleCount: number
+  dirty: boolean
+  syncing: boolean
+  lastFile: string | null
+}
+
+/**
+ * Read graft's stats cache for the given project. Returns null when graft is
+ * not built/installed in `cwd` (no `graft/.cache/stats.json`, or an empty
+ * graph) — callers render nothing in that case.
+ */
+export function readGraftStats(cwd: string): GraftStats | null {
+  const statsPath = join(cwd, 'graft', '.cache', 'stats.json')
+  if (!existsSync(statsPath)) return null
+  try {
+    const raw = JSON.parse(readFileSync(statsPath, 'utf-8')) as Record<string, unknown>
+    if (typeof raw.nodeCount !== 'number' || raw.nodeCount === 0) return null
+    return {
+      nodeCount: raw.nodeCount,
+      edgeCount: typeof raw.edgeCount === 'number' ? raw.edgeCount : 0,
+      staleCount: typeof raw.staleCount === 'number' ? raw.staleCount : 0,
+      dirty: raw.dirty === true,
+      syncing: raw.syncing === true,
+      lastFile: typeof raw.lastFile === 'string' ? raw.lastFile : null,
+    }
+  } catch {
+    return null
+  }
+}

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.55.0' as const
+export const PACKAGE_VERSION = '0.56.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/skills/loader.ts

@@ -82,6 +82,11 @@ export class SkillsLoader implements Skills {
     }
   }
 
+  /** Load a single skill file by path (used by Claude plugins: `skills/<name>/SKILL.md`). */
+  loadSkillFile(path: string, type: 'standard' | 'mipham' = 'standard'): void {
+    this.tryLoad(path, type)
+  }
+
   get(name: string): SkillDefinition | undefined {
     return this.skills.get(name)
   }
@@ -195,40 +200,13 @@ export class SkillsLoader implements Skills {
   }
 
   /**
-   * Recall the skills most relevant to a context (e.g. the session's system
-   * prompt / project context), mirroring MemoryManager.recall's keyword
-   * scoring. Name keywords are a strong signal (+3); description keywords are
-   * weak (+1). Returns up to `limit` skills sorted by relevance.
-   */
-  recall(context: string, limit: number = 5): SkillDefinition[] {
-    const ctxWords = new Set(context.toLowerCase().split(/\s+/))
-    const scored: Array<{ skill: SkillDefinition; score: number }> = []
-
-    for (const skill of this.list()) {
-      if (skill.disableModelInvocation) continue
-      let score = 0
-      for (const word of skill.name.toLowerCase().split(/[-_\s]+/)) {
-        if (word.length > 2 && ctxWords.has(word)) score += 3
-      }
-      for (const word of skill.description.toLowerCase().split(/\s+/)) {
-        if (word.length > 3 && ctxWords.has(word)) score += 1
-      }
-      if (score > 0) scored.push({ skill, score })
-    }
-
-    scored.sort((a, b) => b.score - a.score)
-    return scored.slice(0, limit).map((s) => s.skill)
-  }
-
-  /**
-   * Build the system-reminder block for AI auto-triggering.
-   * With a `context`, only the most relevant skills are injected (selective,
-   * to save tokens); without one, all skills are listed.
+   * Build the system-reminder block listing every skill the AI may invoke via
+   * the Skill tool. A single full listing keeps the whole catalog discoverable:
+   * at session start there is no query to match against, so a keyword "recall"
+   * would silently hide most skills. Capped at `maxTokens` to stay bounded.
    */
-  buildSystemReminder(context?: string, maxTokens: number = 5000): string {
-    const selected = context
-      ? this.recall(context)
-      : this.list().filter((s) => !s.disableModelInvocation)
+  buildSystemReminder(maxTokens: number = 5000): string {
+    const selected = this.list().filter((s) => !s.disableModelInvocation)
 
     if (selected.length === 0) return ''
 

package/src/skills/seam.ts

@@ -6,7 +6,7 @@ export interface Skills {
   get(name: string): SkillDefinition | undefined
   list(): SkillDefinition[]
   has(name: string): boolean
-  buildSystemReminder(context?: string, maxTokens?: number): string
+  buildSystemReminder(maxTokens?: number): string
 }
 
 /** 缝键：ctx.skills。 */

package/src/tools/agent/memory.ts

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import type { ToolDefinition } from '../../shared/index.ts'
+import { MemoryManager } from '../../core/memory/memory-manager'
 
 const MEMORY_DIR = join(homedir(), '.mipham', 'memory')
 
@@ -24,7 +25,7 @@ ${content}
 
 export const memoryTool: ToolDefinition = {
   name: 'Memory',
-  description: 'Read and write persistent memory files in ~/.mipham/memory/.',
+  description: 'Read, write, list, and search persistent memory files in ~/.mipham/memory/.',
   category: 'agent',
   permission: 'auto',
   parameters: {
@@ -32,11 +33,12 @@ export const memoryTool: ToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['read', 'write', 'list'],
+        enum: ['read', 'write', 'list', 'search'],
         description: 'Action to perform',
       },
       name: { type: 'string', description: 'Memory file name (slug)' },
       content: { type: 'string', description: 'Content to write (for write action)' },
+      query: { type: 'string', description: 'Search query (for search action)' },
     },
     required: ['action'],
   },
@@ -49,6 +51,22 @@ export const memoryTool: ToolDefinition = {
       return { success: true, content: files.join('\n') || '(no memories)' }
     }
 
+    // Semantic-less recall (keyword + wikilink + time-decay scoring) — lets the
+    // AI retrieve relevant memories mid-conversation, not only at session start.
+    if (action === 'search') {
+      const query = (params.query as string)?.trim()
+      if (!query) return { success: false, content: '', error: 'query is required' }
+      const mm = new MemoryManager(MEMORY_DIR)
+      mm.loadAll()
+      const results = mm.recall(query, 10)
+      if (results.length === 0) return { success: true, content: '(no matching memories)' }
+      const lines = results.map((entry) => {
+        const snippet = entry.content.replace(/\n+/g, ' ').trim().slice(0, 140)
+        return `- ${entry.name}: ${entry.description || snippet}\n  ${snippet}`
+      })
+      return { success: true, content: lines.join('\n') }
+    }
+
     const name = params.name as string
     if (!name) return { success: false, content: '', error: 'name is required' }
     const filePath = join(MEMORY_DIR, `${name}.md`)

package/src/ui/app.tsx

@@ -22,6 +22,18 @@ import { ChatPanel } from './chat'
 import { InputBar } from './input'
 import { ModelPicker } from './picker'
 import { AgentFooter, type AgentEntry } from './agent-footer'
+import { GraftStatusLine } from './graft-status'
+
+/** Current context-window usage % — undefined when unknown (remote stub). */
+function contextUsagePct(engine: QueryEngine | RemoteEngine): number | undefined {
+  const ctx = engine.getContext() as {
+    getEstimatedTokens(): number
+    getMaxTokens?(): number
+  }
+  const max = ctx.getMaxTokens?.()
+  if (!max || max <= 0) return undefined
+  return Math.round((ctx.getEstimatedTokens() / max) * 100)
+}
 import { AgentViewDashboard } from '../agent-view/dashboard'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import { WorkflowProgress } from './workflow-progress.js'
@@ -965,6 +977,9 @@ export function App({
               agentProgress={agentProgress}
             />
 
+            {/* graft status line — mirrors graft's own "◤ graft · …" bar */}
+            <GraftStatusLine cwd={process.cwd()} ctxPct={contextUsagePct(engine)} />
+
             {/* Status line — Claude Code style */}
             <Box marginTop={1} flexDirection="column">
               <Box flexDirection="row">

package/src/ui/graft-status.tsx

@@ -0,0 +1,59 @@
+import React, { useState } from 'react'
+import { Box, Text } from 'ink'
+import { basename } from 'node:path'
+import { readGraftStats, type GraftStats } from '../shared/graft-stats'
+import { getGraftSavings } from '../shared/graft-savings'
+
+/** Freshness segment mirroring graft's own statusline (see @nanonets/graft format.js). */
+function freshnessSegment(stats: GraftStats): { label: string; color: string } {
+  if (stats.syncing) return { label: 'syncing…', color: 'yellow' }
+  if (stats.dirty && stats.staleCount > 0)
+    return { label: `⚠ ${stats.staleCount} stale`, color: 'yellow' }
+  if (stats.dirty) return { label: '⚠ stale', color: 'yellow' }
+  return { label: '✓ synced', color: 'blue' }
+}
+
+/**
+ * Bottom-of-screen graft status line — mirrors graft's own "◤ graft · …" bar:
+ *   ◤ graft · N nodes / E edges · ✓ synced · ~T tok saved
+ *   ▸ ctx X% · last: file
+ * Reads `graft/.cache/stats.json` once at mount; the session's tok-saved total
+ * is read live each render (the app re-renders on the agent tick). Returns
+ * null (renders nothing) when graft isn't built here.
+ */
+export function GraftStatusLine({ cwd, ctxPct }: { cwd: string; ctxPct?: number }) {
+  const [stats] = useState(() => readGraftStats(cwd))
+  if (!stats) return null
+  const fresh = freshnessSegment(stats)
+  const saved = getGraftSavings()
+  const lastFile = stats.lastFile ? basename(stats.lastFile) : null
+
+  const bottom: string[] = []
+  if (typeof ctxPct === 'number') bottom.push(`ctx ${ctxPct}%`)
+  if (lastFile) bottom.push(`last: ${lastFile}`)
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text dimColor>◤ </Text>
+        <Text color="blue">graft</Text>
+        <Text dimColor>
+          {' '}
+          · {stats.nodeCount} nodes / {stats.edgeCount} edges ·{' '}
+        </Text>
+        <Text color={fresh.color}>{fresh.label}</Text>
+        {saved > 0 && (
+          <>
+            <Text dimColor> · </Text>
+            <Text color="blue">~{saved.toLocaleString()} tok saved</Text>
+          </>
+        )}
+      </Box>
+      {bottom.length > 0 && (
+        <Box>
+          <Text dimColor>▸ {bottom.join(' · ')}</Text>
+        </Box>
+      )}
+    </Box>
+  )
+}