@miphamai/cli 0.22.0 → 0.24.0

package/src/agent/experience-rules.ts

@@ -0,0 +1,188 @@
+export interface ExperienceRule {
+  id: string // rule-<category>-<shortHash>
+  type: 'mandatory' | 'warning'
+  condition: string
+  action: string
+  evidence: {
+    failureCount: number
+    lastFailure: string // ISO date
+    examples: string[]
+  }
+  category: 'timeout' | 'import' | 'search' | 'tool-params' | 'semantic'
+  source: 'agent-experience' | 'manual' | 'pattern-analyzer'
+  agentName: string
+  createdAt: string // ISO date
+}
+
+export interface FailureEntry {
+  date: string
+  description: string
+}
+
+export function parseFailureEntries(content: string): FailureEntry[] {
+  const entries: FailureEntry[] = []
+  const failureIdx = content.indexOf('## Failure Patterns')
+  if (failureIdx === -1) return entries
+
+  const afterFailure = content.slice(failureIdx)
+  const nextSection = afterFailure.indexOf('\n## ', '## Failure Patterns'.length)
+  const section = nextSection !== -1 ? afterFailure.slice(0, nextSection) : afterFailure
+
+  const lines = section.split('\n')
+  for (const line of lines) {
+    const match = line.match(/^- \[(\d{4}-\d{2}-\d{2})\]\s+(.+)/)
+    if (match && match[1] && match[2]) {
+      entries.push({ date: match[1], description: match[2].trim() })
+    }
+  }
+  return entries
+}
+
+export function categorize(description: string): ExperienceRule['category'] {
+  const lower = description.toLowerCase()
+  if (lower.includes('timeout')) return 'timeout'
+  if (/module_not_found|import|\.js/.test(lower)) return 'import'
+  if (/grep|token.*overflow|search.*scope/.test(lower)) return 'search'
+  if (/bash|command.*fail|docker|npm|pnpm|cargo|brew/.test(lower)) return 'tool-params'
+  return 'semantic'
+}
+
+function createRuleId(category: string, description: string): string {
+  // Hash the first 30 chars of description for uniqueness
+  const hash = description
+    .slice(0, 30)
+    .split('')
+    .reduce((acc, c) => {
+      return ((acc << 5) - acc + c.charCodeAt(0)) | 0
+    }, 0)
+    .toString(36)
+    .slice(-6)
+  return `rule-${category}-${hash}`
+}
+
+function conditionForCategory(category: string, entries: FailureEntry[]): string {
+  const combined = entries.map((e) => e.description).join('; ')
+  switch (category) {
+    case 'timeout':
+      return 'heavy CLI commands (npm/docker/pnpm)'
+    case 'import':
+      return 'ESM module imports missing .js extension'
+    case 'search':
+      return 'full-repository Grep without directory scoping'
+    case 'tool-params':
+      return combined.slice(0, 100)
+    default:
+      return combined.slice(0, 100)
+  }
+}
+
+function actionForCategory(category: string): string {
+  switch (category) {
+    case 'timeout':
+      return 'set Bash timeout ≥ 300000ms for heavy commands'
+    case 'import':
+      return 'always append .js extension to ESM relative imports'
+    case 'search':
+      return 'use Glob to narrow directory before Grep'
+    case 'tool-params':
+      return 'review and adjust tool parameters before execution'
+    default:
+      return 'verify tool parameters match known good patterns'
+  }
+}
+
+export class ExperienceRuleExtractor {
+  extract(content: string, agentName: string): ExperienceRule[] {
+    if (!content || !content.includes('## Failure Patterns')) return []
+
+    const entries = parseFailureEntries(content)
+    if (entries.length < 2) return []
+
+    // Group by category
+    const byCategory = new Map<string, FailureEntry[]>()
+    for (const entry of entries) {
+      const cat = categorize(entry.description)
+      const existing = byCategory.get(cat) || []
+      existing.push(entry)
+      byCategory.set(cat, existing)
+    }
+
+    const rules: ExperienceRule[] = []
+    for (const [category, catEntries] of byCategory) {
+      if (catEntries.length < 2) continue
+
+      const type: 'mandatory' | 'warning' = catEntries.length >= 3 ? 'mandatory' : 'warning'
+      const firstEntry = catEntries[0]
+      const lastEntry = catEntries[catEntries.length - 1]
+      if (!firstEntry || !lastEntry) continue
+
+      rules.push({
+        id: createRuleId(category, firstEntry.description),
+        type,
+        condition: conditionForCategory(category, catEntries),
+        action: actionForCategory(category),
+        evidence: {
+          failureCount: catEntries.length,
+          lastFailure: lastEntry.date,
+          examples: catEntries.slice(0, 3).map((e) => e.description),
+        },
+        category: category as ExperienceRule['category'],
+        source: 'agent-experience',
+        agentName,
+        createdAt: new Date().toISOString().slice(0, 10),
+      })
+    }
+
+    return rules
+  }
+
+  prioritize(rules: ExperienceRule[]): ExperienceRule[] {
+    const order: Record<string, number> = {
+      mandatory: 0,
+      warning: 1,
+    }
+    return [...rules].sort((a, b) => {
+      const aOrder = order[a.type] ?? 0
+      const bOrder = order[b.type] ?? 0
+      const typeDiff = aOrder - bOrder
+      if (typeDiff !== 0) return typeDiff
+      // Within same type, more failures first
+      return b.evidence.failureCount - a.evidence.failureCount
+    })
+  }
+
+  formatForInjection(rules: ExperienceRule[]): string {
+    if (rules.length === 0) return ''
+
+    const mandatory = rules.filter((r) => r.type === 'mandatory')
+    const warnings = rules.filter((r) => r.type === 'warning')
+
+    let output = ''
+
+    if (mandatory.length > 0) {
+      output += '## ⚠️ Active Mandatory Rules (learned from past failures)\n\n'
+      for (const r of mandatory) {
+        const idx = mandatory.indexOf(r) + 1
+        output += `${idx}. [${r.category}] ${r.condition} → ${r.action}\n`
+        output += `   Evidence: ${r.evidence.failureCount} failures`
+        if (r.evidence.lastFailure) output += `, last: ${r.evidence.lastFailure}`
+        output += '\n'
+        if (r.evidence.examples.length > 0) {
+          output += `   Example: ${r.evidence.examples[0]}\n`
+        }
+        output += '\n'
+      }
+    }
+
+    if (warnings.length > 0) {
+      output += '## ⚡ Observed Patterns (warning level)\n\n'
+      for (const r of warnings) {
+        const idx = warnings.indexOf(r) + 1
+        output += `${idx}. [${r.category}] ${r.condition} → ${r.action}\n`
+        output += `   Evidence: ${r.evidence.failureCount} occurrences\n\n`
+      }
+    }
+
+    return output.trim()
+  }
+}

