@miphamai/cli 0.51.0 → 0.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -45,7 +45,6 @@
     "commander": "^13.1.0",
     "ink": "^5.2.1",
     "ink-text-input": "^6.0.0",
-    "js-tiktoken": "^1.0.21",
     "react": "^18.3.1",
     "react-devtools-core": "^4.28.5",
     "yaml": "^2.9.0"

package/src/commands/keys.ts

@@ -1,5 +1,6 @@
 import type { CommandHandler } from '../ui/commands'
 import { KeyManager } from '../config/keys-manager'
+import { getProviderApiKey } from '../config/loader'
 
 export const keysCmd: CommandHandler = async (_ctx, args) => {
   const manager = new KeyManager()
@@ -58,6 +59,31 @@ export const keysCmd: CommandHandler = async (_ctx, args) => {
     return { content: lines.join('\n') }
   }
 
+  // /keys view <provider> — show the plaintext API key (decrypting if stored encrypted)
+  if (sub === 'view' || sub === 'show') {
+    const provider = args[1]
+    if (!provider) {
+      return { content: 'Usage: /keys view <provider>\n\nExample: /keys view deepseek' }
+    }
+    const key = getProviderApiKey(provider)
+    if (key === null) {
+      return {
+        content: `No API key found for provider "${provider}".\n\nIf it was stored encrypted, it may be unreadable (missing/corrupt credential key).`,
+      }
+    }
+    return {
+      content: [
+        '── Key View ──',
+        '',
+        `Provider: ${provider}`,
+        `API Key:  ${key}`,
+        '',
+        '⚠️  This is your plaintext API key. Do not share it or paste it anywhere.',
+        '    Rotate it at any time with /keys rotate <provider>.',
+      ].join('\n'),
+    }
+  }
+
   // /keys (list)
   const keys = manager.list()
 

package/src/config/credential-crypto.ts

@@ -0,0 +1,114 @@
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  chmodSync,
+  copyFileSync,
+} from 'node:fs'
+import { dirname, join } from 'node:path'
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
+
+/**
+ * Shared AES-256-GCM primitives for encrypting credentials at rest.
+ *
+ * Extracted from the MCP token store so config.yml API keys get the exact
+ * same at-rest protection (parent/subsidiary CLAUDE.md mandate "存储层
+ * AES-256-GCM"). The wire format `iv || authTag || ciphertext` (base64) is
+ * preserved verbatim from the original token-store implementation so existing
+ * `~/.mipham/mcp-tokens/*.enc` files remain decryptable.
+ */
+
+const ALGORITHM = 'aes-256-gcm'
+const IV_LENGTH = 16
+const AUTH_TAG_LENGTH = 16
+const KEY_LENGTH = 32
+
+/** Prefix marking an encrypted API key value in config.yml. */
+export const ENC_PREFIX = 'enc:v1:'
+
+/** Shared master-credential key file (used by both MCP tokens and config.yml). */
+const CREDENTIAL_KEY_FILENAME = '.cred-key'
+/** Pre-shared-key filename; migrated to {@link CREDENTIAL_KEY_FILENAME} on first use. */
+const LEGACY_KEY_FILENAME = '.mcp-key'
+
+/**
+ * Load the shared credential key from `keyDir`, migrating the legacy
+ * MCP-only `.mcp-key` to the shared `.cred-key` so existing encrypted MCP
+ * tokens stay decryptable. Falls back to creating a fresh key when neither
+ * exists.
+ */
+export function getCredentialKey(keyDir: string): Buffer {
+  const keyPath = join(keyDir, CREDENTIAL_KEY_FILENAME)
+  if (!existsSync(keyPath)) {
+    const legacyPath = join(keyDir, LEGACY_KEY_FILENAME)
+    if (existsSync(legacyPath)) {
+      copyFileSync(legacyPath, keyPath)
+      chmodSync(keyPath, 0o400)
+    }
+  }
+  return getOrCreateKey(keyPath)
+}
+
+/**
+ * Load the 32-byte encryption key from `keyPath`, creating a fresh random key
+ * (with owner-only read permissions) on first use.
+ */
+export function getOrCreateKey(keyPath: string): Buffer {
+  if (existsSync(keyPath)) {
+    return readFileSync(keyPath)
+  }
+  const key = randomBytes(KEY_LENGTH)
+  mkdirSync(dirname(keyPath), { recursive: true })
+  writeFileSync(keyPath, key)
+  chmodSync(keyPath, 0o400)
+  return key
+}
+
+/** Encrypt plaintext with AES-256-GCM. Returns `base64(iv || authTag || ciphertext)`. */
+export function encrypt(plaintext: string, key: Buffer): string {
+  const iv = randomBytes(IV_LENGTH)
+  const cipher = createCipheriv(ALGORITHM, key, iv)
+  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf-8'), cipher.final()])
+  const authTag = cipher.getAuthTag()
+  return Buffer.concat([iv, authTag, encrypted]).toString('base64')
+}
+
+/** Decrypt a value produced by {@link encrypt}. Throws on wrong key / corrupt data. */
+export function decrypt(ciphertext: string, key: Buffer): string {
+  const buf = Buffer.from(ciphertext, 'base64')
+  const iv = buf.subarray(0, IV_LENGTH)
+  const authTag = buf.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH)
+  const encrypted = buf.subarray(IV_LENGTH + AUTH_TAG_LENGTH)
+  const decipher = createDecipheriv(ALGORITHM, key, iv)
+  decipher.setAuthTag(authTag)
+  return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf-8')
+}
+
+/**
+ * True when `value` is an environment-variable template rather than a literal
+ * secret — both `${VAR}` and `$VAR` forms (the provider resolvers accept both).
+ */
+export function isEnvTemplate(value: string): boolean {
+  return /^\$\{.*\}$/.test(value) || /^\$[A-Z_][A-Z0-9_]*$/.test(value)
+}
+
+/**
+ * Encrypt an API key for storage. Environment-variable templates and empty
+ * values are not secrets, so they pass through unchanged (keeping config.yml
+ * readable for env-based setups). Literal secrets get the `enc:v1:` prefix.
+ */
+export function encryptApiKey(apiKey: string, key: Buffer): string {
+  if (!apiKey || isEnvTemplate(apiKey)) return apiKey
+  return ENC_PREFIX + encrypt(apiKey, key)
+}
+
+/**
+ * Decrypt a stored API key. Plaintext (legacy or template) values pass through
+ * unchanged; `enc:v1:` values are decrypted. Throws on a missing/corrupt key so
+ * the caller can surface a clear error instead of sending a garbage key.
+ */
+export function decryptApiKey(stored: string, key: Buffer): string {
+  if (!stored.startsWith(ENC_PREFIX)) return stored
+  return decrypt(stored.slice(ENC_PREFIX.length), key)
+}

