@miphamai/cli 0.12.0 → 0.14.0

package/src/tools/file/read.ts

@@ -1,7 +1,14 @@
 import { readFileSync, existsSync, statSync } from 'node:fs'
-import type { ToolDefinition } from '../../shared/index.ts'
+import type { ToolDefinition, CredentialMaskingConfig } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
 
+// Injected at startup — set via index.tsx
+let credentialConfig: CredentialMaskingConfig | undefined
+
+export function setCredentialMaskingConfigForRead(config: CredentialMaskingConfig): void {
+  credentialConfig = config
+}
+
 export const readTool: ToolDefinition = {
   name: 'Read',
   description: 'Read a file from the local filesystem. Supports offset and limit for large files.',
@@ -37,6 +44,28 @@ export const readTool: ToolDefinition = {
     const offset = (params.offset as number) || 0
     const limit = (params.limit as number) || 2000
     const content = readFileSync(filePath, 'utf-8')
+
+    // ── Credential masking ──
+    if (credentialConfig) {
+      const { matchCredentialFile, maskContent, CREDENTIAL_SENTINEL } =
+        await import('../../core/credential-masker')
+      const rule = matchCredentialFile(filePath, credentialConfig)
+      if (rule) {
+        const masked = maskContent(content, rule)
+        // Full-file mask: return sentinel immediately (offset/limit don't apply)
+        if (masked === CREDENTIAL_SENTINEL) {
+          return { success: true, content: masked }
+        }
+        // Extract mode: apply offset/limit on masked content
+        const maskedLines = masked.split('\n')
+        const maskedSlice = maskedLines.slice(offset, offset + limit)
+        const maskedResult = maskedSlice
+          .map((l, i) => `${String(offset + i + 1).padStart(6, ' ')}\t${l}`)
+          .join('\n')
+        return { success: true, content: maskedResult }
+      }
+    }
+
     const lines = content.split('\n')
     const slice = lines.slice(offset, offset + limit)
     const result = slice

package/src/ui/app.tsx

@@ -372,6 +372,11 @@ export function App({
       setPickerOpen((prev) => !prev)
       return
     }
+    // Ctrl+F → toggle focus mode
+    if (_input === '\x06') {
+      setFocusMode((prev) => !prev)
+      return
+    }
     // Ctrl+O → toggle last tool call expand/collapse
     if (_input === '\x0f') {
       setMessages((prev) => {
@@ -480,7 +485,7 @@ export function App({
             ● {PERMISSION_LABELS[permissionMode]}
           </Text>
           <Text dimColor> · Shift+Tab mode</Text>
-          <Text dimColor> · Ctrl+P model · Ctrl+O expand</Text>
+          <Text dimColor> · Ctrl+P model · Ctrl+F focus · Ctrl+O expand</Text>
           <Text dimColor> · Esc cancel · /help · ← agents</Text>
         </Box>
       </Box>

package/src/ui/chat.tsx

@@ -18,16 +18,16 @@ function displayCwd(): string {
 }
 
 export function ChatPanel({ messages, focusMode }: ChatPanelProps) {
-  // In focus mode, show only the last user+assistant exchange
-  const displayMessages = focusMode ? getLastExchange(messages) : messages
+  // In focus mode, compact tool activity into summary lines
+  const displayMessages = focusMode ? compactForFocus(messages) : messages
 
   return (
     <Box flexDirection="column" marginY={1} flexGrow={1}>
       {focusMode && messages.length > 0 && (
         <Box marginBottom={1}>
           <Text dimColor>
-            🔍 Focus mode — showing last exchange only ({displayMessages.length} of{' '}
-            {messages.length} messages hidden)
+            🔍 Focus — {countHidden(messages, displayMessages)} hidden · /focus to toggle · Ctrl+O
+            to expand
           </Text>
         </Box>
       )}
@@ -92,22 +92,55 @@ export function ChatPanel({ messages, focusMode }: ChatPanelProps) {
 }
 
 /**
- * In focus mode, show only the last user→assistant exchange.
- * Walk backwards from the end to find the last user message, then include
- * everything from that point onward.
+ * Compact messages for focus view:
+ * - Groups consecutive tool calls into [▶ N tools] ↳ name1 ↳ name2 summary lines
+ * - Keeps all user, assistant, and system messages intact
  */
-function getLastExchange(messages: ChatMessage[]): ChatMessage[] {
-  if (messages.length <= 2) return messages
+function compactForFocus(messages: ChatMessage[]): ChatMessage[] {
+  const result: ChatMessage[] = []
+  let toolGroup: ChatMessage[] = []
 
-  // Find the last user message index
-  let lastUserIdx = -1
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]!.role === 'user') {
-      lastUserIdx = i
-      break
+  for (const msg of messages) {
+    if (msg.toolMeta) {
+      toolGroup.push(msg)
+    } else {
+      // Flush pending tool group
+      if (toolGroup.length > 0) {
+        result.push(summarizeToolGroup(toolGroup))
+        toolGroup = []
+      }
+      result.push(msg)
     }
   }
+  // Flush remaining
+  if (toolGroup.length > 0) {
+    result.push(summarizeToolGroup(toolGroup))
+  }
+
+  return result
+}
+
+/** Summarize a group of tool calls into a single compact message. */
+function summarizeToolGroup(tools: ChatMessage[]): ChatMessage {
+  const names = tools.map((t) => t.toolMeta!.name)
+  const uniqueNames = [...new Set(names)]
+  const toolList = uniqueNames.map((n) => `↳ ${n}`).join('  ')
+  return {
+    role: 'system',
+    content: `[▶ ${tools.length} tool${tools.length > 1 ? 's' : ''}]  ${toolList}`,
+    toolMeta: {
+      name: `tools (${tools.length})`,
+      input: '',
+      output: tools.map((t) => t.content).join('\n'),
+      collapsed: true,
+    },
+  }
+}
 
-  if (lastUserIdx === -1) return messages
-  return messages.slice(lastUserIdx)
+/** Count how many messages are hidden in focus mode. */
+function countHidden(all: ChatMessage[], compacted: ChatMessage[]): string {
+  const toolCount = all.filter((m) => m.toolMeta).length
+  const hidden = all.length - compacted.length
+  if (hidden <= 0) return `showing all ${all.length} messages`
+  return `${hidden} tool outputs folded (${toolCount} total tool calls)`
 }

package/src/ui/commands.ts

@@ -2388,6 +2388,111 @@ const workflowsCmd: CommandHandler = async () => {
   return { content: lines.join('\n') }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// /workflow <task> — auto-generate + execute
+// ═══════════════════════════════════════════════════════════════
+
+const workflowSaveCmd = async (name: string): Promise<CommandResult> => {
+  const { existsSync, mkdirSync, writeFileSync, readFileSync } = await import('node:fs')
+  const { join } = await import('node:path')
+
+  const targetDir = join(process.cwd(), '.claude', 'workflows')
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true })
+  }
+
+  // Read the last-run state persisted by the Workflow tool
+  const stateFile = join(targetDir, '.last-run.json')
+  if (!existsSync(stateFile)) {
+    return { content: 'No recent workflow run found. Run a workflow first with /workflow <task>.' }
+  }
+
+  try {
+    const state = JSON.parse(readFileSync(stateFile, 'utf-8'))
+    const script = state.script as string
+    if (!script) {
+      return { content: 'No script found in last run state.' }
+    }
+
+    const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '-')
+    const scriptPath = join(targetDir, `${safeName}.js`)
+    writeFileSync(scriptPath, script, 'utf-8')
+
+    return {
+      content: `Workflow saved to ${scriptPath}\nUse /workflow run ${safeName} to run it again.`,
+    }
+  } catch (err) {
+    return { content: `Failed to save workflow: ${String(err)}` }
+  }
+}
+
+const workflowRunCmd = async (name: string): Promise<CommandResult> => {
+  const { existsSync } = await import('node:fs')
+  const { join } = await import('node:path')
+
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '-')
+
+  const locations = [
+    join(process.cwd(), '.claude', 'workflows'),
+    join(process.env.HOME || '~', '.claude', 'workflows'),
+  ]
+
+  for (const loc of locations) {
+    const scriptPath = join(loc, `${safeName}.js`)
+    if (existsSync(scriptPath)) {
+      return {
+        content: '',
+        forwardToAI:
+          `Read the workflow script at ${scriptPath}, then call the Workflow tool with ` +
+          `the file contents as the "script" parameter to execute it. Report the results.`,
+      }
+    }
+  }
+
+  return {
+    content: `Workflow "${safeName}" not found in .claude/workflows/ or ~/.claude/workflows/`,
+  }
+}
+
+const workflowAutoCmd: CommandHandler = async (_ctx, args) => {
+  const task = args.join(' ').trim()
+
+  if (!task) {
+    return {
+      content:
+        'Usage: /workflow <task description>\n\n' +
+        'Describes the task, and the AI will generate a workflow script to execute it.\n' +
+        'Examples:\n' +
+        '  /workflow audit all routes for missing auth\n' +
+        '  /workflow research the impact of React 19 on our codebase\n' +
+        '  /workflow find all hardcoded credentials in the codebase\n\n' +
+        'Sub-commands:\n' +
+        '  /workflow save <name>  — save last successful workflow script\n' +
+        '  /workflow run <name>    — run a saved workflow by name\n' +
+        '  /workflows              — list all saved workflow scripts',
+    }
+  }
+
+  // Sub-commands
+  const firstArg = args[0] || ''
+  if (firstArg === 'save' && args[1]) {
+    return workflowSaveCmd(args.slice(1).join(' '))
+  }
+  if (firstArg === 'run' && args[1]) {
+    return workflowRunCmd(args.slice(1).join(' '))
+  }
+
+  // Default: forward to AI to generate + execute workflow
+  return {
+    content: '',
+    forwardToAI:
+      `Write and execute a workflow script for this task: ${task}\n\n` +
+      `Use the Workflow tool to execute the generated script. ` +
+      `After the workflow completes, summarize the results and offer to save the script ` +
+      `with /workflow save <name> if it is reusable.`,
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // Permissions
 // ═══════════════════════════════════════════════════════════════
@@ -3052,6 +3157,223 @@ Permission level is controlled by /config permission <level>.`,
 // Security / Audit — security review checklist
 // ═══════════════════════════════════════════════════════════════
 
+const promptAuditCmd: CommandHandler = async () => {
+  const { existsSync, readFileSync, readdirSync, statSync } = await import('node:fs')
+  const { join, extname, basename } = await import('node:path')
+  const cwd = process.cwd()
+
+  // Patterns that suggest prompts written for older/less-capable models
+  const AUDIT_RULES: Array<{
+    id: string
+    pattern: RegExp
+    severity: 'low' | 'medium' | 'high'
+    message: string
+    suggestion: string
+  }> = [
+    {
+      id: 'over-explaining',
+      pattern:
+        /you are (a|an) (helpful |friendly |knowledgeable )?(AI |language model |assistant)/i,
+      severity: 'low',
+      message: 'Self-identification preamble ("You are a...")',
+      suggestion: "Modern models don't need role preamble. Remove or shorten to 1 line.",
+    },
+    {
+      id: 'step-by-step',
+      pattern: /(think|reason|work) (step[ -]?by[ -]?step|through this|carefully about this)/i,
+      severity: 'low',
+      message: 'Step-by-step reasoning prompt',
+      suggestion: 'Reasoning models handle this natively. Remove for token savings.',
+    },
+    {
+      id: 'do-not-list',
+      pattern:
+        /(do not|never|you must not|don't|under no circumstances).*\n.*(do not|never|you must not|don't)/i,
+      severity: 'medium',
+      message: 'Multiple "do not" constraints',
+      suggestion: 'Modern models need fewer prohibitions. Consolidate to 1-2 key constraints.',
+    },
+    {
+      id: 'token-waste',
+      pattern:
+        /(remember|keep in mind|it is important to note|please note that|i want to emphasize)/i,
+      severity: 'low',
+      message: 'Filler emphasis phrases ("remember", "please note")',
+      suggestion: 'Remove filler. State the instruction directly.',
+    },
+    {
+      id: 'format-over-spec',
+      pattern: /(you must (always |only )?respond (in|with|using) (JSON|XML|YAML|markdown|HTML))/i,
+      severity: 'low',
+      message: 'Over-specified output format',
+      suggestion: 'Modern models follow format instructions with fewer words. Shorten.',
+    },
+    {
+      id: 'example-overload',
+      pattern: /((?:example|for instance|e\.g\.,).*\n){3,}/i,
+      severity: 'low',
+      message: 'Three or more examples in sequence',
+      suggestion: '1-2 examples suffice for modern models. Remove redundant ones.',
+    },
+    {
+      id: 'old-model-ref',
+      pattern: /(GPT-3|GPT-3\.5|Claude\s*[12][^3]|text-davinci|command-r|llama\s*2)/i,
+      severity: 'high',
+      message: 'Reference to older model',
+      suggestion: 'Update model references to current generation (Sonnet 5, Opus 5, GPT-5, etc.).',
+    },
+    {
+      id: 'long-preamble',
+      pattern: /^.{200,}$/m,
+      severity: 'medium',
+      message: 'Very long single-line instructions (200+ chars)',
+      suggestion: 'Break into bullet points. Modern models parse structured prompts better.',
+    },
+    {
+      id: 'verbose-constraint',
+      pattern:
+        /you (must|should|shall) (always |only |never )?(ensure|guarantee|verify|validate|confirm|cross-check|double-check)/i,
+      severity: 'medium',
+      message: 'Overly verbose constraint language',
+      suggestion: 'Replace "you must ensure that" with imperative: "Ensure".',
+    },
+  ]
+
+  // Files to scan
+  const scanDirs = [
+    join(cwd, '.mipham', 'skills'),
+    join(cwd, '.mipham', 'rules'),
+    join(cwd, '.claude'),
+  ]
+  const skillFiles: string[] = []
+  // Also check standard project files
+  const projectFiles = [join(cwd, 'CLAUDE.md'), join(cwd, 'MIPHAM.md'), join(cwd, 'PRODUCT.md')]
+
+  // Collect skill/rules files
+  for (const dir of scanDirs) {
+    try {
+      if (!existsSync(dir)) continue
+      const walk = (d: string) => {
+        const entries = readdirSync(d)
+        for (const e of entries) {
+          const fp = join(d, e)
+          const st = statSync(fp)
+          if (st.isDirectory()) {
+            walk(fp)
+            continue
+          }
+          if (['.md', '.SKILL.md', '.mipham-skill.md', '.txt'].some((ext) => fp.endsWith(ext))) {
+            skillFiles.push(fp)
+          }
+        }
+      }
+      walk(dir)
+    } catch {
+      /* skip */
+    }
+  }
+
+  const allFiles = [...new Set([...projectFiles.filter((f) => existsSync(f)), ...skillFiles])]
+
+  if (allFiles.length === 0) {
+    return {
+      content: [
+        '🔍 Prompt Audit',
+        '',
+        'No prompt files found to audit.',
+        'Place skills in .mipham/skills/ and rules in .mipham/rules/.',
+      ].join('\n'),
+    }
+  }
+
+  // Scan each file
+  const results: Array<{
+    file: string
+    line: number
+    ruleId: string
+    severity: string
+    message: string
+    suggestion: string
+  }> = []
+
+  for (const fp of allFiles) {
+    try {
+      const content = readFileSync(fp, 'utf-8')
+      const lines = content.split('\n')
+      for (const rule of AUDIT_RULES) {
+        // Multi-line pattern: check full content
+        if (rule.id === 'do-not-list' || rule.id === 'example-overload') {
+          if (rule.pattern.test(content)) {
+            // Find approx line
+            const match = rule.pattern.exec(content)
+            const idx = match ? content.slice(0, match.index).split('\n').length : 1
+            results.push({
+              file: fp.replace(cwd + '/', ''),
+              line: idx,
+              ruleId: rule.id,
+              severity: rule.severity,
+              message: rule.message,
+              suggestion: rule.suggestion,
+            })
+          }
+          continue
+        }
+
+        // Line-by-line patterns
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i]!
+          if (rule.pattern.test(line)) {
+            results.push({
+              file: fp.replace(cwd + '/', ''),
+              line: i + 1,
+              ruleId: rule.id,
+              severity: rule.severity,
+              message: rule.message,
+              suggestion: rule.suggestion,
+            })
+          }
+        }
+      }
+    } catch {
+      /* skip unreadable files */
+    }
+  }
+
+  // Format output
+  const severityIcon: Record<string, string> = { high: '🔴', medium: '🟡', low: '🟢' }
+  const grouped: Record<string, typeof results> = {}
+  for (const r of results) {
+    const key = r.file
+    if (!grouped[key]) grouped[key] = []
+    grouped[key]!.push(r)
+  }
+
+  const output: string[] = [
+    `🔍 Prompt Audit — ${allFiles.length} file(s) scanned, ${results.length} finding(s)`,
+    '',
+  ]
+
+  if (results.length === 0) {
+    output.push('✅ All prompts look optimized for modern models. No issues found.')
+  } else {
+    for (const [file, items] of Object.entries(grouped)) {
+      output.push(`📄 ${file} (${items!.length} finding${items!.length > 1 ? 's' : ''})`)
+      for (const item of items!) {
+        output.push(
+          `  ${severityIcon[item.severity] || '⚪'} L${item.line}: [${item.ruleId}] ${item.message}`,
+        )
+        output.push(`     → ${item.suggestion}`)
+      }
+      output.push('')
+    }
+  }
+
+  output.push('─'.repeat(60))
+  output.push('Scanned: ' + allFiles.map((f) => basename(f)).join(', '))
+
+  return { content: output.join('\n') }
+}
+
 const securityCmd: CommandHandler = async () => {
   const findings: string[] = []
   const ok: string[] = []
@@ -3691,6 +4013,128 @@ Run \`mipham agents\` for the interactive dashboard.`,
 // Artifacts
 // ═══════════════════════════════════════════════════════════════
 
+const forkCmd: CommandHandler = async (ctx, args) => {
+  const prompt = args.join(' ')
+  if (!prompt.trim()) {
+    return {
+      content: [
+        'Usage: /fork <task description>',
+        '',
+        'Fork a task into an isolated worktree with auto commit/push.',
+        '',
+        'Workflow:',
+        '  1. Creates a new git worktree on branch worktree/<slug>',
+        '  2. Spawns a background agent to work on the task',
+        '  3. Auto-commits changes with Co-Authored-By on completion',
+        '  4. Auto-pushes to origin',
+        '  5. Reports branch and worktree path in the result',
+        '',
+        'Examples:',
+        '  /fork Refactor the auth module',
+        '  /fork Add input validation to all API endpoints',
+      ].join('\n'),
+    }
+  }
+
+  const { execSync } = await import('node:child_process')
+  const { join } = await import('node:path')
+
+  try {
+    execSync('git rev-parse --git-dir', { stdio: 'ignore' })
+  } catch {
+    return { content: '/fork requires a git repository.' }
+  }
+
+  const agentViewManager = ctx.engine.getAgentViewManager?.()
+  if (!agentViewManager) {
+    return { content: 'Agent View manager is initializing...' }
+  }
+
+  const slug = prompt
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 40)
+  const name = `${slug}-${Date.now().toString(36)}`
+  const branch = `worktree/${name}`
+  const wtPath = join(process.cwd(), '.claude', 'worktrees', name)
+
+  try {
+    execSync(`git worktree add -b ${branch} ${wtPath} HEAD`, { stdio: 'ignore', timeout: 30_000 })
+  } catch (err) {
+    try {
+      execSync(`git worktree remove --force ${wtPath}`, { stdio: 'ignore' })
+    } catch {
+      /* ok */
+    }
+    try {
+      execSync(`git branch -D ${branch}`, { stdio: 'ignore' })
+    } catch {
+      /* ok */
+    }
+    return {
+      content: `Worktree creation failed: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+
+  const session = agentViewManager.create(prompt, prompt, {
+    provider: ctx.providerId,
+    model: ctx.modelId,
+  })
+  agentViewManager.addMessage(session.id, { role: 'user', content: prompt })
+  agentViewManager.updateStatus(session.id, 'working')
+  session.worktree = wtPath
+  session.branch = branch
+  session.kind = 'forked'
+
+  const bgReg = (await import('../agent/background-registry')).getBackgroundAgentRegistry()
+  bgReg.spawn(
+    prompt,
+    'general',
+    async (_signal) => {
+      const { SubAgent } = await import('../agent/sub-agent')
+      const sa = new SubAgent(ctx.engine.getRegistry(), ctx.engine.getTools())
+      const result = await sa.execute(prompt, 'fork: ' + prompt.slice(0, 60), {})
+      try {
+        const { execSync: ex } = await import('node:child_process')
+        ex(`git -C ${wtPath} add -A`, { stdio: 'ignore', timeout: 10_000 })
+        const st = ex(`git -C ${wtPath} status --porcelain`, { encoding: 'utf-8', timeout: 10_000 })
+        if (st.trim()) {
+          ex(
+            `git -C ${wtPath} commit -m "feat: ${prompt.slice(0, 60)}\n\nCo-Authored-By: Claude <noreply@anthropic.com>"`,
+            { stdio: 'ignore', timeout: 10_000 },
+          )
+          ex(`git push origin ${branch}`, { stdio: 'ignore', timeout: 30_000 })
+        }
+      } catch {
+        /* best-effort */
+      }
+      return [
+        `## Fork done: ${prompt}`,
+        '',
+        `Branch: \`${branch}\``,
+        `Worktree: \`${wtPath}\``,
+        '',
+        result || '(no output)',
+      ].join('\n')
+    },
+    'forked',
+  )
+
+  return {
+    content: [
+      `✓ Forked: ${session.id}`,
+      `  Task: ${prompt.slice(0, 80)}`,
+      `  Branch: ${branch}`,
+      `  Worktree: ${wtPath}`,
+      `  Status: working`,
+      '',
+      'Agent will auto-commit + push on completion.',
+      'Use /agents to track.',
+    ].join('\n'),
+  }
+}
+
 async function openBrowser(url: string): Promise<void> {
   const cmd =
     process.platform === 'darwin'
@@ -3857,6 +4301,7 @@ const commandsListCmd: CommandHandler = () => {
     '/recommend': 'Project',
     '/security': 'Project',
     '/audit': 'Project',
+    '/prompt-audit': 'Code Quality',
     '/ide': 'Environment',
     '/terminal-setup': 'Environment',
     '/memory': 'Environment',
@@ -3866,6 +4311,7 @@ const commandsListCmd: CommandHandler = () => {
     '/feedback': 'Account',
     '/agents': 'Agents',
     '/bg': 'Agents',
+    '/fork': 'Agents',
     '/artifact': 'Artifacts',
     '/schedule': 'Other',
     '/commit': 'Workflow',
@@ -3977,6 +4423,7 @@ registry.set('/tasks', tasksCmd)
 registry.set('/diff', diffCmd)
 registry.set('/loop', loopCmd)
 registry.set('/no-plan', noPlanCmd)
+registry.set('/workflow', workflowAutoCmd)
 registry.set('/workflows', workflowsCmd)
 registry.set('/review', reviewCmd)
 registry.set('/pr-comments', prCommentsCmd)
@@ -3996,6 +4443,7 @@ registry.set('/permissions', permissionsCmd)
 registry.set('/add-dir', addDirCmd)
 registry.set('/security', securityCmd)
 registry.set('/audit', securityCmd)
+registry.set('/prompt-audit', promptAuditCmd)
 
 // Environment
 registry.set('/theme', themeCmd)
@@ -4010,6 +4458,7 @@ registry.set('/logout', logoutCmd)
 registry.set('/feedback', feedbackCmd)
 registry.set('/agents', agentsCmd)
 registry.set('/bg', bgCmd)
+registry.set('/fork', forkCmd)
 
 // Artifacts
 registry.set('/artifact', artifactBaseCmd)
@@ -4119,6 +4568,7 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/recommend': 'Analyze project + recommend skills & setup',
   '/security': 'Security review checklist',
   '/audit': 'Same as /security',
+  '/prompt-audit': 'Audit prompts for modern model optimization',
   '/ide': 'IDE integration guide',
   '/terminal-setup': 'Shell & terminal config',
   '/memory': 'Manage AI memories',
@@ -4129,6 +4579,7 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/feedback': 'Send feedback',
   '/agents': 'Agent view dashboard',
   '/bg': 'Run a background agent task',
+  '/fork': 'Fork task into isolated worktree',
   '/artifact': 'Manage artifacts',
   '/schedule': 'View scheduled tasks and cron jobs',
   '/commit': 'Generate commit message and review staged changes',