@miphamai/cli 0.22.0 → 0.24.0

package/src/tools/agent/list-agents.ts

@@ -0,0 +1,67 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+import { discoverSessions } from '../../agent/cross-session/discovery'
+
+export const listAgentsTool: ToolDefinition = {
+  name: 'ListAgents',
+  description:
+    'Discover active Mipham Code sessions running on this machine. ' +
+    'Returns session ID, name, machine, working directory, provider, and model for each session. ' +
+    'Use with SendMessage to communicate across sessions.',
+  category: 'agent',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      scope: {
+        type: 'string',
+        enum: ['local', 'all'],
+        default: 'local',
+        description:
+          'Discovery scope. "local" scans this machine only. "all" is reserved for future network discovery.',
+      },
+    },
+  },
+  async execute(params) {
+    const scope = (params.scope as string) || 'local'
+
+    if (scope === 'all') {
+      return {
+        success: true,
+        content:
+          'Network discovery is not yet available. Showing local sessions only.\n\n' +
+          formatSessionList(discoverSessions()),
+      }
+    }
+
+    const sessions = discoverSessions()
+
+    if (sessions.length === 0) {
+      return {
+        success: true,
+        content: 'No active Mipham Code sessions found on this machine.',
+      }
+    }
+
+    return {
+      success: true,
+      content: formatSessionList(sessions),
+    }
+  },
+}
+
+function formatSessionList(sessions: import('../../shared/types').SessionInfo[]): string {
+  const lines: string[] = [`${sessions.length} active session(s):\n`]
+
+  for (const s of sessions) {
+    const modelInfo = s.model ? ` · ${s.model}` : ''
+    const providerInfo = s.provider ? ` (${s.provider})` : ''
+    lines.push(`  ${s.id}`)
+    lines.push(`    Name:    ${s.name}`)
+    lines.push(`    Machine: ${s.machine}${modelInfo}${providerInfo}`)
+    lines.push(`    PID:     ${s.pid} · Started: ${s.startedAt}`)
+    if (s.cwd) lines.push(`    CWD:     ${s.cwd}`)
+    lines.push('')
+  }
+
+  return lines.join('\n').trim()
+}

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

@@ -1,13 +1,12 @@
 import type { ToolDefinition } from '../../shared/index.ts'
