@miphamai/cli 0.36.1 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.36.1",
+  "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

@@ -446,13 +446,12 @@ export class QueryEngine {
 
     // Stream model response
     try {
-      for await (const chunk of this.registry.chat({
-        model: this.registry.getActiveModel(),
+      for await (const chunk of this.chatWithFallback(
         messages,
         systemPrompt,
-        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        toolDefs.length > 0 ? toolDefs : undefined,
         signal,
-      })) {
+      )) {
         yield chunk
 
         if (chunk.type === 'error') {
@@ -533,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
@@ -1144,6 +1149,80 @@ export class QueryEngine {
     return this.registry
   }
 
+  /**
+   * Stream a chat response with graceful provider fallback (v2.1.229 alignment).
+   *
+   * On a connection/availability failure from the active provider (thrown
+   * network error or an error chunk), switches to the configured default
+   * provider and retries once, yielding a `warning` chunk so the UI can tell
+   * the user the provider degraded. Abort errors propagate untouched.
+   */
+  private async *chatWithFallback(
+    messages: import('../shared/types').Message[],
+    systemPrompt: string,
+    toolDefs: Record<string, unknown>[] | undefined,
+    signal?: AbortSignal,
+  ): AsyncGenerator<StreamChunk> {
+    const activeId = this.registry.getActive().config.id
+    const defaultId = this.registry.getDefaultProviderId()
+
+    // ── Attempt 1: active provider ──
+    let failure: string | null = null
+    try {
+      for await (const chunk of this.registry.chat({
+        model: this.registry.getActiveModel(),
+        messages,
+        systemPrompt,
+        tools: toolDefs,
+        signal,
+      })) {
+        if (chunk.type === 'error') {
+          failure = chunk.error ?? 'Unknown error'
+          break
+        }
+        yield chunk
+      }
+      if (failure === null) return
+    } catch (err) {
+      if (isAbortError(err)) throw err
+      failure = String(err)
+    }
+
+    // ── Fallback: configured default provider, once ──
+    if (!defaultId || defaultId === activeId || !this.registry.get(defaultId)) {
+      yield { type: 'error', error: failure }
+      return
+    }
+    const fallbackModel = this.registry
+      .get(defaultId)!
+      .config.models.find((m) => m.status === 'active')?.id
+    if (!fallbackModel) {
+      yield { type: 'error', error: failure }
+      return
+    }
+
+    this.registry.switchProvider(defaultId, fallbackModel)
+    yield {
+      type: 'warning',
+      content: `${activeId} unreachable — degraded to ${defaultId} (${fallbackModel})`,
+    }
+
+    try {
+      for await (const chunk of this.registry.chat({
+        model: fallbackModel,
+        messages,
+        systemPrompt,
+        tools: toolDefs,
+        signal,
+      })) {
+        yield chunk
+      }
+    } catch (err) {
+      if (isAbortError(err)) throw err
+      yield { type: 'error', error: String(err) }
+    }
+  }
+
   getTools(): Map<string, ToolDefinition> {
     return this.tools
   }

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/providers/openai-compat.ts

@@ -8,9 +8,13 @@ export class OpenAICompatProvider implements ProviderInstance {
   constructor(public config: ProviderConfig) {}
 
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
-    // Accept both baseUrl and baseURL (common YAML typo)
+    // Accept both baseUrl and baseURL (common YAML typo); resolve env templates
     const rawBase = (this.config as any).baseUrl || (this.config as any).baseURL
-    const baseUrl = rawBase?.replace(/\/+$/, '') || 'https://api.openai.com/v1'
+    const baseUrl =
+      this.resolveEnvTemplate(
+        rawBase?.replace(/\/+$/, '') || '',
+        'OpenAI-compatible provider: baseUrl',
+      ) || 'https://api.openai.com/v1'
     const apiKey = this.resolveApiKey(this.config.apiKey)
 
     const body = {
@@ -224,11 +228,18 @@ export class OpenAICompatProvider implements ProviderInstance {
   async healthCheck(): Promise<boolean> {
     try {
       const rawBase = (this.config as any).baseUrl || (this.config as any).baseURL
-      const baseUrl = rawBase?.replace(/\/+$/, '') || 'https://api.openai.com/v1'
+      const baseUrl =
+        this.resolveEnvTemplate(
+          rawBase?.replace(/\/+$/, '') || '',
+          'OpenAI-compatible provider: baseUrl',
+        ) || 'https://api.openai.com/v1'
       const apiKey = this.resolveApiKey(this.config.apiKey)
-      const res = await fetch(`${baseUrl}/models`, {
-        headers: { Authorization: `Bearer ${apiKey}` },
-      })
+      // 5s timeout so a down endpoint doesn't hang health checks (v2.1.229 alignment)
+      const res = await fetchWithRetry(
+        `${baseUrl}/models`,
+        { headers: { Authorization: `Bearer ${apiKey}` } },
+        { timeout: 5000, maxRetries: 0 },
+      )
       return res.ok
     } catch {
       return false
@@ -366,21 +377,25 @@ export class OpenAICompatProvider implements ProviderInstance {
     }
   }
 
-  private resolveApiKey(keyTemplate: string): string {
-    // Accept both ${VAR} and $VAR syntax
-    let match = keyTemplate.match(/^\$\{(.+)\}$/)
-    if (!match) match = keyTemplate.match(/^\$([A-Z_][A-Z0-9_]*)$/)
+  /** Resolve a `${VAR}` / `$VAR` template against the environment. */
+  private resolveEnvTemplate(value: string, warnPrefix: string): string {
+    let match = value.match(/^\$\{(.+)\}$/)
+    if (!match) match = value.match(/^\$([A-Z_][A-Z0-9_]*)$/)
     if (match?.[1]) {
       const varName = match[1]
-      const value = process.env[varName]
-      if (!value) {
+      const envValue = process.env[varName]
+      if (!envValue) {
         process.stderr.write(
-          `⚠ OpenAI-compatible provider: apiKey references $${varName} but that environment variable is not set\n`,
+          `⚠ ${warnPrefix} references $${varName} but that environment variable is not set\n`,
         )
         return ''
       }
-      return value
+      return envValue
     }
-    return keyTemplate
+    return value
+  }
+
+  private resolveApiKey(keyTemplate: string): string {
+    return this.resolveEnvTemplate(keyTemplate, 'OpenAI-compatible provider: apiKey')
   }
 }

package/src/providers/registry.ts

@@ -21,10 +21,24 @@ export class ProviderRegistry {
   private providers = new Map<string, ProviderInstance>()
   private activeProviderId: string
   private activeModelId: string
+  private defaultProviderId: string
+  private defaultModelId: string
 
   constructor(providers: ProviderConfig[], defaultProvider: string, defaultModel: string) {
     this.activeProviderId = defaultProvider
     this.activeModelId = defaultModel
+    this.defaultProviderId = defaultProvider
+    this.defaultModelId = defaultModel
+  }
+
+  /** The configured default provider id (used for fallback routing). */
+  getDefaultProviderId(): string {
+    return this.defaultProviderId
+  }
+
+  /** The configured default model id. */
+  getDefaultModelId(): string {
+    return this.defaultModelId
   }
 
   register(id: string, instance: ProviderInstance): void {
@@ -72,6 +86,32 @@ export class ProviderRegistry {
     return undefined
   }
 
+  /**
+   * Check a single provider's health. Returns undefined if not registered,
+   * otherwise the provider's healthCheck() result. Never throws.
+   */
+  async healthStatus(id: string): Promise<boolean | undefined> {
+    const provider = this.providers.get(id)
+    if (!provider) return undefined
+    try {
+      return await provider.healthCheck()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Health of all registered providers, checked concurrently.
+   * Returns a Map of provider id → reachable boolean.
+   */
+  async healthMap(): Promise<Map<string, boolean>> {
+    const ids = this.listIds()
+    const results = await Promise.all(
+      ids.map(async (id) => [id, (await this.healthStatus(id)) ?? false] as const),
+    )
+    return new Map(results)
+  }
+
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
     const provider = this.getActive()
     yield* provider.chat({ ...req, model: req.model || this.activeModelId })

package/src/shared/types.ts

@@ -129,6 +129,7 @@ export interface StreamChunk {
     | 'thinking'
     | 'stop'
     | 'error'
+    | 'warning'
     | 'task_notification'
     | 'usage'
   content?: string

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/app.tsx

@@ -658,6 +658,17 @@ export function App({
             ])
           }
 
+          if (chunk.type === 'warning' && chunk.content) {
+            setMessages((prev) => [...prev, { role: 'system', content: `⚠ ${chunk.content}` }])
+            // Keep the footer's provider/model in sync after an automatic fallback
+            // switch. RemoteEngine's registry is a stub without getActive.
+            const registry = engine.getRegistry()
+            if ('getActive' in registry) {
+              setProviderId(registry.getActive().config.id)
+              setModelId(registry.getActiveModel())
+            }
+          }
+
           if (chunk.type === 'task_notification' && chunk.taskNotification) {
             const tn = chunk.taskNotification
             const isDone = tn.status === 'completed'

package/src/ui/commands.ts

@@ -317,12 +317,20 @@ const contextCmd: CommandHandler = (ctx) => {
   }
 }
 
-const statusCmd: CommandHandler = (ctx) => {
+const statusCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const c = ctx.engine.getContext()
   const tools = ctx.engine.getTools()
   const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js'
   const runtimeVer = typeof Bun !== 'undefined' ? Bun.version : process.version
+  const health = ctx.engine.getRegistry()
+    ? await ctx.engine.getRegistry().healthMap()
+    : new Map<string, boolean>()
+  const providerHealth = ctx.config.providers
+    .filter((p) => p.status !== 'upcoming')
+    .map((p) => `${p.id} ${health.get(p.id) ? '🟢' : '🔴'}`)
+    .join('  ')
+
   return {
     content: stripIndent`
       ${t('commands.status.session_title')}
@@ -337,6 +345,9 @@ const statusCmd: CommandHandler = (ctx) => {
       ${t('commands.status.platform')}   ${process.platform} ${process.arch}
       ${t('commands.status.runtime')}    ${runtime} ${runtimeVer}
       ${t('commands.status.cwd')}        ${process.cwd()}
+
+      Providers
+      ${providerHealth}
     `,
   }
 }
@@ -449,12 +460,19 @@ const providerCmd: CommandHandler = (ctx) => {
   }
 }
 
-const providersCmd: CommandHandler = (ctx) => {
+const providersCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
-  const lines = ctx.config.providers.map(
-    (p) =>
-      `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ${p.status === 'upcoming' ? '[upcoming]' : '✓'}`,
-  )
+  const health = ctx.engine.getRegistry()
+    ? await ctx.engine.getRegistry().healthMap()
+    : new Map<string, boolean>()
+
+  const lines = ctx.config.providers.map((p) => {
+    if (p.status === 'upcoming') {
+      return `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ⏳ [upcoming]`
+    }
+    const ok = health.get(p.id) ?? false
+    return `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ${ok ? '🟢 reachable' : '🔴 unreachable'}`
+  })
   return {
     content: `${t('commands.providers.title')}\n\n${lines.join('\n')}\n\n${t('commands.providers.current', { provider: ctx.providerId, model: ctx.modelId })}`,
   }
@@ -4023,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')