@miphamai/cli 0.55.0 → 0.57.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.57.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/commands/project.ts

@@ -115,17 +115,20 @@ Mode:       ${ctx.config.permission}
 Messages:   ${msgs.length} in context
 Tools:      ${ctx.engine.getTools().size} available
 
-Permission levels:
-  auto    — run tools automatically without asking
-  ask     — prompt before each tool execution (default)
-  bypass  — skip all permission checks (use with caution)
+Switch mode with Shift+Tab. Modes (least → most permissive):
+  default            — per-tool defaults (Bash/Write/Edit ask first)
+  acceptEdits        — reads + edits free; Bash auto-runs read/check commands
+  plan               — reads only (Read/Grep/Glob); nothing writes or runs
+  auto               — run everything without asking (hooks are the safety gate)
+  dontAsk            — only allowlisted tools free; everything else asks
+  bypassPermissions  — skip ALL permission checks (⚠️ use with caution)
 
-Change with /config permission <level>.
+To let Bash run without asking: press Shift+Tab until the status line shows
+"acceptEdits" (or "auto"), then send your message again.
 
 Current directory permissions:
   CWD:      ${process.cwd()}
 
-To add a directory: use /add-dir (coming soon).
 Tool execution is sandboxed to the project directory by default.`,
   }
 }

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'
@@ -763,7 +764,9 @@ export class QueryEngine {
   }
 
   private async *continueWithTools(signal?: AbortSignal): AsyncGenerator<StreamChunk> {
-    const MAX_TURNS = 20
+    // Tool-calling round cap. 20 was too low for real multi-step tasks — the model
+    // hit "max turns" and dropped pending tools mid-task. 100 stays bounded.
+    const MAX_TURNS = 100
     const toolDefs = this.getToolDefinitions()
 
     for (let turn = 0; turn < MAX_TURNS; turn++) {
@@ -1127,6 +1130,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/i18n-core/locales/en-US.json

@@ -804,8 +804,7 @@
     "assistant": { "role_label": "Mipham Code" },
     "user": { "role_label": "User" },
     "input": {
-      "placeholder": "Type a message (Esc to cancel)...",
-      "vim_help": "[NORMAL] h/j/k/l w/b 0/$ dd yy p u / (Esc to insert)"
+      "placeholder": "Type a message (Esc to clear)..."
     },
     "slash_hints": {
       "label": "Commands:",
@@ -942,7 +941,7 @@
     "mcp": { "name": "MCP", "description": "Manage MCP server connections" }
   },
   "errors": {
-    "tool_not_allowed": "Tool \"{name}\" requires user approval (permission: ask). The tool was not executed.",
+    "tool_not_allowed": "Tool \"{name}\" requires user approval (permission: ask). The tool was not executed. Press Shift+Tab to switch permission mode, or run /permissions.",
     "tool_blocked": "Tool \"{name}\" blocked by hook",
     "user_input_blocked": "User input blocked by hook.",
     "dlp_blocked": "Request blocked by DLP policy.",

package/src/i18n-core/locales/zh-CN.json

@@ -804,8 +804,7 @@
     "assistant": { "role_label": "Mipham Code" },
     "user": { "role_label": "用户" },
     "input": {
-      "placeholder": "输入消息（Esc 取消）...",
-      "vim_help": "[NORMAL] h/j/k/l w/b 0/$ dd yy p u /（Esc 插入）"
+      "placeholder": "输入消息（Esc 清空）..."
     },
     "slash_hints": {
       "label": "命令：",
@@ -942,7 +941,7 @@
     "mcp": { "name": "MCP", "description": "管理 MCP 服务器连接" }
   },
   "errors": {
-    "tool_not_allowed": "工具 \"{name}\" 需要用户批准（权限：ask），未执行。",
+    "tool_not_allowed": "工具 \"{name}\" 需要用户批准（权限：ask），未执行。按 Shift+Tab 切换权限模式，或运行 /permissions。",
     "tool_blocked": "工具 \"{name}\" 被钩子拦截",
     "user_input_blocked": "用户输入被钩子拦截。",
     "dlp_blocked": "请求被 DLP 策略阻止。",

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/security/gate.ts

@@ -28,8 +28,9 @@ const PROMPT_INJECTION_PATTERNS: Array<{ regex: RegExp; label: string }> = [
 ]
 
 const DANGEROUS_BASH_PATTERNS: Array<{ regex: RegExp; label: string }> = [
-  { regex: /\$\(.+\)/, label: 'command-substitution' },
-  { regex: /`[^`]+`/, label: 'backtick-substitution' },
+  // NOTE: command substitution ($( … ) / `…`) is legitimate Bash syntax and is NOT
+  // blocked here — its dangerous content (a pipe to sh/bash, a chained rm/cat/sh,
+  // …) is still caught by the pipe/chain patterns below.
   { regex: /;\s*(rm|cat|sh|bash)\b/, label: 'command-chain-injection' },
   { regex: /curl.+\|\s*(sh|bash)\b/, label: 'curl-pipe-shell' },
   { regex: /\|\s*(sh|bash)\b/, label: 'pipe-to-shell' },

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