@metabob/minibob 0.1.2

package/src/activity.ts

@@ -0,0 +1,1464 @@
+/**
+ * minibob Activity Executor
+ * 
+ * Executes activity templates with impulse injection and tool calling.
+ */
+
+import type {
+  ActivityTemplate,
+  ActivityExecution,
+  ActivityTask,
+  TaskResult,
+  Impulse,
+  Message,
+  ToolResult,
+  ToolHandler,
+  ExecutedTask,
+} from "./types"
+import { createLLMClient, type LLMClient } from "./llm"
+import { createToolHandlers, getAllToolDefinitions, type ToolHandlerOptions, type ToolDefinition } from "./tools"
+import {
+  createImpulse,
+  loadImpulses,
+  formatImpulsesForContext,
+  storeActivityOutput,
+  getImpulseStore,
+} from "./impulse"
+import { getMCPClient, isMCPEnabled } from "./mcp"
+import {
+  filterImpulsesByRelevance,
+  calculateSavings,
+  estimateImpulseTokens,
+  generateFilteringSummary,
+} from "./impulse-filter"
+import { assembleTemplateFromExecution } from "./template-generator"
+
+/**
+ * Safe wrapper for Bun.file() with better error handling
+ */
+function safeReadFile(path: string, context?: string): ReturnType<typeof Bun.file> {
+  if (!path || typeof path !== 'string') {
+    const stack = new Error().stack
+    throw new Error(`[activity.ts] Invalid file path: expected string, got ${typeof path}${context ? ` (context: ${context})` : ''}\nStack: ${stack}`)
+  }
+  try {
+    return Bun.file(path)
+  } catch (error) {
+    throw new Error(`Failed to create file handle for '${path}': ${error instanceof Error ? error.message : String(error)}`)
+  }
+}
+
+/**
+ * Substitute {{impulse:id}} placeholders with impulse content
+ */
+async function substituteImpulses(template: string, _impulseIds: string[]): Promise<string> {
+  let result = template
+  
+  // Find all {{impulse:id}} patterns
+  const impulsePattern = /{{impulse:([a-zA-Z0-9_-]+)}}/g
+  const matches = Array.from(template.matchAll(impulsePattern))
+  
+  if (matches.length === 0) {
+    return result
+  }
+  
+  // Load all referenced impulses
+  const referencedIds = matches.map(m => m[1]).filter((id): id is string => id !== undefined)
+  const impulses = await loadImpulses(referencedIds)
+  
+  // Format impulses for context
+  const formatted = formatImpulsesForContext(impulses)
+  
+  // Replace each placeholder
+  for (const match of matches) {
+    const impulseId = match[1]
+    const impulseContent = impulses.find(imp => imp.id === impulseId)
+    
+    if (impulseContent) {
+      // Use formatted content (respects budget)
+      const content = typeof impulseContent.content === 'string' 
+        ? impulseContent.content 
+        : JSON.stringify(impulseContent.content, null, 2)
+      result = result.replace(match[0], content)
+    } else {
+      // Impulse not found, leave placeholder or use empty
+      console.warn(`Impulse not found: ${impulseId}`)
+      result = result.replace(match[0], `[impulse:${impulseId} not found]`)
+    }
+  }
+  
+  return result
+}
+
+// =============================================================================
+// ACTIVITY EXECUTOR
+// =============================================================================
+
+export interface ExecutorConfig {
+  provider: "anthropic" | "openai"
+  apiKey: string
+  model: string
+  workingDirectory: string
+  systemPrompt?: string
+  // Activity management callbacks (for autonomous trailblazing)
+  onSearchActivities?: (category?: string, verbose?: boolean) => Promise<{ count: number; activities: unknown[] }>
+  onCreateActivity?: (params: {
+    goalDescription: string
+    templateName: string
+    category: string
+    variables: Record<string, unknown>
+  }) => Promise<{ templateId: string }>
+  /**
+   * Callback when an activity is executed (for composition tracking)
+   */
+  onActivityExecute?: (templateId: string, variables: Record<string, unknown>, reason?: string) => Promise<ActivityExecution>
+  /**
+   * Custom domain-specific tools to expose to the LLM in addition to built-in tools.
+   * The host application (e.g. PerspectiveMinibobAdapter) injects these so that
+   * activity templates can call Perspective-specific database / API operations.
+   */
+  customTools?: ToolHandlerOptions["customTools"]
+  /**
+   * Maximum nesting depth for nested activity execution.
+   * Prevents runaway recursion when activities call other activities.
+   * Default: 3
+   */
+  maxNestingDepth?: number
+  /**
+   * Activity call stack for cycle detection.
+   * Tracks the chain of activity IDs from root to current execution.
+   * Used to detect and prevent circular activity calls (A → B → A).
+   *
+   * Example: ["process-goal", "explore-codebase", "read-file"]
+   *
+   * Internal use only - populated automatically during composition.
+   */
+  activityCallStack?: string[]
+}
+
+export interface ExecuteOptions {
+  template: ActivityTemplate
+  variables: Record<string, unknown>
+  reason?: string
+  impulses?: Impulse[]  // Context from previous executions
+  onTaskStart?: (taskId: string) => void
+  onTaskComplete?: (taskId: string, result: TaskResult) => void
+  // Parent activity context for composition tracking
+  parentActivityId?: string
+  parentExecutionId?: string
+  goalContext?: string
+}
+
+// =============================================================================
+// PHASE 1.8: State Capture Utilities for Debugging-as-Activity
+// =============================================================================
+
+/**
+ * Capture input state before task execution
+ */
+async function captureInputState(
+  workingDirectory: string,
+  impulseIds: string[],
+  variables: Record<string, unknown>
+): Promise<{
+  filesAvailable: string[]
+  environment: Record<string, string>
+  impulses: string[]
+  variables: Record<string, unknown>
+}> {
+  // List files in working directory (shallow, don't recurse into node_modules, etc.)
+  let filesAvailable: string[] = []
+  try {
+    const glob = new Bun.Glob("**/*")
+    const entries = await Array.fromAsync(glob.scan({ cwd: workingDirectory }))
+    filesAvailable = entries.filter(f => !f.includes("node_modules") && !f.startsWith(".") && !f.startsWith("dist"))
+  } catch (error) {
+    console.warn("[State Capture] Failed to list files:", error instanceof Error ? error.message : String(error))
+  }
+
+  // Capture relevant environment variables (filter sensitive ones)
+  const environment: Record<string, string> = {}
+  const envVarsToCapture = [
+    "NODE_ENV",
+    "PATH",
+    "HOME",
+    "USER",
+    "PWD",
+    "SHELL",
+    // Add more as needed
+  ]
+  for (const key of envVarsToCapture) {
+    const value = process.env[key]
+    if (value) {
+      environment[key] = value
+    }
+  }
+
+  return {
+    filesAvailable,
+    environment,
+    impulses: impulseIds,
+    variables: JSON.parse(JSON.stringify(variables)), // Deep clone
+  }
+}
+
+/**
+ * Capture output state after task execution
+ */
+async function captureOutputState(
+  workingDirectory: string,
+  beforeFiles: string[],
+  toolCalls: Array<{ toolName: string; params: any; result: ToolResult }>
+): Promise<{
+  filesModified: string[]
+  filesCreated: string[]
+  filesDeleted: string[]
+  exitCode?: number
+  stderr?: string
+}> {
+  // List files after execution
+  let afterFiles: string[] = []
+  try {
+    const glob = new Bun.Glob("**/*")
+    const entries = await Array.fromAsync(glob.scan({ cwd: workingDirectory }))
+    afterFiles = entries.filter(f => !f.includes("node_modules") && !f.startsWith(".") && !f.startsWith("dist"))
+  } catch (error) {
+    console.warn("[State Capture] Failed to list files after execution:", error instanceof Error ? error.message : String(error))
+  }
+
+  // Detect created, modified, deleted files
+  const beforeSet = new Set(beforeFiles)
+  const afterSet = new Set(afterFiles)
+  
+  const filesCreated = afterFiles.filter(f => !beforeSet.has(f))
+  const filesDeleted = beforeFiles.filter(f => !afterSet.has(f))
+  
+  // Modified files: files that existed before and after (tool calls track actual modifications)
+  const filesModified: string[] = []
+  for (const call of toolCalls) {
+    if (call.toolName === "write" || call.toolName === "edit") {
+      const filePath = call.params.filePath as string
+      if (filePath && beforeSet.has(filePath)) {
+        filesModified.push(filePath)
+      }
+    }
+  }
+
+  // Extract exit code and stderr from bash tool calls
+  let exitCode: number | undefined
+  let stderr: string | undefined
+  
+  for (const call of toolCalls) {
+    if (call.toolName === "bash" && call.result.metadata) {
+      if (call.result.metadata.exitCode !== undefined) {
+        exitCode = call.result.metadata.exitCode as number
+      }
+      if (call.result.metadata.stderr) {
+        stderr = call.result.metadata.stderr as string
+      }
+    }
+  }
+
+  return {
+    filesModified: Array.from(new Set(filesModified)), // Deduplicate
+    filesCreated,
+    filesDeleted,
+    exitCode,
+    stderr,
+  }
+}
+
+/**
+ * Capture lightweight file hashes for state transition tracking
+ */
+async function captureFileHashes(
+  workingDirectory: string,
+  files: string[]
+): Promise<Record<string, string>> {
+  const hashes: Record<string, string> = {}
+  
+  for (const file of files.slice(0, 50)) { // Limit to 50 files to avoid overhead
+    try {
+      const fullPath = `${workingDirectory}/${file}`
+      const fileContent = await safeReadFile(fullPath).text()
+      const hash = Bun.hash(fileContent).toString(16)
+      hashes[file] = hash
+    } catch (error) {
+      // File might have been deleted or is not readable
+      hashes[file] = "ERROR"
+    }
+  }
+  
+  return hashes
+}
+
+/**
+ * Activity executor for running activity templates
+ */
+export class ActivityExecutor {
+  private llm: LLMClient
+  private toolHandlers: ReturnType<typeof createToolHandlers>
+  private config: ExecutorConfig
+  private customToolDefinitions: ToolDefinition[]
+  private currentActivityId?: string
+  private currentExecutionId?: string
+  private currentGoalContext?: string
+  private toolCallRecords: Array<{ toolName: string; params: any; result: ToolResult; timestamp: number }> = []
+
+  /** Public accessor for LLM client (needed by GoalProcessor for improvisation fallback) */
+  get llmClient(): LLMClient {
+    return this.llm
+  }
+
+  constructor(config: ExecutorConfig) {
+    this.config = config
+    this.llm = createLLMClient(config.provider, config.apiKey)
+    // Collect custom tool definitions for passing to getAllToolDefinitions later
+    this.customToolDefinitions = Object.values(config.customTools ?? {}).map(({ definition }) => definition)
+    this.toolHandlers = createToolHandlers({
+      workingDirectory: config.workingDirectory,
+      onActivityExecute: config.onActivityExecute ?? (async (templateId, variables, reason) => {
+        // Default implementation if no custom callback provided
+        // Get current call stack (or initialize)
+        const callStack = config.activityCallStack ?? []
+
+        // CYCLE DETECTION: Check if this activity is already in the call stack
+        if (callStack.includes(templateId)) {
+          const cycleChain = [...callStack, templateId].join(' → ')
+          console.error(`[Activity] Cycle detected: ${cycleChain}`)
+          return {
+            id: `blocked_cycle_${Date.now()}`,
+            templateId,
+            status: "failed",
+            error: `Cycle detected: ${cycleChain}`,
+          }
+        }
+
+        // DEPTH CHECK: Verify we haven't exceeded maximum depth
+        if (callStack.length >= (config.maxNestingDepth ?? 3)) {
+          const depthChain = [...callStack, templateId].join(' → ')
+          console.warn(`[Activity] Max nesting depth reached: ${depthChain}`)
+          return {
+            id: `blocked_depth_${Date.now()}`,
+            templateId,
+            status: "failed",
+            error: `Maximum nesting depth reached (${callStack.length + 1} > ${config.maxNestingDepth ?? 3})`,
+          }
+        }
+
+        // CONTEXT ISOLATION: Nested activities execute with minimal context
+        // to prevent token accumulation across nesting levels
+        const template = await loadTemplateFromMCPOrLocal(templateId)
+
+        // Create isolated config - only essential settings, no accumulated state
+        const isolatedConfig: ExecutorConfig = {
+          workingDirectory: config.workingDirectory,
+          model: config.model,
+          provider: config.provider,
+          apiKey: config.apiKey,
+          systemPrompt: config.systemPrompt,
+          // Don't inherit parent's custom tools that might have accumulated state
+          customTools: {},
+          // Wire callbacks for further nesting (but depth-limited)
+          onSearchActivities: config.onSearchActivities,
+          onCreateActivity: config.onCreateActivity,
+          onActivityExecute: config.onActivityExecute, // Pass observer callback for composition tracking
+          // IMPORTANT: Pass updated call stack for cycle detection
+          activityCallStack: [...callStack, templateId],
+          // Adjust max depth based on current depth
+          maxNestingDepth: (config.maxNestingDepth ?? 3) - callStack.length,
+        }
+
+        const nestedExecutor = new ActivityExecutor(isolatedConfig)
+        const result = await nestedExecutor.execute({
+          template,
+          // Only pass essential variables, not accumulated context
+          variables: variables ?? {},
+          reason,
+          parentActivityId: this.currentActivityId,
+          parentExecutionId: this.currentExecutionId,
+          // Only pass a brief summary of goal context, not full accumulated context
+          goalContext: reason ? `Parent goal: ${reason.substring(0, 200)}` : undefined,
+        })
+
+        // Record composition if MCP is enabled
+        if (isMCPEnabled() && this.currentActivityId && this.currentExecutionId) {
+          const mcp = getMCPClient()
+          if (mcp) {
+            await mcp.recordComposition({
+              parentActivityId: this.currentActivityId,
+              childActivityId: template.id,
+              executionId: this.currentExecutionId,
+              goalContext: reason ? reason.substring(0, 200) : undefined,
+              success: result.status === "completed",
+            })
+          }
+        }
+
+        // Return summarized result to prevent full trace accumulation
+        return {
+          id: result.id,
+          templateId: result.templateId,
+          status: result.status,
+          summary: result.status === "completed"
+            ? `Activity "${templateId}" completed successfully`
+            : `Activity "${templateId}" failed: ${result.error?.substring(0, 200) ?? "unknown error"}`,
+        }
+      }),
+      onSearchActivities: config.onSearchActivities, // Wire activity search callback
+      onCreateActivity: config.onCreateActivity,     // Wire activity creation callback
+      onImpulseCreate: (impulse) => {
+        // Create impulse
+        createImpulse({
+          id: impulse.id,
+          pointer: impulse.type === "memo" && impulse.content
+            ? { type: "memo", content: impulse.content }
+            : impulse.type === "file" && impulse.content
+            ? { type: "file", path: impulse.content }
+            : { type: "custom", resolver: impulse.type, data: {} },
+          budget: impulse.budget,
+          priority: impulse.priority as "critical" | "high" | "medium" | "low",
+        })
+      },
+      customTools: config.customTools,
+    })
+  }
+
+  /**
+   * Execute an activity template
+   */
+  async execute(options: ExecuteOptions): Promise<ActivityExecution> {
+    const { template, variables, reason, impulses, onTaskStart, onTaskComplete, parentActivityId, parentExecutionId, goalContext } = options
+    const activityId = `act_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+
+    // Store context for composition tracking
+    this.currentActivityId = template.id
+    this.currentExecutionId = activityId
+    this.currentGoalContext = goalContext || reason
+
+    const execution: ActivityExecution = {
+      id: activityId,
+      templateId: template.id,
+      status: "executing",
+      variables,
+      impulses: impulses || [],  // Use provided impulses or empty array
+      taskResults: [],
+      startedAt: Date.now(),
+      // Initialize execution trace for debugging and ribosome pattern
+      executionTrace: {
+        tasks: [],
+        impulsesCreated: [],
+        filesModified: [],
+        goalContext: goalContext ? {
+          goal: goalContext,
+          intent: reason || "",
+          context: variables
+        } : undefined,
+      },
+    }
+
+    console.log(`[Activity] Starting: ${template.name} (${activityId})`)
+    if (reason) {
+      console.log(`[Activity] Reason: ${reason}`)
+    }
+    if (parentActivityId) {
+      console.log(`[Activity] Parent: ${parentActivityId}`)
+    }
+
+    // Register template to backend if MCP is enabled (ensure variant tracking)
+    if (isMCPEnabled()) {
+      const mcp = getMCPClient()
+      if (mcp) {
+        console.log(`[Activity] Registering template variant: ${template.id}`)
+        await mcp.registerTemplate(template)
+      }
+    }
+
+    try {
+      // Step 1: Create impulses from context requirements
+      const impulses = await this.createImpulsesFromRequirements(activityId, template, variables)
+      execution.impulses = impulses
+
+      // Step 2: Sort tasks by dependencies
+      const sortedTasks = this.topologicalSort(template.tasks)
+
+      // Step 3: Execute tasks in order
+      let totalInputTokens = 0
+      let totalOutputTokens = 0
+
+      for (const task of sortedTasks) {
+        onTaskStart?.(task.id)
+        console.log(`[Task] Executing: ${task.id} - ${task.description}`)
+
+        const result = await this.executeTask(activityId, task, variables, impulses, undefined, template.id)
+        execution.taskResults.push(result)
+
+        // Add executed task to trace for dashboard display
+        if (execution.executionTrace) {
+          const executedTask: ExecutedTask = {
+            id: task.id,
+            description: task.description,
+            actualPrompt: result.metadata?.actualPrompt || "",
+            toolCalls: result.metadata?.toolCalls || [],
+            response: result.output || "",
+            result: {
+              status: result.status === "completed" ? "success" :
+                      result.status === "failed" ? "failure" : "partial",
+              error: result.error,
+              metadata: result.metadata
+            },
+            inputState: result.metadata?.inputState,
+            outputState: result.metadata?.outputState,
+            stateTransition: result.metadata?.stateTransition,
+          }
+          execution.executionTrace.tasks.push(executedTask)
+
+          // Track files modified across all tasks
+          if (result.metadata?.outputState?.filesModified) {
+            for (const file of result.metadata.outputState.filesModified) {
+              if (!execution.executionTrace.filesModified.includes(file)) {
+                execution.executionTrace.filesModified.push(file)
+              }
+            }
+          }
+          if (result.metadata?.outputState?.filesCreated) {
+            for (const file of result.metadata.outputState.filesCreated) {
+              if (!execution.executionTrace.filesModified.includes(file)) {
+                execution.executionTrace.filesModified.push(file)
+              }
+            }
+          }
+        }
+
+        if (result.tokens) {
+          totalInputTokens += result.tokens.input
+          totalOutputTokens += result.tokens.output
+        }
+
+        // Create output impulses if task succeeded
+        if (result.status === "completed" && task.outputImpulses && task.outputImpulses.length > 0) {
+          for (const impulseId of task.outputImpulses) {
+            try {
+              createImpulse({
+                id: impulseId,
+                pointer: {
+                  type: "memo",
+                  content: result.output || ""
+                },
+                budget: 5000,
+                priority: "medium"
+              })
+              console.log(`[Activity] Created output impulse: ${impulseId}`)
+            } catch (error) {
+              console.error(`[Activity] Failed to create impulse ${impulseId}:`, error instanceof Error ? error.message : String(error))
+            }
+          }
+        }
+
+        onTaskComplete?.(task.id, result)
+
+        if (result.status === "failed") {
+          console.error(`[Task] Failed: ${task.id} - ${result.error}`)
+          
+          // Check retry policy
+          if (task.retry && task.retry.maxAttempts > 1) {
+            let retryCount = 1
+            while (retryCount < task.retry.maxAttempts && result.status === "failed") {
+              console.log(`[Task] Retrying ${task.id} (attempt ${retryCount + 1}/${task.retry.maxAttempts})`)
+              const retryResult = await this.executeTask(activityId, task, variables, impulses, result.error, template.id)
+              execution.taskResults[execution.taskResults.length - 1] = retryResult
+
+              // Update executed task in trace with retry result
+              if (execution.executionTrace && execution.executionTrace.tasks.length > 0) {
+                const executedTask: ExecutedTask = {
+                  id: task.id,
+                  description: task.description,
+                  actualPrompt: retryResult.metadata?.actualPrompt || "",
+                  toolCalls: retryResult.metadata?.toolCalls || [],
+                  response: retryResult.output || "",
+                  result: {
+                    status: retryResult.status === "completed" ? "success" :
+                            retryResult.status === "failed" ? "failure" : "partial",
+                    error: retryResult.error,
+                    metadata: retryResult.metadata
+                  },
+                  inputState: retryResult.metadata?.inputState,
+                  outputState: retryResult.metadata?.outputState,
+                  stateTransition: retryResult.metadata?.stateTransition,
+                }
+                execution.executionTrace.tasks[execution.executionTrace.tasks.length - 1] = executedTask
+              }
+
+              if (retryResult.tokens) {
+                totalInputTokens += retryResult.tokens.input
+                totalOutputTokens += retryResult.tokens.output
+              }
+
+              if (retryResult.status === "completed") break
+              retryCount++
+            }
+          }
+
+          // If still failed after retries, abort
+          if (execution.taskResults[execution.taskResults.length - 1]?.status === "failed") {
+            execution.status = "failed"
+            break
+          }
+        }
+      }
+
+      // Step 4: Complete execution
+      execution.completedAt = Date.now()
+      if (execution.status !== "failed") {
+        execution.status = "completed"
+      }
+
+      execution.metrics = {
+        duration: execution.completedAt - execution.startedAt,
+        cost: this.estimateCost(totalInputTokens, totalOutputTokens),
+        totalTokens: { input: totalInputTokens, output: totalOutputTokens },
+      }
+
+      console.log(`[Activity] Completed: ${execution.status} in ${execution.metrics.duration}ms`)
+
+      // Report execution to MCP backend if enabled
+      if (isMCPEnabled()) {
+        const mcp = getMCPClient()
+        if (mcp) {
+          console.log(`[Activity] Reporting execution to MCP backend...`)
+          const reported = await mcp.reportExecution(execution)
+          if (reported) {
+            console.log(`[Activity] ✓ Execution reported to backend`)
+          } else {
+            console.warn(`[Activity] ⚠ Failed to report execution to backend`)
+          }
+          
+          // Store execution trace for debugging-as-activity
+          if (execution.executionTrace) {
+            console.log(`[Activity] Storing execution trace...`)
+            const traceStored = await mcp.storeExecutionTrace(execution)
+            if (traceStored) {
+              console.log(`[Activity] ✓ Execution trace stored: ${execution.id}`)
+            } else {
+              console.warn(`[Activity] ⚠ Failed to store execution trace`)
+            }
+          }
+          
+          // Report tool usage patterns
+          if (this.toolCallRecords.length > 0) {
+            console.log(`[Activity] Reporting ${this.toolCallRecords.length} tool usage records...`)
+            const activitySucceeded = execution.status === "completed"
+            
+            for (const record of this.toolCallRecords) {
+              await mcp.recordToolUsage({
+                toolName: record.toolName,
+                activityVariantId: activityId,
+                taskId: undefined, // Could be enhanced to track per-task
+                executionId: execution.id,
+                toolSucceeded: record.result.success,
+                activitySucceeded,
+                paramsComplexity: record.params ? JSON.stringify(record.params).length : 0,
+              }).catch((error) => {
+                console.warn(`[Activity] ⚠ Failed to report tool usage for ${record.toolName}:`, error)
+              })
+            }
+            
+            console.log(`[Activity] ✓ Tool usage patterns reported`)
+          }
+
+          // RIBOSOME: Extract reusable template from successful execution
+          // Only extract if:
+          // 1. Execution was successful
+          // 2. Has execution trace (detailed task history)
+          // 3. Not already a ribosome-generated template (avoid infinite loop)
+          if (
+            execution.status === "completed" &&
+            execution.executionTrace &&
+            template.metadata?.author !== "ribosome"
+          ) {
+            try {
+              console.log(`[Ribosome] Extracting template from successful execution...`)
+
+              // Infer category from original template or default to "tool"
+              const category = template.category || "tool"
+
+              // Generate a descriptive name from the goal or template name
+              const goalDescription = execution.executionTrace.goalContext?.goal || template.name || "unnamed"
+              const shortGoal = goalDescription.substring(0, 50).replace(/[^a-zA-Z0-9]/g, "-").toLowerCase()
+              const templateName = `learned-${shortGoal}-${Date.now().toString(36)}`
+
+              // Call ribosome to extract template
+              const extractedTemplate = assembleTemplateFromExecution(
+                execution,
+                templateName,
+                category as "feature" | "bugfix" | "refactor" | "tool" | "infrastructure"
+              )
+
+              console.log(`[Ribosome] Template extracted: ${extractedTemplate.name}`)
+
+              // Register with backend for Thompson Sampling
+              const registered = await mcp.registerTemplate(extractedTemplate)
+              if (registered) {
+                console.log(`[Ribosome] ✓ Template registered: ${extractedTemplate.id}`)
+
+                // Enqueue for future testing via boredom queue (low priority)
+                try {
+                  const enqueueResponse = await fetch(`${(mcp as any).endpoint}/v2/activities/boredom/enqueue`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                      templateId: extractedTemplate.id,
+                      priority: "low",
+                      reason: `Ribosome-extracted from ${execution.id}`,
+                      variables: {},
+                    }),
+                  })
+
+                  if (enqueueResponse.ok) {
+                    console.log(`[Ribosome] ✓ Template enqueued for testing`)
+                  }
+                } catch (enqueueError) {
+                  // Non-fatal: template is registered, just not queued for immediate testing
+                  console.log(`[Ribosome] Template registered but not enqueued for testing`)
+                }
+              } else {
+                console.log(`[Ribosome] Template already exists or registration failed`)
+              }
+            } catch (ribosomeError) {
+              // Non-fatal: execution succeeded, ribosome extraction is bonus
+              console.log(`[Ribosome] Could not extract template:`, ribosomeError)
+            }
+          }
+        }
+      }
+
+    } catch (error) {
+      execution.status = "failed"
+      execution.completedAt = Date.now()
+      console.error(`[Activity] Error:`, error)
+
+      // Still try to report failure to backend
+      if (isMCPEnabled()) {
+        const mcp = getMCPClient()
+        if (mcp) {
+          await mcp.reportExecution(execution).catch(() => {
+            // Ignore reporting errors on failure
+          })
+        }
+      }
+    }
+
+    return execution
+  }
+
+  /**
+   * Get current executor state for TUI display
+   * Returns real-time information about what MiniBob is doing
+   */
+  getState(): {
+    currentActivityId: string | undefined
+    currentExecutionId: string | undefined
+    currentGoalContext: string | undefined
+    toolCallRecords: Array<{ toolName: string; params: any; result: ToolResult; timestamp: number }>
+    workingDirectory: string
+  } {
+    return {
+      currentActivityId: this.currentActivityId,
+      currentExecutionId: this.currentExecutionId,
+      currentGoalContext: this.currentGoalContext,
+      toolCallRecords: this.toolCallRecords.slice(-10), // Last 10 tool calls
+      workingDirectory: this.config.workingDirectory,
+    }
+  }
+
+  /**
+   * Create impulses from template context requirements
+   */
+  private async createImpulsesFromRequirements(
+    activityId: string,
+    template: ActivityTemplate,
+    variables: Record<string, unknown>
+  ): Promise<Impulse[]> {
+    const impulses: Impulse[] = []
+
+    if (!template.contextRequirements) {
+      return impulses
+    }
+
+    for (const req of template.contextRequirements) {
+      // Interpolate source with variables
+      const source = this.interpolate(req.source, variables)
+
+      let impulse: Impulse
+
+      switch (req.type) {
+        case "file":
+          impulse = createImpulse({
+            id: req.id,
+            pointer: { type: "file", path: source },
+            budget: req.budget,
+            priority: req.priority,
+          })
+          break
+
+        case "glob":
+          // Resolve glob to files and create impulses for each
+          // For simplicity, create a single impulse that will list files
+          impulse = createImpulse({
+            id: req.id,
+            pointer: {
+              type: "custom",
+              resolver: "glob",
+              data: { pattern: source, cwd: this.config.workingDirectory },
+            },
+            budget: req.budget,
+            priority: req.priority,
+          })
+          break
+
+        case "memo":
+          impulse = createImpulse({
+            id: req.id,
+            pointer: { type: "memo", content: source },
+            budget: req.budget,
+            priority: req.priority,
+          })
+          break
+
+        default:
+          impulse = createImpulse({
+            id: req.id,
+            pointer: {
+              type: "custom",
+              resolver: req.type,
+              data: { source },
+            },
+            budget: req.budget,
+            priority: req.priority,
+          })
+      }
+
+      impulses.push(impulse)
+    }
+
+    // Register glob resolver if not already registered
+    getImpulseStore().registerResolver("glob", async (data) => {
+      const pattern = data.pattern as string
+      const cwd = (data.cwd as string) ?? this.config.workingDirectory
+      const glob = new Bun.Glob(pattern)
+      const files: string[] = []
+      for await (const file of glob.scan({ cwd })) {
+        files.push(file)
+        if (files.length >= 50) break
+      }
+      return files.join("\n")
+    })
+
+    return impulses
+  }
+
+  /**
+   * Execute a single task
+   */
+  private async executeTask(
+    activityId: string,
+    task: ActivityTask,
+    variables: Record<string, unknown>,
+    impulses: Impulse[],
+    lastError?: string,
+    templateId?: string
+  ): Promise<TaskResult> {
+    const startedAt = Date.now()
+
+    // Phase 1.8: Declare variables outside try block for catch block access
+    const taskImpulseIds = task.impulseReferences ?? impulses.map((i) => i.id)
+    let impulsesToLoad = taskImpulseIds
+    
+    // Phase 1.8+: Declare state tracking variables outside try block
+    let inputState: any
+    let beforeHashes: Record<string, string> = {}
+    let outputState: any
+    let afterHashes: Record<string, string> = {}
+    let stateTransition: any
+    let prompt = ""
+
+    try {
+      // Phase 1.8: Intelligent impulse filtering
+      let loadedImpulses: Impulse[]
+      let filteringSummary: ReturnType<typeof generateFilteringSummary> | undefined
+
+      // Query relevance metrics if MCP is enabled
+      if (isMCPEnabled() && templateId && taskImpulseIds.length > 0) {
+        const mcp = getMCPClient()
+        if (mcp) {
+          try {
+            // Query relevance metrics from backend
+            const metrics = await mcp.queryImpulseRelevance({
+              activityVariantId: templateId,
+              impulseIds: taskImpulseIds,
+            })
+
+            // Filter impulses based on learned relevance
+            const filterResult = filterImpulsesByRelevance(taskImpulseIds, metrics)
+            impulsesToLoad = filterResult.toLoad
+
+            // Calculate and log savings
+            if (filterResult.toSkip.length > 0) {
+              const impulseStore = getImpulseStore()
+              const tokenSizes = new Map<string, number>()
+              
+              for (const impulseId of taskImpulseIds) {
+                const impulse = impulseStore.get(impulseId)
+                if (impulse) {
+                  tokenSizes.set(impulseId, estimateImpulseTokens(impulse))
+                }
+              }
+
+              const savings = calculateSavings(filterResult.toSkip, tokenSizes)
+              filteringSummary = generateFilteringSummary(filterResult, savings)
+
+              console.log(`[Impulse Filter] Task ${task.id}:`)
+              console.log(`  - Original: ${taskImpulseIds.length} impulses`)
+              console.log(`  - Loaded: ${filterResult.toLoad.length} impulses`)
+              console.log(`  - Skipped: ${filterResult.toSkip.length} impulses`)
+              console.log(`  - Saved: ~${savings.tokensSaved} tokens (~$${savings.costSaved.toFixed(4)})`)
+            }
+          } catch (error) {
+            // Fallback to loading all impulses if filtering fails
+            console.warn(`[Impulse Filter] Failed to filter impulses, loading all:`, error instanceof Error ? error.message : String(error))
+            impulsesToLoad = taskImpulseIds
+          }
+        }
+      }
+
+      // Load filtered impulses
+      loadedImpulses = await loadImpulses(impulsesToLoad)
+
+      // Phase 1.8: Capture input state BEFORE task execution
+      inputState = await captureInputState(
+        this.config.workingDirectory,
+        impulsesToLoad,
+        variables
+      )
+      
+      // Capture file hashes for state transition tracking
+      beforeHashes = await captureFileHashes(
+        this.config.workingDirectory,
+        inputState.filesAvailable
+      )
+
+      // Build prompt with impulse substitution first
+      prompt = await substituteImpulses(task.prompt.template, impulsesToLoad)
+      prompt = this.interpolate(prompt, variables)
+
+      // Add impulse context
+      const impulseContext = formatImpulsesForContext(loadedImpulses)
+      if (impulseContext) {
+        prompt = `${impulseContext}\n\n${prompt}`
+      }
+
+      // Add error context if retrying
+      if (lastError) {
+        prompt = `Previous attempt failed with error:\n${lastError}\n\nPlease try again, addressing the error.\n\n${prompt}`
+      }
+
+      // Build messages
+      const messages: Message[] = [
+        {
+          role: "system",
+          content: this.config.systemPrompt ?? this.getDefaultSystemPrompt(),
+        },
+        {
+          role: "user",
+          content: prompt,
+        },
+      ]
+
+      // Clear previous tool call records for this task
+      this.toolCallRecords = []
+
+      // Wrap tool handlers to capture tool execution data
+      const wrappedHandlers: Record<string, ToolHandler> = {}
+      for (const [toolName, handler] of Object.entries(this.toolHandlers)) {
+        wrappedHandlers[toolName] = async (params: any): Promise<ToolResult> => {
+          const toolResult = await handler(params)
+          
+          // Record tool call for impulse creation
+          this.toolCallRecords.push({
+            toolName,
+            params,
+            result: toolResult,
+            timestamp: Date.now(),
+          })
+          
+          return toolResult
+        }
+      }
+
+      // Execute with tool calling (using wrapped handlers)
+      const result = await this.llm.completeWithTools(
+        {
+          model: this.config.model,
+          messages,
+          tools: getAllToolDefinitions(this.customToolDefinitions),
+          maxTokens: task.prompt.maxTokens ?? 4096,
+        },
+        wrappedHandlers
+      )
+
+      // Create impulses from tool calls
+      for (const record of this.toolCallRecords) {
+        if (record.result.success && record.result.output) {
+          const impulseId = `tool:${record.toolName}:${task.id}:${record.timestamp}`
+          
+          createImpulse({
+            id: impulseId,
+            pointer: {
+              type: "memo",  // Store tool output as memo
+              content: record.result.output,
+            },
+            budget: Math.min(Math.ceil(record.result.output.length / 4), 2000), // Estimate tokens
+            priority: "medium",
+            tags: [`tool:${record.toolName}`, `activity:${activityId}`, `task:${task.id}`],
+          })
+          
+          console.log(`[Impulse] Created from tool call: ${impulseId}`)
+        }
+      }
+
+      // Store output for potential downstream tasks
+      storeActivityOutput(activityId, task.id, result.content)
+
+      // Phase 1.8: Capture output state AFTER task execution
+      outputState = await captureOutputState(
+        this.config.workingDirectory,
+        inputState.filesAvailable,
+        this.toolCallRecords
+      )
+      
+      // Capture file hashes for state transition tracking
+      afterHashes = await captureFileHashes(
+        this.config.workingDirectory,
+        outputState.filesCreated.concat(outputState.filesModified)
+      )
+      
+      stateTransition = {
+        before: beforeHashes,
+        after: afterHashes,
+        workingDirectory: this.config.workingDirectory,
+      }
+
+      // Run validation if specified
+      if (task.validation) {
+        const validationResult = await this.runValidation(task.validation, result.content)
+        if (!validationResult.success) {
+          // Phase 1.8: Record impulse relevance (validation failed)
+          await this.recordImpulseRelevance(templateId, taskImpulseIds, impulsesToLoad, false)
+          
+          return {
+            taskId: task.id,
+            status: "failed",
+            output: result.content,
+            error: `Validation failed: ${validationResult.error}`,
+            startedAt,
+            completedAt: Date.now(),
+            tokens: { input: result.usage.inputTokens, output: result.usage.outputTokens },
+            // Phase 1.8+: Include state even for validation failures (helps debugging)
+            metadata: {
+              inputState,
+              outputState,
+              stateTransition,
+              toolCalls: this.toolCallRecords.map((r, index) => ({
+                id: `tool:${r.toolName}:${task.id}:${r.timestamp}`,
+                name: r.toolName,
+                arguments: r.params,
+                result: {
+                  success: r.result.success,
+                  output: r.result.output,
+                  error: r.result.error,
+                  metadata: r.result.metadata
+                }
+              })),
+              actualPrompt: prompt,
+            },
+          }
+        }
+      }
+
+      // Phase 1.8: Record impulse relevance (success)
+      await this.recordImpulseRelevance(templateId, taskImpulseIds, impulsesToLoad, true)
+
+      return {
+        taskId: task.id,
+        status: "completed",
+        output: result.content,
+        startedAt,
+        completedAt: Date.now(),
+        tokens: { input: result.usage.inputTokens, output: result.usage.outputTokens },
+        // Phase 1.8+: Include state tracking for ribosome
+        metadata: {
+          inputState,
+          outputState,
+          stateTransition,
+          toolCalls: this.toolCallRecords.map((r, index) => ({
+            id: `tool:${r.toolName}:${task.id}:${r.timestamp}`,
+            name: r.toolName,
+            arguments: r.params,
+            result: {
+              success: r.result.success,
+              output: r.result.output,
+              error: r.result.error,
+              metadata: r.result.metadata
+            }
+          })),
+          actualPrompt: prompt,
+        },
+      }
+    } catch (error) {
+      // Phase 1.8: Record impulse relevance (execution failed)
+      await this.recordImpulseRelevance(templateId, taskImpulseIds, impulsesToLoad, false)
+
+      // Phase 1.8+: Try to capture output state even on error
+      let errorOutputState
+      let errorAfterHashes
+      try {
+        // Only capture state if inputState was initialized (error occurred after state capture)
+        if (inputState && inputState.filesAvailable) {
+          errorOutputState = await captureOutputState(
+            this.config.workingDirectory,
+            inputState.filesAvailable,
+            this.toolCallRecords
+          )
+          errorAfterHashes = await captureFileHashes(
+            this.config.workingDirectory,
+            errorOutputState.filesCreated.concat(errorOutputState.filesModified)
+          )
+        }
+      } catch (stateError) {
+        // State capture failed - not critical, continue
+        console.warn(`[State Capture] Failed during error handling:`, stateError)
+      }
+      
+      return {
+        taskId: task.id,
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error),
+        startedAt,
+        completedAt: Date.now(),
+        // Phase 1.8+: Include partial state (very helpful for debugging failures)
+        metadata: errorOutputState ? {
+          inputState,
+          outputState: errorOutputState,
+          stateTransition: {
+            before: beforeHashes,
+            after: errorAfterHashes || {},
+            workingDirectory: this.config.workingDirectory,
+          },
+          toolCalls: this.toolCallRecords.map((r, index) => ({
+            id: `tool:${r.toolName}:${task.id}:${r.timestamp}`,
+            name: r.toolName,
+            arguments: r.params,
+            result: {
+              success: r.result.success,
+              output: r.result.output,
+              error: r.result.error,
+              metadata: r.result.metadata
+            }
+          })),
+        } : undefined,
+      }
+    }
+  }
+
+  /**
+   * Phase 1.8: Record impulse relevance metrics to backend
+   */
+  private async recordImpulseRelevance(
+    templateId: string | undefined,
+    allImpulseIds: string[],
+    loadedImpulseIds: string[],
+    executionSucceeded: boolean
+  ): Promise<void> {
+    if (!isMCPEnabled() || !templateId || allImpulseIds.length === 0) {
+      return
+    }
+
+    const mcp = getMCPClient()
+    if (!mcp) return
+
+    try {
+      // Record relevance for each impulse
+      for (const impulseId of allImpulseIds) {
+        const wasLoaded = loadedImpulseIds.includes(impulseId)
+        await mcp.recordImpulseRelevance({
+          impulseId,
+          activityVariantId: templateId,
+          wasLoaded,
+          executionSucceeded,
+        })
+      }
+    } catch (error) {
+      // Non-blocking: log error but don't fail task
+      console.warn(`[Impulse Filter] Failed to record relevance:`, error instanceof Error ? error.message : String(error))
+    }
+  }
+
+  /**
+   * Run validation checks
+   */
+  private async runValidation(validation: ActivityTask["validation"], taskOutput?: string): Promise<{ success: boolean; error?: string }> {
+    if (!validation) return { success: true }
+
+    // Check required files exist
+    if (validation.requiredFiles) {
+      for (const filePath of validation.requiredFiles) {
+        const file = safeReadFile(filePath)
+        if (!(await file.exists())) {
+          return { success: false, error: `Required file missing: ${filePath}` }
+        }
+      }
+    }
+
+    // Check required patterns
+    if (validation.requiredPatterns) {
+      for (const patternSpec of validation.requiredPatterns) {
+        // Support both string patterns (checked in task output) and { file, pattern } objects
+        if (typeof patternSpec === 'string') {
+          // Simple string pattern - check in task output
+          if (!taskOutput) {
+            return { success: false, error: `Cannot validate pattern "${patternSpec}": task output not available` }
+          }
+          const regex = new RegExp(patternSpec)
+          if (!regex.test(taskOutput)) {
+            return { success: false, error: `Required pattern not found in task output: ${patternSpec}` }
+          }
+        } else {
+          // Object format { file, pattern } - check in specific file
+          const { file: filePath, pattern } = patternSpec
+          const file = safeReadFile(filePath)
+          if (!(await file.exists())) {
+            return { success: false, error: `File missing for pattern check: ${filePath}` }
+          }
+          const content = await file.text()
+          const regex = new RegExp(pattern)
+          if (!regex.test(content)) {
+            return { success: false, error: `Pattern not found in ${filePath}: ${pattern}` }
+          }
+        }
+      }
+    }
+
+    // Check forbidden patterns
+    if (validation.forbiddenPatterns) {
+      for (const { file: filePath, pattern } of validation.forbiddenPatterns) {
+        const file = safeReadFile(filePath)
+        if (await file.exists()) {
+          const content = await file.text()
+          const regex = new RegExp(pattern)
+          if (regex.test(content)) {
+            return { success: false, error: `Forbidden pattern found in ${filePath}: ${pattern}` }
+          }
+        }
+      }
+    }
+
+    // Run validation commands
+    if (validation.commands) {
+      for (const { command, expectedOutput } of validation.commands) {
+        const bashHandler = this.toolHandlers.bash
+        if (!bashHandler) {
+          return { success: false, error: "bash tool handler not available" }
+        }
+        const result = await bashHandler({ command })
+        if (!result.success) {
+          return { success: false, error: `Validation command failed: ${command}` }
+        }
+        if (expectedOutput && !result.output?.includes(expectedOutput)) {
+          return { success: false, error: `Unexpected output from: ${command}` }
+        }
+      }
+    }
+
+    return { success: true }
+  }
+
+  /**
+   * Topological sort for task dependencies
+   */
+  private topologicalSort(tasks: ActivityTask[]): ActivityTask[] {
+    const taskMap = new Map(tasks.map((t) => [t.id, t]))
+    const visited = new Set<string>()
+    const result: ActivityTask[] = []
+
+    const visit = (taskId: string): void => {
+      if (visited.has(taskId)) return
+      visited.add(taskId)
+
+      const task = taskMap.get(taskId)
+      if (!task) return
+
+      for (const depId of task.dependencies ?? []) {
+        visit(depId)
+      }
+
+      result.push(task)
+    }
+
+    for (const task of tasks) {
+      visit(task.id)
+    }
+
+    return result
+  }
+
+  /**
+   * Interpolate variables into template string
+   */
+  private interpolate(template: string, variables: Record<string, unknown>): string {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+      const value = variables[key]
+      if (value === undefined) return `{{${key}}}`
+      if (typeof value === "object") return JSON.stringify(value, null, 2)
+      return String(value)
+    })
+  }
+
+  /**
+   * Estimate cost based on token usage
+   */
+  private estimateCost(inputTokens: number, outputTokens: number): number {
+    // Approximate costs for Claude 3.5 Sonnet
+    const inputCostPerMillion = 3.0
+    const outputCostPerMillion = 15.0
+
+    return (
+      (inputTokens / 1_000_000) * inputCostPerMillion +
+      (outputTokens / 1_000_000) * outputCostPerMillion
+    )
+  }
+
+  /**
+   * Get default system prompt
+   * 
+   * ARCHITECTURE: Enforces activity-first constraint per corrected trailblazing architecture.
+   * MiniBob must search for existing activities and create new ones for non-trivial tasks.
+   */
+  private getDefaultSystemPrompt(): string {
+    return `You are minibob, an autonomous vessel that creates and composes activities instead of using direct tool calls.
+
+**CORE PRINCIPLE**: You learn by creating reusable activities, not by executing one-off tool calls.
+
+**CONSTRAINTS - ACTIVITY-FIRST APPROACH**:
+
+For NON-TRIVIAL tasks (anything beyond simple reads/status checks):
+  1. search_activities() to find existing templates
+  2. If match found: Execute the activity
+  3. If no match: create_activity_goal_seeking() to create new template
+  4. Record your reasoning for the choice
+
+For TRIVIAL tasks (simple operations that don't benefit from templating):
+  - Simple file reads (read a single file to check content)
+  - Basic git status checks (git status, git diff)
+  - Simple list operations (ls, find single file)
+  ✅ Direct tool use allowed
+
+**EXAMPLES**:
+
+Non-Trivial (MUST use activities):
+  ❌ "Fix all TypeScript errors" → search_activities → create if no match
+  ❌ "Add authentication" → search_activities → create if no match
+  ❌ "Refactor component" → search_activities → create if no match
+  ❌ "Deploy to production" → search_activities → create if no match
+
+Trivial (Direct tools OK):
+  ✅ "Read src/index.ts to see imports" → read tool
+  ✅ "Check git status" → bash git status
+  ✅ "List files in src/" → bash ls src/
+
+**WORKFLOW**:
+1. Analyze task complexity
+2. If non-trivial: search_activities() first
+   - Found match? Execute it
+   - No match? create_activity_goal_seeking()
+3. If trivial: Use direct tools (read, bash, git)
+4. Always explain your reasoning
+
+**GUIDELINES**:
+- Prefer activity composition over direct execution
+- Create reusable templates from complex workflows
+- Search before creating (avoid duplicate activities)
+- Report activity execution results clearly
+- When stuck, ask specific targeted questions
+
+Be autonomous, learn from execution, and build reusable knowledge.`
+  }
+}
+
+/**
+ * Load an activity template from a JSON file
+ */
+export async function loadTemplate(path: string): Promise<ActivityTemplate> {
+  const file = safeReadFile(path)
+  if (!(await file.exists())) {
+    throw new Error(`Template not found: ${path}`)
+  }
+  const content = await file.json()
+  return content as ActivityTemplate
+}
+
+/**
+ * Load activity template from MCP backend or local file
+ * 
+ * If templateIdOrPath looks like a file path (contains / or .json), load from file.
+ * Otherwise, try to load from MCP backend first, then fall back to local templates/ directory.
+ */
+export async function loadTemplateFromMCPOrLocal(templateIdOrPath: string): Promise<ActivityTemplate> {
+  // Check if it's a file path
+  if (templateIdOrPath.includes("/") || templateIdOrPath.endsWith(".json")) {
+    return loadTemplate(templateIdOrPath)
+  }
+
+  // Try MCP first if enabled
+  if (isMCPEnabled()) {
+    const mcp = getMCPClient()
+    if (mcp) {
+      console.log(`[Activity] Fetching template "${templateIdOrPath}" from MCP backend...`)
+      const template = await mcp.getActivityTemplate(templateIdOrPath)
+      if (template) {
+        console.log(`[Activity] ✓ Template loaded from MCP backend`)
+        return template
+      }
+      console.log(`[Activity] Template not found in MCP, trying local...`)
+    }
+  }
+
+  // Fall back to local templates directory
+  const localPath = `templates/${templateIdOrPath}.json`
+  return loadTemplate(localPath)
+}
+
+/**
+ * Create executor and run activity
+ */
+export async function runActivity(
+  config: ExecutorConfig,
+  templatePath: string,
+  variables: Record<string, unknown>,
+  reason?: string
+): Promise<ActivityExecution> {
+  const template = await loadTemplate(templatePath)
+  const executor = new ActivityExecutor(config)
+  return executor.execute({ template, variables, reason })
+}
+
+/**
+ * Format execution duration in human-readable format
+ * @param ms - Duration in milliseconds
+ * @returns Formatted string (e.g., "1.2s" or "345ms")
+ */
+export function formatDuration(ms: number): string {
+  if (ms >= 1000) {
+    return `${(ms / 1000).toFixed(1)}s`
+  }
+  return `${Math.round(ms)}ms`
+}