@miphamai/cli 0.36.2 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.36.2",
+  "version": "0.37.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/agent-registry.ts

@@ -73,7 +73,7 @@ export class AgentRegistry {
                 .split(',')
                 .map((s) => s.trim())
             : undefined,
-          background: (data.background as boolean) || false,
+          background: typeof data.background === 'boolean' ? data.background : undefined,
           memory: data.memory as 'user' | 'project' | 'local' | undefined,
           source,
           filePath: fullPath,
@@ -125,7 +125,6 @@ export class AgentRegistry {
         systemPrompt: BUILTIN_SYSTEM_PROMPTS[builtinType],
         model: 'inherit',
         permissionMode: 'inherit',
-        background: false,
         source: 'builtin',
       }
     }

package/src/agent/message-router.ts

@@ -2,6 +2,7 @@ import { getMessageBus } from './message-bus'
 import { getFileInboxTransport } from './cross-session/file-inbox'
 import { discoverSessions, createSessionInfo } from './cross-session/discovery'
 import type { AgentMessage } from './message-bus'
+import type { SessionInfo } from '../shared/types'
 
 export interface RouteResult {
   success: boolean
@@ -10,6 +11,35 @@ export interface RouteResult {
   messageId?: string
 }
 
+export interface SessionResolution {
+  session?: SessionInfo
+  error?: string
+}
+
+/**
+ * Resolve a recipient among live sessions by bare name — session ID first,
+ * then session name. A name must uniquely match exactly one session; ambiguity
+ * and non-matches are reported as errors.
+ */
+export function resolveRecipientSession(sessions: SessionInfo[], to: string): SessionResolution {
+  const byId = sessions.find((s) => s.id === to)
+  if (byId) return { session: byId }
+
+  const byName = sessions.filter((s) => s.name === to)
+  if (byName.length === 1) return { session: byName[0] }
+  if (byName.length > 1) {
+    return {
+      error:
+        `Ambiguous session name "${to}" matches ${byName.length} live sessions. ` +
+        `Use a session ID to disambiguate (ListAgents).`,
+    }
+  }
+
+  return {
+    error: `No active session found matching "${to}". Use ListAgents to discover available sessions.`,
+  }
+}
+
 /**
  * MessageRouter decides how to deliver a message based on the recipient.
  *
@@ -33,17 +63,14 @@ export class MessageRouter {
       }
     }
 
-    // Cross-session routing
+    // Cross-session routing (by session ID or bare name)
     const sessions = discoverSessions()
-    const targetSession = sessions.find((s) => s.id === to)
+    const resolution = resolveRecipientSession(sessions, to)
 
-    if (!targetSession) {
-      return {
-        success: false,
-        routedTo: 'unknown',
-        error: `No active session found with ID "${to}". Use ListAgents to discover available sessions.`,
-      }
+    if (resolution.error) {
+      return { success: false, routedTo: 'unknown', error: resolution.error }
     }
+    const targetSession = resolution.session!
 
     // Get sender info
     const senderSession = createSessionInfo(from, from)
@@ -53,7 +80,7 @@ export class MessageRouter {
       const msg: AgentMessage = {
         id: `xmsg-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
         from,
-        to,
+        to: targetSession.id,
         summary: summary.slice(0, 200),
         message,
         timestamp: new Date(),
@@ -61,7 +88,7 @@ export class MessageRouter {
         type: 'message',
       }
 
-      const delivered = await transport.send(senderSession, to, msg)
+      const delivered = await transport.send(senderSession, targetSession.id, msg)
       if (!delivered) {
         return { success: false, routedTo: 'inbox', error: 'Failed to write message to inbox.' }
       }

package/src/agent/sub-agent.ts

@@ -270,6 +270,13 @@ export class SubAgent {
     )
 
     context.setSystemPrompt(systemPrompt)
+
+    // Seed inherited parent conversation (fork inheritance) as a byte-identical
+    // prefix so the provider prompt cache is reused.
+    if (options.inheritContext && options.inheritContext.messages.length > 0) {
+      context.seedMessages(options.inheritContext.messages)
+    }
+
     context.addMessage({ role: 'user', content: prompt })
 
     const messages = context.getMessages()

package/src/agent/types.ts

@@ -1,5 +1,7 @@
 // apps/cli/src/agent/types.ts
 
+import type { Message } from '../shared/index.ts'
+
 export type SubAgentType = 'general' | 'explore' | 'plan' | 'code-review'
 
 export interface AgentFrontmatter {
@@ -26,7 +28,8 @@ export interface AgentDefinition {
   permissionMode: string
   maxTurns?: number
   skills?: string[]
-  background: boolean
+  /** Force background (true) or sync (false) execution. Unset inherits the tool default. */
+  background?: boolean
   source: 'builtin' | 'project' | 'user'
   filePath?: string
   memory?: 'user' | 'project' | 'local' // agent memory scope
@@ -47,6 +50,8 @@ export interface SubAgentOptions {
   onProgress?: (chunk: string) => void
   /** When set, tool executions use this path as cwd (git worktree isolation). */
   worktreePath?: string
+  /** Seed the sub-agent with a parent conversation prefix (e.g., fork inheritance). */
+  inheritContext?: { messages: Message[] }
   /** CRSI: when false, skip pattern analysis after agent execution. Default true. */
   autoPatternAnalysis?: boolean
 }

package/src/core/context-token.ts

@@ -12,6 +12,8 @@ export interface CacheTracker {
   isInCache(msg: Message): boolean
   /** Returns a snapshot of the cache state for metrics / logging. */
   getStatus(): CacheStatus
+  /** Record the set of messages currently held in the provider prompt cache. */
+  markCached?(messages: Message[]): void
   /** Clear the tracker state (does NOT evict from provider cache). */
   invalidate(): void
 }
@@ -41,11 +43,53 @@ export class NoopCacheTracker implements CacheTracker {
     this.messageCount = messages.length
   }
 
+  markCached(_messages: Message[]): void {
+    // No-op — prompt caching is disabled with this tracker.
+  }
+
   invalidate(): void {
     this.messageCount = 0
   }
 }
 