package/src/config/defaults.ts

@@ -28,7 +28,7 @@ export const DEFAULT_CONFIG: MiphamConfig = {
   },
   features: {
     mcp: { oauthEnabled: true },
-    context: { useRealTokenizer: true, adaptiveThresholds: true },
+    context: { adaptiveThresholds: true },
   },
   crsi: {
     ruleInjection: true,

package/src/config/loader.ts

@@ -27,6 +27,7 @@ import {
   DEFAULT_BACKGROUND_AGENT_CONFIG,
   DEFAULT_CROSS_SESSION_CONFIG,
 } from './defaults'
+import { getCredentialKey, encryptApiKey, decryptApiKey, ENC_PREFIX } from './credential-crypto'
 
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const BACKUP_PREFIX = 'config.backup-'
@@ -294,6 +295,9 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
     backupConfig(userConfigPath)
   }
 
+  // ── Decrypt API keys at rest (enc:v1:) back to plaintext ──
+  decryptProviderApiKeys(config.providers)
+
   return config
 }
 
@@ -438,6 +442,58 @@ export function loadCrossSessionConfig(cwd: string = process.cwd()): CrossSessio
   return merged
 }
 
+/**
+ * Decrypt any encrypted (`enc:v1:`) provider API keys in place, after config
+ * merge. Plaintext (legacy / env-template) values pass through untouched. On
+ * decrypt failure (missing/corrupt credential key) the key is cleared and a
+ * warning is written, so the provider surfaces "apiKey not set" rather than
+ * sending a garbage value.
+ */
+function decryptProviderApiKeys(providers: ProviderConfig[] | undefined): void {
+  if (!providers) return
+  const needsKey = providers.some((p) => p.apiKey.startsWith(ENC_PREFIX))
+  if (!needsKey) return
+  const key = getCredentialKey(MIPHAM_HOME)
+  for (const p of providers) {
+    if (!p.apiKey.startsWith(ENC_PREFIX)) continue
+    try {
+      p.apiKey = decryptApiKey(p.apiKey, key)
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err)
+      process.stderr.write(
+        `⚠ Mipham Code: failed to decrypt API key for "${p.id}" (credential key missing/corrupt?): ${msg}\n`,
+      )
+      p.apiKey = ''
+    }
+  }
+}
+
+/**
+ * Read a single provider's API key from config.yml, decrypting it if stored
+ * encrypted. Returns null when the provider has no key or the key can't be
+ * decrypted. Used by `/keys view` to show the plaintext key on request.
+ */
+export function getProviderApiKey(providerId: string, cwd: string = process.cwd()): string | null {
+  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
+  const projectConfigPath = join(cwd, '.mipham', 'config.yml')
+  const configPath = existsSync(userConfigPath) ? userConfigPath : projectConfigPath
+
+  try {
+    if (!existsSync(configPath)) return null
+    const raw = readFileSync(configPath, 'utf-8')
+    const doc = (parseYaml(raw) as Record<string, unknown>) || {}
+    const providers = (doc.providers as Array<Record<string, unknown>>) || []
+    const p = providers.find((x) => x.id === providerId)
+    if (!p || typeof p.apiKey !== 'string') return null
+    if (!p.apiKey.startsWith(ENC_PREFIX)) return p.apiKey
+    return decryptApiKey(p.apiKey, getCredentialKey(MIPHAM_HOME))
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err)
+    process.stderr.write(`⚠ Mipham Code: failed to read API key for "${providerId}": ${msg}\n`)
+    return null
+  }
+}
+
 /**
  * Persist an API key for a single provider to the user-level config.yml.
  * Reads the existing YAML, updates/replaces the provider's apiKey field,
@@ -445,16 +501,10 @@ export function loadCrossSessionConfig(cwd: string = process.cwd()): CrossSessio
  *
  * Returns true on success, false on failure.
  */
