@miphamai/cli 0.54.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.54.0",
+  "version": "0.56.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/agent-registry.ts

@@ -10,9 +10,12 @@ interface FrontmatterResult {
 }
 
 function parseFrontmatter(raw: string): FrontmatterResult {
-  const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/)
+  // Strip a leading UTF-8 BOM — otherwise `^---` never matches and a
+  // BOM-prefixed file is silently treated as body text (effectively ignored).
+  const src = raw.replace(/^\uFEFF/, '')
+  const match = src.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/)
   if (!match) {
-    return { data: {}, content: raw }
+    return { data: {}, content: src }
   }
   return {
     data: parseYaml(match[1] || '') as Record<string, unknown>,

package/src/agent/cross-session/discovery.ts

@@ -9,7 +9,7 @@ import {
 } from 'node:fs'
 import { join, basename } from 'node:path'
 import { homedir, hostname } from 'node:os'
-import type { SessionInfo } from '../../shared/types'
+import type { SessionInfo, CrossSessionInbound } from '../../shared/types'
 
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const ACTIVE_SESSIONS_DIR = join(MIPHAM_HOME, '.active-sessions')
@@ -97,6 +97,7 @@ export function createSessionInfo(
   cwd?: string,
   provider?: string,
   model?: string,
+  crossSessionInbound?: CrossSessionInbound,
 ): SessionInfo {
   return {
     id: sessionId,
@@ -107,6 +108,7 @@ export function createSessionInfo(
     cwd,
     provider,
     model,
+    crossSessionInbound,
   }
 }
 

package/src/agent/message-router.ts

@@ -90,6 +90,16 @@ export class MessageRouter {
     }
     const targetSession = resolution.session!
 
+    // Recipient refuses inbound messages — report "refused" instead of a silent
+    // success so the sender knows the message was not delivered.
+    if (targetSession.crossSessionInbound === 'deny') {
+      return {
+        success: false,
+        routedTo: 'inbox',
+        error: `Session "${targetSession.name}" refuses inbound messages.`,
+      }
+    }
+
     // Get sender info — resolve the human-readable name when the sender is a
     // registered session, else fall back to the raw id (e.g. non-session senders).
     const senderName = discoverSessions().find((s) => s.id === from)?.name ?? from

package/src/commands/project.ts

@@ -7,6 +7,7 @@
  */
 import type { CommandHandler, CommandContext, CommandResult } from '../ui/commands.js'
 import { getWorkspaceTrust } from '../core/workspace-trust'
+import { atomicWriteFileSync } from '../shared/atomic-write'
 
 export {
   initCmd,
@@ -20,7 +21,7 @@ export {
 }
 
 const initCmd: CommandHandler = async (ctx) => {
-  const { existsSync, mkdirSync, writeFileSync } = await import('node:fs')
+  const { existsSync, mkdirSync } = await import('node:fs')
   const { join } = await import('node:path')
   const { homedir } = await import('node:os')
 
@@ -78,7 +79,7 @@ providers:
 ${providerYaml}
 `
 
-    writeFileSync(userConfigPath, configContent, 'utf-8')
+    atomicWriteFileSync(userConfigPath, configContent)
     return {
       content: `✅ Mipham Code initialized!
 
@@ -434,7 +435,7 @@ permission: ask
 providers:
 ${providerYaml}
 `
-    writeFileSync(configPath, defaultConfig, 'utf-8')
+    atomicWriteFileSync(configPath, defaultConfig)
     created.push('.mipham/config.yml')
   } else {
     skipped.push('.mipham/config.yml (already exists)')

package/src/config/loader.ts

@@ -6,11 +6,11 @@ import {
   readdirSync,
   unlinkSync,
   chmodSync,
-  writeFileSync,
 } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml'
+import { atomicWriteFileSync } from '../shared/atomic-write'
 import type {
   MiphamConfig,
   ProviderConfig,
@@ -533,7 +533,7 @@ export function saveProviderApiKey(providerId: string, apiKey: string): boolean
     doc.providers = providers
 
     // Write back
-    writeFileSync(configPath, stringifyYaml(doc), { encoding: 'utf-8', mode: 0o600 })
+    atomicWriteFileSync(configPath, stringifyYaml(doc), { mode: 0o600 })
     return true
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err)

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/core/instructions.ts

@@ -10,9 +10,12 @@ interface FrontmatterResult {
 }
 
 function parseFrontmatter(raw: string): FrontmatterResult {
-  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  // Strip a leading UTF-8 BOM — otherwise `^---` never matches and a
+  // BOM-prefixed file is silently treated as body text (effectively ignored).
+  const src = raw.replace(/^\uFEFF/, '')
+  const match = src.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
   if (!match) {
-    return { data: {}, content: raw }
+    return { data: {}, content: src }
   }
   return {
     data: parseYaml(match[1] || '') as Record<string, unknown>,
@@ -101,6 +104,16 @@ export class InstructionsLoader {
       parts.push(this.buildPermissionContext(permissionMode))
     }
 
+    // 开场克制：寒暄只回一句短问候，不上能力清单（避免把「你好」当「你是谁」处理）
+    parts.push(`## Greeting Restraint
+
+When the user's message is only a greeting or small talk ("hello", "hi",
+"你好", "您好", "在吗", "早上好"), reply with ONE brief, warm line —
+e.g. "你好，我是 Mipham，有什么可以帮你的？" Do NOT introduce yourself,
+list your capabilities/tools/MCP servers, or enumerate what you can do.
+Only describe your capabilities when the user explicitly asks ("你是谁",
+"你能做什么", "what can you do", "introduce yourself").`)
+
     // Inject critical thinking self-check layer (for analysis/comparison tasks)
     parts.push(`## Critical Thinking Self-Check
 

package/src/index.tsx

@@ -28,7 +28,7 @@ import { QueryEngine } from './core/engine'
 import { ExperienceRuleEngine } from './core/rule-engine.js'
 import { SessionLog } from './core/session-log'
 import { SessionStore } from './core/session-store'
-import type { PermissionLevel, MiphamConfig } from './shared/types'
+import type { PermissionLevel, MiphamConfig, McpServerConfig } from './shared/types'
 import { SkillsLoader } from './skills/loader'
 import { PluginManager } from './plugin/plugin-manager'
 import { loadPlugins } from './plugin/plugin-loader'
@@ -194,6 +194,38 @@ function SetupGate(props: SetupGateProps) {
   })
 }
 
+/**
+ * Connect all MCP servers in parallel and register their tools into the shared
+ * registry. Runs lazily in the background so a slow or dead server (e.g. a 15s
+ * connect timeout) never blocks first paint. Failures are non-fatal.
+ */
+async function connectMcpServers(
+  mcpServers: McpServerConfig[],
+  tools: ReturnType<typeof createToolRegistry>,
+): Promise<void> {
+  if (mcpServers.length === 0) return
+  const mcp = McpClient.getInstance()
+  // Wire runtime tool-list changes before connect so mid-connect updates land.
+  syncMcpToolsOnChange(mcp, tools)
+  const results = await Promise.allSettled(
+    mcpServers.map(async (server) => {
+      await mcp.connect(server)
+      const count = registerMcpServerTools(server.name, tools)
+      if (count > 0) {
+        process.stderr.write(`[mcp] "${server.name}": registered ${count} tools\n`)
+      }
+    }),
+  )
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i]!
+    if (result.status === 'rejected') {
+      process.stderr.write(
+        `[mcp] Failed to connect "${mcpServers[i]!.name}": ${String(result.reason)}\n`,
+      )
+    }
+  }
+}
+
 export async function runApp(options: RunOptions): Promise<void> {
   // Metrics: count CLI invocation + active session
   getMetrics().cliInvocations.inc()
@@ -364,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
@@ -455,33 +487,10 @@ export async function runApp(options: RunOptions): Promise<void> {
   mountSkills(vajraContext, skillsLoader)
   mountLlm(vajraContext, registry)
 
-  // Connect MCP servers and register their tools into the tool registry.
-  // Uses Promise.allSettled for parallel connection — failures are non-fatal.
-  const mcpServers = config.skills?.mcpServers ?? []
-  if (mcpServers.length > 0) {
-    const mcp = McpClient.getInstance()
-    const results = await Promise.allSettled(
-      mcpServers.map(async (server) => {
-        await mcp.connect(server)
-        const count = registerMcpServerTools(server.name, tools)
-        if (count > 0) {
-          process.stderr.write(`[mcp] "${server.name}": registered ${count} tools\n`)
-        }
-      }),
-    )
-    // Log failures (non-fatal — app starts without that server's tools)
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i]!
-      if (result.status === 'rejected') {
-        process.stderr.write(
-          `[mcp] Failed to connect "${mcpServers[i]!.name}": ${String(result.reason)}\n`,
-        )
-      }
-    }
-  }
-
-  // Wire runtime MCP tool changes (tools/list_changed) into the central registry.
-  syncMcpToolsOnChange(McpClient.getInstance(), tools)
+  // Connect MCP servers lazily in the background: the UI renders immediately,
+  // and each server's tools register into the shared registry as it connects.
+  // A dead server (e.g. a 15s connect timeout) no longer blocks startup.
+  void connectMcpServers(config.skills?.mcpServers ?? [], tools)
 
   // Initialize hook engine — register skill-defined hooks
   const hookEngine = new HookEngine()