+/**
+ * Tracks which messages are currently held in the provider's prompt cache.
+ * The engine informs it of the cached prefix after each successful request
+ * (Anthropic caches "all messages except the newest"; DeepSeek/OpenAI auto-cache
+ * the same prefix). Object-identity based, so it stays valid across the
+ * ContextManager's shallow-copied message arrays.
+ */
+export class PrefixCacheTracker implements CacheTracker {
+  private cachedMessages = new WeakSet<Message>()
+  private cachedCount = 0
+  private cachedTokens = 0
+
+  markCached(messages: Message[]): void {
+    this.cachedMessages = new WeakSet(messages)
+    this.cachedCount = messages.length
+    this.cachedTokens = messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0)
+  }
+
+  isInCache(msg: Message): boolean {
+    return this.cachedMessages.has(msg)
+  }
+
+  getStatus(): CacheStatus {
+    return {
+      totalMessages: this.cachedCount,
+      cachedMessages: this.cachedCount,
+      cachedTokens: this.cachedTokens,
+      uncachedTokens: 0,
+    }
+  }
+
+  invalidate(): void {
+    this.cachedMessages = new WeakSet()
+    this.cachedCount = 0
+    this.cachedTokens = 0
+  }
+}
+
 /**
  * Estimate the token count for a single message.
  *

package/src/core/context.ts

@@ -116,6 +116,17 @@ export class ContextManager {
     this.checkCompression()
   }
 
+  /**
+   * Seed a batch of pre-existing messages (e.g., an inherited parent
+   * conversation). Unlike addMessage, this does not trigger compaction so the
+   * byte-identical prefix is preserved for prompt-cache hits.
+   */
+  seedMessages(messages: Message[]): void {
+    if (messages.length === 0) return
+    this.messages.push(...messages)
+    this.reEstimateTokens()
+  }
+
   getMessages(): Message[] {
     return [...this.messages]
   }