package/src/agent/message-router.ts

@@ -0,0 +1,83 @@
+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'
+
+export interface RouteResult {
+  success: boolean
+  routedTo: 'bus' | 'inbox' | 'unknown'
+  error?: string
+  messageId?: string
+}
+
+/**
+ * MessageRouter decides how to deliver a message based on the recipient.
+ *
+ * - "main" or background task IDs → in-memory AgentMessageBus (same process)
+ * - Session IDs matching discoverable sessions → file inbox (cross-session)
+ * - Unknown → error
+ */
+export class MessageRouter {
+  /**
+   * Route a message to the appropriate transport.
+   */
+  async route(from: string, to: string, summary: string, message: string): Promise<RouteResult> {
+    // Same-process routing: "main" or background task IDs
+    if (to === 'main' || to.startsWith('bg-') || to.startsWith('sub-agent-')) {
+      try {
+        const bus = getMessageBus()
+        const msgId = bus.post(from, to, summary, message)
+        return { success: true, routedTo: 'bus', messageId: msgId }
+      } catch (err) {
+        return { success: false, routedTo: 'bus', error: String(err) }
+      }
+    }
+
+    // Cross-session routing
+    const sessions = discoverSessions()
+    const targetSession = sessions.find((s) => s.id === to)
+
+    if (!targetSession) {
+      return {
+        success: false,
+        routedTo: 'unknown',
+        error: `No active session found with ID "${to}". Use ListAgents to discover available sessions.`,
+      }
+    }
+
+    // Get sender info
+    const senderSession = createSessionInfo(from, from)
+
+    try {
+      const transport = getFileInboxTransport()
+      const msg: AgentMessage = {
+        id: `xmsg-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+        from,
+        to,
+        summary: summary.slice(0, 200),
+        message,
+        timestamp: new Date(),
+        read: false,
+        type: 'message',
+      }
+
+      const delivered = await transport.send(senderSession, to, msg)
+      if (!delivered) {
+        return { success: false, routedTo: 'inbox', error: 'Failed to write message to inbox.' }
+      }
+
+      return { success: true, routedTo: 'inbox', messageId: msg.id }
+    } catch (err) {
+      return { success: false, routedTo: 'inbox', error: String(err) }
+    }
+  }
+}
+
+let _router: MessageRouter | null = null
+
+export function getMessageRouter(): MessageRouter {
+  if (!_router) {
+    _router = new MessageRouter()
+  }
+  return _router
+}

package/src/agent/pattern-analyzer.ts

@@ -0,0 +1,154 @@
+import { readdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { AgentExperience } from './agent-experience.js'
+import { parseFailureEntries, categorize, type ExperienceRule } from './experience-rules.js'
+import type { ToolRule } from '../core/rule-engine.js'
+
+export interface Pattern {
+  id: string
+  category: 'timeout' | 'import' | 'search' | 'tool-params' | 'semantic'
+  agentName: string
+  frequency: number
+  confidence: 'high' | 'medium' | 'low'
+  examples: string[]
+  firstSeen: string
+  lastSeen: string
+}
+
+export class PatternAnalyzer {
+  analyzeAgent(agentName: string, baseDir?: string): Pattern[] {
+    const dir = baseDir || join(homedir(), '.mipham', 'agent-memory')
+    const exp = new AgentExperience(agentName, dir)
+    const content = exp.getExperience()
+    if (!content) return []
+
+    const allEntries = parseFailureEntries(content)
+
+    // Group by category
+    const byCategory = new Map<string, { descriptions: string[]; dates: string[] }>()
+    for (const entry of allEntries) {
+      const cat = categorize(entry.description)
+      const existing = byCategory.get(cat) || { descriptions: [], dates: [] }
+      existing.descriptions.push(entry.description)
+      existing.dates.push(entry.date)
+      byCategory.set(cat, existing)
+    }
+
+    const patterns: Pattern[] = []
+    for (const [category, data] of byCategory) {
+      if (data.descriptions.length < 3) continue
+
+      patterns.push({
+        id: `pattern-${category}-${agentName}`,
+        category: category as Pattern['category'],
+        agentName,
+        frequency: data.descriptions.length,
+        confidence: data.descriptions.length >= 5 ? 'high' : 'medium',
+        examples: data.descriptions.slice(0, 5),
+        firstSeen: data.dates[0] ?? '',
+        lastSeen: data.dates[data.dates.length - 1] ?? '',
+      })
+    }
+
+    return patterns
+  }
+
+  analyzeAllAgents(baseDir?: string): Pattern[] {
+    const dir = baseDir || join(homedir(), '.mipham', 'agent-memory')
+    if (!existsSync(dir)) return []
+
+    let agents: string[]
+    try {
+      agents = readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+    } catch {
+      return []
+    }
+
+    const allPatterns: Pattern[] = []
+    for (const agent of agents) {
+      allPatterns.push(...this.analyzeAgent(agent, baseDir))
+    }
+    return allPatterns
+  }
+
+  toRule(pattern: Pattern): ExperienceRule {
+    return {
+      id: `${pattern.id}-${Date.now().toString(36)}`,
+      type: pattern.frequency >= 3 ? 'mandatory' : 'warning',
+      condition: this._conditionForCategory(pattern),
+      action: this._actionForCategory(pattern.category),
+      evidence: {
+        failureCount: pattern.frequency,
+        lastFailure: pattern.lastSeen,
+        examples: pattern.examples.slice(0, 3),
+      },
+      category: pattern.category,
+      source: 'pattern-analyzer',
+      agentName: pattern.agentName,
+      createdAt: new Date().toISOString().slice(0, 10),
+    }
+  }
+
+  toToolRule(pattern: Pattern): ToolRule {
+    const toolNameMap: Record<string, string> = {
+      timeout: 'Bash',
+      'tool-params': 'Bash',
+      import: 'Write',
+      search: 'Grep',
+      semantic: 'Bash',
+    }
+
+    return {
+      id: pattern.id,
+      toolName: toolNameMap[pattern.category] || 'Bash',
+      category: pattern.category,
+      match: (p: Record<string, unknown>): boolean => {
+        if (pattern.category === 'timeout') {
+          const cmd = String(p.command ?? '')
+          const heavy = /npm|docker|pnpm|cargo|brew|install|build/.test(cmd)
+          if (!heavy) return false
+          const timeout = (p as Record<string, unknown>).timeout as number | undefined
+          return !timeout || timeout < 300_000
+        }
+        return true
+      },
+      fix: (p: Record<string, unknown>) => ({
+        modified: pattern.category === 'timeout' ? { ...p, timeout: 300_000 } : p,
+        warning: `🤖 [auto-rule] ${pattern.category}: ${pattern.frequency} 次同类失败 — ${this._actionForCategory(pattern.category)}`,
+      }),
+      source: 'pattern-analyzer',
+      enabled: true,
+    }
+  }
+
+  // ── Private helpers ──
+
+  private _conditionForCategory(pattern: Pattern): string {
+    switch (pattern.category) {
+      case 'timeout':
+        return 'heavy CLI commands (npm/docker/pnpm/cargo)'
+      case 'import':
+        return 'ESM module imports missing .js extension'
+      case 'search':
+        return 'full-repository search without directory scoping'
+      default:
+        return pattern.examples[0]?.slice(0, 100) || 'unknown condition'
+    }
+  }
+
+  private _actionForCategory(category: string): string {
+    switch (category) {
+      case 'timeout':
+        return 'set Bash timeout ≥ 300000ms for heavy commands'
+      case 'import':
+        return 'append .js extension to ESM relative imports'
+      case 'search':
+        return 'use Glob to narrow directory before Grep'
+      default:
+        return 'review and adjust tool parameters before execution'
+    }
+  }
+}

package/src/agent/sub-agent.ts

@@ -7,6 +7,16 @@ import { getMessageBus } from './message-bus'
 import type { HookEngine } from '../core/hooks'
 import type { PermissionSystem } from '../core/permission'
 import { AgentExperience } from './agent-experience'
+import { PatternAnalyzer } from './pattern-analyzer.js'
+import type { ExperienceRuleEngine } from '../core/rule-engine.js'
+
+// Singleton instances (created lazily)
+let _patternAnalyzer: PatternAnalyzer | undefined
+
+function getPatternAnalyzer(): PatternAnalyzer {
+  if (!_patternAnalyzer) _patternAnalyzer = new PatternAnalyzer()
+  return _patternAnalyzer
+}
 
 const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
   general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
@@ -32,6 +42,7 @@ export class SubAgent {
     private toolRegistry: Map<string, ToolDefinition>,
     private permission?: PermissionSystem,
     private hookEngine?: HookEngine,
+    private ruleEngine?: ExperienceRuleEngine,
   ) {}
 
   /**
@@ -85,6 +96,24 @@ export class SubAgent {
             options.agentDef,
           )
         }
+
+        // CRSI: trigger pattern analysis after each agent execution
+        // Gated by crsi.autoPatternAnalysis feature flag
+        if (options.autoPatternAnalysis !== false) {
+          try {
+            const analyzer = getPatternAnalyzer()
+            const agentName = options.agentDef?.name || agentType
+            const patterns = analyzer.analyzeAgent(agentName)
+            if (patterns.length > 0 && this.ruleEngine) {
+              for (const pattern of patterns) {
+                const toolRule = analyzer.toToolRule(pattern)
+                this.ruleEngine.register(toolRule)
+              }
+            }
+          } catch {
+            // Pattern analysis failure never blocks agent execution
+          }
+        }
       })
 
       return `[background-task:${taskId}]`
@@ -97,6 +126,25 @@ export class SubAgent {
         await this.hookEngine.executeSubagentStop(agentType, description, 'sub-agent', true, result)
       }
       this.logSuccessExperience(agentType, description, result, options.agentDef)
+
+      // CRSI: trigger pattern analysis after successful sync execution
+      // Gated by crsi.autoPatternAnalysis feature flag
+      if (options.autoPatternAnalysis !== false) {
+        try {
+          const analyzer = getPatternAnalyzer()
+          const agentName = options.agentDef?.name || agentType
+          const patterns = analyzer.analyzeAgent(agentName)
+          if (patterns.length > 0 && this.ruleEngine) {
+            for (const pattern of patterns) {
+              const toolRule = analyzer.toToolRule(pattern)
+              this.ruleEngine.register(toolRule)
+            }
+          }
+        } catch {
+          // Pattern analysis failure never blocks agent execution
+        }
+      }
+
       return result
     } catch (err) {
       if (this.hookEngine) {
@@ -109,6 +157,25 @@ export class SubAgent {
         )
       }
       this.logFailureExperience(agentType, description, String(err), options.agentDef)
+
+      // CRSI: trigger pattern analysis after failed sync execution (failures produce patterns too)
+      // Gated by crsi.autoPatternAnalysis feature flag
+      if (options.autoPatternAnalysis !== false) {
+        try {
+          const analyzer = getPatternAnalyzer()
+          const agentName = options.agentDef?.name || agentType
+          const patterns = analyzer.analyzeAgent(agentName)
+          if (patterns.length > 0 && this.ruleEngine) {
+            for (const pattern of patterns) {
+              const toolRule = analyzer.toToolRule(pattern)
+              this.ruleEngine.register(toolRule)
+            }
+          }
+        } catch {
+          // Pattern analysis failure never blocks agent execution
+        }
+      }
+
       throw err
     }
   }

package/src/agent/types.ts

@@ -46,4 +46,6 @@ export interface SubAgentOptions {
   onProgress?: (chunk: string) => void
   /** When set, tool executions use this path as cwd (git worktree isolation). */
   worktreePath?: string
+  /** CRSI: when false, skip pattern analysis after agent execution. Default true. */
+  autoPatternAnalysis?: boolean
 }

package/src/config/defaults.ts

@@ -3,6 +3,7 @@ import type {
   InferenceHookConfig,
   CredentialMaskingConfig,
   BackgroundAgentConfig,
+  CrossSessionConfig,
 } from '../shared/index.ts'
 import { DEFAULT_PROVIDERS } from '../shared/index.ts'
 import { PACKAGE_VERSION } from '../shared/index.ts'
@@ -21,6 +22,12 @@ export const DEFAULT_CONFIG: MiphamConfig = {
     mcp: { oauthEnabled: true },
     context: { useRealTokenizer: true, adaptiveThresholds: true },
   },
+  crsi: {
+    ruleInjection: true,
+    preToolHook: true,
+    autoPatternAnalysis: true,
+    autoRuleManagement: true,
+  },
 }
 
 export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {
@@ -51,3 +58,8 @@ export const DEFAULT_BACKGROUND_AGENT_CONFIG: BackgroundAgentConfig = {
   auto_worktree: true,
   commit_coauthors: true,
 }
+
+export const DEFAULT_CROSS_SESSION_CONFIG: CrossSessionConfig = {
+  crossSessionInbound: 'ask',
+  dialogExpiry: 300,
+}

package/src/config/loader.ts

@@ -17,12 +17,14 @@ import type {
   InferenceHookConfig,
   CredentialMaskingConfig,
   BackgroundAgentConfig,
+  CrossSessionConfig,
 } from '../shared/index.ts'
 import {
   DEFAULT_CONFIG,
   DEFAULT_INFERENCE_HOOK_CONFIG,
   DEFAULT_CREDENTIAL_MASKING_CONFIG,
   DEFAULT_BACKGROUND_AGENT_CONFIG,
+  DEFAULT_CROSS_SESSION_CONFIG,
 } from './defaults'
 
 const MIPHAM_HOME = join(homedir(), '.mipham')
@@ -376,3 +378,34 @@ export function loadBackgroundAgentConfig(cwd: string = process.cwd()): Backgrou
 
   return merged
 }
+
+/**
+ * Load cross-session messaging configuration from the same config sources.
+ * Merges project-level over user-level. Returns defaults if no section present.
+ */
+export function loadCrossSessionConfig(cwd: string = process.cwd()): CrossSessionConfig {
+  const configPath = join(cwd, '.mipham', 'config.yml')
+  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
+
+  let merged = { ...DEFAULT_CROSS_SESSION_CONFIG }
+
+  const paths = [userConfigPath, configPath] // project wins (loaded last)
+  for (const path of paths) {
+    try {
+      if (!existsSync(path)) continue
+      const raw = readFileSync(path, 'utf-8')
+      const parsed = parseYaml(raw) as Record<string, unknown>
+      const section = parsed.cross_session as Partial<CrossSessionConfig> | undefined
+      if (section) {
+        merged = {
+          crossSessionInbound: section.crossSessionInbound ?? merged.crossSessionInbound,
+          dialogExpiry: section.dialogExpiry ?? merged.dialogExpiry,
+        }
+      }
+    } catch {
+      // Silently skip malformed configs
+    }
+  }
+
+  return merged
+}

package/src/core/credential-masker/env-filter.ts

@@ -0,0 +1,39 @@
+import { CREDENTIAL_SENTINEL } from './types'
+import type { CredentialMaskingConfig } from '../../shared/index.ts'
+
+/**
+ * Filter sensitive environment variables before spawning a subprocess.
+ * Returns a sanitized copy of process.env with matching vars removed.
+ */
+export function filterEnv(
+  env: Record<string, string | undefined>,
+  config: CredentialMaskingConfig,
+): Record<string, string | undefined> {
+  if (!config.enabled || !config.env_filter.enabled) return { ...env }
+
+  const filtered: Record<string, string | undefined> = {}
+  for (const [key, value] of Object.entries(env)) {
+    let blocked = false
+    for (const pattern of config.env_filter.patterns) {
+      try {
+        // Strip (?i) inline flags — JS uses the 'i' flag instead
+        const clean = pattern.replace(/^\(\?i\)/, '')
+        const regex = new RegExp(clean, 'i')
+        if (regex.test(key)) {
+          blocked = true
+          break
+        }
+      } catch {
+        // Invalid regex — skip
+      }
+    }
+    if (blocked) {
+      // Replace with sentinel so tools can detect they're filtered
+      filtered[key] = CREDENTIAL_SENTINEL
+    } else {
+      filtered[key] = value
+    }
+  }
+
+  return filtered
+}

package/src/core/credential-masker/index.ts

@@ -0,0 +1,35 @@
+export { CREDENTIAL_SENTINEL } from './types'
+export type { MaskingStrategy } from './types'
+
+export { MaskingPipeline, getPipeline, maskContent } from './pipeline'
+export { matchCredentialFile, matchPath, globToRegex } from './matcher'
+export { filterEnv } from './env-filter'
+export { maskOutput } from './output-scrub'
+
+// Strategies
+export { FullMaskingStrategy } from './strategies/full'
+export { ExtractMaskingStrategy } from './strategies/extract'
+export { JwtMaskingStrategy } from './strategies/jwt'
+export { AwsMaskingStrategy } from './strategies/aws'
+
+import { getPipeline } from './pipeline'
+import { FullMaskingStrategy } from './strategies/full'
+import { ExtractMaskingStrategy } from './strategies/extract'
+import { JwtMaskingStrategy } from './strategies/jwt'
+import { AwsMaskingStrategy } from './strategies/aws'
+
+/**
+ * Initialize the masking pipeline with all built-in strategies.
+ * Call once at startup. Safe to call multiple times (idempotent).
+ */
+let _initialized = false
+
+export function initializePipeline(): void {
+  if (_initialized) return
+  const pipeline = getPipeline()
+  pipeline.register(new FullMaskingStrategy())
+  pipeline.register(new ExtractMaskingStrategy())
+  pipeline.register(new JwtMaskingStrategy())
+  pipeline.register(new AwsMaskingStrategy())
+  _initialized = true
+}