@miphamai/cli 0.15.0 → 0.16.1

package/src/config/defaults.ts

@@ -13,6 +13,10 @@ export const DEFAULT_CONFIG: MiphamConfig = {
   defaultModel: 'deepseek-v4-pro',
   permission: 'auto',
   providers: DEFAULT_PROVIDERS,
+  marketplace: {
+    strictKnownMarketplaces: [],
+    blockedMarketplaces: [],
+  },
 }
 
 export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {

package/src/config/preferences.ts

@@ -0,0 +1,45 @@
+/**
+ * Lightweight preferences store backed by ~/.mipham/preferences.json.
+ * Used for persisting user-level UI state (e.g. last code review effort).
+ *
+ * NOT for config.yml settings — those belong in the YAML config system.
+ * NOT for secrets — this file is plain JSON, not encrypted.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const PREFS_PATH = join(homedir(), '.mipham', 'preferences.json')
+
+function readPrefs(): Record<string, string> {
+  try {
+    if (!existsSync(PREFS_PATH)) return {}
+    const raw = readFileSync(PREFS_PATH, 'utf-8')
+    const parsed: unknown = JSON.parse(raw)
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return {}
+    return parsed as Record<string, string>
+  } catch {
+    return {}
+  }
+}
+
+function writePrefs(prefs: Record<string, string>): void {
+  try {
+    const dir = join(homedir(), '.mipham')
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 })
+    writeFileSync(PREFS_PATH, JSON.stringify(prefs, null, 2), { mode: 0o600, encoding: 'utf-8' })
+  } catch {
+    // best-effort; never crash because preferences failed to save
+  }
+}
+
+export function getPreference(key: string, defaultValue: string): string {
+  const prefs = readPrefs()
+  return prefs[key] ?? defaultValue
+}
+
+export function setPreference(key: string, value: string): void {
+  const prefs = readPrefs()
+  prefs[key] = value
+  writePrefs(prefs)
+}

package/src/core/context.ts

@@ -55,6 +55,15 @@ export class ContextManager {
 
   constructor(private config: ContextConfig) {}
 
+  /** Dynamically update the max token limit (e.g., when switching models). */
+  updateMaxTokens(maxTokens: number): void {
+    this.config.maxTokens = maxTokens
+  }
+
+  getMaxTokens(): number {
+    return this.config.maxTokens
+  }
+
   /** Set an optional LLM summarizer for intelligent compaction. */
   setSummarizer(fn: Summarizer): void {
     this.summarizer = fn

package/src/core/engine.ts

@@ -41,7 +41,7 @@ export class QueryEngine {
     private registry: ProviderRegistry,
     private context: ContextManager,
     private tools: Map<string, ToolDefinition>,
-    private permission: PermissionSystem = new PermissionSystem('bypass'),
+    private permission: PermissionSystem = new PermissionSystem('default'),
   ) {}
 
   /** Register a hook engine for pre/post tool-use lifecycle events. */
@@ -277,6 +277,7 @@ export class QueryEngine {
 
     // ── PreInference DLP checkpoint ──
     if (isInferenceHookEnabled(this.inferenceHookConfig)) {
+      const hookConfig = this.inferenceHookConfig!
       const provider = this.registry.getActive().config.id
       const model = this.registry.getActiveModel()
       const request = buildRequest(
@@ -284,9 +285,9 @@ export class QueryEngine {
         'session-1',
         provider,
         model,
-        this.inferenceHookConfig!.organization_id,
+        hookConfig.organization_id,
       )
-      const verdict = await sendInferenceCheck(this.inferenceHookConfig!, request)
+      const verdict = await sendInferenceCheck(hookConfig, request)
       if (!verdict.allowed) {
         yield {
           type: 'error',
@@ -556,6 +557,7 @@ export class QueryEngine {
 
       // ── PreInference DLP checkpoint (every tool-calling turn) ──
       if (isInferenceHookEnabled(this.inferenceHookConfig)) {
+        const hookConfig = this.inferenceHookConfig!
         const provider = this.registry.getActive().config.id
         const model = this.registry.getActiveModel()
         const request = buildRequest(
@@ -563,9 +565,9 @@ export class QueryEngine {
           'session-1',
           provider,
           model,
-          this.inferenceHookConfig!.organization_id,
+          hookConfig.organization_id,
         )
-        const verdict = await sendInferenceCheck(this.inferenceHookConfig!, request)
+        const verdict = await sendInferenceCheck(hookConfig, request)
         if (!verdict.allowed) {
           yield {
             type: 'error',
@@ -821,6 +823,16 @@ export class QueryEngine {
 
   switchProvider(providerId: string, modelId?: string): void {
     this.registry.switchProvider(providerId, modelId)
+    // Update context manager's max tokens to match the new model's context window
+    if (modelId) {
+      const model = this.registry.findModel(modelId)
+      if (model) {
+        const DISABLE_1M = process.env.MIPHAM_DISABLE_1M_CONTEXT === '1'
+        const maxTokens =
+          DISABLE_1M && model.contextWindow > 200_000 ? 200_000 : model.contextWindow
+        this.context.updateMaxTokens(maxTokens)
+      }
+    }
   }
 
   /** Wrap context compaction with PreCompact/PostCompact hooks. */

package/src/core/permission-config.ts

@@ -1,4 +1,4 @@
-import type { PermissionConfig, PermissionMode } from '../shared/index.ts'
+import type { PermissionConfig, PermissionMode, PermissionRestrictions } from '../shared/index.ts'
 
 const DEFAULT_CONFIG: PermissionConfig = {
   mode: 'default',
@@ -15,11 +15,15 @@ export function loadPermissionConfig(raw: Partial<PermissionConfig> = {}): Permi
     mode: (raw.mode as PermissionMode) || DEFAULT_CONFIG.mode,
     allow: Array.isArray(raw.allow) ? raw.allow : [...DEFAULT_CONFIG.allow],
     deny: Array.isArray(raw.deny) ? raw.deny : [...DEFAULT_CONFIG.deny],
+    restrictions: raw.restrictions ?? undefined,
   }
 }
 
-/** Valid mode transition order for Shift+Tab cycling. */
-export const MODE_CYCLE: PermissionMode[] = [
+/**
+ * Permission modes ordered from least to most permissive.
+ * Used to enforce maxAllowedMode: any mode ranked higher than the cap is forbidden.
+ */
+export const PERMISSION_MODE_HIERARCHY: PermissionMode[] = [
   'default',
   'acceptEdits',
   'plan',
@@ -28,7 +32,67 @@ export const MODE_CYCLE: PermissionMode[] = [
   'bypassPermissions',
 ]
 
-export function nextMode(current: PermissionMode): PermissionMode {
-  const idx = MODE_CYCLE.indexOf(current)
-  return MODE_CYCLE[(idx + 1) % MODE_CYCLE.length]!
+/** Valid mode transition order for Shift+Tab cycling. */
+export const MODE_CYCLE: PermissionMode[] = [...PERMISSION_MODE_HIERARCHY]
+
+/** Resolve which modes are actually permitted given the restrictions. */
+export function getAllowedModes(restrictions?: PermissionRestrictions): PermissionMode[] {
+  let allowed = [...MODE_CYCLE]
+
+  if (restrictions?.forbiddenModes && restrictions.forbiddenModes.length > 0) {
+    const forbidden = new Set(restrictions.forbiddenModes)
+    allowed = allowed.filter((m) => !forbidden.has(m))
+  }
+
+  if (restrictions?.maxAllowedMode) {
+    const capIdx = PERMISSION_MODE_HIERARCHY.indexOf(restrictions.maxAllowedMode)
+    if (capIdx >= 0) {
+      allowed = allowed.filter((m) => PERMISSION_MODE_HIERARCHY.indexOf(m) <= capIdx)
+    }
+  }
+
+  return allowed
+}
+
+/** Check whether a given mode is permitted under the restrictions. */
+export function isModeAllowed(
+  mode: PermissionMode,
+  restrictions?: PermissionRestrictions,
+): boolean {
+  return getAllowedModes(restrictions).includes(mode)
+}
+
+/**
+ * Return the highest allowed mode at or below `desired` given the restrictions.
+ * Used to silently downgrade when a forbidden mode is requested.
+ */
+export function clampMode(
+  desired: PermissionMode,
+  restrictions?: PermissionRestrictions,
+): PermissionMode {
+  const allowed = getAllowedModes(restrictions)
+  if (allowed.includes(desired)) return desired
+
+  // Walk downward through the hierarchy to find the closest allowed mode
+  const desiredIdx = PERMISSION_MODE_HIERARCHY.indexOf(desired)
+  for (let i = desiredIdx - 1; i >= 0; i--) {
+    const candidate = PERMISSION_MODE_HIERARCHY[i]!
+    if (allowed.includes(candidate)) return candidate
+  }
+
+  // Fallback: return the first allowed mode (should always be at least 'default')
+  return allowed[0] ?? 'default'
+}
+
+export function nextMode(
+  current: PermissionMode,
+  restrictions?: PermissionRestrictions,
+): PermissionMode {
+  const allowed = getAllowedModes(restrictions)
+  const idx = allowed.indexOf(current)
+  if (idx === -1) {
+    // Current mode is not in the allowed set — clamp then find next
+    return clampMode(current, restrictions)
+  }
+  return allowed[(idx + 1) % allowed.length]!
 }

package/src/core/permission.ts

@@ -3,10 +3,11 @@ import type {
   PermissionMode,
   PermissionLevel,
   PermissionRule,
+  PermissionRestrictions,
 } from '../shared/index.ts'
 import type { PermissionRuleEntry } from '../shared/index.ts'
 import { matchBashRule, compileRule } from './permission-rules'
-import { loadPermissionConfig, nextMode, MODE_CYCLE } from './permission-config'
+import { loadPermissionConfig, nextMode, clampMode, MODE_CYCLE } from './permission-config'
 
 const VALID_MODES: Set<string> = new Set<string>(MODE_CYCLE)
 
@@ -25,6 +26,9 @@ export class PermissionSystem {
   private checkCache = new Map<string, PermissionLevel>()
   private cacheMode: PermissionMode | null = null
 
+  // ── Org-level restrictions (P0 security) ──
+  private restrictions: PermissionRestrictions | undefined = undefined
+
   /** Invalidate the permission cache (called on any rule/mode change). */
   private invalidateCache(): void {
     this.checkCache.clear()
@@ -44,7 +48,7 @@ export class PermissionSystem {
   // ── Mode management ──
 
   setMode(mode: PermissionMode): void {
-    this.mode = mode
+    this.mode = clampMode(mode, this.restrictions)
     this.invalidateCache()
   }
 
@@ -53,10 +57,26 @@ export class PermissionSystem {
   }
 
   cycleMode(): PermissionMode {
-    this.mode = nextMode(this.mode)
+    this.mode = nextMode(this.mode, this.restrictions)
     return this.mode
   }
 
+  // ── Restrictions (P0: org-level policy gap) ──
+
+  /** Apply org-level permission restrictions. Overwrites any previous restrictions. */
+  setRestrictions(restrictions: PermissionRestrictions | undefined): void {
+    this.restrictions = restrictions
+    // Re-clamp current mode against new restrictions
+    if (restrictions) {
+      this.mode = clampMode(this.mode, restrictions)
+    }
+    this.invalidateCache()
+  }
+
+  getRestrictions(): PermissionRestrictions | undefined {
+    return this.restrictions
+  }
+
   // ── Rule management ──
 
   allow(rule: string): void {
@@ -71,11 +91,21 @@ export class PermissionSystem {
     this.askRules.push(compileRule(rule, 'ask'))
   }
 
-  loadConfig(raw: { mode?: string; allow?: string[]; deny?: string[] }): void {
+  loadConfig(raw: {
+    mode?: string
+    allow?: string[]
+    deny?: string[]
+    restrictions?: PermissionRestrictions
+  }): void {
     const config = loadPermissionConfig(
-      raw as Partial<{ mode: PermissionMode; allow: string[]; deny: string[] }>,
+      raw as Partial<{
+        mode: PermissionMode
+        allow: string[]
+        deny: string[]
+        restrictions: PermissionRestrictions
+      }>,
     )
-    this.mode = config.mode
+    this.mode = clampMode(config.mode, config.restrictions ?? this.restrictions)
 
     this.allowRules = []
     this.denyRules = []
@@ -88,6 +118,10 @@ export class PermissionSystem {
       this.denyRules.push(compileRule(rule, 'deny'))
     }
 
+    if (config.restrictions) {
+      this.restrictions = config.restrictions
+    }
+
     this.invalidateCache()
   }
 
@@ -105,6 +139,11 @@ export class PermissionSystem {
    * 8. System default → 'ask'
    */
   check(tool: ToolDefinition, input: Record<string, unknown>): PermissionLevel {
+    // ── Guard: reject undefined/null tool (defense-in-depth) ──
+    if (!tool) {
+      return 'ask' // absent tool → safest default
+    }
+
     // ── Cache lookup (P2): reuse decision for same tool+mode+input ──
     const cacheKey = tool.name + '|' + JSON.stringify(input, Object.keys(input).sort())
     if (this.cacheMode === this.mode) {
@@ -246,9 +285,11 @@ export class PermissionSystem {
 
   setDefaultLevel(level: PermissionLevel): void {
     // Map legacy 3-level to new mode
-    if (level === 'auto') this.mode = 'auto'
-    else if (level === 'bypass') this.mode = 'bypassPermissions'
-    else this.mode = 'default'
+    let newMode: PermissionMode
+    if (level === 'auto') newMode = 'auto'
+    else if (level === 'bypass') newMode = 'bypassPermissions'
+    else newMode = 'default'
+    this.mode = clampMode(newMode, this.restrictions)
     this.invalidateCache()
   }
 

package/src/core/session-store.ts

@@ -17,6 +17,7 @@ export interface SessionMetadata {
   provider: string
   model: string
   messageCount: number
+  cwd?: string
 }
 
 export interface StoredSession {
@@ -44,7 +45,7 @@ export class SessionStore {
   static save(
     name: string,
     messages: Message[],
-    metadata?: { provider?: string; model?: string },
+    metadata?: { provider?: string; model?: string; cwd?: string },
   ): void {
     ensureDir()
     const path = filePath(name)
@@ -57,6 +58,7 @@ export class SessionStore {
         provider: metadata?.provider || 'unknown',
         model: metadata?.model || 'unknown',
         messageCount: messages.length,
+        cwd: metadata?.cwd,
       },
       messages,
     }
@@ -132,7 +134,10 @@ export class SessionStore {
   /**
    * Auto-save with timestamp-based name.
    */
-  static autoSave(messages: Message[], metadata?: { provider?: string; model?: string }): string {
+  static autoSave(
+    messages: Message[],
+    metadata?: { provider?: string; model?: string; cwd?: string },
+  ): string {
     const name = `session-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`
     SessionStore.save(name, messages, metadata)
     return name

package/src/index.tsx

@@ -1,4 +1,5 @@
 import { join } from 'node:path'
+import { existsSync } from 'node:fs'
 import { render } from 'ink'
 import { App } from './ui/app'
 import { loadConfig, loadInferenceHookConfig, loadCredentialMaskingConfig } from './config/loader'
@@ -85,12 +86,53 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Initialize plugin manager
   const pluginManager = new PluginManager()
 
+  // Generate session name for tracking (used by /cd to persist cwd)
+  const sessionName =
+    options.resume || `session-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`
+
   // Initialize context — restore saved session if available
-  const context = new ContextManager({ maxTokens: 200_000, compactionThreshold: 0.9 })
+  // Read the active model's context window for dynamic max-token sizing.
+  // MIPHAM_DISABLE_1M_CONTEXT=1 caps the effective window at 200K even for
+  // models that support larger contexts (e.g. 1M).
+  // When the model is unknown (not in any provider's model list), assume a
+  // conservative 128K context window. Set MIPHAM_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT=1
+  // to restore the old behavior (default 200K fallback for unknown models).
+  const activeModel = registry.findModel(defaultModel)
+  let modelContextWindow: number
+  if (activeModel) {
+    modelContextWindow = activeModel.contextWindow
+  } else if (process.env.MIPHAM_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT === '1') {
+    modelContextWindow = 200_000 // old behavior: default fallback
+  } else {
+    modelContextWindow = 128_000 // conservative assumption for unknown models
+    console.error(
+      `[mipham] ⚠ Unknown model "${defaultModel}": assuming 128K context window. ` +
+        `Set MIPHAM_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT=1 to disable.`,
+    )
+  }
+
+  const DISABLE_1M = process.env.MIPHAM_DISABLE_1M_CONTEXT === '1'
+  const contextMaxTokens = DISABLE_1M && modelContextWindow > 200_000 ? 200_000 : modelContextWindow
+
+  if (DISABLE_1M && modelContextWindow <= 200_000) {
+    console.error(
+      '[mipham] ⚠ MIPHAM_DISABLE_1M_CONTEXT is set but auto-compaction is not holding the session to 200K — model context window is already ≤ 200K',
+    )
+  }
+
+  const context = new ContextManager({ maxTokens: contextMaxTokens, compactionThreshold: 0.9 })
 
   if (options.resume) {
     const saved = SessionStore.load(options.resume)
     if (saved) {
+      // Restore working directory if saved
+      if (saved.metadata.cwd && existsSync(saved.metadata.cwd)) {
+        try {
+          process.chdir(saved.metadata.cwd)
+        } catch {
+          // cwd may no longer exist; silently continue
+        }
+      }
       for (const msg of saved.messages) {
         context.addMessage(msg)
       }
@@ -169,6 +211,11 @@ export async function runApp(options: RunOptions): Promise<void> {
     engine.getPermission().setDefaultLevel(config.permission as PermissionLevel)
   }
 
+  // Apply org-level permission restrictions (P0: bypassPermissions policy gap)
+  if (config.permissionRestrictions) {
+    engine.getPermission().setRestrictions(config.permissionRestrictions)
+  }
+
   // Initialize agent registry and load plugin agents/skills/MCP/hooks
   const agentRegistry = new AgentRegistry()
   agentRegistry.loadUserAgents()
@@ -190,9 +237,10 @@ export async function runApp(options: RunOptions): Promise<void> {
   const saveAndExit = () => {
     artifactServer.stop()
     if (context.getMessageCount() > 0) {
-      SessionStore.autoSave(context.getMessages(), {
+      SessionStore.save(sessionName, context.getMessages(), {
         provider: defaultProvider,
         model: defaultModel,
+        cwd: process.cwd(),
       })
     }
     process.exit(0)
@@ -211,6 +259,7 @@ export async function runApp(options: RunOptions): Promise<void> {
       skillsLoader={skillsLoader}
       pluginManager={pluginManager}
       version={options.version}
+      sessionId={sessionName}
     />,
   )
   await waitUntilExit()

package/src/providers/registry.ts

@@ -64,6 +64,14 @@ export class ProviderRegistry {
     return provider.config.models.filter((m) => m.status === 'active')
   }
 
+  findModel(modelId: string): ModelInfo | undefined {
+    for (const provider of this.providers.values()) {
+      const model = provider.config.models.find((m) => m.id === modelId)
+      if (model) return model
+    }
+    return undefined
+  }
+
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
     const provider = this.getActive()
     yield* provider.chat({ ...req, model: req.model || this.activeModelId })

package/src/shared/sanitize.ts

@@ -0,0 +1,38 @@
+/**
+ * Unicode sanitization for tool inputs.
+ * Strips invisible/control characters that could hide command content
+ * from visual inspection or enable homoglyph attacks.
+ *
+ * Claude Code v2.1.223 parity: hidden command text via tabs/invisible Unicode.
+ */
+
+const DANGEROUS_UNICODE = /[​‌‍‎‏‪‫‬‭‮⁠⁦⁧⁨⁩]/g
+
+/**
+ * Strip dangerous invisible Unicode characters from a string.
+ * - Zero-width: U+200B (ZWSP), U+200C (ZWNJ), U+200D (ZWJ), U+200E/F (LTR/RTL marks)
+ * - Bidi controls: U+202A-E, U+2066-9
+ * - Word joiner: U+2060
+ * - BOM: U+FEFF
+ */
+export function stripDangerousUnicode(input: string): string {
+  if (!input) return input
+  return input.replace(DANGEROUS_UNICODE, '')
+}
+
+/**
+ * Recursively sanitize all string values in a params object.
+ */
+export function sanitizeParams(params: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === 'string') {
+      result[key] = stripDangerousUnicode(value)
+    } else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+      result[key] = sanitizeParams(value as Record<string, unknown>)
+    } else {
+      result[key] = value
+    }
+  }
+  return result
+}

package/src/shared/types.ts

@@ -160,8 +160,16 @@ export interface MiphamConfig {
   defaultProvider: string
   defaultModel: string
   permission: ToolPermission
+  /** Org-level permission restrictions (forbiddenModes, maxAllowedMode). */
+  permissionRestrictions?: PermissionRestrictions
   providers: ProviderConfig[]
   skills?: { paths: string[]; mcpServers: McpServerConfig[] }
+  marketplace?: {
+    /** If set, only allow installs from matching repos (e.g. ["One-Mipham/*"]) */
+    strictKnownMarketplaces?: string[]
+    /** Block installs from matching repos (e.g. ["malicious-org/*"]) */
+    blockedMarketplaces?: string[]
+  }
 }
 
 export interface McpServerConfig {
@@ -287,10 +295,20 @@ export type PermissionMode =
 /** Backward-compatible alias: PermissionMode plus legacy 'ask' and 'bypass' */
 export type PermissionLevel = PermissionMode | 'ask' | 'bypass'
 
+/** Org-level restrictions that cap or forbid specific permission modes. */
+export interface PermissionRestrictions {
+  /** Modes that may not be entered (cycle skips them). */
+  forbiddenModes?: PermissionMode[]
+  /** Ceiling — modes ranked higher (more permissive) than this are treated as forbidden. */
+  maxAllowedMode?: PermissionMode
+}
+
 export interface PermissionConfig {
   mode: PermissionMode
   allow: string[]
   deny: string[]
+  /** Optional org-level restrictions enforced on every mode transition. */
+  restrictions?: PermissionRestrictions
 }
 
 export interface PermissionRuleEntry {

package/src/skills/community-registry.json

@@ -0,0 +1,72 @@
+[
+  {
+    "name": "code-review",
+    "description": "Automated code review with multiple dimensions — complexity, security, performance, quality",
+    "url": "https://github.com/One-Mipham/skill-code-review",
+    "file": "code-review.SKILL.md",
+    "category": "Development",
+    "author": "MiphamAI",
+    "builtin": true
+  },
+  {
+    "name": "systematic-debugging",
+    "description": "Systematic debugging workflow — find root cause before fixing",
+    "url": "https://github.com/anthropics/skills",
+    "file": "systematic-debugging.SKILL.md",
+    "category": "Development",
+    "author": "Anthropic"
+  },
+  {
+    "name": "test-driven-development",
+    "description": "TDD workflow — write failing test first, then implement",
+    "url": "https://github.com/anthropics/skills",
+    "file": "test-driven-development.SKILL.md",
+    "category": "Development",
+    "author": "Anthropic",
+    "builtin": true
+  },
+  {
+    "name": "web-access",
+    "description": "Web search, scraping, and browser automation — search engines, page fetching, authenticated sites",
+    "url": "https://github.com/One-Mipham/skill-web-access",
+    "file": "web-access.SKILL.md",
+    "category": "Network",
+    "author": "MiphamAI",
+    "builtin": true
+  },
+  {
+    "name": "doc-generator",
+    "description": "Generate API docs, READMEs, and changelogs from code analysis",
+    "url": "https://github.com/One-Mipham/skill-doc-generator",
+    "file": "doc-generator.SKILL.md",
+    "category": "Documentation",
+    "author": "MiphamAI",
+    "builtin": true
+  },
+  {
+    "name": "github-ops",
+    "description": "GitHub PR/issue management and automation — labels, milestones, reviews",
+    "url": "https://github.com/One-Mipham/skill-github-ops",
+    "file": "github-ops.SKILL.md",
+    "category": "DevOps",
+    "author": "MiphamAI",
+    "builtin": true
+  },
+  {
+    "name": "security-review",
+    "description": "Security audit and vulnerability scanning for code changes — OWASP, secrets, supply chain",
+    "url": "https://github.com/One-Mipham/skill-security-review",
+    "file": "security-review.SKILL.md",
+    "category": "Security",
+    "author": "MiphamAI",
+    "builtin": true
+  },
+  {
+    "name": "frontend-design",
+    "description": "Distinctive visual design guidance for UI components — typography, color, layout",
+    "url": "https://github.com/anthropics/skills",
+    "file": "frontend-design.SKILL.md",
+    "category": "Design",
+    "author": "Anthropic"
+  }
+]