@@ -252,6 +263,11 @@ export class ContextManager {
     this.cacheTracker = tracker
   }
 
+  /** Mark a set of messages as cached by the provider (called after a request). */
+  markCached(messages: Message[]): void {
+    this.cacheTracker.markCached?.(messages)
+  }
+
   /** Get a snapshot of the provider prompt-cache state. */
   getCacheStatus(): CacheStatus {
     return this.cacheTracker.getStatus()

package/src/core/credential-masker/output-scrub.ts

@@ -1,6 +1,15 @@
 import { CREDENTIAL_SENTINEL } from './types'
 import type { CredentialMaskingConfig } from '../../shared/index.ts'
 
+/**
+ * Well-known secret token prefixes. These are high-signal formats that must
+ * never leak into output, independent of the configured patterns.
+ * - GitHub: ghp_ (personal access), gho_ (OAuth), ghs_ (server), ghu_/ghr_ (user/server-to-server), github_pat_ (fine-grained)
+ * - GitLab: glpat- (personal access), gldt- (deploy), glrt- (runner), gloas- (OAuth app)
+ */
+const TOKEN_REDACTION_PATTERN =
+  /\b(?:ghp_|gho_|ghs_|ghu_|ghr_|github_pat_|glpat-|gldt-|glrt-|gloas-)[A-Za-z0-9_-]{8,}/g
+
 /**
  * Scrub credential patterns from stdout/stderr output.
  * Uses the configured output_scrubbing patterns to detect and replace
@@ -10,6 +19,10 @@ export function maskOutput(output: string, config: CredentialMaskingConfig): str
   if (!config.enabled || !config.output_scrubbing.enabled) return output
 
   let masked = output
+
+  // Redact bare secret tokens by prefix (always on, independent of config patterns).
+  masked = masked.replace(TOKEN_REDACTION_PATTERN, CREDENTIAL_SENTINEL)
+
   for (const pattern of config.output_scrubbing.patterns) {
     try {
       // Strip (?i) inline flags — JS uses the 'i' flag instead

package/src/core/engine.ts

@@ -532,6 +532,12 @@ export class QueryEngine {
       return
     }
 
+    // Record the provider's cached prefix (all messages except the newest)
+    // for cache-aware microcompaction.
+    if (messages.length >= 2) {
+      this.context.markCached(messages.slice(0, -1))
+    }
+
     // Track last assistant content for goal checking
     if (assistantContent) {
       this.lastAssistantContent = assistantContent

package/src/index.tsx

@@ -21,6 +21,7 @@ import { bootstrapProviders } from './providers/bootstrap'
 import { InstructionsLoader } from './core/instructions'
 import { loadSessionMemories, getMemoryManager } from './core/memory/memory-loader'
 import { ContextManager } from './core/context'
+import { PrefixCacheTracker } from './core/context-token'
 import { QueryEngine } from './core/engine'
 import { ExperienceRuleEngine } from './core/rule-engine.js'
 import { SessionStore } from './core/session-store'
@@ -325,6 +326,8 @@ export async function runApp(options: RunOptions): Promise<void> {
     compactionThreshold: 0.9,
     contextWindow: adaptiveThresholds ? modelContextWindow : undefined,
   })
+  // Cache-aware microcompaction: track the provider's prompt-cache prefix.
+  context.setCacheTracker(new PrefixCacheTracker())
 
   // Adaptive memory budget: scale with model's context window
   getMemoryManager().setContextWindow(modelContextWindow)

package/src/providers/anthropic.ts

@@ -52,15 +52,20 @@ export class AnthropicProvider implements ProviderInstance {
     let currentToolId = ''
     let accumulatedToolInput = ''
 
+    const messages = this.convertMessages(req.messages)
+    this.markPrefixCacheBreakpoint(messages)
+
     const body: Record<string, unknown> = {
       model: req.model,
       max_tokens: req.maxTokens || 4096,
       stream: true,
-      messages: this.convertMessages(req.messages),
+      messages,
     }
 
     if (req.systemPrompt) {
-      body.system = req.systemPrompt
+      // Mark the system prompt for prompt caching — it's the largest stable
+      // block and byte-identical across turns, so it always hits the cache.
+      body.system = [{ type: 'text', text: req.systemPrompt, cache_control: { type: 'ephemeral' } }]
     }
 
     if (req.temperature !== undefined) {
@@ -68,11 +73,14 @@ export class AnthropicProvider implements ProviderInstance {
     }
 
     if (req.tools && req.tools.length > 0) {
-      body.tools = req.tools.map((t) => ({
+      const tools: Record<string, unknown>[] = req.tools.map((t) => ({
         name: t.name,
         description: t.description,
         input_schema: t.parameters || t.input_schema || { type: 'object', properties: {} },
       }))
+      // Cache the tools: mark the last tool definition as a breakpoint.
+      tools[tools.length - 1]!.cache_control = { type: 'ephemeral' }
+      body.tools = tools
     }
 
     const response = await fetchWithRetry(`${this.baseUrl}/messages`, {
@@ -239,6 +247,20 @@ export class AnthropicProvider implements ProviderInstance {
     return apiKey.length > 0 && apiKey.startsWith('sk-ant-')
   }
 
+  /**
+   * Mark the stable conversation prefix for prompt caching. The breakpoint is
+   * placed on the last block of the second-to-last message, leaving only the
+   * newest message uncached.
+   */
+  private markPrefixCacheBreakpoint(messages: Record<string, unknown>[]): void {
+    if (messages.length < 2) return
+    const boundary = messages[messages.length - 2]!
+    const content = boundary.content
+    if (!Array.isArray(content) || content.length === 0) return
+    const lastBlock = content[content.length - 1] as Record<string, unknown>
+    lastBlock.cache_control = { type: 'ephemeral' }
+  }
+
   private convertMessages(messages: Message[]): Record<string, unknown>[] {
     const result: Record<string, unknown>[] = []
 

package/src/tools/agent/agent.ts

@@ -5,13 +5,26 @@ import { getBackgroundAgentRegistry } from '../../agent/background-registry'
 
 const VALID_TYPES: SubAgentType[] = ['general', 'explore', 'plan', 'code-review']
 
+/**
+ * Resolve whether a sub-agent should run in the background.
+ * Precedence: explicit `run_in_background` param > agent frontmatter
+ * `background` field > default (background, Claude Code 2.1.232 parity).
+ */
+export function resolveRunInBackground(
+  runInBackground: boolean | undefined,
+  agentDef?: { background?: boolean },
+): boolean {
+  return runInBackground ?? agentDef?.background ?? true
+}
+
 export const agentTool: ToolDefinition = {
   name: 'Agent',
   description:
     'Launch a sub-agent to handle complex, multi-step tasks independently. ' +
     'Available types: general (default), explore (code search), plan (design), code-review. ' +
-    'Set run_in_background: true to execute asynchronously — returns a task ID immediately; ' +
-    'results are retrievable via the Task tool (output action) or Agent View.',
+    'Runs in the background by default — returns a task ID immediately; results are ' +
+    'retrievable via the Task tool (output action) or Agent View. ' +
+    'Set run_in_background: false to run synchronously.',
   category: 'agent',
   permission: 'ask',
   parameters: {
@@ -26,7 +39,7 @@ export const agentTool: ToolDefinition = {
       run_in_background: {
         type: 'boolean',
         description:
-          'When true, execute asynchronously and return a task ID immediately. Use Task output to retrieve results. Default: false.',
+          'When false, execute synchronously and return the result directly. Default: true (background).',
       },
     },
     required: ['description', 'prompt'],
@@ -35,7 +48,6 @@ export const agentTool: ToolDefinition = {
     const description = params.description as string
     const prompt = params.prompt as string
     const agentType = (params.subagent_type as SubAgentType) || 'general'
-    const runInBackground = params.run_in_background === true
 
     if (!VALID_TYPES.includes(agentType)) {
       return {
@@ -58,6 +70,10 @@ export const agentTool: ToolDefinition = {
 
     // Resolve agent definition from registry (custom > builtin)
     const agentDef = ctx.agentRegistry?.resolve(agentType)
+    const runInBackground = resolveRunInBackground(
+      params.run_in_background as boolean | undefined,
+      agentDef,
+    )
 
     try {
       const sub = new SubAgent(

package/src/tools/agent/send-message.ts

@@ -6,7 +6,7 @@ export const sendMessageTool: ToolDefinition = {
   description:
     'Send a message to another agent or session. ' +
     'Use "main" for the parent conversation, a background task ID for same-process agents, ' +
-    'or a session ID for cross-session messaging (use ListAgents to discover sessions).',
+    'or a session ID (or unique session name) for cross-session messaging (use ListAgents to discover sessions).',
   category: 'agent',
   permission: 'auto',
   parameters: {
@@ -15,7 +15,7 @@ export const sendMessageTool: ToolDefinition = {
       to: {
         type: 'string',
         description:
-          'Recipient: "main" for the parent conversation, a background task ID, or a session ID for cross-session messaging.',
+          'Recipient: "main" for the parent conversation, a background task ID, or a session ID / unique session name for cross-session messaging.',
       },
       summary: {
         type: 'string',

package/src/tools/exec/bash.ts

@@ -1,5 +1,6 @@
 import type { ToolDefinition, CredentialMaskingConfig } from '../../shared/index.ts'
 import { sanitizeCommand } from '../../shared/sanitize.ts'
+import { DANGEROUS_GIT_PATTERNS } from './git.ts'
 
 // Injected at startup — set via index.tsx
 let credentialConfig: CredentialMaskingConfig | undefined
@@ -124,6 +125,19 @@ function isBlocked(command: string): string | null {
     return `Command "${sanitizedFirstWord}" rejected by security policy.`
   }
 
+  // Detect dangerous git operations invoked via Bash. The Git tool guards these,
+  // but shelling out with `git push --force` would bypass it — apply the same
+  // pattern list to any Bash command that starts with a git invocation.
+  const gitInvocation = normalized.trim().match(/^(?:sudo\s+)?git(?:\s+|$)(.*)$/i)
+  if (gitInvocation) {
+    const subcommand = gitInvocation[1] || ''
+    for (const { pattern, description } of DANGEROUS_GIT_PATTERNS) {
+      if (pattern.test(subcommand)) {
+        return `Dangerous git command blocked: "${description}". Run manually if intended.`
+      }
+    }
+  }
+
   // Check dangerous patterns (on original, normalized, and sanitized)
   for (const pattern of BLOCKED_PATTERNS) {
     if (pattern.test(command) || pattern.test(normalized) || pattern.test(sanitized)) {

package/src/tools/exec/git.ts

@@ -2,7 +2,7 @@ import type { ToolDefinition } from '../../shared/index.ts'
 
 // P0-4 (v2.1.222 alignment): Regex-based word-boundary patterns replace
 // fragile substring matching. Each pattern describes what it blocks.
-const DANGEROUS_GIT_PATTERNS: Array<{ pattern: RegExp; description: string }> = [
+export const DANGEROUS_GIT_PATTERNS: Array<{ pattern: RegExp; description: string }> = [
   // Destructive push
   { pattern: /\bpush\s+.*--force(?:-with-lease)?\b/, description: 'push --force' },
   { pattern: /\bpush\s+.*-[fF]\b/, description: 'push -f (force)' },

package/src/ui/commands.ts

@@ -4041,8 +4041,10 @@ const forkCmd: CommandHandler = async (ctx, args) => {
         ctx.engine.getTools(),
         ctx.engine.getPermission(),
       )
+      const parentContext = ctx.engine.getContext()
       const result = await sa.execute(prompt, 'fork: ' + prompt.slice(0, 60), {
         worktreePath: wtPath,
+        inheritContext: { messages: parentContext.getMessages() },
       })
       try {
         const { execSync: ex } = await import('node:child_process')