@miphamai/cli 0.39.1 → 0.40.0

package/bin/mipham.ts

@@ -1094,17 +1094,9 @@ async function main() {
   process.on('SIGINT', restoreTerminal)
   process.on('SIGTERM', restoreTerminal)
 
-  // ── Read version fresh from package.json at startup (bypasses Bun module cache) ──
-  const { readFileSync } = await import('node:fs')
-  const { join } = await import('node:path')
-  let APP_VERSION = '0.0.0'
-  try {
-    const pkgPath = join(import.meta.dirname!, '..', 'package.json')
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
-    APP_VERSION = pkg.version
-  } catch {
-    // fallback — version will be '0.0.0'
-  }
+  // ── Version: build-time constant (bundled into the compiled binary) ──
+  const { PACKAGE_NAME, PACKAGE_VERSION } = await import('../src/shared/package-info')
+  const APP_VERSION = PACKAGE_VERSION
 
   // ── Version flag ──────────────────────────────────────────────────────────
   if (
@@ -1112,8 +1104,7 @@ async function main() {
     process.argv.includes('-v') ||
     process.argv.includes('-V')
   ) {
-    const pkg = JSON.parse(readFileSync(join(import.meta.dirname!, '..', 'package.json'), 'utf-8'))
-    console.log(`${pkg.name} v${pkg.version}`)
+    console.log(`${PACKAGE_NAME} v${PACKAGE_VERSION}`)
     process.exit(0)
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.39.1",
+  "version": "0.40.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -29,15 +29,14 @@
     "bin/",
     "src/",
     "skills/",
-    "assets/",
-    "dist/"
+    "assets/"
   ],
   "engines": {
     "node": ">=22.0.0"
   },
   "scripts": {
     "dev": "bun run bin/mipham.ts",
-    "build": "bun build --compile --minify --external react-devtools-core ./bin/mipham.ts --outfile dist/mipham",
+    "build": "bun build --compile --minify ./bin/mipham.ts --outfile dist/mipham",
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   },

package/src/core/auto-memory.ts

@@ -17,6 +17,7 @@ import type { ExperienceRuleEngine, ToolRule } from './rule-engine.js'
 import type { EffectivenessTracker } from '../agent/effectiveness-tracker.js'
 import type { ErrorSignatureDB } from './error-signature-db.js'
 import type { CrsiProvenanceBridge } from '../agent/crsi-provenance-bridge.js'
+import { getMetrics } from './metrics'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 
@@ -228,11 +229,28 @@ export class AutoMemoryEngine {
       this.writeSessionSummary()
     }
 
-    // Flush CRSI state — evaluate first (reports verdicts to megasystem,
-    // applies auto-degrade/disable/upgrade), then persist.
-    if (this.effectivenessTracker) {
-      this.effectivenessTracker.evaluate()
-      this.effectivenessTracker.persist()
+    // Flush CRSI effectiveness (evaluate + apply auto-management).
+    this.flushEffectiveness()
+  }
+
+  /**
+   * Evaluate rule effectiveness and apply auto-management to the rule engine:
+   * ineffective rules are disabled so intercept() stops injecting them, and
+   * recovered rules are re-enabled. Without this, `evaluate()`'s verdicts are
+   * computed but never acted upon — the self-improvement loop stays open.
+   */
+  flushEffectiveness(): void {
+    if (!this.effectivenessTracker) return
+
+    const { upgrades, disables } = this.effectivenessTracker.evaluate()
+    this.effectivenessTracker.persist()
+
+    if (this.ruleEngine) {
+      for (const id of disables) {
+        this.ruleEngine.setRuleEnabled(id, false)
+        getMetrics().crsiRuleDisables.inc()
+      }
+      for (const id of upgrades) this.ruleEngine.setRuleEnabled(id, true)
     }
   }
 

package/src/core/engine.ts

@@ -35,6 +35,7 @@ import { DreamEngine } from './dream-engine.js'
 import { ConstitutionLoader } from './constitution-loader.js'
 import { SelfCritique } from './self-critique.js'
 import { UsageTracker } from './usage-tracker'
+import { getMetrics } from './metrics'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
 import { getMessageBus, type AgentMessage } from '../agent/message-bus'
@@ -921,6 +922,7 @@ export class QueryEngine {
   }
 
   private async executeTool(name: string, params: Record<string, unknown>): Promise<ToolResult> {
+    getMetrics().toolCalls.inc({ tool_name: name })
     const tool = this.tools.get(name)
     if (!tool) {
       // P2-4: Provide a more helpful error for unavailable tools
@@ -970,6 +972,7 @@ export class QueryEngine {
     if (this.crsiConfig?.preToolHook !== false && this.ruleEngine) {
       const ruleResult = this.ruleEngine.intercept(name, effectiveParams)
       if (Object.keys(ruleResult.modified).length > 0) {
+        getMetrics().crsiRuleApplications.inc()
         effectiveParams = ruleResult.modified
       }
       if (ruleResult.warnings.length > 0) {
@@ -980,6 +983,7 @@ export class QueryEngine {
     // ── SIS PreFlightChecker — known error pattern interception ──
     const preflight = this.getPreFlightChecker().check(name, effectiveParams)
     if (preflight.action === 'block') {
+      getMetrics().sisInterceptions.inc()
       return {
         success: false,
         content: preflight.warning || 'SIS 免疫系统拦截了此操作',
@@ -987,6 +991,7 @@ export class QueryEngine {
       }
     }
     if (preflight.action === 'fix' && preflight.modifiedParams) {
+      getMetrics().sisInterceptions.inc()
       effectiveParams = preflight.modifiedParams
       if (preflight.warning) {
         hookWarnings = [...hookWarnings, preflight.warning]

package/src/core/metrics.ts

@@ -6,6 +6,11 @@
  * collected in-memory and can be exported in Prometheus text format
  * or JSON.
  *
+ * All metric types support *labels*: calling `.inc({ tool_name: 'bash' })`
+ * records a value for the `tool_name="bash"` series, distinct from the
+ * unlabelled series.  The registry deduplicates metric families by
+ * `name + base labels`, so a family is created once and reused.
+ *
  * Usage:
  *   import { getMetrics } from '../core/metrics.js'
  *
@@ -25,7 +30,7 @@ export interface MetricLabels {
   [key: string]: string
 }
 
-/** Format labels into Prometheus {...} string. */
+/** Format labels into Prometheus {...} string (keys sorted for determinism). */
 function formatLabels(labels?: MetricLabels): string {
   if (!labels || Object.keys(labels).length === 0) return ''
   const parts = Object.entries(labels)
@@ -34,36 +39,53 @@ function formatLabels(labels?: MetricLabels): string {
   return `{${parts.join(',')}}`
 }
 
+/** Merge base labels with an extra set and format the result. */
+function mergedLabels(base: MetricLabels, extra?: MetricLabels): string {
+  return formatLabels({ ...base, ...(extra ?? {}) })
+}
+
 // ── Counter ──────────────────────────────────────────────────────────────
 
 export class Counter {
   readonly name: string
   readonly help: string
-  readonly labels: MetricLabels
-  private _value = 0
+  readonly baseLabels: MetricLabels
+  /** key = formatted merged labels, value = running count. */
+  private _series = new Map<string, number>()
 
   constructor(name: string, help: string, labels?: MetricLabels) {
     this.name = name
     this.help = help
-    this.labels = labels ?? {}
+    this.baseLabels = labels ?? {}
+    // Seed the base series so the metric is always present (even at 0).
+    this._series.set(formatLabels(this.baseLabels), 0)
   }
 
-  inc(amount = 1): void {
-    this._value += amount
+  /** Increment. Accepts either an amount, labels, or both via a second arg. */
+  inc(amountOrLabels?: number | MetricLabels, maybeAmount?: number): void {
+    let amount = 1
+    let extra: MetricLabels | undefined
+    if (typeof amountOrLabels === 'number') amount = amountOrLabels
+    else if (amountOrLabels) extra = amountOrLabels
+    if (maybeAmount !== undefined) amount = maybeAmount
+    const key = mergedLabels(this.baseLabels, extra)
+    this._series.set(key, (this._series.get(key) ?? 0) + amount)
   }
 
-  get value(): number {
-    return this._value
+  /** Current value of a labelled series (base series when no labels given). */
+  value(extra?: MetricLabels): number {
+    return this._series.get(mergedLabels(this.baseLabels, extra)) ?? 0
   }
 
-  /** Full metric name with labels for dedup key. */
+  /** Identity key for registry dedup (name + base labels). */
   get key(): string {
-    return this.name + formatLabels(this.labels)
+    return this.name + formatLabels(this.baseLabels)
   }
 
   toPrometheus(): string {
-    const labelStr = formatLabels(this.labels)
-    return `${this.name}${labelStr} ${this._value}`
+    return Array.from(this._series.entries())
+      .map(([labelStr, v]) => `${this.name}${labelStr} ${v}`)
+      .join('\n')
   }
 
   toJSON(): object {
@@ -71,8 +93,7 @@ export class Counter {
       name: this.name,
       type: 'counter',
       help: this.help,
-      labels: this.labels,
-      value: this._value,
+      series: Array.from(this._series.entries()).map(([labels, value]) => ({ labels, value })),
     }
   }
 }
@@ -82,38 +103,52 @@ export class Counter {
 export class Gauge {
   readonly name: string
   readonly help: string
-  readonly labels: MetricLabels
-  private _value = 0
+  readonly baseLabels: MetricLabels
+  private _series = new Map<string, number>()
 
   constructor(name: string, help: string, labels?: MetricLabels) {
     this.name = name
     this.help = help
-    this.labels = labels ?? {}
+    this.baseLabels = labels ?? {}
+    this._series.set(formatLabels(this.baseLabels), 0)
   }
 
-  inc(amount = 1): void {
-    this._value += amount
+  inc(amountOrLabels?: number | MetricLabels, maybeAmount?: number): void {
+    let amount = 1
+    let extra: MetricLabels | undefined
+    if (typeof amountOrLabels === 'number') amount = amountOrLabels
+    else if (amountOrLabels) extra = amountOrLabels
+    if (maybeAmount !== undefined) amount = maybeAmount
+    const key = mergedLabels(this.baseLabels, extra)
+    this._series.set(key, (this._series.get(key) ?? 0) + amount)
   }
 
-  dec(amount = 1): void {
-    this._value -= amount
+  dec(amountOrLabels?: number | MetricLabels, maybeAmount?: number): void {
+    let amount = 1
+    let extra: MetricLabels | undefined
+    if (typeof amountOrLabels === 'number') amount = amountOrLabels
+    else if (amountOrLabels) extra = amountOrLabels
+    if (maybeAmount !== undefined) amount = maybeAmount
+    const key = mergedLabels(this.baseLabels, extra)
+    this._series.set(key, (this._series.get(key) ?? 0) - amount)
   }
 
-  set(value: number): void {
-    this._value = value
+  set(value: number, extra?: MetricLabels): void {
+    this._series.set(mergedLabels(this.baseLabels, extra), value)
   }
 
-  get value(): number {
-    return this._value
+  value(extra?: MetricLabels): number {
+    return this._series.get(mergedLabels(this.baseLabels, extra)) ?? 0
   }
 
   get key(): string {
-    return this.name + formatLabels(this.labels)
+    return this.name + formatLabels(this.baseLabels)
   }
 
   toPrometheus(): string {
-    const labelStr = formatLabels(this.labels)
-    return `${this.name}${labelStr} ${this._value}`
+    return Array.from(this._series.entries())
+      .map(([labelStr, v]) => `${this.name}${labelStr} ${v}`)
+      .join('\n')
   }
 
   toJSON(): object {
@@ -121,8 +156,7 @@ export class Gauge {
       name: this.name,
       type: 'gauge',
       help: this.help,
-      labels: this.labels,
-      value: this._value,
+      series: Array.from(this._series.entries()).map(([labels, value]) => ({ labels, value })),
     }
   }
 }
@@ -131,82 +165,100 @@ export class Gauge {
 
 const DEFAULT_BUCKETS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]
 
+interface HistogramSeries {
+  labels: MetricLabels
+  count: number
+  sum: number
+  bucketCounts: number[]
+}
+
 export class Histogram {
   readonly name: string
   readonly help: string
-  readonly labels: MetricLabels
+  readonly baseLabels: MetricLabels
   readonly buckets: number[]
-  private _count = 0
-  private _sum = 0
-  private _bucketCounts: number[]
+  private _series = new Map<string, HistogramSeries>()
 
   constructor(name: string, help: string, buckets?: number[], labels?: MetricLabels) {
     this.name = name
     this.help = help
-    this.labels = labels ?? {}
     this.buckets = buckets ?? DEFAULT_BUCKETS
-    this._bucketCounts = new Array(this.buckets.length).fill(0)
+    this.baseLabels = labels ?? {}
+    this._series.set(formatLabels(this.baseLabels), {
+      labels: this.baseLabels,
+      count: 0,
+      sum: 0,
+      bucketCounts: new Array(this.buckets.length).fill(0),
+    })
+  }
+
+  private getSeries(extra?: MetricLabels): HistogramSeries {
+    const key = mergedLabels(this.baseLabels, extra)
+    let s = this._series.get(key)
+    if (!s) {
+      s = {
+        labels: { ...this.baseLabels, ...(extra ?? {}) },
+        count: 0,
+        sum: 0,
+        bucketCounts: new Array(this.buckets.length).fill(0),
+      }
+      this._series.set(key, s)
+    }
+    return s
   }
 
-  observe(value: number): void {
-    this._count++
-    this._sum += value
+  observe(value: number, extra?: MetricLabels): void {
+    const s = this.getSeries(extra)
+    s.count++
+    s.sum += value
     for (let i = 0; i < this.buckets.length; i++) {
       if (value <= (this.buckets[i] ?? Infinity)) {
-        this._bucketCounts[i] = (this._bucketCounts[i] ?? 0) + 1
+        s.bucketCounts[i] = (s.bucketCounts[i] ?? 0) + 1
       }
     }
   }
 
-  get count(): number {
-    return this._count
+  get key(): string {
+    return this.name + formatLabels(this.baseLabels)
   }
 
-  get sum(): number {
-    return this._sum
+  /** Total observations in the base (unlabelled) series. */
+  get count(): number {
+    return this._series.get(formatLabels(this.baseLabels))?.count ?? 0
   }
 
-  get key(): string {
-    return this.name + formatLabels(this.labels)
+  /** Sum of observations in the base (unlabelled) series. */
+  get sum(): number {
+    return this._series.get(formatLabels(this.baseLabels))?.sum ?? 0
   }
 
   toPrometheus(): string {
-    const labelStr = formatLabels(this.labels)
     const lines: string[] = []
-
-    // _bucket values
-    for (let i = 0; i < this.buckets.length; i++) {
-      const bucketLabel = formatLabels({
-        ...this.labels,
-        le: String(this.buckets[i]),
-      })
-      lines.push(`${this.name}_bucket${bucketLabel} ${this._bucketCounts[i]}`)
+    for (const s of this._series.values()) {
+      for (let i = 0; i < this.buckets.length; i++) {
+        const leLabel = formatLabels({ ...s.labels, le: String(this.buckets[i]) })
+        lines.push(`${this.name}_bucket${leLabel} ${s.bucketCounts[i] ?? 0}`)
+      }
+      const infLabel = formatLabels({ ...s.labels, le: '+Inf' })
+      lines.push(`${this.name}_bucket${infLabel} ${s.count}`)
+      const labelStr = formatLabels(s.labels)
+      lines.push(`${this.name}_sum${labelStr} ${s.sum}`)
+      lines.push(`${this.name}_count${labelStr} ${s.count}`)
     }
-    // +Inf bucket
-    const infLabel = formatLabels({ ...this.labels, le: '+Inf' })
-    lines.push(`${this.name}_bucket${infLabel} ${this._count}`)
-
-    // _sum and _count
-    lines.push(`${this.name}_sum${labelStr} ${this._sum}`)
-    lines.push(`${this.name}_count${labelStr} ${this._count}`)
-
     return lines.join('\n')
   }
 
   toJSON(): object {
-    const bucketResults: { le: string; count: number }[] = []
-    for (let i = 0; i < this.buckets.length; i++) {
-      bucketResults.push({ le: String(this.buckets[i]), count: this._bucketCounts[i] ?? 0 })
-    }
-    bucketResults.push({ le: '+Inf', count: this._count })
     return {
       name: this.name,
       type: 'histogram',
       help: this.help,
-      labels: this.labels,
-      count: this._count,
-      sum: this._sum,
-      buckets: bucketResults,
+      series: Array.from(this._series.values()).map((s) => ({
+        labels: s.labels,
+        count: s.count,
+        sum: s.sum,
+        buckets: this.buckets.map((le, i) => ({ le: String(le), count: s.bucketCounts[i] ?? 0 })),
+      })),
     }
   }
 }
@@ -238,6 +290,15 @@ export class MetricsRegistry {
   /** Active CLI sessions gauge. */
   readonly activeSessions: Gauge
 
+  /** CRSI auto-fix rule applications counter. */
+  readonly crsiRuleApplications: Counter
+
+  /** CRSI rules disabled for low effectiveness counter. */
+  readonly crsiRuleDisables: Counter
+
+  /** SIS immune system interceptions (block/fix of known error patterns). */
+  readonly sisInterceptions: Counter
+
   constructor() {
     // Pre-register standard metrics
     this.cliInvocations = this.counter(
@@ -264,6 +325,21 @@ export class MetricsRegistry {
     )
 
     this.activeSessions = this.gauge('mipham_code_active_sessions', 'Number of active CLI sessions')
+
+    this.crsiRuleApplications = this.counter(
+      'mipham_code_crsi_rule_applications_total',
+      'Number of CRSI auto-fix rule applications',
+    )
+
+    this.crsiRuleDisables = this.counter(
+      'mipham_code_crsi_rule_disables_total',
+      'Number of CRSI rules disabled for low effectiveness',
+    )
+
+    this.sisInterceptions = this.counter(
+      'mipham_code_sis_interceptions_total',
+      'Number of SIS immune system interceptions',
+    )
   }
 
   // ── Factory methods ─────────────────────────────────────────────

package/src/daemon/index.ts

@@ -22,6 +22,7 @@ import { loadOrCreateToken } from './auth'
 import { RateLimiter } from './rate-limiter'
 import { PACKAGE_VERSION } from '../shared/package-info'
 import type { DaemonStatus } from './types'
+import { logger } from './logger'
 
 const HOME = homedir()
 const MIPHAM_HOME = join(HOME, '.mipham')
@@ -133,7 +134,7 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
   if (sessionsCount === 0) {
     const migrated = db.migrateFromJsonl()
     if (migrated > 0) {
-      console.log(`Daemon: migrated ${migrated} JSONL session(s) to SQLite`)
+      logger.info('migrated JSONL sessions to SQLite', { count: migrated })
     }
   }
 

package/src/daemon/logger.ts

@@ -0,0 +1,84 @@
+/**
+ * Minimal structured JSON logger for the Mipham Code daemon.
+ *
+ * Emits one JSON object per line to stdout (debug/info) or stderr
+ * (warn/error), so logs can be aggregated by the process manager
+ * (PM2, systemd, Docker) without ad-hoc string formatting.
+ *
+ * Usage:
+ *   import { logger } from './logger'
+ *   logger.info('migrated sessions', { count })
+ *   logger.child({ sessionId }).error('prompt failed', { error: err })
+ */
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+export interface LogFields {
+  [key: string]: unknown
+}
+
+const ORDER: Record<LogLevel, number> = { debug: 10, info: 20, warn: 30, error: 40 }
+
+/** Serialize a value for JSON logging, converting Error to {message, stack}. */
+function sanitizeValue(v: unknown): unknown {
+  if (v instanceof Error) {
+    return { message: v.message, stack: v.stack }
+  }
+  return v
+}
+
+export class Logger {
+  constructor(
+    private readonly name: string,
+    private readonly fields: LogFields = {},
+    private readonly minLevel: LogLevel = 'info',
+  ) {}
+
+  /** Return a child logger with extra context fields merged in. */
+  child(fields: LogFields): Logger {
+    return new Logger(this.name, { ...this.fields, ...fields }, this.minLevel)
+  }
+
+  private emit(level: LogLevel, msg: string, fields?: LogFields): void {
+    if (ORDER[level] < ORDER[this.minLevel]) return
+
+    const entry: Record<string, unknown> = {
+      ts: new Date().toISOString(),
+      level,
+      name: this.name,
+      msg,
+      ...this.fields,
+    }
+    if (fields) {
+      for (const [k, v] of Object.entries(fields)) {
+        entry[k] = sanitizeValue(v)
+      }
+    }
+
+    const line = JSON.stringify(entry) + '\n'
+    if (level === 'warn' || level === 'error') {
+      process.stderr.write(line)
+    } else {
+      process.stdout.write(line)
+    }
+  }
+
+  debug(msg: string, fields?: LogFields): void {
+    this.emit('debug', msg, fields)
+  }
+
+  info(msg: string, fields?: LogFields): void {
+    this.emit('info', msg, fields)
+  }
+
+  warn(msg: string, fields?: LogFields): void {
+    this.emit('warn', msg, fields)
+  }
+
+  error(msg: string, fields?: LogFields): void {
+    this.emit('error', msg, fields)
+  }
+}
+
+/** Shared daemon logger. */
+export const logger = new Logger('mipham-daemon')

package/src/daemon/schedule-manager.ts

@@ -5,6 +5,7 @@
 import type { DaemonDatabase } from './database'
 import type { WorkerPool } from './worker-pool'
 import type { DaemonSchedule } from './types'
+import { logger } from './logger'
 
 // Simple minute-granularity cron expression parser.
 //
@@ -125,7 +126,7 @@ export class ScheduleManager {
       if (!worker) continue
 
       worker.processPrompt(schedule.prompt).catch((err: unknown) => {
-        console.error(`ScheduleManager: error firing schedule ${schedule.id}:`, err)
+        logger.error('error firing schedule', { scheduleId: schedule.id, error: err })
       })
 
       const now = new Date()

package/src/daemon/server.ts

@@ -12,6 +12,7 @@ import { RateLimiter } from './rate-limiter'
 import { corsMiddleware, addCorsHeaders } from './cors'
 import { PACKAGE_VERSION } from '../shared/package-info'
 import { WorkerPool } from './worker-pool'
+import { logger } from './logger'
 import type { SessionWorker } from './session-worker'
 import type { ClientMessage } from './attach-protocol'
 import { QueryEngine } from '../core/engine'
@@ -192,7 +193,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
 
       return worker
     } catch (err) {
-      console.error(`Server: error creating worker for session ${sessionId}:`, err)
+      logger.error('error creating worker', { sessionId, error: err })
       return null
     }
   }
@@ -208,6 +209,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
       const url = new URL(req.url)
       const path = url.pathname
       const method = req.method
+      logger.info('request', { method, path })
 
       // ── Rate limiting (skip health endpoint) ──────────
       if (path !== '/api/v1/health') {
@@ -296,7 +298,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
         const sessionId = sessionMatch[1]!
         // Stop worker (interrupt, persist, mark idle) before closing session
         pool.stopWorker(sessionId).catch((err: unknown) => {
-          console.error(`Server: error stopping worker for session ${sessionId}:`, err)
+          logger.error('error stopping worker', { sessionId, error: err })
         })
         // Remove engine from cache
         engineCache.delete(sessionId)
@@ -346,7 +348,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
         // Fire and forget — respond immediately while processing
         // streams results to connected WebSocket clients.
         worker.processPrompt(prompt).catch((err: unknown) => {
-          console.error(`Server: error processing prompt for session ${sessionId}:`, err)
+          logger.error('error processing prompt', { sessionId, error: err })
         })
 
         return json({ ok: true, data: { sessionId, status: 'processing' } }, { status: 202 })
@@ -628,7 +630,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
             if (!worker) return
 
             worker.processPrompt(parsed.prompt).catch((err: unknown) => {
-              console.error(`Server: error processing WS prompt for session ${sessionId}:`, err)
+              logger.error('error processing WS prompt', { sessionId, error: err })
             })
             break
           }

package/src/daemon/worker-pool.ts

@@ -22,6 +22,7 @@ import type { DaemonDatabase } from './database'
 import type { QueryEngine } from '../core/engine'
 import type { ContextManager } from '../core/context'
 import type { ProviderRegistry } from '../providers/registry'
+import { logger } from './logger'
 
 export class WorkerPool {
   private workers: Map<string, SessionWorker>
@@ -149,7 +150,7 @@ export class WorkerPool {
       this.stopWorker(sessionId).catch((err) => {
         // Log but never crash — this runs in a Timer callback outside
         // any request context
-        console.error(`WorkerPool: error auto-stopping idle worker for session ${sessionId}:`, err)
+        logger.error('error auto-stopping idle worker', { sessionId, error: err })
       })
     }, this.idleTimeoutMs)
 

package/src/index.tsx

@@ -193,8 +193,9 @@ function SetupGate(props: SetupGateProps) {
 }
 
 export async function runApp(options: RunOptions): Promise<void> {
-  // Metrics: count CLI invocation
+  // Metrics: count CLI invocation + active session
   getMetrics().cliInvocations.inc()
+  getMetrics().activeSessions.inc()
 
   // ── Workspace Trust Check ──
   await checkWorkspaceTrust()
@@ -591,6 +592,14 @@ export async function runApp(options: RunOptions): Promise<void> {
         })
       }
     }
+    // Flush CRSI effectiveness — evaluate rules and apply auto-degrade/disable.
+    // Best-effort: the self-improvement flush must never block session exit.
+    try {
+      engine.getAutoMemory().flushEffectiveness()
+    } catch {
+      // ignore — CRSI flush is non-critical
+    }
+    getMetrics().activeSessions.dec()
     process.exit(0)
   }
 

package/src/providers/registry.ts

@@ -1,5 +1,6 @@
 import type { ProviderConfig, ModelInfo, Message, StreamChunk } from '../shared/index.ts'
 import type { Llm } from './llm'
+import { getMetrics } from '../core/metrics'
 
 export interface ProviderInstance {
   config: ProviderConfig
@@ -115,6 +116,23 @@ export class ProviderRegistry implements Llm {
 
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
     const provider = this.getActive()
-    yield* provider.chat({ ...req, model: req.model || this.activeModelId })
+    const providerId = this.activeProviderId
+    const modelId = req.model || this.activeModelId
+    const metrics = getMetrics()
+    const start = Date.now()
+    metrics.modelRequests.inc({ provider: providerId, model: modelId })
+    try {
+      for await (const chunk of provider.chat({ ...req, model: modelId })) {
+        if (chunk.type === 'error') {
+          metrics.modelRequestErrors.inc({ provider: providerId, error_type: 'api_error' })
+        }
+        yield chunk
+      }
+    } catch (err) {
+      metrics.modelRequestErrors.inc({ provider: providerId, error_type: 'exception' })
+      throw err
+    } finally {
+      metrics.modelRequestDurationMs.observe(Date.now() - start, { provider: providerId })
+    }
   }
 }

package/src/shared/package-info.ts

@@ -1,22 +1,15 @@
 /**
  * Mipham Code — package metadata (bundled version)
  *
- * Reads directly from the CLI's own package.json at runtime
- * so npm consumers don't need the @mipham/shared workspace package.
+ * Compile-time constants (bundled into the compiled binary — no runtime
+ * package.json read). Version is synced by scripts/bump-version.sh.
  */
 
-import { readFileSync } from 'node:fs'
-import path from 'node:path'
-
-// resolve package.json relative to this source file
-const PKG_PATH = path.join(import.meta.dirname!, '..', '..', 'package.json')
-const pkg = JSON.parse(readFileSync(PKG_PATH, 'utf-8'))
-
 /** npm 包全名（含 scope） */
-export const PACKAGE_NAME: string = pkg.name
+export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION: string = pkg.version
+export const PACKAGE_VERSION = '0.40.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/ui/commands.ts

@@ -668,6 +668,13 @@ const crsiRestoreCmd: CommandHandler = (ctx, args) => {
   return { content: `Rule \`${ruleId}\` has been re-enabled.` }
 }
 
+/** Render a tiny ASCII sparkline from a series of 0-1 values (success rates). */
+function crsiSparkline(values: number[]): string {
+  if (values.length === 0) return '—'
+  const chars = '▁▂▃▄▅▆▇█'
+  return values.map((v) => chars[Math.min(Math.max(Math.round(v * 7), 0), 7)] ?? '▁').join('')
+}
+
 const crsiStatsCmd: CommandHandler = async (ctx) => {
   const engine = ctx.engine.getRuleEngine()
   const tracker = ctx.engine.getEffectivenessTracker()
@@ -682,21 +689,43 @@ const crsiStatsCmd: CommandHandler = async (ctx) => {
   lines.push(`Auto-generated: ${rules.filter((r) => r.source === 'pattern-analyzer').length}`)
   lines.push(`Manual: ${rules.filter((r) => r.source === 'manual').length}`)
 
-  if (tracker) {
+  const effs = tracker?.allRules ?? []
+  if (effs.length > 0) {
     let totalInterceptions = 0
     let totalSuccesses = 0
-    for (const r of rules) {
-      const eff = tracker.getEffectiveness(r.id)
-      if (eff) {
-        totalInterceptions += eff.appliedCount
-        totalSuccesses += eff.successAfterCount
-      }
+    for (const eff of effs) {
+      totalInterceptions += eff.appliedCount
+      totalSuccesses += eff.successAfterCount
     }
     lines.push('')
     lines.push(`Total interceptions: ${totalInterceptions}`)
     lines.push(
       `Success rate after rules: ${totalInterceptions > 0 ? Math.round((totalSuccesses / totalInterceptions) * 100) : 0}%`,
     )
+
+    lines.push('')
+    lines.push('### Rule effectiveness')
+    lines.push('| Rule | Status | Applied | Success | Trend |')
+    lines.push('|------|--------|---------|---------|-------|')
+    const statusIcon: Record<string, string> = { active: '🟢', degrading: '🟡', disabled: '⚫' }
+    for (const eff of effs) {
+      const icon = statusIcon[eff.status] ?? '⚪'
+      const rate =
+        eff.appliedCount > 0 ? Math.round((eff.successAfterCount / eff.appliedCount) * 100) : 0
+      const trend = crsiSparkline(eff.evaluationHistory.map((h) => 1 - h.failureRate))
+      lines.push(
+        `| ${eff.ruleId} | ${icon} ${eff.status} | ${eff.appliedCount} | ${rate}% | ${trend} |`,
+      )
+    }
+
+    const disabled = effs.filter((e) => e.status === 'disabled')
+    if (disabled.length > 0) {
+      lines.push('')
+      lines.push('### Disabled rules (retired)')
+      for (const d of disabled) {
+        lines.push(`- ${d.ruleId} (failure rate ${Math.round(d.postRuleFailureRate * 100)}%)`)
+      }
+    }
   }
 
   return { content: lines.join('\n') }
@@ -907,6 +936,21 @@ const sisStatsCmd: CommandHandler = (ctx) => {
   )
   lines.push(`平均成功率: ${Math.round(stats.avgSuccessRate * 100)}%`)
   lines.push(`总拦截次数: ${stats.totalInterceptions}`)
+
+  const active = db.getActive()
+  if (active.length > 0) {
+    lines.push('')
+    lines.push('### 签名明细（按拦截次数排序）')
+    lines.push('| 签名 | 状态 | 拦截 | 成功率 |')
+    lines.push('|------|------|------|--------|')
+    for (const s of active) {
+      const icon = s.status === 'active' ? '🟢' : '🟡'
+      lines.push(
+        `| ${s.id} | ${icon} ${s.status} | ${s.occurrences} | ${Math.round(s.successRate * 100)}% |`,
+      )
+    }
+  }
+
   return { content: lines.join('\n') }
 }