@@ -549,12 +558,20 @@ export async function runApp(options: RunOptions): Promise<void> {
   // so `@mipham-code` can address this session; uniqueness is enforced against
   // other live sessions (suffix -2, -3, …). The id stays a stable `session-<ts>`.
   const defaultName = basename(process.cwd()) || 'session'
+
+  // Load cross-session config first so the registered SessionInfo carries this
+  // session's inbound policy — senders discover it and report "refused" instead
+  // of a silent drop when policy is 'deny'.
+  const crossSessionConfig = loadCrossSessionConfig(process.cwd())
+  engine.setCrossSessionConfig(crossSessionConfig)
+
   const sessionInfo = createSessionInfo(
     sessionName,
     ensureUniqueSessionName(defaultName, discoverSessions()),
     process.cwd(),
     defaultProvider,
     defaultModel,
+    crossSessionConfig.crossSessionInbound,
   )
   registerActiveSession(sessionInfo)
 
@@ -568,10 +585,6 @@ export async function runApp(options: RunOptions): Promise<void> {
     heartbeatInterval.unref()
   }
 
-  // Load cross-session config and wire into the engine's inbound policy
-  const crossSessionConfig = loadCrossSessionConfig(process.cwd())
-  engine.setCrossSessionConfig(crossSessionConfig)
-
   // P2-1: Trigger SessionStart hooks after full initialization
   hookEngine.executeSessionStart(sessionName).catch(() => {
     // Hook failures never block session startup

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/atomic-write.ts

@@ -0,0 +1,17 @@
+import { writeFileSync, renameSync } from 'node:fs'
+
+/**
+ * Write a file atomically: write to a same-directory `.tmp` file, then rename
+ * over the target. Same-filesystem rename is atomic, so a crash or kill
+ * mid-write can never leave a truncated/corrupt file — readers see either the
+ * old or the new content, never a partial write.
+ */
+export function atomicWriteFileSync(
+  path: string,
+  content: string,
+  options: { mode?: number } = {},
+): void {
+  const tmp = path + '.tmp'
+  writeFileSync(tmp, content, { encoding: 'utf-8', mode: options.mode ?? 0o600 })
+  renameSync(tmp, 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.54.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/shared/types.ts

@@ -430,6 +430,7 @@ export interface SessionInfo {
   cwd?: string
   provider?: string
   model?: string
+  crossSessionInbound?: CrossSessionInbound
 }
 
 // ── Background Agent Types ──

package/src/skills/loader.ts

@@ -13,9 +13,12 @@ interface FrontmatterResult {
 }
 
 function parseFrontmatter(raw: string): FrontmatterResult {
-  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  // Strip a leading UTF-8 BOM — otherwise `^---` never matches and a
+  // BOM-prefixed file is silently treated as body text (effectively ignored).
+  const src = raw.replace(/^\uFEFF/, '')
+  const match = src.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
   if (!match) {
-    return { data: {}, content: raw }
+    return { data: {}, content: src }
   }
   return {
     data: parseYaml(match[1] || '') as Record<string, unknown>,
@@ -79,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)
   }
@@ -192,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/config-wizard.tsx

@@ -14,7 +14,8 @@ import { useI18n } from '../i18n-context'
 import TextInput from 'ink-text-input'
 import { DEFAULT_PROVIDERS, OLLAMA_PRESET_MODELS } from '../shared/constants'
 import type { ModelInfo } from '../shared/types'
-import { mkdirSync, writeFileSync } from 'node:fs'
+import { mkdirSync } from 'node:fs'
+import { atomicWriteFileSync } from '../shared/atomic-write'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { execSync } from 'node:child_process'
@@ -115,7 +116,7 @@ function writeConfigFile(providerId: string, modelId: string, apiKey: string): v
     ...models.map((m) => `      - id: ${m.id}`),
   ]
 
-  writeFileSync(join(configDir, 'config.yml'), lines.join('\n'), 'utf-8')
+  atomicWriteFileSync(join(configDir, 'config.yml'), lines.join('\n'))
 }
 
 function checkOllama(): { installed: boolean; running: boolean; models: string[] } {

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>
+  )
+}

package/src/core/output-styles.ts

@@ -1,95 +0,0 @@
-/**
- * OutputStylesLoader — loads custom response persona styles from .mipham/output-styles/.
- *
- * Each .md file in the directory is a named style. The active style's content
- * is injected into the system prompt to shape the AI's tone and communication style.
- *
- * Usage:
- *   const loader = new OutputStylesLoader(cwd)
- *   loader.list()               // ['concise', 'academic', ...]
- *   loader.get('concise')       // style content or undefined
- *   loader.setActive('concise') // switch active style
- *   loader.getActiveContent()   // active style content (for system prompt)
- */
-
-import { readdirSync, readFileSync, existsSync } from 'node:fs'
-import { join, basename, extname } from 'node:path'
-
-export class OutputStylesLoader {
-  private stylesDir: string
-  private activeStyle: string | null = null
-
-  constructor(cwd: string) {
-    this.stylesDir = join(cwd, '.mipham', 'output-styles')
-  }
-
-  /**
-   * List all available style names (filename without .md extension).
-   */
-  list(): string[] {
-    if (!existsSync(this.stylesDir)) return []
-    try {
-      return readdirSync(this.stylesDir)
-        .filter((f) => f.endsWith('.md'))
-        .map((f) => basename(f, extname(f)))
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Get the content of a named style. Returns undefined if not found.
-   */
-  get(name: string): string | undefined {
-    if (!existsSync(this.stylesDir)) return undefined
-    const filepath = join(this.stylesDir, `${name}.md`)
-    if (!existsSync(filepath)) return undefined
-    try {
-      return readFileSync(filepath, 'utf-8').trim()
-    } catch {
-      return undefined
-    }
-  }
-
-  /**
-   * Set the active output style.
-   */
-  setActive(name: string): boolean {
-    const content = this.get(name)
-    if (!content) return false
-    this.activeStyle = name
-    return true
-  }
-
-  /**
-   * Clear the active output style (revert to default personality).
-   */
-  clearActive(): void {
-    this.activeStyle = null
-  }
-
-  /**
-   * Get the active style name (null if none selected).
-   */
-  getActiveName(): string | null {
-    return this.activeStyle
-  }
-
-  /**
-   * Get the active style content for system prompt injection.
-   * Returns empty string if no style is active.
-   */
-  getActiveContent(): string {
-    if (!this.activeStyle) return ''
-    const content = this.get(this.activeStyle)
-    if (!content) return ''
-    return [
-      `[Output Style: ${this.activeStyle}]`,
-      'Adopt the following communication style in all your responses:',
-      '',
-      content,
-      '',
-      '---',
-    ].join('\n')
-  }
-}