-export function saveProviderApiKey(
-  providerId: string,
-  apiKey: string,
-  cwd: string = process.cwd(),
-): boolean {
-  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
-  const projectConfigPath = join(cwd, '.mipham', 'config.yml')
-
-  // Prefer user-level config; fall back to project-level if no user config exists.
-  const configPath = existsSync(userConfigPath) ? userConfigPath : projectConfigPath
+export function saveProviderApiKey(providerId: string, apiKey: string): boolean {
+  // API keys are user-level secrets — always persist to the user config, never
+  // the project config (which lives in the repo and could be committed).
+  const configPath = join(MIPHAM_HOME, 'config.yml')
 
   try {
     mkdirSync(MIPHAM_HOME, { recursive: true, mode: 0o700 })
@@ -464,19 +514,20 @@ export function saveProviderApiKey(
     if (existsSync(configPath)) {
       const raw = readFileSync(configPath, 'utf-8')
       doc = (parseYaml(raw) as Record<string, unknown>) || {}
-    } else if (configPath === projectConfigPath) {
-      mkdirSync(join(cwd, '.mipham'), { recursive: true })
     }
 
     // Find and update the provider in the providers array
     const providers = (doc.providers as Array<Record<string, unknown>>) || []
     const idx = providers.findIndex((p) => p.id === providerId)
 
+    // Encrypt literal keys at rest (env-variable templates pass through).
+    const storedKey = encryptApiKey(apiKey, getCredentialKey(MIPHAM_HOME))
+
     if (idx >= 0) {
-      providers[idx] = { ...providers[idx], apiKey }
+      providers[idx] = { ...providers[idx], apiKey: storedKey }
     } else {
       // Provider not in config — append it
-      providers.push({ id: providerId, apiKey })
+      providers.push({ id: providerId, apiKey: storedKey })
     }
 
     doc.providers = providers

package/src/core/instructions.ts

@@ -20,9 +20,37 @@ function parseFrontmatter(raw: string): FrontmatterResult {
   }
 }
 
+/** Strip the named sections (by heading title) from a markdown document. */
+export function stripSections(content: string, excluded: string[]): string {
+  if (excluded.length === 0) return content
+  const lines = content.split('\n')
+  const out: string[] = []
+  let skipLevel = 0
+  for (const line of lines) {
+    const m = line.match(/^(#{1,3})\s+(.+?)\s*$/)
+    if (m) {
+      const level = m[1]!.length
+      const title = m[2]!.trim()
+      if (excluded.includes(title)) {
+        skipLevel = level
+      } else if (skipLevel > 0 && level <= skipLevel) {
+        skipLevel = 0
+      }
+    }
+    if (skipLevel === 0) out.push(line)
+  }
+  return out.join('\n')
+}
+
+/** Normalize a `prompt-exclude` frontmatter value (YAML list or single string). */
+export function parsePromptExclude(value: unknown): string[] {
+  if (Array.isArray(value)) return value.map((v) => String(v))
+  if (typeof value === 'string') return [value]
+  return []
+}
+
 export class InstructionsLoader {
   private instructions: InstructionFile[] = []
-  private skillsReminder = ''
 
   loadAll(cwd: string): void {
     this.instructions = []
@@ -59,7 +87,13 @@ export class InstructionsLoader {
         directory: 'Directory Rules',
         user: 'User Preferences',
       }
-      parts.push(`<!-- ${levelLabel[inst.level] || inst.level} (${inst.path}) -->\n${inst.content}`)
+      // Strip doc-only sections declared via `prompt-exclude` frontmatter
+      // (changelog/roadmap/catalog are human-facing, not machine rules).
+      const content = stripSections(
+        inst.content,
+        parsePromptExclude(inst.frontmatter['prompt-exclude']),
+      )
+      parts.push(`<!-- ${levelLabel[inst.level] || inst.level} (${inst.path}) -->\n${content}`)
     }
 
     // P2-2: Inject current permission mode so the model knows its constraints
@@ -67,11 +101,6 @@ export class InstructionsLoader {
       parts.push(this.buildPermissionContext(permissionMode))
     }
 
-    // Append skills reminder after all instructions
-    if (this.skillsReminder) {
-      parts.push(this.skillsReminder)
-    }
-
     // Inject critical thinking self-check layer (for analysis/comparison tasks)
     parts.push(`## Critical Thinking Self-Check
 
@@ -177,11 +206,6 @@ Never omit it or present the work as purely human-authored.`)
     return parts.join('\n\n---\n\n')
   }
 
-  /** Set the skills system-reminder block to inject into the system prompt. */
-  setSkillsReminder(reminder: string): void {
-    this.skillsReminder = reminder
-  }
-
   /**
    * P2-2: Build a permission-mode context block for the system prompt.
    * Tells the model its current permission level and what to expect.

package/src/index.tsx

@@ -281,12 +281,6 @@ export async function runApp(options: RunOptions): Promise<void> {
     skillsLoader.loadExternal(config.skills.paths)
   }
 
-  // Inject skills system-reminder into system prompt for AI auto-triggering
-  const skillsReminder = skillsLoader.buildSystemReminder()
-  if (skillsReminder) {
-    instructions.setSkillsReminder(skillsReminder)
-  }
-
   // Initialize plugin manager
   const pluginManager = new PluginManager()
 
@@ -327,8 +321,6 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Phase 9 feature flags (all default true — opt-out via config)
   const features = config.features || {}
   const adaptiveThresholds = features.context?.adaptiveThresholds !== false
-  // gated via TokenCounter — set to false to fall back to chars/4 heuristic
-  const _useRealTokenizer = features.context?.useRealTokenizer !== false
 
   const context = new ContextManager({
     maxTokens: contextMaxTokens,
@@ -372,9 +364,13 @@ 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)
 
     // Inject previous session summary for AI continuity
     let prompt = basePrompt
+    if (skillsReminder) {
+      prompt = `${prompt}\n\n${skillsReminder}`
+    }
     if (memoryReminder) {
       prompt = `${prompt}\n\n${memoryReminder}`
     }

package/src/mcp/token-store.ts

@@ -8,13 +8,8 @@ import {
   chmodSync,
 } from 'node:fs'
 import { join, dirname } from 'node:path'
-import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
 import { homedir } from 'node:os'
-
-const ALGORITHM = 'aes-256-gcm'
-const IV_LENGTH = 16
-const AUTH_TAG_LENGTH = 16
-const KEY_LENGTH = 32
+import { encrypt, decrypt, getCredentialKey } from '../config/credential-crypto'
 
 interface TokenData {
   accessToken: string
@@ -24,43 +19,13 @@ interface TokenData {
   scopes?: string[]
 }
 
-function getEncryptionKey(keyPath: string): Buffer {
-  if (existsSync(keyPath)) {
-    return readFileSync(keyPath)
-  }
-  const key = randomBytes(KEY_LENGTH)
-  mkdirSync(dirname(keyPath), { recursive: true })
-  writeFileSync(keyPath, key)
-  chmodSync(keyPath, 0o400)
-  return key
-}
-
-function encrypt(plaintext: string, key: Buffer): string {
-  const iv = randomBytes(IV_LENGTH)
-  const cipher = createCipheriv(ALGORITHM, key, iv)
-  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf-8'), cipher.final()])
-  const authTag = cipher.getAuthTag()
-  return Buffer.concat([iv, authTag, encrypted]).toString('base64')
-}
-
-function decrypt(ciphertext: string, key: Buffer): string {
-  const buf = Buffer.from(ciphertext, 'base64')
-  const iv = buf.subarray(0, IV_LENGTH)
-  const authTag = buf.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH)
-  const encrypted = buf.subarray(IV_LENGTH + AUTH_TAG_LENGTH)
-  const decipher = createDecipheriv(ALGORITHM, key, iv)
-  decipher.setAuthTag(authTag)
-  return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf-8')
-}
-
 export class TokenStore {
   private key: Buffer
   private storeDir: string
 
   constructor(storeDir?: string) {
     this.storeDir = storeDir || join(homedir(), '.mipham', 'mcp-tokens')
-    const keyPath = join(dirname(this.storeDir), '.mcp-key')
-    this.key = getEncryptionKey(keyPath)
+    this.key = getCredentialKey(dirname(this.storeDir))
   }
 
   save(serverName: string, data: TokenData): void {

package/src/shared/package-info.ts

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

package/src/shared/types.ts

@@ -151,7 +151,7 @@ export interface MiphamConfig {
 
 export interface FeatureFlags {
   mcp: { oauthEnabled: boolean }
-  context: { useRealTokenizer: boolean; adaptiveThresholds: boolean }
+  context: { adaptiveThresholds: boolean }
 }
 
 export interface CrsiConfig {
@@ -483,8 +483,8 @@ export interface SkillDefinition {
   allowedTools?: string[]
   /** When true, the skill is NOT shown in system-reminder for AI auto-triggering */
   disableModelInvocation?: boolean
-  /** When true, users can invoke this skill directly via /<name> */
-  userInvocable?: boolean
+  /** External command-line binaries the skill requires (frontmatter: requires-bins). */
+  requiresBins?: string[]
   /** The markdown body content of the skill file (instructions for the AI to follow). */
   body?: string
 }

package/src/skills/bin-check.ts

@@ -0,0 +1,40 @@
+import { existsSync } from 'node:fs'
+import { join, delimiter } from 'node:path'
+
+// Windows executable extensions (subset of PATHEXT) probed for bare names.
+const WINDOWS_EXECUTABLES = ['.exe', '.cmd', '.bat', '.com']
+
+/**
+ * Check whether a command-line binary is available on the system PATH.
+ * Accepts an explicit `pathVar` for testability; defaults to `process.env.PATH`.
+ * A value containing a path separator is treated as an explicit path and
+ * checked for existence directly.
+ */
+export function isBinAvailable(bin: string, pathVar: string = process.env.PATH || ''): boolean {
+  // Explicit path (absolute or relative) — check existence directly.
+  if (bin.includes('/') || bin.includes('\\')) {
+    return existsSync(bin)
+  }
+
+  const isWindows = process.platform === 'win32'
+  const names = isWindows ? WINDOWS_EXECUTABLES.map((ext) => bin + ext) : [bin]
+  const dirs = pathVar.split(delimiter).filter(Boolean)
+
+  for (const dir of dirs) {
+    for (const name of names) {
+      if (existsSync(join(dir, name))) return true
+    }
+  }
+  return false
+}
+
+/**
+ * Return the subset of `bins` that are NOT available on PATH. An empty result
+ * means every required binary is present.
+ */
+export function checkRequiredBins(
+  bins: string[],
+  pathVar: string = process.env.PATH || '',
+): string[] {
+  return bins.filter((bin) => !isBinAvailable(bin, pathVar))
+}

package/src/skills/loader.ts

@@ -182,7 +182,7 @@ export class SkillsLoader implements Skills {
         model: data.model as string | undefined,
         allowedTools: data['allowed-tools'] as string[] | undefined,
         disableModelInvocation: data['disable-model-invocation'] as boolean | undefined,
-        userInvocable: data['user-invocable'] as boolean | undefined,
+        requiresBins: data['requires-bins'] as string[] | undefined,
       }
 
       this.skills.set(skill.name, skill)
@@ -191,18 +191,43 @@ 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.
-   * Injects available skill names + descriptions so the AI can match
-   * user requests to relevant skills.
+   * With a `context`, only the most relevant skills are injected (selective,
+   * to save tokens); without one, all skills are listed.
    */
-  buildSystemReminder(maxTokens: number = 5000): string {
-    const skills = this.list().filter((s) => {
-      // Skip skills that disable model invocation
-      return !s.disableModelInvocation
-    })
+  buildSystemReminder(context?: string, maxTokens: number = 5000): string {
+    const selected = context
+      ? this.recall(context)
+      : this.list().filter((s) => !s.disableModelInvocation)
 
-    if (skills.length === 0) return ''
+    if (selected.length === 0) return ''
 
     const lines: string[] = [
       '<system-reminder>',
@@ -210,7 +235,7 @@ export class SkillsLoader implements Skills {
     ]
 
     let tokenBudget = 0
-    for (const skill of skills) {
+    for (const skill of selected) {
       const safeDesc = sanitizeSkillDescription(skill.description, skill.type)
       const entry = `- ${skill.name}: ${safeDesc}`
       const entryTokens = Math.ceil(entry.length / 4) + 1 // rough estimate

package/src/skills/sanitizer.ts

@@ -54,7 +54,6 @@ const BUILTIN_COMMANDS = new Set([
   '/sis',
   '/plan',
   '/no-plan',
-  '/triage',
   '/workflows',
   '/tasks',
 ])
@@ -182,7 +181,7 @@ export function checkSkillShadow(
   mcpToolNames?: string[],
 ): ShadowCheck {
   // Check against builtin commands
-  if (BUILTIN_COMMANDS.has(skillName)) {
+  if (BUILTIN_COMMANDS.has('/' + skillName)) {
     return { shadowed: true, conflictsWith: skillName, conflictType: 'command' }
   }
 

package/src/skills/seam.ts

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

package/src/tools/agent/skill.ts

@@ -2,6 +2,7 @@ import type { ToolDefinition } from '../../shared'
 import { executeForkedSkill } from '../../skills/fork-executor'
 import { sanitizeSkillBody } from '../../skills/sanitizer'
 import { ensureSkillAssets } from '../../skills/skill-assets'
+import { checkRequiredBins } from '../../skills/bin-check'
 
 export const skillTool: ToolDefinition = {
   name: 'Skill',
@@ -47,6 +48,19 @@ export const skillTool: ToolDefinition = {
         console.warn(`Skill asset extraction failed for "${skillName}":`, err)
       }
 
+      // Preflight: fail fast with a clear error if a required binary is missing.
+      if (skill.requiresBins?.length) {
+        const missing = checkRequiredBins(skill.requiresBins)
+        if (missing.length > 0) {
+          const list = missing.map((b) => `\`${b}\``).join(', ')
+          return {
+            success: false,
+            content: '',
+            error: `Skill "${skillName}" requires ${list}, which ${missing.length === 1 ? 'is' : 'are'} not available on PATH. Install and retry.`,
+          }
+        }
+      }
+
       // Check if skill has context: fork — execute in isolated subagent
       if (skill.context === 'fork') {
         const registry = ctx.registry

package/src/ui/commands.ts

@@ -4665,6 +4665,7 @@ const commandsListCmd: CommandHandler = () => {
     '/keys': 'Account',
     '/keys rotate': 'Account',
     '/keys audit': 'Account',
+    '/keys view': 'Account',
     '/feedback': 'Account',
     '/agents': 'Agents',
     '/bg': 'Agents',
@@ -4847,6 +4848,7 @@ registry.set('/logout', logoutCmd)
 registry.set('/keys', keysCmd)
 registry.set('/keys rotate', keysCmd)
 registry.set('/keys audit', keysCmd)
+registry.set('/keys view', keysCmd)
 registry.set('/feedback', feedbackCmd)
 registry.set('/agents', agentsCmd)
 registry.set('/bg', bgCmd)
@@ -5006,6 +5008,7 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/keys': 'List API key rotation status',
   '/keys rotate': 'Rotate an API key',
   '/keys audit': 'Check for expired keys',
+  '/keys view': 'View a provider plaintext API key',
   '/feedback': 'Send feedback',
   '/agents': 'Agent view dashboard',
   '/bg': 'Run a background agent task',

package/src/ui/config-wizard.tsx

@@ -18,6 +18,7 @@ import { mkdirSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { execSync } from 'node:child_process'
+import { getCredentialKey, encryptApiKey } from '../config/credential-crypto'
 
 // ── Types ──
 
@@ -93,6 +94,8 @@ function writeConfigFile(providerId: string, modelId: string, apiKey: string): v
     }
     return result
   }
+  const storedKey = encryptApiKey(apiKey, getCredentialKey(configDir))
+
   const lines = [
     '# Mipham Code Configuration',
     `# Generated by Config Wizard — ${new Date().toISOString()}`,
@@ -107,7 +110,7 @@ function writeConfigFile(providerId: string, modelId: string, apiKey: string): v
     `    name: ${provider?.name || providerId}`,
     `    protocol: ${provider?.protocol || 'openai-compatible'}`,
     ...(provider?.baseUrl ? [`    baseUrl: ${provider.baseUrl}`] : []),
-    `    apiKey: ${apiKey}`,
+    `    apiKey: ${storedKey}`,
     `    models:`,
     ...models.map((m) => `      - id: ${m.id}`),
   ]

package/src/core/tokenizer.ts

@@ -1,80 +0,0 @@
-import type { Tiktoken } from 'js-tiktoken'
-import type { Message } from '../shared/types'
-
-let encoder: Tiktoken | null = null
-let initPromise: Promise<void> | null = null
-
-async function getEncoder(): Promise<Tiktoken> {
-  if (encoder) return encoder
-  if (!initPromise) {
-    initPromise = (async () => {
-      const { getEncoding } = await import('js-tiktoken')
-      encoder = getEncoding('cl100k_base')
-    })()
-  }
-  await initPromise
-  return encoder!
-}
-
-export class TokenCounter {
-  private cache = new Map<string, number>()
-  private initialized = false
-
-  private async ensureInit(): Promise<void> {
-    if (!this.initialized) {
-      await getEncoder()
-      this.initialized = true
-    }
-  }
-
-  async count(text: string): Promise<number> {
-    if (!text) return 0
-    const cached = this.cache.get(text)
-    if (cached !== undefined) return cached
-    await this.ensureInit()
-    const tokens = encoder!.encode(text).length
-    this.cache.set(text, tokens)
-    return tokens
-  }
-
-  /** Synchronous fallback — chars/4 heuristic when WASM not loaded. */
-  countSync(text: string): number {
-    if (!text) return 0
-    const cached = this.cache.get(text)
-    if (cached !== undefined) return cached
-    return Math.ceil(text.length / 4)
-  }
-
-  async countMessages(messages: Message[]): Promise<number> {
-    let total = 0
-    for (const msg of messages) {
-      if (typeof msg.content === 'string') {
-        total += await this.count(msg.content)
-      } else if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === 'text' && block.text) {
-            total += await this.count(block.text)
-          }
-        }
-      }
-      total += 4 // per-message format overhead
-    }
-    return total
-  }
-
-  async truncateToTokens(text: string, maxTokens: number): Promise<string> {
-    await this.ensureInit()
-    const tokens = encoder!.encode(text)
-    if (tokens.length <= maxTokens) return text
-    return text.slice(0, Math.floor(text.length * (maxTokens / tokens.length)))
-  }
-
-  invalidateCache(): void {
-    this.cache.clear()
-  }
-
-  static reset(): void {
-    encoder = null
-    initPromise = null
-  }
-}