-import { getMessageBus } from '../../agent/message-bus'
+import { getMessageRouter } from '../../agent/message-router'
 
 export const sendMessageTool: ToolDefinition = {
   name: 'SendMessage',
   description:
-    'Send a message to another agent or the main conversation. ' +
-    'Use "main" as the recipient to message the parent session, ' +
-    'or a background task ID (e.g., "bg-1-xxx") to message a specific agent. ' +
-    'Messages are stored in the AgentMessageBus and can be polled by the recipient.',
+    '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).',
   category: 'agent',
   permission: 'auto',
   parameters: {
@@ -16,7 +15,7 @@ export const sendMessageTool: ToolDefinition = {
       to: {
         type: 'string',
         description:
-          'Recipient: "main" for the parent conversation, a background task ID, or an agent name.',
+          'Recipient: "main" for the parent conversation, a background task ID, or a session ID for cross-session messaging.',
       },
       summary: {
         type: 'string',
@@ -34,34 +33,32 @@ export const sendMessageTool: ToolDefinition = {
     const summary = (params.summary as string) || '(no subject)'
     const message = params.message as string
 
-    // Determine sender: use sessionId or 'main'
     const from =
       ctx.sessionId === 'sub-agent'
         ? `sub-agent-${Date.now().toString(36)}`
         : ctx.sessionId || 'main'
 
-    try {
-      const bus = getMessageBus()
-      const msgId = bus.post(from, to, summary, message)
+    const router = getMessageRouter()
+    const result = await router.route(from, to, summary, message)
 
-      const unreadForRecipient = bus.unreadCount(to)
-
-      return {
-        success: true,
-        content:
-          `── Message Sent ──\n\n` +
-          `ID:      ${msgId}\n` +
-          `From:    ${from}\n` +
-          `To:      ${to}\n` +
-          `Summary: ${summary.slice(0, 100)}\n\n` +
-          `The recipient has ${unreadForRecipient} unread message(s).`,
-      }
-    } catch (err) {
+    if (!result.success) {
       return {
         success: false,
         content: '',
-        error: `Failed to send message: ${String(err)}`,
+        error: `Failed to send message: ${result.error}`,
       }
     }
+
+    const routedLabel = result.routedTo === 'bus' ? 'in-process' : 'cross-session'
+
+    return {
+      success: true,
+      content:
+        `── Message Sent (${routedLabel}) ──\n\n` +
+        `ID:      ${result.messageId}\n` +
+        `From:    ${from}\n` +
+        `To:      ${to}\n` +
+        `Summary: ${summary.slice(0, 100)}`,
+    }
   },
 }

package/src/tools/exec/bash.ts

@@ -122,6 +122,57 @@ function isBlocked(command: string): string | null {
   return null // safe
 }
 
+/**
+ * Detect sandbox violations from stderr output.
+ * Parses common OS-level error patterns indicating denied access.
+ */
+export function detectViolations(stderr: string): string[] {
+  const violations: string[] = []
+
+  // File access violations
+  const accessPatterns = /(?:Permission denied|EACCES|EPERM|Operation not permitted)/gi
+  const accessMatches = stderr.match(accessPatterns)
+  if (accessMatches && accessMatches.length > 0) {
+    // Extract file paths from error messages
+    const pathPattern =
+      /(?:Permission denied|EACCES|EPERM|Operation not permitted).*?['"]?(\/[^\s'"]+)['"]?/gi
+    const paths: string[] = []
+    let match: RegExpExecArray | null
+    while ((match = pathPattern.exec(stderr)) !== null) {
+      paths.push(match[1]!)
+    }
+
+    if (paths.length > 0) {
+      violations.push(`  File access denied: ${paths.join(', ')}`)
+    } else {
+      violations.push(`  File access denied (${accessMatches.length} occurrence(s))`)
+    }
+  }
+
+  // Network access violations
+  const netPatterns =
+    /(?:Network is unreachable|Connection refused|ECONNREFUSED|ENETUNREACH|Could not resolve host|Name or service not known|ETIMEDOUT|Connection timed out)/gi
+  const netMatches = stderr.match(netPatterns)
+  if (netMatches && netMatches.length > 0) {
+    // Extract host:port from error messages
+    const hostPattern =
+      /(?:connect to|Could not resolve host|Failed to connect to)\s+([^\s:]+(?::\d+)?)/gi
+    const hosts: string[] = []
+    let match: RegExpExecArray | null
+    while ((match = hostPattern.exec(stderr)) !== null) {
+      hosts.push(match[1]!)
+    }
+
+    if (hosts.length > 0) {
+      violations.push(`  Network access denied: ${hosts.join(', ')}`)
+    } else {
+      violations.push(`  Network access denied (${netMatches.length} occurrence(s))`)
+    }
+  }
+
+  return violations
+}
+
 export const bashTool: ToolDefinition = {
   name: 'Bash',
   description:
@@ -173,6 +224,9 @@ export const bashTool: ToolDefinition = {
       const exitCode = await proc.exited
       clearTimeout(timer)
 
+      // Read stderr for violation detection and error reporting
+      const rawStderr = await new Response(proc.stderr).text()
+
       // ── Credential masking: scrub output ──
       let output = rawOutput
       if (credentialConfig?.enabled && credentialConfig.output_scrubbing.enabled) {
@@ -180,20 +234,30 @@ export const bashTool: ToolDefinition = {
         output = maskOutput(rawOutput, credentialConfig)
       }
 
+      // ── Sandbox violation detection ──
+      const violations = detectViolations(rawStderr)
+
       if (exitCode !== 0) {
-        const rawStderr = await new Response(proc.stderr).text()
         const stderr =
           credentialConfig?.enabled && credentialConfig.output_scrubbing.enabled
             ? (await import('../../core/credential-masker')).maskOutput(rawStderr, credentialConfig)
             : rawStderr
+        let errorContent = output.slice(0, 5_000)
+        if (violations.length > 0) {
+          errorContent += '\n\n── Sandbox Violations ──\n' + violations.join('\n')
+        }
         return {
           success: false,
-          content: output.slice(0, 5_000),
+          content: errorContent,
           error: `Exit code ${exitCode}: ${stderr.slice(0, 1_000)}`,
         }
       }
 
-      return { success: true, content: output.slice(0, 100_000) || '(no output)' }
+      let successContent = output.slice(0, 100_000) || '(no output)'
+      if (violations.length > 0) {
+        successContent += '\n\n── Sandbox Violations ──\n' + violations.join('\n')
+      }
+      return { success: true, content: successContent }
     } catch (err) {
       return {
         success: false,

package/src/tools/index.ts

@@ -29,6 +29,7 @@ import { toolSearchTool } from './system/tool-search'
 import { artifactTool } from './artifact/artifact'
 import { reportFindingsTool } from './agent/report-findings'
 import { sendMessageTool } from './agent/send-message'
+import { listAgentsTool } from './agent/list-agents'
 import { computerUseTool } from './computer/computer-use'
 import { scheduleWakeupTool } from './scheduling/schedule-wakeup.js'
 import { cronCreateTool, cronDeleteTool, cronListTool } from './scheduling/cron.js'
@@ -145,6 +146,7 @@ export function createToolRegistry(): Map<string, ToolDefinition> {
     withValidation(workflowTool),
     withValidation(reportFindingsTool),
     withValidation(sendMessageTool),
+    withValidation(listAgentsTool),
     // Network tools
     withValidation(webFetchTool),
     withValidation(webSearchTool),

package/src/ui/commands.ts

@@ -446,6 +446,124 @@ const skillsCmd: CommandHandler = (ctx) => {
   return { content: lines.join('\n') }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// CRSI (Conversational Rule Self-Improvement)
+// ═══════════════════════════════════════════════════════════════
+
+const crsiRulesCmd: CommandHandler = (ctx) => {
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+  const rules = engine.getActiveRules()
+  if (rules.length === 0) {
+    return { content: 'No active CRSI rules.' }
+  }
+  const lines: string[] = ['## Active CRSI Rules', '']
+  for (const r of rules) {
+    const status = r.enabled ? '✅' : '⛔'
+    lines.push(`- \`${r.id}\` [${r.category}] ${r.toolName} — ${r.source} ${status}`)
+  }
+  lines.push('', `Total: ${rules.length} active rules`)
+  lines.push('', 'Use `/crsi disable <rule-id>` to disable a rule.')
+  return { content: lines.join('\n') }
+}
+
+const crsiDisableCmd: CommandHandler = (ctx, args) => {
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+  const ruleId = args[0]?.trim()
+  if (!ruleId) {
+    return { content: 'Usage: /crsi disable <rule-id>' }
+  }
+  engine.setRuleEnabled(ruleId, false)
+  return {
+    content: `Rule \`${ruleId}\` has been disabled. Use \`/crsi restore ${ruleId}\` to re-enable.`,
+  }
+}
+
+const crsiAnalyzeCmd: CommandHandler = async (ctx) => {
+  const analyzer = ctx.engine.getPatternAnalyzer()
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI system is not available.' }
+  }
+
+  const patterns = analyzer.analyzeAllAgents()
+  if (patterns.length === 0) {
+    return { content: 'No failure patterns found across agents.' }
+  }
+
+  let registered = 0
+  for (const pattern of patterns) {
+    const toolRule = analyzer.toToolRule(pattern)
+    engine.register(toolRule)
+    registered++
+  }
+
+  const lines: string[] = [
+    '## CRSI Analysis Complete',
+    '',
+    `Found ${patterns.length} patterns, ${registered} rules registered.`,
+    '',
+  ]
+  for (const p of patterns) {
+    lines.push(
+      `- [${p.category}] \`${p.agentName}\` — ${p.frequency} failures (${p.confidence} confidence)`,
+    )
+  }
+  return { content: lines.join('\n') }
+}
+
+const crsiRestoreCmd: CommandHandler = (ctx, args) => {
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+  const ruleId = args.join(' ').trim()
+  if (!ruleId) {
+    return { content: 'Usage: /crsi restore <rule-id>' }
+  }
+  engine.setRuleEnabled(ruleId, true)
+  return { content: `Rule \`${ruleId}\` has been re-enabled.` }
+}
+
+const crsiStatsCmd: CommandHandler = async (ctx) => {
+  const engine = ctx.engine.getRuleEngine()
+  const tracker = ctx.engine.getEffectivenessTracker()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+
+  const rules = engine.getActiveRules()
+  const lines: string[] = ['## CRSI Statistics', '']
+  lines.push(`Total active rules: ${rules.length}`)
+  lines.push(`Builtin: ${rules.filter((r) => r.source === 'builtin').length}`)
+  lines.push(`Auto-generated: ${rules.filter((r) => r.source === 'pattern-analyzer').length}`)
+  lines.push(`Manual: ${rules.filter((r) => r.source === 'manual').length}`)
+
+  if (tracker) {
+    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
+      }
+    }
+    lines.push('')
+    lines.push(`Total interceptions: ${totalInterceptions}`)
+    lines.push(
+      `Success rate after rules: ${totalInterceptions > 0 ? Math.round((totalSuccesses / totalInterceptions) * 100) : 0}%`,
+    )
+  }
+
+  return { content: lines.join('\n') }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // Workflow
 // ═══════════════════════════════════════════════════════════════
@@ -3072,6 +3190,11 @@ const commandsListCmd: CommandHandler = () => {
     '/plugin-enable': 'Plugins',
     '/plugin-disable': 'Plugins',
     '/commands': 'Tools & Skills',
+    '/crsi rules': 'Tools & Skills',
+    '/crsi disable': 'Tools & Skills',
+    '/crsi analyze': 'Tools & Skills',
+    '/crsi restore': 'Tools & Skills',
+    '/crsi stats': 'Tools & Skills',
     '/plan': 'Workflow',
     '/no-plan': 'Workflow',
     '/tdd': 'Workflow',
@@ -3209,6 +3332,11 @@ registry.set('/remove-plugin', removePluginCmd)
 registry.set('/plugin-enable', pluginEnableCmd)
 registry.set('/plugin-disable', pluginDisableCmd)
 registry.set('/commands', commandsListCmd)
+registry.set('/crsi rules', crsiRulesCmd)
+registry.set('/crsi disable', crsiDisableCmd)
+registry.set('/crsi analyze', crsiAnalyzeCmd)
+registry.set('/crsi restore', crsiRestoreCmd)
+registry.set('/crsi stats', crsiStatsCmd)
 
 // Workflow
 registry.set('/plan', planCmd)
@@ -3359,6 +3487,11 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/remove-plugin': 'Remove an installed plugin',
   '/plugin-enable': 'Enable a disabled plugin',
   '/plugin-disable': 'Disable an enabled plugin',
+  '/crsi rules': 'List all active CRSI rules with their status',
+  '/crsi disable': 'Disable a CRSI rule by ID',
+  '/crsi analyze': 'Manually trigger CRSI pattern analysis across all agents',
+  '/crsi restore': 'Restore a disabled or degraded CRSI rule',
+  '/crsi stats': 'Show CRSI overall effectiveness statistics',
   '/plan': 'Enter plan mode',
   '/no-plan': 'Exit plan mode',
   '/tdd': 'Test-Driven Development workflow (RED → GREEN → REFACTOR)',