@soederpop/luca 0.1.2 → 0.2.1

package/src/introspection/generated.agi.ts

@@ -1,7 +1,7 @@
 import { setBuildTimeData, setContainerBuildTimeData } from './index.js';
 
 // Auto-generated introspection registry data
-// Generated at: 2026-03-30T06:52:55.070Z
+// Generated at: 2026-04-05T06:58:06.272Z
 
 setBuildTimeData('features.googleDocs', {
   "id": "features.googleDocs",
@@ -8692,6 +8692,19 @@ setBuildTimeData('features.processManager', {
       ],
       "returns": "void"
     },
+    "setupToolsConsumer": {
+      "description": "When an assistant uses processManager, inject system prompt guidance about how to manage processes safely and effectively.",
+      "parameters": {
+        "consumer": {
+          "type": "Helper",
+          "description": "Parameter consumer"
+        }
+      },
+      "required": [
+        "consumer"
+      ],
+      "returns": "void"
+    },
     "spawn": {
       "description": "Spawn a long-running process and return a handle immediately. The returned SpawnHandler provides events for stdout/stderr streaming, exit/crash notifications, and methods to kill or await the process.",
       "parameters": {
@@ -11111,6 +11124,19 @@ setBuildTimeData('features.contentDb', {
   "shortcut": "features.contentDb",
   "className": "ContentDb",
   "methods": {
+    "setupToolsConsumer": {
+      "description": "When an assistant uses contentDb, inject system prompt guidance about progressive document exploration.",
+      "parameters": {
+        "consumer": {
+          "type": "Helper",
+          "description": "Parameter consumer"
+        }
+      },
+      "required": [
+        "consumer"
+      ],
+      "returns": "void"
+    },
     "renderTree": {
       "description": "Render a tree view of the collection directory structure. Built with container.fs so it works without the `tree` binary.",
       "parameters": {
@@ -11838,274 +11864,6 @@ setBuildTimeData('clients.websocket', {
   "envVars": []
 });
 
-setBuildTimeData('clients.openai', {
-  "id": "clients.openai",
-  "description": "OpenAI client — wraps the OpenAI SDK for chat completions, responses API, embeddings, and image generation. Provides convenience methods for common operations while tracking token usage and request counts. Supports both the Chat Completions API and the newer Responses API.",
-  "shortcut": "clients.openai",
-  "className": "OpenAIClient",
-  "methods": {
-    "connect": {
-      "description": "Test the API connection by listing models.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<this>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "await openai.connect()"
-        }
-      ]
-    },
-    "createChatCompletion": {
-      "description": "Create a chat completion using the Chat Completions API.",
-      "parameters": {
-        "messages": {
-          "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
-          "description": "Array of chat messages"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
-          "description": "Additional parameters for the completion"
-        }
-      },
-      "required": [
-        "messages"
-      ],
-      "returns": "Promise<OpenAI.Chat.Completions.ChatCompletion>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createChatCompletion([\n { role: 'system', content: 'You are a helpful assistant.' },\n { role: 'user', content: 'Hello!' }\n])\nconsole.log(response.choices[0]?.message?.content)"
-        }
-      ]
-    },
-    "createResponse": {
-      "description": "Create a response using the Responses API.",
-      "parameters": {
-        "input": {
-          "type": "OpenAI.Responses.ResponseInput | string",
-          "description": "The input prompt or message array"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Responses.ResponseCreateParamsNonStreaming>",
-          "description": "Additional parameters for the response"
-        }
-      },
-      "required": [
-        "input"
-      ],
-      "returns": "Promise<OpenAI.Responses.Response>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createResponse('Explain quantum computing')"
-        }
-      ]
-    },
-    "streamResponse": {
-      "description": "Stream a response using the Responses API.",
-      "parameters": {
-        "input": {
-          "type": "OpenAI.Responses.ResponseInput | string",
-          "description": "The input prompt or message array"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Responses.ResponseCreateParamsStreaming>",
-          "description": "Additional parameters for the streaming response"
-        }
-      },
-      "required": [
-        "input"
-      ],
-      "returns": "Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const stream = await openai.streamResponse('Write a poem')\nfor await (const event of stream) {\n if (event.type === 'response.output_text.delta') {\n   process.stdout.write(event.delta)\n }\n}"
-        }
-      ]
-    },
-    "createCompletion": {
-      "description": "Create a legacy text completion.",
-      "parameters": {
-        "prompt": {
-          "type": "string",
-          "description": "The text prompt to complete"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Completions.CompletionCreateParams>",
-          "description": "Additional parameters for the completion"
-        }
-      },
-      "required": [
-        "prompt"
-      ],
-      "returns": "Promise<OpenAI.Completions.Completion>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createCompletion('Once upon a time')"
-        }
-      ]
-    },
-    "createEmbedding": {
-      "description": "Create text embeddings for semantic search or similarity comparisons.",
-      "parameters": {
-        "input": {
-          "type": "string | string[]",
-          "description": "A string or array of strings to embed"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Embeddings.EmbeddingCreateParams>",
-          "description": "Additional parameters (model, etc.)"
-        }
-      },
-      "required": [
-        "input"
-      ],
-      "returns": "Promise<OpenAI.Embeddings.CreateEmbeddingResponse>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createEmbedding('Hello world')\nconsole.log(response.data[0].embedding.length)"
-        }
-      ]
-    },
-    "createImage": {
-      "description": "Generate an image from a text prompt using DALL-E.",
-      "parameters": {
-        "prompt": {
-          "type": "string",
-          "description": "Description of the image to generate"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Images.ImageGenerateParams>",
-          "description": "Additional parameters (size, n, etc.)"
-        }
-      },
-      "required": [
-        "prompt"
-      ],
-      "returns": "Promise<OpenAI.Images.ImagesResponse>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createImage('A sunset over mountains')\nconsole.log(response.data[0].url)"
-        }
-      ]
-    },
-    "listModels": {
-      "description": "List all available models.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<OpenAI.Models.ModelsPage>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const models = await openai.listModels()"
-        }
-      ]
-    },
-    "ask": {
-      "description": "Ask a single question and get a text response. Convenience wrapper around `createChatCompletion` for simple Q&A.",
-      "parameters": {
-        "question": {
-          "type": "string",
-          "description": "The question to ask"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
-          "description": "Additional completion parameters"
-        }
-      },
-      "required": [
-        "question"
-      ],
-      "returns": "Promise<string>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const answer = await openai.ask('What is 2 + 2?')\nconsole.log(answer) // '4'"
-        }
-      ]
-    },
-    "chat": {
-      "description": "Send a multi-turn conversation and get a text response. Convenience wrapper around `createChatCompletion` that returns just the text.",
-      "parameters": {
-        "messages": {
-          "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
-          "description": "Array of chat messages"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
-          "description": "Additional completion parameters"
-        }
-      },
-      "required": [
-        "messages"
-      ],
-      "returns": "Promise<string>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const reply = await openai.chat([\n { role: 'system', content: 'You are a pirate.' },\n { role: 'user', content: 'Hello!' }\n])"
-        }
-      ]
-    }
-  },
-  "getters": {
-    "defaultModel": {
-      "description": "The default model used for completions, from options or 'gpt-4o'.",
-      "returns": "string"
-    },
-    "raw": {
-      "description": "The underlying OpenAI SDK instance for advanced use cases.",
-      "returns": "OpenAI"
-    }
-  },
-  "events": {
-    "connected": {
-      "name": "connected",
-      "description": "Event emitted by OpenAIClient",
-      "arguments": {}
-    },
-    "failure": {
-      "name": "failure",
-      "description": "Event emitted by OpenAIClient",
-      "arguments": {}
-    },
-    "completion": {
-      "name": "completion",
-      "description": "Event emitted by OpenAIClient",
-      "arguments": {}
-    },
-    "embedding": {
-      "name": "embedding",
-      "description": "Event emitted by OpenAIClient",
-      "arguments": {}
-    },
-    "image": {
-      "name": "image",
-      "description": "Event emitted by OpenAIClient",
-      "arguments": {}
-    },
-    "models": {
-      "name": "models",
-      "description": "Event emitted by OpenAIClient",
-      "arguments": {}
-    }
-  },
-  "state": {},
-  "options": {},
-  "envVars": [],
-  "examples": [
-    {
-      "language": "ts",
-      "code": "const openai = container.client('openai', { defaultModel: 'gpt-4o' })\nconst answer = await openai.ask('What is the meaning of life?')\nconsole.log(answer)"
-    }
-  ]
-});
-
 setBuildTimeData('clients.supabase', {
   "id": "clients.supabase",
   "description": "Supabase client for the Luca container system. Wraps the official `@supabase/supabase-js` SDK and exposes it through Luca's typed state, events, and introspection system. The SDK is isomorphic so this single implementation works in both Node and browser containers. Use `client.sdk` for full SDK access, or use the convenience wrappers for common operations (auth, database queries, storage, edge functions, realtime).",
@@ -12302,270 +12060,6 @@ setBuildTimeData('clients.supabase', {
   ]
 });
 
-setBuildTimeData('clients.elevenlabs', {
-  "id": "clients.elevenlabs",
-  "description": "ElevenLabs client — text-to-speech synthesis via the ElevenLabs REST API. Provides methods for listing voices, listing models, and generating speech audio. Audio is returned as a Buffer; use `say()` for a convenience method that writes to disk.",
-  "shortcut": "clients.elevenlabs",
-  "className": "ElevenLabsClient",
-  "methods": {
-    "beforeRequest": {
-      "description": "Inject the xi-api-key header before each request.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    },
-    "connect": {
-      "description": "Validate the API key by listing available models.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<this>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "await el.connect()"
-        }
-      ]
-    },
-    "listVoices": {
-      "description": "List available voices with optional search and filtering.",
-      "parameters": {
-        "options": {
-          "type": "{\n    search?: string\n    category?: string\n    voice_type?: string\n    page_size?: number\n    next_page_token?: string\n  }",
-          "description": "Query parameters for filtering voices"
-        }
-      },
-      "required": [],
-      "returns": "Promise<any>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const voices = await el.listVoices()\nconst premade = await el.listVoices({ category: 'premade' })"
-        }
-      ]
-    },
-    "getVoice": {
-      "description": "Get details for a single voice.",
-      "parameters": {
-        "voiceId": {
-          "type": "string",
-          "description": "The voice ID to look up"
-        }
-      },
-      "required": [
-        "voiceId"
-      ],
-      "returns": "Promise<any>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const voice = await el.getVoice('21m00Tcm4TlvDq8ikWAM')\nconsole.log(voice.name, voice.settings)"
-        }
-      ]
-    },
-    "listModels": {
-      "description": "List available TTS models.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<any[]>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const models = await el.listModels()\nconsole.log(models.map(m => m.model_id))"
-        }
-      ]
-    },
-    "synthesize": {
-      "description": "Synthesize speech from text, returning audio as a Buffer.",
-      "parameters": {
-        "text": {
-          "type": "string",
-          "description": "The text to convert to speech"
-        },
-        "options": {
-          "type": "SynthesizeOptions",
-          "description": "Voice, model, format, and voice settings overrides",
-          "properties": {
-            "voiceId": {
-              "type": "string",
-              "description": ""
-            },
-            "modelId": {
-              "type": "string",
-              "description": ""
-            },
-            "outputFormat": {
-              "type": "string",
-              "description": ""
-            },
-            "voiceSettings": {
-              "type": "ElevenLabsVoiceSettings",
-              "description": ""
-            },
-            "disableCache": {
-              "type": "boolean",
-              "description": ""
-            }
-          }
-        }
-      },
-      "required": [
-        "text"
-      ],
-      "returns": "Promise<Buffer>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data\n\nconst custom = await el.synthesize('Hello', {\n voiceId: '21m00Tcm4TlvDq8ikWAM',\n voiceSettings: { stability: 0.5, similarityBoost: 0.8 }\n})"
-        }
-      ]
-    },
-    "say": {
-      "description": "Synthesize speech and write the audio to a file.",
-      "parameters": {
-        "text": {
-          "type": "string",
-          "description": "The text to convert to speech"
-        },
-        "outputPath": {
-          "type": "string",
-          "description": "File path to write the audio to"
-        },
-        "options": {
-          "type": "SynthesizeOptions",
-          "description": "Voice, model, format, and voice settings overrides",
-          "properties": {
-            "voiceId": {
-              "type": "string",
-              "description": ""
-            },
-            "modelId": {
-              "type": "string",
-              "description": ""
-            },
-            "outputFormat": {
-              "type": "string",
-              "description": ""
-            },
-            "voiceSettings": {
-              "type": "ElevenLabsVoiceSettings",
-              "description": ""
-            },
-            "disableCache": {
-              "type": "boolean",
-              "description": ""
-            }
-          }
-        }
-      },
-      "required": [
-        "text",
-        "outputPath"
-      ],
-      "returns": "Promise<string>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const path = await el.say('Hello world', './hello.mp3')\nconsole.log(`Audio saved to ${path}`)"
-        }
-      ]
-    }
-  },
-  "getters": {
-    "apiKey": {
-      "description": "The resolved API key from options or environment.",
-      "returns": "string"
-    }
-  },
-  "events": {
-    "failure": {
-      "name": "failure",
-      "description": "Event emitted by ElevenLabsClient",
-      "arguments": {}
-    },
-    "voices": {
-      "name": "voices",
-      "description": "Event emitted by ElevenLabsClient",
-      "arguments": {}
-    },
-    "speech": {
-      "name": "speech",
-      "description": "Event emitted by ElevenLabsClient",
-      "arguments": {}
-    }
-  },
-  "state": {},
-  "options": {},
-  "envVars": [],
-  "examples": [
-    {
-      "language": "ts",
-      "code": "const el = container.client('elevenlabs')\nawait el.connect()\nconst voices = await el.listVoices()\nconst audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data"
-    }
-  ],
-  "types": {
-    "SynthesizeOptions": {
-      "description": "",
-      "properties": {
-        "voiceId": {
-          "type": "string",
-          "description": "",
-          "optional": true
-        },
-        "modelId": {
-          "type": "string",
-          "description": "",
-          "optional": true
-        },
-        "outputFormat": {
-          "type": "string",
-          "description": "",
-          "optional": true
-        },
-        "voiceSettings": {
-          "type": "ElevenLabsVoiceSettings",
-          "description": "",
-          "optional": true
-        },
-        "disableCache": {
-          "type": "boolean",
-          "description": "",
-          "optional": true
-        }
-      }
-    },
-    "ElevenLabsVoiceSettings": {
-      "description": "",
-      "properties": {
-        "stability": {
-          "type": "number",
-          "description": "",
-          "optional": true
-        },
-        "similarityBoost": {
-          "type": "number",
-          "description": "",
-          "optional": true
-        },
-        "style": {
-          "type": "number",
-          "description": "",
-          "optional": true
-        },
-        "speed": {
-          "type": "number",
-          "description": "",
-          "optional": true
-        },
-        "useSpeakerBoost": {
-          "type": "boolean",
-          "description": "",
-          "optional": true
-        }
-      }
-    }
-  }
-});
-
 setBuildTimeData('clients.comfyui', {
   "id": "clients.comfyui",
   "description": "ComfyUI client — execute Stable Diffusion workflows via the ComfyUI API. Connects to a ComfyUI instance to queue prompts, track execution via WebSocket or polling, and download generated images. Supports both UI-format and API-format workflows with automatic conversion.",
@@ -12863,156 +12357,688 @@ setBuildTimeData('clients.comfyui', {
   }
 });
 
-setBuildTimeData('servers.mcp', {
-  "id": "servers.mcp",
-  "description": "MCP (Model Context Protocol) server for exposing tools, resources, and prompts to AI clients like Claude Code. Uses the low-level MCP SDK Server class directly with Zod 4 native JSON Schema conversion. Register tools, resources, and prompts programmatically, then start the server over stdio (for CLI integration) or HTTP (for remote access).",
-  "shortcut": "servers.mcp",
-  "className": "MCPServer",
+setBuildTimeData('clients.openai', {
+  "id": "clients.openai",
+  "description": "OpenAI client — wraps the OpenAI SDK for chat completions, responses API, embeddings, and image generation. Provides convenience methods for common operations while tracking token usage and request counts. Supports both the Chat Completions API and the newer Responses API.",
+  "shortcut": "clients.openai",
+  "className": "OpenAIClient",
   "methods": {
-    "tool": {
-      "description": "Register an MCP tool. The tool's Zod schema is converted to JSON Schema for the protocol listing, and used for runtime argument validation. Tool handlers can return a string (auto-wrapped as text content) or a full CallToolResult object for advanced responses (images, errors, etc).",
+    "connect": {
+      "description": "Test the API connection by listing models.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<this>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "await openai.connect()"
+        }
+      ]
+    },
+    "createChatCompletion": {
+      "description": "Create a chat completion using the Chat Completions API.",
       "parameters": {
-        "name": {
-          "type": "string",
-          "description": "Unique tool name"
+        "messages": {
+          "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
+          "description": "Array of chat messages"
         },
         "options": {
-          "type": "ToolRegistrationOptions",
-          "description": "Tool schema, description, and handler",
-          "properties": {
-            "schema": {
-              "type": "z.ZodObject<any>",
-              "description": ""
-            },
-            "description": {
-              "type": "string",
-              "description": ""
-            },
-            "handler": {
-              "type": "(args: any, ctx: MCPContext) => any",
-              "description": ""
-            }
-          }
+          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
+          "description": "Additional parameters for the completion"
         }
       },
       "required": [
-        "name",
-        "options"
+        "messages"
       ],
-      "returns": "this"
+      "returns": "Promise<OpenAI.Chat.Completions.ChatCompletion>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createChatCompletion([\n { role: 'system', content: 'You are a helpful assistant.' },\n { role: 'user', content: 'Hello!' }\n])\nconsole.log(response.choices[0]?.message?.content)"
+        }
+      ]
     },
-    "resource": {
-      "description": "Register an MCP resource. Resources expose data (files, configs, etc) that AI clients can read by URI. Accepts either a handler function directly or an options object with additional metadata (name, description, mimeType).",
+    "createResponse": {
+      "description": "Create a response using the Responses API.",
       "parameters": {
-        "uri": {
-          "type": "string",
-          "description": "Unique resource URI (e.g. \"project://readme\")"
+        "input": {
+          "type": "OpenAI.Responses.ResponseInput | string",
+          "description": "The input prompt or message array"
         },
-        "handlerOrOptions": {
-          "type": "ResourceRegistrationOptions['handler'] | ResourceRegistrationOptions",
-          "description": "Handler function or options object with handler"
+        "options": {
+          "type": "Partial<OpenAI.Responses.ResponseCreateParamsNonStreaming>",
+          "description": "Additional parameters for the response"
         }
       },
       "required": [
-        "uri",
-        "handlerOrOptions"
+        "input"
       ],
-      "returns": "this"
+      "returns": "Promise<OpenAI.Responses.Response>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createResponse('Explain quantum computing')"
+        }
+      ]
     },
-    "prompt": {
-      "description": "Register an MCP prompt. Prompts are reusable message templates that AI clients can invoke with optional string arguments.",
+    "streamResponse": {
+      "description": "Stream a response using the Responses API.",
       "parameters": {
-        "name": {
+        "input": {
+          "type": "OpenAI.Responses.ResponseInput | string",
+          "description": "The input prompt or message array"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Responses.ResponseCreateParamsStreaming>",
+          "description": "Additional parameters for the streaming response"
+        }
+      },
+      "required": [
+        "input"
+      ],
+      "returns": "Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const stream = await openai.streamResponse('Write a poem')\nfor await (const event of stream) {\n if (event.type === 'response.output_text.delta') {\n   process.stdout.write(event.delta)\n }\n}"
+        }
+      ]
+    },
+    "createCompletion": {
+      "description": "Create a legacy text completion.",
+      "parameters": {
+        "prompt": {
           "type": "string",
-          "description": "Unique prompt name"
+          "description": "The text prompt to complete"
         },
         "options": {
-          "type": "PromptRegistrationOptions",
-          "description": "Prompt handler, optional args schema, and description",
-          "properties": {
-            "description": {
-              "type": "string",
-              "description": ""
-            },
-            "args": {
-              "type": "Record<string, z.ZodType>",
-              "description": ""
-            },
-            "handler": {
-              "type": "(args: Record<string, string | undefined>, ctx: MCPContext) => Promise<PromptMessage[]> | PromptMessage[]",
-              "description": ""
-            }
-          }
+          "type": "Partial<OpenAI.Completions.CompletionCreateParams>",
+          "description": "Additional parameters for the completion"
         }
       },
       "required": [
-        "name",
-        "options"
+        "prompt"
       ],
-      "returns": "this"
+      "returns": "Promise<OpenAI.Completions.Completion>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createCompletion('Once upon a time')"
+        }
+      ]
     },
-    "configure": {
-      "description": "Configure the MCP protocol server and register all protocol handlers. Called automatically before start() if not already configured.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<this>"
+    "createEmbedding": {
+      "description": "Create text embeddings for semantic search or similarity comparisons.",
+      "parameters": {
+        "input": {
+          "type": "string | string[]",
+          "description": "A string or array of strings to embed"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Embeddings.EmbeddingCreateParams>",
+          "description": "Additional parameters (model, etc.)"
+        }
+      },
+      "required": [
+        "input"
+      ],
+      "returns": "Promise<OpenAI.Embeddings.CreateEmbeddingResponse>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createEmbedding('Hello world')\nconsole.log(response.data[0].embedding.length)"
+        }
+      ]
     },
-    "start": {
-      "description": "Start the MCP server with the specified transport.",
+    "createImage": {
+      "description": "Generate an image from a text prompt using DALL-E.",
       "parameters": {
+        "prompt": {
+          "type": "string",
+          "description": "Description of the image to generate"
+        },
         "options": {
-          "type": "{\n    transport?: 'stdio' | 'http'\n    port?: number\n    host?: string\n    mcpCompat?: MCPCompatMode\n    stdioCompat?: StdioCompatMode\n  }",
-          "description": "Transport configuration. Defaults to stdio.",
-          "properties": {
-            "transport": {
-              "type": "any",
-              "description": "'stdio' for CLI integration, 'http' for remote access"
-            },
-            "port": {
-              "type": "any",
-              "description": "Port for HTTP transport (default 3001)"
-            }
-          }
+          "type": "Partial<OpenAI.Images.ImageGenerateParams>",
+          "description": "Additional parameters (size, n, etc.)"
         }
       },
-      "required": [],
-      "returns": "Promise<this>"
+      "required": [
+        "prompt"
+      ],
+      "returns": "Promise<OpenAI.Images.ImagesResponse>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createImage('A sunset over mountains')\nconsole.log(response.data[0].url)"
+        }
+      ]
     },
-    "stop": {
-      "description": "Stop the MCP server and close all connections.",
+    "listModels": {
+      "description": "List all available models.",
       "parameters": {},
       "required": [],
-      "returns": "Promise<this>"
-    }
-  },
-  "getters": {
-    "mcpServer": {
-      "description": "The underlying MCP protocol server instance. Created during configure().",
-      "returns": "MCPProtocolServer"
-    },
-    "handlerContext": {
-      "description": "The handler context passed to all tool, resource, and prompt handlers.",
-      "returns": "MCPContext"
-    }
-  },
-  "events": {
-    "toolRegistered": {
-      "name": "toolRegistered",
-      "description": "Event emitted by MCPServer",
-      "arguments": {}
-    },
-    "resourceRegistered": {
-      "name": "resourceRegistered",
-      "description": "Event emitted by MCPServer",
-      "arguments": {}
-    },
-    "promptRegistered": {
-      "name": "promptRegistered",
-      "description": "Event emitted by MCPServer",
-      "arguments": {}
+      "returns": "Promise<OpenAI.Models.ModelsPage>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const models = await openai.listModels()"
+        }
+      ]
     },
-    "toolCalled": {
-      "name": "toolCalled",
+    "ask": {
+      "description": "Ask a single question and get a text response. Convenience wrapper around `createChatCompletion` for simple Q&A.",
+      "parameters": {
+        "question": {
+          "type": "string",
+          "description": "The question to ask"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
+          "description": "Additional completion parameters"
+        }
+      },
+      "required": [
+        "question"
+      ],
+      "returns": "Promise<string>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const answer = await openai.ask('What is 2 + 2?')\nconsole.log(answer) // '4'"
+        }
+      ]
+    },
+    "chat": {
+      "description": "Send a multi-turn conversation and get a text response. Convenience wrapper around `createChatCompletion` that returns just the text.",
+      "parameters": {
+        "messages": {
+          "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
+          "description": "Array of chat messages"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
+          "description": "Additional completion parameters"
+        }
+      },
+      "required": [
+        "messages"
+      ],
+      "returns": "Promise<string>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const reply = await openai.chat([\n { role: 'system', content: 'You are a pirate.' },\n { role: 'user', content: 'Hello!' }\n])"
+        }
+      ]
+    }
+  },
+  "getters": {
+    "defaultModel": {
+      "description": "The default model used for completions, from options or 'gpt-4o'.",
+      "returns": "string"
+    },
+    "raw": {
+      "description": "The underlying OpenAI SDK instance for advanced use cases.",
+      "returns": "OpenAI"
+    }
+  },
+  "events": {
+    "connected": {
+      "name": "connected",
+      "description": "Event emitted by OpenAIClient",
+      "arguments": {}
+    },
+    "failure": {
+      "name": "failure",
+      "description": "Event emitted by OpenAIClient",
+      "arguments": {}
+    },
+    "completion": {
+      "name": "completion",
+      "description": "Event emitted by OpenAIClient",
+      "arguments": {}
+    },
+    "embedding": {
+      "name": "embedding",
+      "description": "Event emitted by OpenAIClient",
+      "arguments": {}
+    },
+    "image": {
+      "name": "image",
+      "description": "Event emitted by OpenAIClient",
+      "arguments": {}
+    },
+    "models": {
+      "name": "models",
+      "description": "Event emitted by OpenAIClient",
+      "arguments": {}
+    }
+  },
+  "state": {},
+  "options": {},
+  "envVars": [],
+  "examples": [
+    {
+      "language": "ts",
+      "code": "const openai = container.client('openai', { defaultModel: 'gpt-4o' })\nconst answer = await openai.ask('What is the meaning of life?')\nconsole.log(answer)"
+    }
+  ]
+});
+
+setBuildTimeData('clients.elevenlabs', {
+  "id": "clients.elevenlabs",
+  "description": "ElevenLabs client — text-to-speech synthesis via the ElevenLabs REST API. Provides methods for listing voices, listing models, and generating speech audio. Audio is returned as a Buffer; use `say()` for a convenience method that writes to disk.",
+  "shortcut": "clients.elevenlabs",
+  "className": "ElevenLabsClient",
+  "methods": {
+    "beforeRequest": {
+      "description": "Inject the xi-api-key header before each request.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "connect": {
+      "description": "Validate the API key by listing available models.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<this>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "await el.connect()"
+        }
+      ]
+    },
+    "listVoices": {
+      "description": "List available voices with optional search and filtering.",
+      "parameters": {
+        "options": {
+          "type": "{\n    search?: string\n    category?: string\n    voice_type?: string\n    page_size?: number\n    next_page_token?: string\n  }",
+          "description": "Query parameters for filtering voices"
+        }
+      },
+      "required": [],
+      "returns": "Promise<any>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const voices = await el.listVoices()\nconst premade = await el.listVoices({ category: 'premade' })"
+        }
+      ]
+    },
+    "getVoice": {
+      "description": "Get details for a single voice.",
+      "parameters": {
+        "voiceId": {
+          "type": "string",
+          "description": "The voice ID to look up"
+        }
+      },
+      "required": [
+        "voiceId"
+      ],
+      "returns": "Promise<any>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const voice = await el.getVoice('21m00Tcm4TlvDq8ikWAM')\nconsole.log(voice.name, voice.settings)"
+        }
+      ]
+    },
+    "listModels": {
+      "description": "List available TTS models.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<any[]>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const models = await el.listModels()\nconsole.log(models.map(m => m.model_id))"
+        }
+      ]
+    },
+    "synthesize": {
+      "description": "Synthesize speech from text, returning audio as a Buffer.",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to convert to speech"
+        },
+        "options": {
+          "type": "SynthesizeOptions",
+          "description": "Voice, model, format, and voice settings overrides",
+          "properties": {
+            "voiceId": {
+              "type": "string",
+              "description": ""
+            },
+            "modelId": {
+              "type": "string",
+              "description": ""
+            },
+            "outputFormat": {
+              "type": "string",
+              "description": ""
+            },
+            "voiceSettings": {
+              "type": "ElevenLabsVoiceSettings",
+              "description": ""
+            },
+            "disableCache": {
+              "type": "boolean",
+              "description": ""
+            }
+          }
+        }
+      },
+      "required": [
+        "text"
+      ],
+      "returns": "Promise<Buffer>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data\n\nconst custom = await el.synthesize('Hello', {\n voiceId: '21m00Tcm4TlvDq8ikWAM',\n voiceSettings: { stability: 0.5, similarityBoost: 0.8 }\n})"
+        }
+      ]
+    },
+    "say": {
+      "description": "Synthesize speech and write the audio to a file.",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The text to convert to speech"
+        },
+        "outputPath": {
+          "type": "string",
+          "description": "File path to write the audio to"
+        },
+        "options": {
+          "type": "SynthesizeOptions",
+          "description": "Voice, model, format, and voice settings overrides",
+          "properties": {
+            "voiceId": {
+              "type": "string",
+              "description": ""
+            },
+            "modelId": {
+              "type": "string",
+              "description": ""
+            },
+            "outputFormat": {
+              "type": "string",
+              "description": ""
+            },
+            "voiceSettings": {
+              "type": "ElevenLabsVoiceSettings",
+              "description": ""
+            },
+            "disableCache": {
+              "type": "boolean",
+              "description": ""
+            }
+          }
+        }
+      },
+      "required": [
+        "text",
+        "outputPath"
+      ],
+      "returns": "Promise<string>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const path = await el.say('Hello world', './hello.mp3')\nconsole.log(`Audio saved to ${path}`)"
+        }
+      ]
+    }
+  },
+  "getters": {
+    "apiKey": {
+      "description": "The resolved API key from options or environment.",
+      "returns": "string"
+    }
+  },
+  "events": {
+    "failure": {
+      "name": "failure",
+      "description": "Event emitted by ElevenLabsClient",
+      "arguments": {}
+    },
+    "voices": {
+      "name": "voices",
+      "description": "Event emitted by ElevenLabsClient",
+      "arguments": {}
+    },
+    "speech": {
+      "name": "speech",
+      "description": "Event emitted by ElevenLabsClient",
+      "arguments": {}
+    }
+  },
+  "state": {},
+  "options": {},
+  "envVars": [],
+  "examples": [
+    {
+      "language": "ts",
+      "code": "const el = container.client('elevenlabs')\nawait el.connect()\nconst voices = await el.listVoices()\nconst audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data"
+    }
+  ],
+  "types": {
+    "SynthesizeOptions": {
+      "description": "",
+      "properties": {
+        "voiceId": {
+          "type": "string",
+          "description": "",
+          "optional": true
+        },
+        "modelId": {
+          "type": "string",
+          "description": "",
+          "optional": true
+        },
+        "outputFormat": {
+          "type": "string",
+          "description": "",
+          "optional": true
+        },
+        "voiceSettings": {
+          "type": "ElevenLabsVoiceSettings",
+          "description": "",
+          "optional": true
+        },
+        "disableCache": {
+          "type": "boolean",
+          "description": "",
+          "optional": true
+        }
+      }
+    },
+    "ElevenLabsVoiceSettings": {
+      "description": "",
+      "properties": {
+        "stability": {
+          "type": "number",
+          "description": "",
+          "optional": true
+        },
+        "similarityBoost": {
+          "type": "number",
+          "description": "",
+          "optional": true
+        },
+        "style": {
+          "type": "number",
+          "description": "",
+          "optional": true
+        },
+        "speed": {
+          "type": "number",
+          "description": "",
+          "optional": true
+        },
+        "useSpeakerBoost": {
+          "type": "boolean",
+          "description": "",
+          "optional": true
+        }
+      }
+    }
+  }
+});
+
+setBuildTimeData('servers.mcp', {
+  "id": "servers.mcp",
+  "description": "MCP (Model Context Protocol) server for exposing tools, resources, and prompts to AI clients like Claude Code. Uses the low-level MCP SDK Server class directly with Zod 4 native JSON Schema conversion. Register tools, resources, and prompts programmatically, then start the server over stdio (for CLI integration) or HTTP (for remote access).",
+  "shortcut": "servers.mcp",
+  "className": "MCPServer",
+  "methods": {
+    "tool": {
+      "description": "Register an MCP tool. The tool's Zod schema is converted to JSON Schema for the protocol listing, and used for runtime argument validation. Tool handlers can return a string (auto-wrapped as text content) or a full CallToolResult object for advanced responses (images, errors, etc).",
+      "parameters": {
+        "name": {
+          "type": "string",
+          "description": "Unique tool name"
+        },
+        "options": {
+          "type": "ToolRegistrationOptions",
+          "description": "Tool schema, description, and handler",
+          "properties": {
+            "schema": {
+              "type": "z.ZodType",
+              "description": ""
+            },
+            "description": {
+              "type": "string",
+              "description": ""
+            },
+            "handler": {
+              "type": "Function | ((args: any, ctx: any) => any)",
+              "description": ""
+            }
+          }
+        }
+      },
+      "required": [
+        "name",
+        "options"
+      ],
+      "returns": "this"
+    },
+    "resource": {
+      "description": "Register an MCP resource. Resources expose data (files, configs, etc) that AI clients can read by URI. Accepts either a handler function directly or an options object with additional metadata (name, description, mimeType).",
+      "parameters": {
+        "uri": {
+          "type": "string",
+          "description": "Unique resource URI (e.g. \"project://readme\")"
+        },
+        "handlerOrOptions": {
+          "type": "ResourceRegistrationOptions['handler'] | ResourceRegistrationOptions",
+          "description": "Handler function or options object with handler"
+        }
+      },
+      "required": [
+        "uri",
+        "handlerOrOptions"
+      ],
+      "returns": "this"
+    },
+    "prompt": {
+      "description": "Register an MCP prompt. Prompts are reusable message templates that AI clients can invoke with optional string arguments.",
+      "parameters": {
+        "name": {
+          "type": "string",
+          "description": "Unique prompt name"
+        },
+        "options": {
+          "type": "PromptRegistrationOptions",
+          "description": "Prompt handler, optional args schema, and description",
+          "properties": {
+            "description": {
+              "type": "string",
+              "description": ""
+            },
+            "args": {
+              "type": "Record<string, z.ZodType>",
+              "description": ""
+            },
+            "handler": {
+              "type": "(args: Record<string, string | undefined>, ctx: MCPContext) => Promise<PromptMessage[]> | PromptMessage[]",
+              "description": ""
+            }
+          }
+        }
+      },
+      "required": [
+        "name",
+        "options"
+      ],
+      "returns": "this"
+    },
+    "configure": {
+      "description": "Configure the MCP protocol server and register all protocol handlers. Called automatically before start() if not already configured.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<this>"
+    },
+    "start": {
+      "description": "Start the MCP server with the specified transport.",
+      "parameters": {
+        "options": {
+          "type": "{\n    transport?: 'stdio' | 'http'\n    port?: number\n    host?: string\n    mcpCompat?: MCPCompatMode\n    stdioCompat?: StdioCompatMode\n  }",
+          "description": "Transport configuration. Defaults to stdio.",
+          "properties": {
+            "transport": {
+              "type": "any",
+              "description": "'stdio' for CLI integration, 'http' for remote access"
+            },
+            "port": {
+              "type": "any",
+              "description": "Port for HTTP transport (default 3001)"
+            }
+          }
+        }
+      },
+      "required": [],
+      "returns": "Promise<this>"
+    },
+    "stop": {
+      "description": "Stop the MCP server and close all connections.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<this>"
+    }
+  },
+  "getters": {
+    "mcpServer": {
+      "description": "The underlying MCP protocol server instance. Created during configure().",
+      "returns": "MCPProtocolServer"
+    },
+    "handlerContext": {
+      "description": "The handler context passed to all tool, resource, and prompt handlers.",
+      "returns": "MCPContext"
+    }
+  },
+  "events": {
+    "toolRegistered": {
+      "name": "toolRegistered",
+      "description": "Event emitted by MCPServer",
+      "arguments": {}
+    },
+    "resourceRegistered": {
+      "name": "resourceRegistered",
+      "description": "Event emitted by MCPServer",
+      "arguments": {}
+    },
+    "promptRegistered": {
+      "name": "promptRegistered",
+      "description": "Event emitted by MCPServer",
+      "arguments": {}
+    },
+    "toolCalled": {
+      "name": "toolCalled",
       "description": "Event emitted by MCPServer",
       "arguments": {}
     }
@@ -13031,7 +13057,7 @@ setBuildTimeData('servers.mcp', {
       "description": "",
       "properties": {
         "schema": {
-          "type": "z.ZodObject<any>",
+          "type": "z.ZodType",
           "description": "",
           "optional": true
         },
@@ -13041,17 +13067,9 @@ setBuildTimeData('servers.mcp', {
           "optional": true
         },
         "handler": {
-          "type": "(args: any, ctx: MCPContext) => any",
-          "description": ""
-        }
-      }
-    },
-    "MCPContext": {
-      "description": "Context object passed to all MCP tool, resource, and prompt handlers.",
-      "properties": {
-        "container": {
-          "type": "NodeContainer",
-          "description": ""
+          "type": "Function | ((args: any, ctx: any) => any)",
+          "description": "",
+          "optional": true
         }
       }
     },
@@ -13079,6 +13097,15 @@ setBuildTimeData('servers.mcp', {
         }
       }
     },
+    "MCPContext": {
+      "description": "Context object passed to all MCP tool, resource, and prompt handlers.",
+      "properties": {
+        "container": {
+          "type": "NodeContainer",
+          "description": ""
+        }
+      }
+    },
     "PromptRegistrationOptions": {
       "description": "",
       "properties": {
@@ -13370,8 +13397,51 @@ setBuildTimeData('features.assistantsManager', {
   "shortcut": "features.assistantsManager",
   "className": "AssistantsManager",
   "methods": {
+    "intercept": {
+      "description": "Registers a pipeline interceptor that is applied to every assistant created by this manager. Interceptors are applied at the given interception point on each assistant at creation time. This mirrors the per-assistant `assistant.intercept(point, fn)` API, but scopes it globally across all assistants managed here — useful for cross-cutting concerns like logging, tracing, or policy enforcement.",
+      "parameters": {
+        "point": {
+          "type": "K",
+          "description": "The interception point (beforeAsk, beforeTurn, beforeToolCall, afterToolCall, beforeResponse)"
+        },
+        "fn": {
+          "type": "InterceptorFn<InterceptorPoints[K]>",
+          "description": "Middleware function receiving (ctx, next)"
+        }
+      },
+      "required": [
+        "point",
+        "fn"
+      ],
+      "returns": "this",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "manager.intercept('beforeAsk', async (ctx, next) => {\n console.log(`[${ctx.assistant.name}] asking: ${ctx.message}`)\n await next()\n})"
+        }
+      ]
+    },
+    "addDiscoveryFolder": {
+      "description": "Registers an additional folder to scan during assistant discovery and immediately triggers a new discovery pass.",
+      "parameters": {
+        "folderPath": {
+          "type": "string",
+          "description": "Absolute path to a folder containing assistant subdirectories"
+        }
+      },
+      "required": [
+        "folderPath"
+      ],
+      "returns": "Promise<this>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "await manager.addDiscoveryFolder('/path/to/more/assistants')\nconsole.log(manager.available) // includes assistants from the new folder"
+        }
+      ]
+    },
     "discover": {
-      "description": "Discovers assistants by listing subdirectories in ~/.luca/assistants/ and cwd/assistants/. Each subdirectory containing a CORE.md is an assistant.",
+      "description": "",
       "parameters": {},
       "required": [],
       "returns": "Promise<this>"
@@ -13615,6 +13685,47 @@ setBuildTimeData('features.conversation', {
       ],
       "returns": "this"
     },
+    "stub": {
+      "description": "Register a hardcoded stub response that bypasses the API when the user's message matches. Streaming is still simulated — chunk/preview events fire word-by-word.",
+      "parameters": {
+        "matcher": {
+          "type": "string | RegExp",
+          "description": "Exact string match, substring, or RegExp tested against user input"
+        },
+        "response": {
+          "type": "string | (() => string)",
+          "description": "The text to stream back, or a zero-arg function that returns it"
+        }
+      },
+      "required": [
+        "matcher",
+        "response"
+      ],
+      "returns": "this",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "conversation.stub('hello', 'Hi there!')\nconversation.stub(/weather/i, () => 'Sunny and 72°F.')"
+        }
+      ]
+    },
+    "fork": {
+      "description": "Fork the conversation into a new independent instance. The fork inherits the same system prompt, tools, and full message history, but has its own identity and state — changes in either direction do not affect the other.",
+      "parameters": {
+        "overrides": {
+          "type": "Partial<ConversationOptions>",
+          "description": "Optional option overrides for the forked conversation (e.g. different model or title)"
+        }
+      },
+      "required": [],
+      "returns": "Conversation",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const fork = conversation.fork()\nawait fork.ask('What if we took a different approach?')\n// original conversation is unchanged"
+        }
+      ]
+    },
     "estimateTokens": {
       "description": "Estimate the input token count for the current messages array using the js-tiktoken tokenizer. Updates state.",
       "parameters": {},
@@ -13793,48 +13904,48 @@ setBuildTimeData('features.conversation', {
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "rawEvent": {
-      "name": "rawEvent",
+    "chunk": {
+      "name": "chunk",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "mcpEvent": {
-      "name": "mcpEvent",
+    "preview": {
+      "name": "preview",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "chunk": {
-      "name": "chunk",
+    "turnEnd": {
+      "name": "turnEnd",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "preview": {
-      "name": "preview",
+    "response": {
+      "name": "response",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "responseCompleted": {
-      "name": "responseCompleted",
+    "rawEvent": {
+      "name": "rawEvent",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "toolCallsStart": {
-      "name": "toolCallsStart",
+    "mcpEvent": {
+      "name": "mcpEvent",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "toolCallsEnd": {
-      "name": "toolCallsEnd",
+    "responseCompleted": {
+      "name": "responseCompleted",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "turnEnd": {
-      "name": "turnEnd",
+    "toolCallsStart": {
+      "name": "toolCallsStart",
       "description": "Event emitted by Conversation",
       "arguments": {}
     },
-    "response": {
-      "name": "response",
+    "toolCallsEnd": {
+      "name": "toolCallsEnd",
       "description": "Event emitted by Conversation",
       "arguments": {}
     }
@@ -13933,7 +14044,7 @@ setBuildTimeData('features.openapi', {
       ],
       "returns": "EndpointInfo | undefined"
     },
-    "toTools": {
+    "toOpenAITools": {
       "description": "Convert all endpoints into OpenAI-compatible tool definitions.",
       "parameters": {
         "filter": {
@@ -14027,7 +14138,7 @@ setBuildTimeData('features.openapi', {
   "examples": [
     {
       "language": "ts",
-      "code": "const api = container.feature('openapi', { url: 'https://petstore.swagger.io/v2' })\nawait api.load()\n\n// Inspect all endpoints\napi.endpoints\n\n// Get a single endpoint by its friendly name\napi.endpoint('getPetById')\n\n// Convert to OpenAI tool definitions\napi.toTools()\n\n// Convert a single endpoint to a function definition\napi.toFunction('getPetById')"
+      "code": "const api = container.feature('openapi', { url: 'https://petstore.swagger.io/v2' })\nawait api.load()\n\n// Inspect all endpoints\napi.endpoints\n\n// Get a single endpoint by its friendly name\napi.endpoint('getPetById')\n\n// Convert to OpenAI tool definitions\napi.toOpenAITools()\n\n// Convert a single endpoint to a function definition\napi.toFunction('getPetById')"
     }
   ],
   "types": {
@@ -14144,6 +14255,19 @@ setBuildTimeData('features.browserUse', {
   "shortcut": "features.browserUse",
   "className": "BrowserUse",
   "methods": {
+    "setupToolsConsumer": {
+      "description": "When an assistant uses browserUse, inject system prompt guidance about the browser interaction loop.",
+      "parameters": {
+        "consumer": {
+          "type": "Helper",
+          "description": "Parameter consumer"
+        }
+      },
+      "required": [
+        "consumer"
+      ],
+      "returns": "void"
+    },
     "afterInitialize": {
       "description": "",
       "parameters": {},
@@ -14959,7 +15083,7 @@ setBuildTimeData('features.skillsLibrary', {
       "description": "",
       "parameters": {
         "assistant": {
-          "type": "Assistant",
+          "type": "Feature",
           "description": "Parameter assistant"
         }
       },
@@ -15094,6 +15218,24 @@ setBuildTimeData('features.skillsLibrary', {
         "{ skillName, question }"
       ],
       "returns": "Promise<string>"
+    },
+    "findRelevantSkillsForAssistant": {
+      "description": "Fork the given assistant and ask it which skills (if any) are relevant to the user's query. Returns an array of skill names that should be loaded before the real question is answered. The fork is ephemeral (historyMode: 'none') and uses structured output so the result is always a clean string array — never free text.",
+      "parameters": {
+        "assistant": {
+          "type": "Assistant",
+          "description": "The assistant instance to fork"
+        },
+        "userQuery": {
+          "type": "string",
+          "description": "The user's original question"
+        }
+      },
+      "required": [
+        "assistant",
+        "userQuery"
+      ],
+      "returns": "Promise<string[]>"
     }
   },
   "getters": {
@@ -15133,6 +15275,11 @@ setBuildTimeData('features.skillsLibrary', {
       "name": "skillDiscovered",
       "description": "Event emitted by SkillsLibrary",
       "arguments": {}
+    },
+    "foundSkills": {
+      "name": "foundSkills",
+      "description": "Event emitted by SkillsLibrary",
+      "arguments": {}
     }
   },
   "state": {},
@@ -15530,6 +15677,10 @@ setBuildTimeData('features.assistant', {
       "description": "Parsed YAML frontmatter from CORE.md, or empty object if none.",
       "returns": "Record<string, any>"
     },
+    "effectiveOptions": {
+      "description": "Merged options where CORE.md frontmatter provides defaults and constructor options take precedence. Prefer this over `this.options` anywhere model parameters or runtime config is consumed.",
+      "returns": "AssistantOptions & Record<string, any>"
+    },
     "paths": {
       "description": "Provides a helper for creating paths off of the assistant's base folder",
       "returns": "any"
@@ -15657,6 +15808,475 @@ setBuildTimeData('features.assistant', {
   ]
 });
 
+setBuildTimeData('features.memory', {
+  "id": "features.memory",
+  "description": "Semantic memory storage and retrieval for AI agents. Provides categorized memory with embedding-based search, metadata filtering, epoch tracking, and assistant tool integration. Built natively on Luca's SQLite and semanticSearch features.",
+  "shortcut": "features.memory",
+  "className": "Memory",
+  "methods": {
+    "initDb": {
+      "description": "Initialize the SQLite database and create tables. Called automatically on first use, but can be called explicitly.",
+      "parameters": {},
+      "required": [],
+      "returns": "void",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const mem = container.feature('memory')\nawait mem.initDb()"
+        }
+      ]
+    },
+    "remember": {
+      "description": "Tool handler: store a memory, deduplicating by similarity.",
+      "parameters": {
+        "args": {
+          "type": "{ category: string; text: string; metadata?: Record<string, any> }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "void"
+    },
+    "recall": {
+      "description": "Tool handler: search memories by semantic similarity.",
+      "parameters": {
+        "args": {
+          "type": "{ category: string; query: string; n_results?: number }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "void"
+    },
+    "forgetCategory": {
+      "description": "Tool handler: wipe all memories in a category.",
+      "parameters": {
+        "args": {
+          "type": "{ category: string }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "void"
+    },
+    "listCategories": {
+      "description": "Tool handler: list all categories with counts.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "setupToolsConsumer": {
+      "description": "When an assistant uses memory, inject system prompt guidance.",
+      "parameters": {
+        "consumer": {
+          "type": "Helper",
+          "description": "Parameter consumer"
+        }
+      },
+      "required": [
+        "consumer"
+      ],
+      "returns": "void"
+    },
+    "create": {
+      "description": "Create a new memory in the given category.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category to store the memory in"
+        },
+        "text": {
+          "type": "string",
+          "description": "The text content of the memory"
+        },
+        "metadata": {
+          "type": "Record<string, any>",
+          "description": "Optional metadata key-value pairs"
+        }
+      },
+      "required": [
+        "category",
+        "text"
+      ],
+      "returns": "Promise<MemoryRecord>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const mem = container.feature('memory')\nawait mem.create('facts', 'The user lives in Austin', { confidence: 0.9 })"
+        }
+      ]
+    },
+    "createUnique": {
+      "description": "Create a memory only if no sufficiently similar memory exists.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category to store the memory in"
+        },
+        "text": {
+          "type": "string",
+          "description": "The text content of the memory"
+        },
+        "metadata": {
+          "type": "Record<string, any>",
+          "description": "Optional metadata"
+        },
+        "similarityThreshold": {
+          "type": "any",
+          "description": "Minimum cosine similarity to consider a duplicate (0-1, default 0.95)"
+        }
+      },
+      "required": [
+        "category",
+        "text"
+      ],
+      "returns": "Promise<MemoryRecord | null>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const mem = container.feature('memory')\nawait mem.createUnique('facts', 'User prefers dark mode', {}, 0.9)"
+        }
+      ]
+    },
+    "get": {
+      "description": "Get a memory by ID.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category the memory belongs to"
+        },
+        "id": {
+          "type": "number",
+          "description": "The memory ID"
+        }
+      },
+      "required": [
+        "category",
+        "id"
+      ],
+      "returns": "Promise<MemoryRecord | null>"
+    },
+    "getAll": {
+      "description": "Get all memories in a category, with optional metadata filtering.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category to query"
+        },
+        "options": {
+          "type": "{ limit?: number; sortOrder?: 'asc' | 'desc'; filterMetadata?: Record<string, any> }",
+          "description": "Query options",
+          "properties": {
+            "limit": {
+              "type": "any",
+              "description": "Max results (default 20)"
+            },
+            "sortOrder": {
+              "type": "any",
+              "description": "'asc' or 'desc' by created_at (default 'desc')"
+            },
+            "filterMetadata": {
+              "type": "any",
+              "description": "Filter by metadata key-value pairs"
+            }
+          }
+        }
+      },
+      "required": [
+        "category"
+      ],
+      "returns": "Promise<MemoryRecord[]>"
+    },
+    "update": {
+      "description": "Update a memory's text and/or metadata.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category the memory belongs to"
+        },
+        "id": {
+          "type": "number",
+          "description": "The memory ID"
+        },
+        "updates": {
+          "type": "{ text?: string; metadata?: Record<string, any> }",
+          "description": "Fields to update",
+          "properties": {
+            "text": {
+              "type": "any",
+              "description": "New text content (re-embeds automatically)"
+            },
+            "metadata": {
+              "type": "any",
+              "description": "Metadata to merge"
+            }
+          }
+        }
+      },
+      "required": [
+        "category",
+        "id",
+        "updates"
+      ],
+      "returns": "Promise<MemoryRecord | null>"
+    },
+    "delete": {
+      "description": "Delete a specific memory.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category"
+        },
+        "id": {
+          "type": "number",
+          "description": "The memory ID"
+        }
+      },
+      "required": [
+        "category",
+        "id"
+      ],
+      "returns": "Promise<boolean>"
+    },
+    "wipeCategory": {
+      "description": "Delete all memories in a category.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category to wipe"
+        }
+      },
+      "required": [
+        "category"
+      ],
+      "returns": "Promise<number>"
+    },
+    "wipeAll": {
+      "description": "Delete all memories across all categories in this namespace.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<number>"
+    },
+    "count": {
+      "description": "Count memories in a category (or all categories if omitted).",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "Optional category to count"
+        }
+      },
+      "required": [],
+      "returns": "Promise<number>"
+    },
+    "categories": {
+      "description": "List all categories that have memories.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<string[]>"
+    },
+    "search": {
+      "description": "Search memories by semantic similarity.",
+      "parameters": {
+        "category": {
+          "type": "string",
+          "description": "The category to search in"
+        },
+        "query": {
+          "type": "string",
+          "description": "The search query (will be embedded)"
+        },
+        "nResults": {
+          "type": "any",
+          "description": "Maximum number of results (default 5)"
+        },
+        "options": {
+          "type": "{ maxDistance?: number; filterMetadata?: Record<string, any> }",
+          "description": "Additional search options",
+          "properties": {
+            "maxDistance": {
+              "type": "any",
+              "description": "Maximum cosine distance threshold (0-2, default none)"
+            },
+            "filterMetadata": {
+              "type": "any",
+              "description": "Filter by metadata key-value pairs"
+            }
+          }
+        }
+      },
+      "required": [
+        "category",
+        "query"
+      ],
+      "returns": "Promise<MemorySearchResult[]>"
+    },
+    "getEpoch": {
+      "description": "Get the current epoch value.",
+      "parameters": {},
+      "required": [],
+      "returns": "number"
+    },
+    "setEpoch": {
+      "description": "Set the epoch to a specific value.",
+      "parameters": {
+        "value": {
+          "type": "number",
+          "description": "The new epoch value"
+        }
+      },
+      "required": [
+        "value"
+      ],
+      "returns": "void"
+    },
+    "incrementEpoch": {
+      "description": "Increment the epoch by 1.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<number>"
+    },
+    "createEvent": {
+      "description": "Create a timestamped event memory in the 'events' category, automatically tagged with the current epoch.",
+      "parameters": {
+        "text": {
+          "type": "string",
+          "description": "The event description"
+        },
+        "metadata": {
+          "type": "Record<string, any>",
+          "description": "Optional additional metadata"
+        }
+      },
+      "required": [
+        "text"
+      ],
+      "returns": "Promise<MemoryRecord>"
+    },
+    "getEvents": {
+      "description": "Get events, optionally filtered by epoch.",
+      "parameters": {
+        "options": {
+          "type": "{ epoch?: number; limit?: number }",
+          "description": "Query options",
+          "properties": {
+            "epoch": {
+              "type": "any",
+              "description": "Filter to a specific epoch"
+            },
+            "limit": {
+              "type": "any",
+              "description": "Max results (default 10)"
+            }
+          }
+        }
+      },
+      "required": [],
+      "returns": "Promise<MemoryRecord[]>"
+    },
+    "exportToJson": {
+      "description": "Export all memories in this namespace to a JSON-serializable object.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<{ namespace: string; epoch: number; memories: MemoryRecord[] }>"
+    },
+    "importFromJson": {
+      "description": "Import memories from a JSON export. Optionally replaces all existing memories.",
+      "parameters": {
+        "data": {
+          "type": "{ namespace?: string; epoch?: number; memories: Array<{ category: string; document: string; metadata?: Record<string, any> }> }",
+          "description": "The exported data object"
+        },
+        "replace": {
+          "type": "any",
+          "description": "If true, wipe existing memories before importing (default true)"
+        }
+      },
+      "required": [
+        "data"
+      ],
+      "returns": "Promise<number>"
+    }
+  },
+  "getters": {},
+  "events": {
+    "dbInitialized": {
+      "name": "dbInitialized",
+      "description": "Event emitted by Memory",
+      "arguments": {}
+    },
+    "memoryCreated": {
+      "name": "memoryCreated",
+      "description": "Event emitted by Memory",
+      "arguments": {}
+    },
+    "memoryDeleted": {
+      "name": "memoryDeleted",
+      "description": "Event emitted by Memory",
+      "arguments": {}
+    },
+    "epochChanged": {
+      "name": "epochChanged",
+      "description": "Event emitted by Memory",
+      "arguments": {}
+    }
+  },
+  "state": {},
+  "options": {},
+  "envVars": [],
+  "examples": [
+    {
+      "language": "ts",
+      "code": "const mem = container.feature('memory')\nawait mem.create('user-prefs', 'Prefers dark mode', { source: 'onboarding' })\nconst results = await mem.search('user-prefs', 'UI preferences')"
+    }
+  ],
+  "types": {
+    "MemoryRecord": {
+      "description": "--- Types ---",
+      "properties": {
+        "id": {
+          "type": "number",
+          "description": ""
+        },
+        "category": {
+          "type": "string",
+          "description": ""
+        },
+        "document": {
+          "type": "string",
+          "description": ""
+        },
+        "metadata": {
+          "type": "Record<string, any>",
+          "description": ""
+        },
+        "created_at": {
+          "type": "string",
+          "description": ""
+        },
+        "updated_at": {
+          "type": "string",
+          "description": ""
+        }
+      }
+    },
+    "MemorySearchResult": {
+      "description": "",
+      "properties": {
+        "distance": {
+          "type": "number",
+          "description": ""
+        }
+      }
+    }
+  }
+});
+
 setBuildTimeData('features.claudeCode', {
   "id": "features.claudeCode",
   "description": "Claude Code CLI wrapper feature. Spawns and manages Claude Code sessions as subprocesses, streaming structured JSON events back through the container's event system. Sessions are long-lived: each call to `run()` spawns a `claude -p` process with `--output-format stream-json`, parses NDJSON from stdout line-by-line, and emits typed events on the feature's event bus.",
@@ -16109,6 +16729,77 @@ setBuildTimeData('features.claudeCode', {
         }
       ]
     },
+    "listProcessSessions": {
+      "description": "List all Claude Code processes currently registered in ~/.claude/sessions/. Returns each session's metadata along with whether the process is still alive.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<Array<{\n    pid: number\n    sessionId: string\n    cwd: string\n    startedAt: number\n    kind: string\n    entrypoint: string\n    alive: boolean\n  }>>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const sessions = await cc.listProcessSessions()\nfor (const s of sessions) {\n console.log(`[${s.alive ? 'LIVE' : 'dead'}] PID ${s.pid} in ${s.cwd}`)\n}"
+        }
+      ]
+    },
+    "getProcessSession": {
+      "description": "Read a single process session by PID from ~/.claude/sessions/<pid>.json.",
+      "parameters": {
+        "pid": {
+          "type": "number",
+          "description": "The process ID"
+        }
+      },
+      "required": [
+        "pid"
+      ],
+      "returns": "Promise<{\n    pid: number\n    sessionId: string\n    cwd: string\n    startedAt: number\n    kind: string\n    entrypoint: string\n  } | null>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const session = await cc.getProcessSession(12345)\nconsole.log(session?.cwd)"
+        }
+      ]
+    },
+    "getConversationHistory": {
+      "description": "Read the conversation history for a Claude Code session from its JSONL file in ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl. Returns an array of parsed message objects (user, assistant, tool_use, tool_result).",
+      "parameters": {
+        "sessionId": {
+          "type": "string",
+          "description": "The Claude CLI session ID (from listProcessSessions or getProcessSession)"
+        },
+        "cwd": {
+          "type": "string",
+          "description": "The working directory of the session (used to locate the project folder)"
+        }
+      },
+      "required": [
+        "sessionId"
+      ],
+      "returns": "Promise<any[]>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const sessions = await cc.listProcessSessions()\nconst s = sessions[0]\nconst history = await cc.getConversationHistory(s.sessionId, s.cwd)\nconsole.log(history.length, 'turns')"
+        }
+      ]
+    },
+    "listSessionsForCwd": {
+      "description": "List all conversation sessions stored for a given working directory. Reads ~/.claude/projects/<encoded-cwd>/ and returns metadata for each .jsonl file.",
+      "parameters": {
+        "cwd": {
+          "type": "string",
+          "description": "The working directory path to look up"
+        }
+      },
+      "required": [],
+      "returns": "Promise<Array<{\n    sessionId: string\n    filePath: string\n    messageCount: number\n  }>>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const sessions = await cc.listSessionsForCwd('/Users/me/my-project')\nfor (const s of sessions) {\n console.log(s.sessionId, s.messageCount, 'messages')\n}"
+        }
+      ]
+    },
     "cleanupMcpTempFiles": {
       "description": "Clean up any temp MCP config files created during sessions.",
       "parameters": {},
@@ -18197,6 +18888,98 @@ setBuildTimeData('features.fileTools', {
   "envVars": []
 });
 
+setBuildTimeData('features.codingTools', {
+  "id": "features.codingTools",
+  "description": "Shell primitives for AI coding assistants: rg, ls, cat, sed, awk. Wraps standard Unix tools into the assistant tool surface with LLM-optimized descriptions and system prompt guidance. These are the raw, flexible tools for reading, searching, and exploring code. Compose with other features (fileTools, processManager, skillsLibrary) in assistant hooks for a complete coding tool surface. Usage: ```typescript assistant.use(container.feature('codingTools')) ```",
+  "shortcut": "features.codingTools",
+  "className": "CodingTools",
+  "methods": {
+    "rg": {
+      "description": "",
+      "parameters": {
+        "args": {
+          "type": "{ args: string; cwd?: string }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "Promise<string>"
+    },
+    "ls": {
+      "description": "",
+      "parameters": {
+        "args": {
+          "type": "{ args?: string; cwd?: string }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "Promise<string>"
+    },
+    "cat": {
+      "description": "",
+      "parameters": {
+        "args": {
+          "type": "{ args: string; cwd?: string }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "Promise<string>"
+    },
+    "sed": {
+      "description": "",
+      "parameters": {
+        "args": {
+          "type": "{ args: string; cwd?: string }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "Promise<string>"
+    },
+    "awk": {
+      "description": "",
+      "parameters": {
+        "args": {
+          "type": "{ args: string; cwd?: string }",
+          "description": "Parameter args"
+        }
+      },
+      "required": [
+        "args"
+      ],
+      "returns": "Promise<string>"
+    },
+    "setupToolsConsumer": {
+      "description": "",
+      "parameters": {
+        "consumer": {
+          "type": "Helper",
+          "description": "Parameter consumer"
+        }
+      },
+      "required": [
+        "consumer"
+      ],
+      "returns": "void"
+    }
+  },
+  "getters": {},
+  "events": {},
+  "state": {},
+  "options": {},
+  "envVars": []
+});
+
 // Container introspection data
 setContainerBuildTimeData('Container', {
   "className": "Container",
@@ -18305,7 +19088,7 @@ setContainerBuildTimeData('Container', {
           "description": "The id of the feature to create."
         },
         "options": {
-          "type": "ConstructorParameters<Features[T]>[0]",
+          "type": "FeatureInputOptions<Features>[T] | Record<string, unknown>",
           "description": "The options to pass to the feature constructor."
         }
       },
@@ -18314,6 +19097,52 @@ setContainerBuildTimeData('Container', {
       ],
       "returns": "InstanceType<Features[T]>"
     },
+    "entity": {
+      "description": "Creates a lightweight entity object with observable state, a typed event bus, and access to the container. Same id + options always returns the same cached base instance. An optional third argument auto-extends the entity with functions and getters. All extended methods and getters can access the entity (state, options, container, on/off/emit, etc.) via `this`.",
+      "parameters": {
+        "id": {
+          "type": "string",
+          "description": "Stable identifier for this entity (included in cache key)"
+        },
+        "options": {
+          "type": "TOptions",
+          "description": "Arbitrary options stored on `entity.options` (included in cache key)"
+        },
+        "extensions": {
+          "type": "Ext & ThisType<Entity<TState, TOptions, TEvents> & Ext>",
+          "description": "Optional object of functions/getters to graft onto the entity"
+        }
+      },
+      "required": [
+        "id"
+      ],
+      "returns": "Entity<TState, TOptions, TEvents> & Ext",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "// Basic entity with typed state and events\nconst counter = container.entity<{ count: number }>('counter')\ncounter.setState({ count: 0 })\ncounter.on('tick', () => counter.setState(s => ({ count: s.count + 1 })))\n\n// With options and auto-extension\nconst user = container.entity('user:42', { name: 'Alice' }, {\n greet() { return `Hello ${this.options.name}` },\n get label() { return `User: ${this.options.name}` },\n})\nuser.greet() // \"Hello Alice\""
+        }
+      ]
+    },
+    "getHelperByUUID": {
+      "description": "Look up any helper instance (feature, client, server) by its UUID. Returns undefined if the UUID is unknown or the instance was never created.",
+      "parameters": {
+        "uuid": {
+          "type": "string",
+          "description": "The `instance.uuid` value assigned at construction time"
+        }
+      },
+      "required": [
+        "uuid"
+      ],
+      "returns": "Helper | undefined",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const assistant = container.feature('assistant')\nconst { uuid } = assistant\n// ... later ...\nconst same = container.getHelperByUUID(uuid) // === assistant"
+        }
+      ]
+    },
     "start": {
       "description": "Start the container. Emits the 'started' event and sets `state.started` to true. Plugins and features can listen for this event to perform initialization.",
       "parameters": {},
@@ -18620,7 +19449,7 @@ setContainerBuildTimeData('NodeContainer', {
     },
     "urlUtils": {
       "description": "Returns URL utility functions for parsing URIs.",
-      "returns": "{ parse: (uri: string) => url.URL | null }"
+      "returns": "{ parse: (uri: string) => url.UrlWithStringQuery }"
     },
     "paths": {
       "description": "Returns path utility functions scoped to the current working directory (join, resolve, relative, dirname, parse).",
@@ -27338,6 +28167,19 @@ export const introspectionData = [
         ],
         "returns": "void"
       },
+      "setupToolsConsumer": {
+        "description": "When an assistant uses processManager, inject system prompt guidance about how to manage processes safely and effectively.",
+        "parameters": {
+          "consumer": {
+            "type": "Helper",
+            "description": "Parameter consumer"
+          }
+        },
+        "required": [
+          "consumer"
+        ],
+        "returns": "void"
+      },
       "spawn": {
         "description": "Spawn a long-running process and return a handle immediately. The returned SpawnHandler provides events for stdout/stderr streaming, exit/crash notifications, and methods to kill or await the process.",
         "parameters": {
@@ -29750,6 +30592,19 @@ export const introspectionData = [
     "shortcut": "features.contentDb",
     "className": "ContentDb",
     "methods": {
+      "setupToolsConsumer": {
+        "description": "When an assistant uses contentDb, inject system prompt guidance about progressive document exploration.",
+        "parameters": {
+          "consumer": {
+            "type": "Helper",
+            "description": "Parameter consumer"
+          }
+        },
+        "required": [
+          "consumer"
+        ],
+        "returns": "void"
+      },
       "renderTree": {
         "description": "Render a tree view of the collection directory structure. Built with container.fs so it works without the `tree` binary.",
         "parameters": {
@@ -30268,210 +31123,701 @@ export const introspectionData = [
             "description": "Additional axios request config"
           }
         },
-        "required": [
-          "url"
-        ],
+        "required": [
+          "url"
+        ],
+        "returns": "Promise<any>"
+      },
+      "post": {
+        "description": "Send a POST request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
+        "parameters": {
+          "url": {
+            "type": "string",
+            "description": "Request path relative to baseURL"
+          },
+          "data": {
+            "type": "any",
+            "description": "Request body"
+          },
+          "options": {
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
+          }
+        },
+        "required": [
+          "url"
+        ],
+        "returns": "Promise<any>"
+      },
+      "delete": {
+        "description": "Send a DELETE request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
+        "parameters": {
+          "url": {
+            "type": "string",
+            "description": "Request path relative to baseURL"
+          },
+          "params": {
+            "type": "any",
+            "description": "Query parameters"
+          },
+          "options": {
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
+          }
+        },
+        "required": [
+          "url"
+        ],
+        "returns": "Promise<any>"
+      },
+      "get": {
+        "description": "Send a GET request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
+        "parameters": {
+          "url": {
+            "type": "string",
+            "description": "Request path relative to baseURL"
+          },
+          "params": {
+            "type": "any",
+            "description": "Query parameters"
+          },
+          "options": {
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
+          }
+        },
+        "required": [
+          "url"
+        ],
+        "returns": "Promise<any>"
+      },
+      "handleError": {
+        "description": "Handle an axios error by emitting 'failure' and returning the error as JSON.",
+        "parameters": {
+          "error": {
+            "type": "AxiosError",
+            "description": "Parameter error"
+          }
+        },
+        "required": [
+          "error"
+        ],
+        "returns": "Promise<object>"
+      }
+    },
+    "getters": {
+      "useJSON": {
+        "description": "Whether JSON content-type headers should be set automatically.",
+        "returns": "any"
+      },
+      "baseURL": {
+        "description": "",
+        "returns": "any"
+      }
+    },
+    "events": {
+      "failure": {
+        "name": "failure",
+        "description": "Event emitted by RestClient",
+        "arguments": {}
+      }
+    },
+    "state": {},
+    "options": {},
+    "envVars": [],
+    "examples": [
+      {
+        "language": "ts",
+        "code": "const api = container.client('rest', { baseURL: 'https://api.example.com', json: true })\nconst users = await api.get('/users')\nawait api.post('/users', { name: 'Alice' })"
+      }
+    ]
+  },
+  {
+    "id": "clients.websocket",
+    "description": "WebSocketClient helper",
+    "shortcut": "clients.websocket",
+    "className": "WebSocketClient",
+    "methods": {
+      "connect": {
+        "description": "Establish a WebSocket connection to the configured baseURL. Wires all raw WebSocket events (open, message, close, error) to the Helper event bus and updates connection state accordingly. Resolves once the connection is open; rejects on error.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<this>"
+      },
+      "send": {
+        "description": "Send data over the WebSocket connection. Automatically JSON-serializes the payload. If not currently connected, attempts to connect first.",
+        "parameters": {
+          "data": {
+            "type": "any",
+            "description": "The data to send (will be JSON.stringify'd)"
+          }
+        },
+        "required": [
+          "data"
+        ],
+        "returns": "Promise<void>"
+      },
+      "ask": {
+        "description": "Send a request and wait for a correlated response. The message is sent with a unique `requestId`; the remote side is expected to reply with a message containing `replyTo` set to that same ID.",
+        "parameters": {
+          "type": {
+            "type": "string",
+            "description": "A string identifying the request type"
+          },
+          "data": {
+            "type": "any",
+            "description": "Optional payload to include with the request"
+          },
+          "timeout": {
+            "type": "any",
+            "description": "How long to wait for a response (default 10 000 ms)"
+          }
+        },
+        "required": [
+          "type"
+        ],
+        "returns": "Promise<R>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const result = await ws.ask('getUser', { id: 42 })"
+          }
+        ]
+      },
+      "disconnect": {
+        "description": "Gracefully close the WebSocket connection. Suppresses auto-reconnect and updates connection state to disconnected.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<this>"
+      }
+    },
+    "getters": {
+      "hasError": {
+        "description": "Whether the client is in an error state.",
+        "returns": "any"
+      }
+    },
+    "events": {
+      "open": {
+        "name": "open",
+        "description": "Event emitted by WebSocketClient",
+        "arguments": {}
+      },
+      "error": {
+        "name": "error",
+        "description": "Event emitted by WebSocketClient",
+        "arguments": {}
+      },
+      "message": {
+        "name": "message",
+        "description": "Event emitted by WebSocketClient",
+        "arguments": {}
+      },
+      "close": {
+        "name": "close",
+        "description": "Event emitted by WebSocketClient",
+        "arguments": {}
+      },
+      "reconnecting": {
+        "name": "reconnecting",
+        "description": "Event emitted by WebSocketClient",
+        "arguments": {}
+      }
+    },
+    "state": {},
+    "options": {},
+    "envVars": []
+  },
+  {
+    "id": "clients.supabase",
+    "description": "Supabase client for the Luca container system. Wraps the official `@supabase/supabase-js` SDK and exposes it through Luca's typed state, events, and introspection system. The SDK is isomorphic so this single implementation works in both Node and browser containers. Use `client.sdk` for full SDK access, or use the convenience wrappers for common operations (auth, database queries, storage, edge functions, realtime).",
+    "shortcut": "clients.supabase",
+    "className": "SupabaseClient",
+    "methods": {
+      "from": {
+        "description": "Start a query on a Postgres table or view.",
+        "parameters": {
+          "table": {
+            "type": "string",
+            "description": "The table or view name to query"
+          }
+        },
+        "required": [
+          "table"
+        ],
+        "returns": "void"
+      },
+      "rpc": {
+        "description": "Call a Postgres function (RPC).",
+        "parameters": {
+          "fn": {
+            "type": "string",
+            "description": "The function name"
+          },
+          "params": {
+            "type": "Record<string, unknown>",
+            "description": "Arguments to pass to the function"
+          },
+          "options": {
+            "type": "{ head?: boolean; get?: boolean; count?: \"exact\" | \"planned\" | \"estimated\" }",
+            "description": "Optional settings (head, get, count)"
+          }
+        },
+        "required": [
+          "fn"
+        ],
+        "returns": "void"
+      },
+      "signInWithPassword": {
+        "description": "Sign in with email and password.",
+        "parameters": {
+          "email": {
+            "type": "string",
+            "description": "Parameter email"
+          },
+          "password": {
+            "type": "string",
+            "description": "Parameter password"
+          }
+        },
+        "required": [
+          "email",
+          "password"
+        ],
+        "returns": "void"
+      },
+      "signUp": {
+        "description": "Create a new user account with email and password.",
+        "parameters": {
+          "email": {
+            "type": "string",
+            "description": "Parameter email"
+          },
+          "password": {
+            "type": "string",
+            "description": "Parameter password"
+          }
+        },
+        "required": [
+          "email",
+          "password"
+        ],
+        "returns": "void"
+      },
+      "signOut": {
+        "description": "Sign the current user out.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      },
+      "getSession": {
+        "description": "Get the current session, if any.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      },
+      "getUser": {
+        "description": "Get the current user, if any.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      },
+      "invoke": {
+        "description": "Invoke a Supabase Edge Function by name.",
+        "parameters": {
+          "name": {
+            "type": "string",
+            "description": "Parameter name"
+          },
+          "body": {
+            "type": "any",
+            "description": "Parameter body"
+          }
+        },
+        "required": [
+          "name"
+        ],
+        "returns": "void"
+      },
+      "subscribe": {
+        "description": "Subscribe to realtime changes on a Postgres table.",
+        "parameters": {
+          "channelName": {
+            "type": "string",
+            "description": "A name for this subscription channel"
+          },
+          "table": {
+            "type": "string",
+            "description": "The table to listen to"
+          },
+          "callback": {
+            "type": "(payload: any) => void",
+            "description": "Called with the payload on each change"
+          },
+          "event": {
+            "type": "\"INSERT\" | \"UPDATE\" | \"DELETE\" | \"*\"",
+            "description": "The event type to listen for (default: all changes)"
+          }
+        },
+        "required": [
+          "channelName",
+          "table",
+          "callback"
+        ],
+        "returns": "RealtimeChannel"
+      },
+      "unsubscribe": {
+        "description": "Unsubscribe and remove a realtime channel by name.",
+        "parameters": {
+          "channelName": {
+            "type": "string",
+            "description": "The channel name to remove"
+          }
+        },
+        "required": [
+          "channelName"
+        ],
+        "returns": "void"
+      },
+      "unsubscribeAll": {
+        "description": "Unsubscribe and remove all realtime channels.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      },
+      "connect": {
+        "description": "Connect is a no-op since the Supabase SDK initializes on construction. The client is ready to use immediately after creation.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      },
+      "disconnect": {
+        "description": "Disconnect by signing out and removing all realtime channels.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      }
+    },
+    "getters": {
+      "sdk": {
+        "description": "Returns the raw Supabase SDK client for full access to all SDK methods.",
+        "returns": "SupabaseSDKClient<any, any>"
+      },
+      "storage": {
+        "description": "Returns the Supabase Storage client for managing buckets and files.",
+        "returns": "any"
+      },
+      "functions": {
+        "description": "Returns the Supabase Functions client.",
+        "returns": "any"
+      }
+    },
+    "events": {},
+    "state": {},
+    "options": {},
+    "envVars": [],
+    "examples": [
+      {
+        "language": "ts",
+        "code": "const supabase = container.client('supabase', {\n supabaseUrl: 'https://xyz.supabase.co',\n supabaseKey: 'your-anon-key',\n})\n\n// Query data\nconst { data } = await supabase.from('users').select('*')\n\n// Auth\nawait supabase.signInWithPassword('user@example.com', 'password')\n\n// Realtime\nsupabase.subscribe('changes', 'users', (payload) => {\n console.log('Change:', payload)\n})"
+      }
+    ]
+  },
+  {
+    "id": "clients.comfyui",
+    "description": "ComfyUI client — execute Stable Diffusion workflows via the ComfyUI API. Connects to a ComfyUI instance to queue prompts, track execution via WebSocket or polling, and download generated images. Supports both UI-format and API-format workflows with automatic conversion.",
+    "shortcut": "clients.comfyui",
+    "className": "ComfyUIClient",
+    "methods": {
+      "queuePrompt": {
+        "description": "Queue a prompt (API-format workflow) for execution.",
+        "parameters": {
+          "prompt": {
+            "type": "Record<string, any>",
+            "description": "The API-format workflow object"
+          },
+          "clientId": {
+            "type": "string",
+            "description": "Override the client ID for this request"
+          }
+        },
+        "required": [
+          "prompt"
+        ],
+        "returns": "Promise<{ prompt_id: string; number: number }>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const { prompt_id } = await comfy.queuePrompt(apiWorkflow)"
+          }
+        ]
+      },
+      "getQueue": {
+        "description": "Get the current prompt queue status.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<{ queue_running: any[]; queue_pending: any[] }>"
+      },
+      "getHistory": {
+        "description": "Get execution history, optionally for a specific prompt.",
+        "parameters": {
+          "promptId": {
+            "type": "string",
+            "description": "If provided, returns history for this prompt only"
+          }
+        },
+        "required": [],
+        "returns": "Promise<Record<string, any>>"
+      },
+      "getSystemStats": {
+        "description": "Get system stats including GPU memory and queue info.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<any>"
+      },
+      "getObjectInfo": {
+        "description": "Get node type info with input/output schemas.",
+        "parameters": {
+          "nodeClass": {
+            "type": "string",
+            "description": "If provided, returns info for this node type only"
+          }
+        },
+        "required": [],
         "returns": "Promise<any>"
       },
-      "post": {
-        "description": "Send a POST request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
+      "interrupt": {
+        "description": "Interrupt the currently executing prompt.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<void>"
+      },
+      "getModels": {
+        "description": "List available models, optionally filtered by type.",
         "parameters": {
-          "url": {
+          "type": {
             "type": "string",
-            "description": "Request path relative to baseURL"
-          },
-          "data": {
-            "type": "any",
-            "description": "Request body"
-          },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
+            "description": "Model type filter (e.g., 'checkpoints', 'loras')"
           }
         },
-        "required": [
-          "url"
-        ],
-        "returns": "Promise<any>"
+        "required": [],
+        "returns": "Promise<string[]>"
       },
-      "delete": {
-        "description": "Send a DELETE request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
+      "getEmbeddings": {
+        "description": "List available embedding models.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<string[]>"
+      },
+      "uploadImage": {
+        "description": "Upload an image to ComfyUI's input directory.",
         "parameters": {
-          "url": {
-            "type": "string",
-            "description": "Request path relative to baseURL"
+          "file": {
+            "type": "Buffer | Blob",
+            "description": "The image data as Buffer or Blob"
           },
-          "params": {
-            "type": "any",
-            "description": "Query parameters"
+          "filename": {
+            "type": "string",
+            "description": "File name for the upload"
           },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
+          "opts": {
+            "type": "{ subfolder?: string; type?: string; overwrite?: boolean }",
+            "description": "Upload options (subfolder, type, overwrite)"
           }
         },
         "required": [
-          "url"
+          "file",
+          "filename"
         ],
         "returns": "Promise<any>"
       },
-      "get": {
-        "description": "Send a GET request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
+      "viewImage": {
+        "description": "Download a generated image from ComfyUI as a Buffer.",
         "parameters": {
-          "url": {
+          "filename": {
             "type": "string",
-            "description": "Request path relative to baseURL"
+            "description": "The image filename"
           },
-          "params": {
+          "subfolder": {
             "type": "any",
-            "description": "Query parameters"
+            "description": "Subfolder within the output directory"
           },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
+          "type": {
+            "type": "any",
+            "description": "Image type ('output', 'input', 'temp')"
           }
         },
         "required": [
-          "url"
+          "filename"
         ],
-        "returns": "Promise<any>"
+        "returns": "Promise<Buffer>"
       },
-      "handleError": {
-        "description": "Handle an axios error by emitting 'failure' and returning the error as JSON.",
-        "parameters": {
-          "error": {
-            "type": "AxiosError",
-            "description": "Parameter error"
-          }
-        },
-        "required": [
-          "error"
-        ],
-        "returns": "Promise<object>"
-      }
-    },
-    "getters": {
-      "useJSON": {
-        "description": "Whether JSON content-type headers should be set automatically.",
-        "returns": "any"
+      "connectWs": {
+        "description": "Open a WebSocket connection to ComfyUI for real-time execution tracking. Events emitted: `execution_start`, `executing`, `progress`, `executed`, `execution_cached`, `execution_error`, `execution_complete`.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<void>"
       },
-      "baseURL": {
-        "description": "",
-        "returns": "any"
-      }
-    },
-    "events": {
-      "failure": {
-        "name": "failure",
-        "description": "Event emitted by RestClient",
-        "arguments": {}
-      }
-    },
-    "state": {},
-    "options": {},
-    "envVars": [],
-    "examples": [
-      {
-        "language": "ts",
-        "code": "const api = container.client('rest', { baseURL: 'https://api.example.com', json: true })\nconst users = await api.get('/users')\nawait api.post('/users', { name: 'Alice' })"
-      }
-    ]
-  },
-  {
-    "id": "clients.websocket",
-    "description": "WebSocketClient helper",
-    "shortcut": "clients.websocket",
-    "className": "WebSocketClient",
-    "methods": {
-      "connect": {
-        "description": "Establish a WebSocket connection to the configured baseURL. Wires all raw WebSocket events (open, message, close, error) to the Helper event bus and updates connection state accordingly. Resolves once the connection is open; rejects on error.",
+      "disconnectWs": {
+        "description": "Close the WebSocket connection.",
         "parameters": {},
         "required": [],
-        "returns": "Promise<this>"
+        "returns": "void"
       },
-      "send": {
-        "description": "Send data over the WebSocket connection. Automatically JSON-serializes the payload. If not currently connected, attempts to connect first.",
+      "toApiFormat": {
+        "description": "Convert a UI-format workflow to the API format that /prompt expects. Requires a running ComfyUI instance to fetch `object_info` so we can map positional `widgets_values` to their named input fields. If the workflow is already in API format, it's returned as-is.",
         "parameters": {
-          "data": {
-            "type": "any",
-            "description": "The data to send (will be JSON.stringify'd)"
+          "workflow": {
+            "type": "Record<string, any>",
+            "description": "Parameter workflow"
           }
         },
         "required": [
-          "data"
+          "workflow"
         ],
-        "returns": "Promise<void>"
+        "returns": "Promise<Record<string, any>>"
       },
-      "ask": {
-        "description": "Send a request and wait for a correlated response. The message is sent with a unique `requestId`; the remote side is expected to reply with a message containing `replyTo` set to that same ID.",
+      "runWorkflow": {
+        "description": "Run a ComfyUI workflow with optional runtime input overrides. Inputs can be provided in two forms: **Direct node mapping** (when no `inputMap` in options): ``` { '3': { seed: 42 }, '6': { text: 'a cat' } } ``` **Named inputs** (when `inputMap` is provided in options): ``` inputs: { positive_prompt: 'a cat', seed: 42 } options.inputMap: { positive_prompt: { nodeId: '6', field: 'text' }, seed: { nodeId: '3', field: 'seed' } } ```",
         "parameters": {
-          "type": {
-            "type": "string",
-            "description": "A string identifying the request type"
+          "workflow": {
+            "type": "Record<string, any>",
+            "description": "Parameter workflow"
           },
-          "data": {
-            "type": "any",
-            "description": "Optional payload to include with the request"
+          "inputs": {
+            "type": "Record<string, any>",
+            "description": "Parameter inputs"
           },
-          "timeout": {
-            "type": "any",
-            "description": "How long to wait for a response (default 10 000 ms)"
+          "options": {
+            "type": "WorkflowRunOptions",
+            "description": "Parameter options",
+            "properties": {
+              "poll": {
+                "type": "boolean",
+                "description": "Use polling instead of WebSocket for tracking execution"
+              },
+              "pollInterval": {
+                "type": "number",
+                "description": "Polling interval in ms (default 1000)"
+              },
+              "inputMap": {
+                "type": "InputMapping",
+                "description": "Named input mapping: semantic name -> { nodeId, field }"
+              },
+              "outputDir": {
+                "type": "string",
+                "description": "If provided, output images are downloaded to this directory"
+              }
+            }
           }
         },
         "required": [
-          "type"
+          "workflow"
         ],
-        "returns": "Promise<R>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const result = await ws.ask('getUser', { id: 42 })"
-          }
-        ]
-      },
-      "disconnect": {
-        "description": "Gracefully close the WebSocket connection. Suppresses auto-reconnect and updates connection state to disconnected.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<this>"
+        "returns": "Promise<WorkflowResult>"
       }
     },
     "getters": {
-      "hasError": {
-        "description": "Whether the client is in an error state.",
-        "returns": "any"
+      "clientId": {
+        "description": "The unique client ID used for WebSocket session tracking.",
+        "returns": "string"
+      },
+      "wsURL": {
+        "description": "The WebSocket URL derived from baseURL or overridden via options.",
+        "returns": "string"
       }
     },
     "events": {
-      "open": {
-        "name": "open",
-        "description": "Event emitted by WebSocketClient",
+      "execution_start": {
+        "name": "execution_start",
+        "description": "Event emitted by ComfyUIClient",
         "arguments": {}
       },
-      "error": {
-        "name": "error",
-        "description": "Event emitted by WebSocketClient",
+      "execution_complete": {
+        "name": "execution_complete",
+        "description": "Event emitted by ComfyUIClient",
         "arguments": {}
       },
-      "message": {
-        "name": "message",
-        "description": "Event emitted by WebSocketClient",
+      "executing": {
+        "name": "executing",
+        "description": "Event emitted by ComfyUIClient",
         "arguments": {}
       },
-      "close": {
-        "name": "close",
-        "description": "Event emitted by WebSocketClient",
+      "progress": {
+        "name": "progress",
+        "description": "Event emitted by ComfyUIClient",
         "arguments": {}
       },
-      "reconnecting": {
-        "name": "reconnecting",
-        "description": "Event emitted by WebSocketClient",
+      "executed": {
+        "name": "executed",
+        "description": "Event emitted by ComfyUIClient",
+        "arguments": {}
+      },
+      "execution_cached": {
+        "name": "execution_cached",
+        "description": "Event emitted by ComfyUIClient",
+        "arguments": {}
+      },
+      "execution_error": {
+        "name": "execution_error",
+        "description": "Event emitted by ComfyUIClient",
         "arguments": {}
       }
     },
     "state": {},
     "options": {},
-    "envVars": []
+    "envVars": [],
+    "examples": [
+      {
+        "language": "ts",
+        "code": "const comfy = container.client('comfyui', { baseURL: 'http://localhost:8188' })\nconst result = await comfy.runWorkflow(workflow, {\n '6': { text: 'a beautiful sunset' }\n})\nconsole.log(result.images)"
+      }
+    ],
+    "types": {
+      "WorkflowRunOptions": {
+        "description": "",
+        "properties": {
+          "poll": {
+            "type": "boolean",
+            "description": "Use polling instead of WebSocket for tracking execution",
+            "optional": true
+          },
+          "pollInterval": {
+            "type": "number",
+            "description": "Polling interval in ms (default 1000)",
+            "optional": true
+          },
+          "inputMap": {
+            "type": "InputMapping",
+            "description": "Named input mapping: semantic name -> { nodeId, field }",
+            "optional": true
+          },
+          "outputDir": {
+            "type": "string",
+            "description": "If provided, output images are downloaded to this directory",
+            "optional": true
+          }
+        }
+      },
+      "WorkflowResult": {
+        "description": "",
+        "properties": {
+          "promptId": {
+            "type": "string",
+            "description": ""
+          },
+          "outputs": {
+            "type": "Record<string, any>",
+            "description": ""
+          },
+          "images": {
+            "type": "Array<{ filename: string; subfolder: string; type: string; localPath?: string }>",
+            "description": "",
+            "optional": true
+          }
+        }
+      }
+    }
   },
   {
     "id": "clients.openai",
@@ -30740,201 +32086,6 @@ export const introspectionData = [
       }
     ]
   },
-  {
-    "id": "clients.supabase",
-    "description": "Supabase client for the Luca container system. Wraps the official `@supabase/supabase-js` SDK and exposes it through Luca's typed state, events, and introspection system. The SDK is isomorphic so this single implementation works in both Node and browser containers. Use `client.sdk` for full SDK access, or use the convenience wrappers for common operations (auth, database queries, storage, edge functions, realtime).",
-    "shortcut": "clients.supabase",
-    "className": "SupabaseClient",
-    "methods": {
-      "from": {
-        "description": "Start a query on a Postgres table or view.",
-        "parameters": {
-          "table": {
-            "type": "string",
-            "description": "The table or view name to query"
-          }
-        },
-        "required": [
-          "table"
-        ],
-        "returns": "void"
-      },
-      "rpc": {
-        "description": "Call a Postgres function (RPC).",
-        "parameters": {
-          "fn": {
-            "type": "string",
-            "description": "The function name"
-          },
-          "params": {
-            "type": "Record<string, unknown>",
-            "description": "Arguments to pass to the function"
-          },
-          "options": {
-            "type": "{ head?: boolean; get?: boolean; count?: \"exact\" | \"planned\" | \"estimated\" }",
-            "description": "Optional settings (head, get, count)"
-          }
-        },
-        "required": [
-          "fn"
-        ],
-        "returns": "void"
-      },
-      "signInWithPassword": {
-        "description": "Sign in with email and password.",
-        "parameters": {
-          "email": {
-            "type": "string",
-            "description": "Parameter email"
-          },
-          "password": {
-            "type": "string",
-            "description": "Parameter password"
-          }
-        },
-        "required": [
-          "email",
-          "password"
-        ],
-        "returns": "void"
-      },
-      "signUp": {
-        "description": "Create a new user account with email and password.",
-        "parameters": {
-          "email": {
-            "type": "string",
-            "description": "Parameter email"
-          },
-          "password": {
-            "type": "string",
-            "description": "Parameter password"
-          }
-        },
-        "required": [
-          "email",
-          "password"
-        ],
-        "returns": "void"
-      },
-      "signOut": {
-        "description": "Sign the current user out.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
-      "getSession": {
-        "description": "Get the current session, if any.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
-      "getUser": {
-        "description": "Get the current user, if any.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
-      "invoke": {
-        "description": "Invoke a Supabase Edge Function by name.",
-        "parameters": {
-          "name": {
-            "type": "string",
-            "description": "Parameter name"
-          },
-          "body": {
-            "type": "any",
-            "description": "Parameter body"
-          }
-        },
-        "required": [
-          "name"
-        ],
-        "returns": "void"
-      },
-      "subscribe": {
-        "description": "Subscribe to realtime changes on a Postgres table.",
-        "parameters": {
-          "channelName": {
-            "type": "string",
-            "description": "A name for this subscription channel"
-          },
-          "table": {
-            "type": "string",
-            "description": "The table to listen to"
-          },
-          "callback": {
-            "type": "(payload: any) => void",
-            "description": "Called with the payload on each change"
-          },
-          "event": {
-            "type": "\"INSERT\" | \"UPDATE\" | \"DELETE\" | \"*\"",
-            "description": "The event type to listen for (default: all changes)"
-          }
-        },
-        "required": [
-          "channelName",
-          "table",
-          "callback"
-        ],
-        "returns": "RealtimeChannel"
-      },
-      "unsubscribe": {
-        "description": "Unsubscribe and remove a realtime channel by name.",
-        "parameters": {
-          "channelName": {
-            "type": "string",
-            "description": "The channel name to remove"
-          }
-        },
-        "required": [
-          "channelName"
-        ],
-        "returns": "void"
-      },
-      "unsubscribeAll": {
-        "description": "Unsubscribe and remove all realtime channels.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
-      "connect": {
-        "description": "Connect is a no-op since the Supabase SDK initializes on construction. The client is ready to use immediately after creation.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
-      "disconnect": {
-        "description": "Disconnect by signing out and removing all realtime channels.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      }
-    },
-    "getters": {
-      "sdk": {
-        "description": "Returns the raw Supabase SDK client for full access to all SDK methods.",
-        "returns": "SupabaseSDKClient<any, any>"
-      },
-      "storage": {
-        "description": "Returns the Supabase Storage client for managing buckets and files.",
-        "returns": "any"
-      },
-      "functions": {
-        "description": "Returns the Supabase Functions client.",
-        "returns": "any"
-      }
-    },
-    "events": {},
-    "state": {},
-    "options": {},
-    "envVars": [],
-    "examples": [
-      {
-        "language": "ts",
-        "code": "const supabase = container.client('supabase', {\n supabaseUrl: 'https://xyz.supabase.co',\n supabaseKey: 'your-anon-key',\n})\n\n// Query data\nconst { data } = await supabase.from('users').select('*')\n\n// Auth\nawait supabase.signInWithPassword('user@example.com', 'password')\n\n// Realtime\nsupabase.subscribe('changes', 'users', (payload) => {\n console.log('Change:', payload)\n})"
-      }
-    ]
-  },
   {
     "id": "clients.elevenlabs",
     "description": "ElevenLabs client — text-to-speech synthesis via the ElevenLabs REST API. Provides methods for listing voices, listing models, and generating speech audio. Audio is returned as a Buffer; use `say()` for a convenience method that writes to disk.",
@@ -31198,302 +32349,6 @@ export const introspectionData = [
       }
     }
   },
-  {
-    "id": "clients.comfyui",
-    "description": "ComfyUI client — execute Stable Diffusion workflows via the ComfyUI API. Connects to a ComfyUI instance to queue prompts, track execution via WebSocket or polling, and download generated images. Supports both UI-format and API-format workflows with automatic conversion.",
-    "shortcut": "clients.comfyui",
-    "className": "ComfyUIClient",
-    "methods": {
-      "queuePrompt": {
-        "description": "Queue a prompt (API-format workflow) for execution.",
-        "parameters": {
-          "prompt": {
-            "type": "Record<string, any>",
-            "description": "The API-format workflow object"
-          },
-          "clientId": {
-            "type": "string",
-            "description": "Override the client ID for this request"
-          }
-        },
-        "required": [
-          "prompt"
-        ],
-        "returns": "Promise<{ prompt_id: string; number: number }>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const { prompt_id } = await comfy.queuePrompt(apiWorkflow)"
-          }
-        ]
-      },
-      "getQueue": {
-        "description": "Get the current prompt queue status.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<{ queue_running: any[]; queue_pending: any[] }>"
-      },
-      "getHistory": {
-        "description": "Get execution history, optionally for a specific prompt.",
-        "parameters": {
-          "promptId": {
-            "type": "string",
-            "description": "If provided, returns history for this prompt only"
-          }
-        },
-        "required": [],
-        "returns": "Promise<Record<string, any>>"
-      },
-      "getSystemStats": {
-        "description": "Get system stats including GPU memory and queue info.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<any>"
-      },
-      "getObjectInfo": {
-        "description": "Get node type info with input/output schemas.",
-        "parameters": {
-          "nodeClass": {
-            "type": "string",
-            "description": "If provided, returns info for this node type only"
-          }
-        },
-        "required": [],
-        "returns": "Promise<any>"
-      },
-      "interrupt": {
-        "description": "Interrupt the currently executing prompt.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<void>"
-      },
-      "getModels": {
-        "description": "List available models, optionally filtered by type.",
-        "parameters": {
-          "type": {
-            "type": "string",
-            "description": "Model type filter (e.g., 'checkpoints', 'loras')"
-          }
-        },
-        "required": [],
-        "returns": "Promise<string[]>"
-      },
-      "getEmbeddings": {
-        "description": "List available embedding models.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<string[]>"
-      },
-      "uploadImage": {
-        "description": "Upload an image to ComfyUI's input directory.",
-        "parameters": {
-          "file": {
-            "type": "Buffer | Blob",
-            "description": "The image data as Buffer or Blob"
-          },
-          "filename": {
-            "type": "string",
-            "description": "File name for the upload"
-          },
-          "opts": {
-            "type": "{ subfolder?: string; type?: string; overwrite?: boolean }",
-            "description": "Upload options (subfolder, type, overwrite)"
-          }
-        },
-        "required": [
-          "file",
-          "filename"
-        ],
-        "returns": "Promise<any>"
-      },
-      "viewImage": {
-        "description": "Download a generated image from ComfyUI as a Buffer.",
-        "parameters": {
-          "filename": {
-            "type": "string",
-            "description": "The image filename"
-          },
-          "subfolder": {
-            "type": "any",
-            "description": "Subfolder within the output directory"
-          },
-          "type": {
-            "type": "any",
-            "description": "Image type ('output', 'input', 'temp')"
-          }
-        },
-        "required": [
-          "filename"
-        ],
-        "returns": "Promise<Buffer>"
-      },
-      "connectWs": {
-        "description": "Open a WebSocket connection to ComfyUI for real-time execution tracking. Events emitted: `execution_start`, `executing`, `progress`, `executed`, `execution_cached`, `execution_error`, `execution_complete`.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<void>"
-      },
-      "disconnectWs": {
-        "description": "Close the WebSocket connection.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
-      "toApiFormat": {
-        "description": "Convert a UI-format workflow to the API format that /prompt expects. Requires a running ComfyUI instance to fetch `object_info` so we can map positional `widgets_values` to their named input fields. If the workflow is already in API format, it's returned as-is.",
-        "parameters": {
-          "workflow": {
-            "type": "Record<string, any>",
-            "description": "Parameter workflow"
-          }
-        },
-        "required": [
-          "workflow"
-        ],
-        "returns": "Promise<Record<string, any>>"
-      },
-      "runWorkflow": {
-        "description": "Run a ComfyUI workflow with optional runtime input overrides. Inputs can be provided in two forms: **Direct node mapping** (when no `inputMap` in options): ``` { '3': { seed: 42 }, '6': { text: 'a cat' } } ``` **Named inputs** (when `inputMap` is provided in options): ``` inputs: { positive_prompt: 'a cat', seed: 42 } options.inputMap: { positive_prompt: { nodeId: '6', field: 'text' }, seed: { nodeId: '3', field: 'seed' } } ```",
-        "parameters": {
-          "workflow": {
-            "type": "Record<string, any>",
-            "description": "Parameter workflow"
-          },
-          "inputs": {
-            "type": "Record<string, any>",
-            "description": "Parameter inputs"
-          },
-          "options": {
-            "type": "WorkflowRunOptions",
-            "description": "Parameter options",
-            "properties": {
-              "poll": {
-                "type": "boolean",
-                "description": "Use polling instead of WebSocket for tracking execution"
-              },
-              "pollInterval": {
-                "type": "number",
-                "description": "Polling interval in ms (default 1000)"
-              },
-              "inputMap": {
-                "type": "InputMapping",
-                "description": "Named input mapping: semantic name -> { nodeId, field }"
-              },
-              "outputDir": {
-                "type": "string",
-                "description": "If provided, output images are downloaded to this directory"
-              }
-            }
-          }
-        },
-        "required": [
-          "workflow"
-        ],
-        "returns": "Promise<WorkflowResult>"
-      }
-    },
-    "getters": {
-      "clientId": {
-        "description": "The unique client ID used for WebSocket session tracking.",
-        "returns": "string"
-      },
-      "wsURL": {
-        "description": "The WebSocket URL derived from baseURL or overridden via options.",
-        "returns": "string"
-      }
-    },
-    "events": {
-      "execution_start": {
-        "name": "execution_start",
-        "description": "Event emitted by ComfyUIClient",
-        "arguments": {}
-      },
-      "execution_complete": {
-        "name": "execution_complete",
-        "description": "Event emitted by ComfyUIClient",
-        "arguments": {}
-      },
-      "executing": {
-        "name": "executing",
-        "description": "Event emitted by ComfyUIClient",
-        "arguments": {}
-      },
-      "progress": {
-        "name": "progress",
-        "description": "Event emitted by ComfyUIClient",
-        "arguments": {}
-      },
-      "executed": {
-        "name": "executed",
-        "description": "Event emitted by ComfyUIClient",
-        "arguments": {}
-      },
-      "execution_cached": {
-        "name": "execution_cached",
-        "description": "Event emitted by ComfyUIClient",
-        "arguments": {}
-      },
-      "execution_error": {
-        "name": "execution_error",
-        "description": "Event emitted by ComfyUIClient",
-        "arguments": {}
-      }
-    },
-    "state": {},
-    "options": {},
-    "envVars": [],
-    "examples": [
-      {
-        "language": "ts",
-        "code": "const comfy = container.client('comfyui', { baseURL: 'http://localhost:8188' })\nconst result = await comfy.runWorkflow(workflow, {\n '6': { text: 'a beautiful sunset' }\n})\nconsole.log(result.images)"
-      }
-    ],
-    "types": {
-      "WorkflowRunOptions": {
-        "description": "",
-        "properties": {
-          "poll": {
-            "type": "boolean",
-            "description": "Use polling instead of WebSocket for tracking execution",
-            "optional": true
-          },
-          "pollInterval": {
-            "type": "number",
-            "description": "Polling interval in ms (default 1000)",
-            "optional": true
-          },
-          "inputMap": {
-            "type": "InputMapping",
-            "description": "Named input mapping: semantic name -> { nodeId, field }",
-            "optional": true
-          },
-          "outputDir": {
-            "type": "string",
-            "description": "If provided, output images are downloaded to this directory",
-            "optional": true
-          }
-        }
-      },
-      "WorkflowResult": {
-        "description": "",
-        "properties": {
-          "promptId": {
-            "type": "string",
-            "description": ""
-          },
-          "outputs": {
-            "type": "Record<string, any>",
-            "description": ""
-          },
-          "images": {
-            "type": "Array<{ filename: string; subfolder: string; type: string; localPath?: string }>",
-            "description": "",
-            "optional": true
-          }
-        }
-      }
-    }
-  },
   {
     "id": "servers.mcp",
     "description": "MCP (Model Context Protocol) server for exposing tools, resources, and prompts to AI clients like Claude Code. Uses the low-level MCP SDK Server class directly with Zod 4 native JSON Schema conversion. Register tools, resources, and prompts programmatically, then start the server over stdio (for CLI integration) or HTTP (for remote access).",
@@ -31512,7 +32367,7 @@ export const introspectionData = [
             "description": "Tool schema, description, and handler",
             "properties": {
               "schema": {
-                "type": "z.ZodObject<any>",
+                "type": "z.ZodType",
                 "description": ""
               },
               "description": {
@@ -31520,7 +32375,7 @@ export const introspectionData = [
                 "description": ""
               },
               "handler": {
-                "type": "(args: any, ctx: MCPContext) => any",
+                "type": "Function | ((args: any, ctx: any) => any)",
                 "description": ""
               }
             }
@@ -31662,7 +32517,7 @@ export const introspectionData = [
         "description": "",
         "properties": {
           "schema": {
-            "type": "z.ZodObject<any>",
+            "type": "z.ZodType",
             "description": "",
             "optional": true
           },
@@ -31672,17 +32527,9 @@ export const introspectionData = [
             "optional": true
           },
           "handler": {
-            "type": "(args: any, ctx: MCPContext) => any",
-            "description": ""
-          }
-        }
-      },
-      "MCPContext": {
-        "description": "Context object passed to all MCP tool, resource, and prompt handlers.",
-        "properties": {
-          "container": {
-            "type": "NodeContainer",
-            "description": ""
+            "type": "Function | ((args: any, ctx: any) => any)",
+            "description": "",
+            "optional": true
           }
         }
       },
@@ -31710,6 +32557,15 @@ export const introspectionData = [
           }
         }
       },
+      "MCPContext": {
+        "description": "Context object passed to all MCP tool, resource, and prompt handlers.",
+        "properties": {
+          "container": {
+            "type": "NodeContainer",
+            "description": ""
+          }
+        }
+      },
       "PromptRegistrationOptions": {
         "description": "",
         "properties": {
@@ -31998,8 +32854,51 @@ export const introspectionData = [
     "shortcut": "features.assistantsManager",
     "className": "AssistantsManager",
     "methods": {
+      "intercept": {
+        "description": "Registers a pipeline interceptor that is applied to every assistant created by this manager. Interceptors are applied at the given interception point on each assistant at creation time. This mirrors the per-assistant `assistant.intercept(point, fn)` API, but scopes it globally across all assistants managed here — useful for cross-cutting concerns like logging, tracing, or policy enforcement.",
+        "parameters": {
+          "point": {
+            "type": "K",
+            "description": "The interception point (beforeAsk, beforeTurn, beforeToolCall, afterToolCall, beforeResponse)"
+          },
+          "fn": {
+            "type": "InterceptorFn<InterceptorPoints[K]>",
+            "description": "Middleware function receiving (ctx, next)"
+          }
+        },
+        "required": [
+          "point",
+          "fn"
+        ],
+        "returns": "this",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "manager.intercept('beforeAsk', async (ctx, next) => {\n console.log(`[${ctx.assistant.name}] asking: ${ctx.message}`)\n await next()\n})"
+          }
+        ]
+      },
+      "addDiscoveryFolder": {
+        "description": "Registers an additional folder to scan during assistant discovery and immediately triggers a new discovery pass.",
+        "parameters": {
+          "folderPath": {
+            "type": "string",
+            "description": "Absolute path to a folder containing assistant subdirectories"
+          }
+        },
+        "required": [
+          "folderPath"
+        ],
+        "returns": "Promise<this>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "await manager.addDiscoveryFolder('/path/to/more/assistants')\nconsole.log(manager.available) // includes assistants from the new folder"
+          }
+        ]
+      },
       "discover": {
-        "description": "Discovers assistants by listing subdirectories in ~/.luca/assistants/ and cwd/assistants/. Each subdirectory containing a CORE.md is an assistant.",
+        "description": "",
         "parameters": {},
         "required": [],
         "returns": "Promise<this>"
@@ -32242,6 +33141,47 @@ export const introspectionData = [
         ],
         "returns": "this"
       },
+      "stub": {
+        "description": "Register a hardcoded stub response that bypasses the API when the user's message matches. Streaming is still simulated — chunk/preview events fire word-by-word.",
+        "parameters": {
+          "matcher": {
+            "type": "string | RegExp",
+            "description": "Exact string match, substring, or RegExp tested against user input"
+          },
+          "response": {
+            "type": "string | (() => string)",
+            "description": "The text to stream back, or a zero-arg function that returns it"
+          }
+        },
+        "required": [
+          "matcher",
+          "response"
+        ],
+        "returns": "this",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "conversation.stub('hello', 'Hi there!')\nconversation.stub(/weather/i, () => 'Sunny and 72°F.')"
+          }
+        ]
+      },
+      "fork": {
+        "description": "Fork the conversation into a new independent instance. The fork inherits the same system prompt, tools, and full message history, but has its own identity and state — changes in either direction do not affect the other.",
+        "parameters": {
+          "overrides": {
+            "type": "Partial<ConversationOptions>",
+            "description": "Optional option overrides for the forked conversation (e.g. different model or title)"
+          }
+        },
+        "required": [],
+        "returns": "Conversation",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const fork = conversation.fork()\nawait fork.ask('What if we took a different approach?')\n// original conversation is unchanged"
+          }
+        ]
+      },
       "estimateTokens": {
         "description": "Estimate the input token count for the current messages array using the js-tiktoken tokenizer. Updates state.",
         "parameters": {},
@@ -32420,48 +33360,48 @@ export const introspectionData = [
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "rawEvent": {
-        "name": "rawEvent",
+      "chunk": {
+        "name": "chunk",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "mcpEvent": {
-        "name": "mcpEvent",
+      "preview": {
+        "name": "preview",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "chunk": {
-        "name": "chunk",
+      "turnEnd": {
+        "name": "turnEnd",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "preview": {
-        "name": "preview",
+      "response": {
+        "name": "response",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "responseCompleted": {
-        "name": "responseCompleted",
+      "rawEvent": {
+        "name": "rawEvent",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "toolCallsStart": {
-        "name": "toolCallsStart",
+      "mcpEvent": {
+        "name": "mcpEvent",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "toolCallsEnd": {
-        "name": "toolCallsEnd",
+      "responseCompleted": {
+        "name": "responseCompleted",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "turnEnd": {
-        "name": "turnEnd",
+      "toolCallsStart": {
+        "name": "toolCallsStart",
         "description": "Event emitted by Conversation",
         "arguments": {}
       },
-      "response": {
-        "name": "response",
+      "toolCallsEnd": {
+        "name": "toolCallsEnd",
         "description": "Event emitted by Conversation",
         "arguments": {}
       }
@@ -32559,7 +33499,7 @@ export const introspectionData = [
         ],
         "returns": "EndpointInfo | undefined"
       },
-      "toTools": {
+      "toOpenAITools": {
         "description": "Convert all endpoints into OpenAI-compatible tool definitions.",
         "parameters": {
           "filter": {
@@ -32653,7 +33593,7 @@ export const introspectionData = [
     "examples": [
       {
         "language": "ts",
-        "code": "const api = container.feature('openapi', { url: 'https://petstore.swagger.io/v2' })\nawait api.load()\n\n// Inspect all endpoints\napi.endpoints\n\n// Get a single endpoint by its friendly name\napi.endpoint('getPetById')\n\n// Convert to OpenAI tool definitions\napi.toTools()\n\n// Convert a single endpoint to a function definition\napi.toFunction('getPetById')"
+        "code": "const api = container.feature('openapi', { url: 'https://petstore.swagger.io/v2' })\nawait api.load()\n\n// Inspect all endpoints\napi.endpoints\n\n// Get a single endpoint by its friendly name\napi.endpoint('getPetById')\n\n// Convert to OpenAI tool definitions\napi.toOpenAITools()\n\n// Convert a single endpoint to a function definition\napi.toFunction('getPetById')"
       }
     ],
     "types": {
@@ -32769,6 +33709,19 @@ export const introspectionData = [
     "shortcut": "features.browserUse",
     "className": "BrowserUse",
     "methods": {
+      "setupToolsConsumer": {
+        "description": "When an assistant uses browserUse, inject system prompt guidance about the browser interaction loop.",
+        "parameters": {
+          "consumer": {
+            "type": "Helper",
+            "description": "Parameter consumer"
+          }
+        },
+        "required": [
+          "consumer"
+        ],
+        "returns": "void"
+      },
       "afterInitialize": {
         "description": "",
         "parameters": {},
@@ -33582,7 +34535,7 @@ export const introspectionData = [
         "description": "",
         "parameters": {
           "assistant": {
-            "type": "Assistant",
+            "type": "Feature",
             "description": "Parameter assistant"
           }
         },
@@ -33717,6 +34670,24 @@ export const introspectionData = [
           "{ skillName, question }"
         ],
         "returns": "Promise<string>"
+      },
+      "findRelevantSkillsForAssistant": {
+        "description": "Fork the given assistant and ask it which skills (if any) are relevant to the user's query. Returns an array of skill names that should be loaded before the real question is answered. The fork is ephemeral (historyMode: 'none') and uses structured output so the result is always a clean string array — never free text.",
+        "parameters": {
+          "assistant": {
+            "type": "Assistant",
+            "description": "The assistant instance to fork"
+          },
+          "userQuery": {
+            "type": "string",
+            "description": "The user's original question"
+          }
+        },
+        "required": [
+          "assistant",
+          "userQuery"
+        ],
+        "returns": "Promise<string[]>"
       }
     },
     "getters": {
@@ -33756,6 +34727,11 @@ export const introspectionData = [
         "name": "skillDiscovered",
         "description": "Event emitted by SkillsLibrary",
         "arguments": {}
+      },
+      "foundSkills": {
+        "name": "foundSkills",
+        "description": "Event emitted by SkillsLibrary",
+        "arguments": {}
       }
     },
     "state": {},
@@ -34152,6 +35128,10 @@ export const introspectionData = [
         "description": "Parsed YAML frontmatter from CORE.md, or empty object if none.",
         "returns": "Record<string, any>"
       },
+      "effectiveOptions": {
+        "description": "Merged options where CORE.md frontmatter provides defaults and constructor options take precedence. Prefer this over `this.options` anywhere model parameters or runtime config is consumed.",
+        "returns": "AssistantOptions & Record<string, any>"
+      },
       "paths": {
         "description": "Provides a helper for creating paths off of the assistant's base folder",
         "returns": "any"
@@ -34278,6 +35258,474 @@ export const introspectionData = [
       }
     ]
   },
+  {
+    "id": "features.memory",
+    "description": "Semantic memory storage and retrieval for AI agents. Provides categorized memory with embedding-based search, metadata filtering, epoch tracking, and assistant tool integration. Built natively on Luca's SQLite and semanticSearch features.",
+    "shortcut": "features.memory",
+    "className": "Memory",
+    "methods": {
+      "initDb": {
+        "description": "Initialize the SQLite database and create tables. Called automatically on first use, but can be called explicitly.",
+        "parameters": {},
+        "required": [],
+        "returns": "void",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const mem = container.feature('memory')\nawait mem.initDb()"
+          }
+        ]
+      },
+      "remember": {
+        "description": "Tool handler: store a memory, deduplicating by similarity.",
+        "parameters": {
+          "args": {
+            "type": "{ category: string; text: string; metadata?: Record<string, any> }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "void"
+      },
+      "recall": {
+        "description": "Tool handler: search memories by semantic similarity.",
+        "parameters": {
+          "args": {
+            "type": "{ category: string; query: string; n_results?: number }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "void"
+      },
+      "forgetCategory": {
+        "description": "Tool handler: wipe all memories in a category.",
+        "parameters": {
+          "args": {
+            "type": "{ category: string }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "void"
+      },
+      "listCategories": {
+        "description": "Tool handler: list all categories with counts.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      },
+      "setupToolsConsumer": {
+        "description": "When an assistant uses memory, inject system prompt guidance.",
+        "parameters": {
+          "consumer": {
+            "type": "Helper",
+            "description": "Parameter consumer"
+          }
+        },
+        "required": [
+          "consumer"
+        ],
+        "returns": "void"
+      },
+      "create": {
+        "description": "Create a new memory in the given category.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category to store the memory in"
+          },
+          "text": {
+            "type": "string",
+            "description": "The text content of the memory"
+          },
+          "metadata": {
+            "type": "Record<string, any>",
+            "description": "Optional metadata key-value pairs"
+          }
+        },
+        "required": [
+          "category",
+          "text"
+        ],
+        "returns": "Promise<MemoryRecord>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const mem = container.feature('memory')\nawait mem.create('facts', 'The user lives in Austin', { confidence: 0.9 })"
+          }
+        ]
+      },
+      "createUnique": {
+        "description": "Create a memory only if no sufficiently similar memory exists.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category to store the memory in"
+          },
+          "text": {
+            "type": "string",
+            "description": "The text content of the memory"
+          },
+          "metadata": {
+            "type": "Record<string, any>",
+            "description": "Optional metadata"
+          },
+          "similarityThreshold": {
+            "type": "any",
+            "description": "Minimum cosine similarity to consider a duplicate (0-1, default 0.95)"
+          }
+        },
+        "required": [
+          "category",
+          "text"
+        ],
+        "returns": "Promise<MemoryRecord | null>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const mem = container.feature('memory')\nawait mem.createUnique('facts', 'User prefers dark mode', {}, 0.9)"
+          }
+        ]
+      },
+      "get": {
+        "description": "Get a memory by ID.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category the memory belongs to"
+          },
+          "id": {
+            "type": "number",
+            "description": "The memory ID"
+          }
+        },
+        "required": [
+          "category",
+          "id"
+        ],
+        "returns": "Promise<MemoryRecord | null>"
+      },
+      "getAll": {
+        "description": "Get all memories in a category, with optional metadata filtering.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category to query"
+          },
+          "options": {
+            "type": "{ limit?: number; sortOrder?: 'asc' | 'desc'; filterMetadata?: Record<string, any> }",
+            "description": "Query options",
+            "properties": {
+              "limit": {
+                "type": "any",
+                "description": "Max results (default 20)"
+              },
+              "sortOrder": {
+                "type": "any",
+                "description": "'asc' or 'desc' by created_at (default 'desc')"
+              },
+              "filterMetadata": {
+                "type": "any",
+                "description": "Filter by metadata key-value pairs"
+              }
+            }
+          }
+        },
+        "required": [
+          "category"
+        ],
+        "returns": "Promise<MemoryRecord[]>"
+      },
+      "update": {
+        "description": "Update a memory's text and/or metadata.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category the memory belongs to"
+          },
+          "id": {
+            "type": "number",
+            "description": "The memory ID"
+          },
+          "updates": {
+            "type": "{ text?: string; metadata?: Record<string, any> }",
+            "description": "Fields to update",
+            "properties": {
+              "text": {
+                "type": "any",
+                "description": "New text content (re-embeds automatically)"
+              },
+              "metadata": {
+                "type": "any",
+                "description": "Metadata to merge"
+              }
+            }
+          }
+        },
+        "required": [
+          "category",
+          "id",
+          "updates"
+        ],
+        "returns": "Promise<MemoryRecord | null>"
+      },
+      "delete": {
+        "description": "Delete a specific memory.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category"
+          },
+          "id": {
+            "type": "number",
+            "description": "The memory ID"
+          }
+        },
+        "required": [
+          "category",
+          "id"
+        ],
+        "returns": "Promise<boolean>"
+      },
+      "wipeCategory": {
+        "description": "Delete all memories in a category.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category to wipe"
+          }
+        },
+        "required": [
+          "category"
+        ],
+        "returns": "Promise<number>"
+      },
+      "wipeAll": {
+        "description": "Delete all memories across all categories in this namespace.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<number>"
+      },
+      "count": {
+        "description": "Count memories in a category (or all categories if omitted).",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "Optional category to count"
+          }
+        },
+        "required": [],
+        "returns": "Promise<number>"
+      },
+      "categories": {
+        "description": "List all categories that have memories.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<string[]>"
+      },
+      "search": {
+        "description": "Search memories by semantic similarity.",
+        "parameters": {
+          "category": {
+            "type": "string",
+            "description": "The category to search in"
+          },
+          "query": {
+            "type": "string",
+            "description": "The search query (will be embedded)"
+          },
+          "nResults": {
+            "type": "any",
+            "description": "Maximum number of results (default 5)"
+          },
+          "options": {
+            "type": "{ maxDistance?: number; filterMetadata?: Record<string, any> }",
+            "description": "Additional search options",
+            "properties": {
+              "maxDistance": {
+                "type": "any",
+                "description": "Maximum cosine distance threshold (0-2, default none)"
+              },
+              "filterMetadata": {
+                "type": "any",
+                "description": "Filter by metadata key-value pairs"
+              }
+            }
+          }
+        },
+        "required": [
+          "category",
+          "query"
+        ],
+        "returns": "Promise<MemorySearchResult[]>"
+      },
+      "getEpoch": {
+        "description": "Get the current epoch value.",
+        "parameters": {},
+        "required": [],
+        "returns": "number"
+      },
+      "setEpoch": {
+        "description": "Set the epoch to a specific value.",
+        "parameters": {
+          "value": {
+            "type": "number",
+            "description": "The new epoch value"
+          }
+        },
+        "required": [
+          "value"
+        ],
+        "returns": "void"
+      },
+      "incrementEpoch": {
+        "description": "Increment the epoch by 1.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<number>"
+      },
+      "createEvent": {
+        "description": "Create a timestamped event memory in the 'events' category, automatically tagged with the current epoch.",
+        "parameters": {
+          "text": {
+            "type": "string",
+            "description": "The event description"
+          },
+          "metadata": {
+            "type": "Record<string, any>",
+            "description": "Optional additional metadata"
+          }
+        },
+        "required": [
+          "text"
+        ],
+        "returns": "Promise<MemoryRecord>"
+      },
+      "getEvents": {
+        "description": "Get events, optionally filtered by epoch.",
+        "parameters": {
+          "options": {
+            "type": "{ epoch?: number; limit?: number }",
+            "description": "Query options",
+            "properties": {
+              "epoch": {
+                "type": "any",
+                "description": "Filter to a specific epoch"
+              },
+              "limit": {
+                "type": "any",
+                "description": "Max results (default 10)"
+              }
+            }
+          }
+        },
+        "required": [],
+        "returns": "Promise<MemoryRecord[]>"
+      },
+      "exportToJson": {
+        "description": "Export all memories in this namespace to a JSON-serializable object.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<{ namespace: string; epoch: number; memories: MemoryRecord[] }>"
+      },
+      "importFromJson": {
+        "description": "Import memories from a JSON export. Optionally replaces all existing memories.",
+        "parameters": {
+          "data": {
+            "type": "{ namespace?: string; epoch?: number; memories: Array<{ category: string; document: string; metadata?: Record<string, any> }> }",
+            "description": "The exported data object"
+          },
+          "replace": {
+            "type": "any",
+            "description": "If true, wipe existing memories before importing (default true)"
+          }
+        },
+        "required": [
+          "data"
+        ],
+        "returns": "Promise<number>"
+      }
+    },
+    "getters": {},
+    "events": {
+      "dbInitialized": {
+        "name": "dbInitialized",
+        "description": "Event emitted by Memory",
+        "arguments": {}
+      },
+      "memoryCreated": {
+        "name": "memoryCreated",
+        "description": "Event emitted by Memory",
+        "arguments": {}
+      },
+      "memoryDeleted": {
+        "name": "memoryDeleted",
+        "description": "Event emitted by Memory",
+        "arguments": {}
+      },
+      "epochChanged": {
+        "name": "epochChanged",
+        "description": "Event emitted by Memory",
+        "arguments": {}
+      }
+    },
+    "state": {},
+    "options": {},
+    "envVars": [],
+    "examples": [
+      {
+        "language": "ts",
+        "code": "const mem = container.feature('memory')\nawait mem.create('user-prefs', 'Prefers dark mode', { source: 'onboarding' })\nconst results = await mem.search('user-prefs', 'UI preferences')"
+      }
+    ],
+    "types": {
+      "MemoryRecord": {
+        "description": "--- Types ---",
+        "properties": {
+          "id": {
+            "type": "number",
+            "description": ""
+          },
+          "category": {
+            "type": "string",
+            "description": ""
+          },
+          "document": {
+            "type": "string",
+            "description": ""
+          },
+          "metadata": {
+            "type": "Record<string, any>",
+            "description": ""
+          },
+          "created_at": {
+            "type": "string",
+            "description": ""
+          },
+          "updated_at": {
+            "type": "string",
+            "description": ""
+          }
+        }
+      },
+      "MemorySearchResult": {
+        "description": "",
+        "properties": {
+          "distance": {
+            "type": "number",
+            "description": ""
+          }
+        }
+      }
+    }
+  },
   {
     "id": "features.claudeCode",
     "description": "Claude Code CLI wrapper feature. Spawns and manages Claude Code sessions as subprocesses, streaming structured JSON events back through the container's event system. Sessions are long-lived: each call to `run()` spawns a `claude -p` process with `--output-format stream-json`, parses NDJSON from stdout line-by-line, and emits typed events on the feature's event bus.",
@@ -34730,6 +36178,77 @@ export const introspectionData = [
           }
         ]
       },
+      "listProcessSessions": {
+        "description": "List all Claude Code processes currently registered in ~/.claude/sessions/. Returns each session's metadata along with whether the process is still alive.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<Array<{\n    pid: number\n    sessionId: string\n    cwd: string\n    startedAt: number\n    kind: string\n    entrypoint: string\n    alive: boolean\n  }>>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const sessions = await cc.listProcessSessions()\nfor (const s of sessions) {\n console.log(`[${s.alive ? 'LIVE' : 'dead'}] PID ${s.pid} in ${s.cwd}`)\n}"
+          }
+        ]
+      },
+      "getProcessSession": {
+        "description": "Read a single process session by PID from ~/.claude/sessions/<pid>.json.",
+        "parameters": {
+          "pid": {
+            "type": "number",
+            "description": "The process ID"
+          }
+        },
+        "required": [
+          "pid"
+        ],
+        "returns": "Promise<{\n    pid: number\n    sessionId: string\n    cwd: string\n    startedAt: number\n    kind: string\n    entrypoint: string\n  } | null>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const session = await cc.getProcessSession(12345)\nconsole.log(session?.cwd)"
+          }
+        ]
+      },
+      "getConversationHistory": {
+        "description": "Read the conversation history for a Claude Code session from its JSONL file in ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl. Returns an array of parsed message objects (user, assistant, tool_use, tool_result).",
+        "parameters": {
+          "sessionId": {
+            "type": "string",
+            "description": "The Claude CLI session ID (from listProcessSessions or getProcessSession)"
+          },
+          "cwd": {
+            "type": "string",
+            "description": "The working directory of the session (used to locate the project folder)"
+          }
+        },
+        "required": [
+          "sessionId"
+        ],
+        "returns": "Promise<any[]>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const sessions = await cc.listProcessSessions()\nconst s = sessions[0]\nconst history = await cc.getConversationHistory(s.sessionId, s.cwd)\nconsole.log(history.length, 'turns')"
+          }
+        ]
+      },
+      "listSessionsForCwd": {
+        "description": "List all conversation sessions stored for a given working directory. Reads ~/.claude/projects/<encoded-cwd>/ and returns metadata for each .jsonl file.",
+        "parameters": {
+          "cwd": {
+            "type": "string",
+            "description": "The working directory path to look up"
+          }
+        },
+        "required": [],
+        "returns": "Promise<Array<{\n    sessionId: string\n    filePath: string\n    messageCount: number\n  }>>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const sessions = await cc.listSessionsForCwd('/Users/me/my-project')\nfor (const s of sessions) {\n console.log(s.sessionId, s.messageCount, 'messages')\n}"
+          }
+        ]
+      },
       "cleanupMcpTempFiles": {
         "description": "Clean up any temp MCP config files created during sessions.",
         "parameters": {},
@@ -36811,6 +38330,97 @@ export const introspectionData = [
     "state": {},
     "options": {},
     "envVars": []
+  },
+  {
+    "id": "features.codingTools",
+    "description": "Shell primitives for AI coding assistants: rg, ls, cat, sed, awk. Wraps standard Unix tools into the assistant tool surface with LLM-optimized descriptions and system prompt guidance. These are the raw, flexible tools for reading, searching, and exploring code. Compose with other features (fileTools, processManager, skillsLibrary) in assistant hooks for a complete coding tool surface. Usage: ```typescript assistant.use(container.feature('codingTools')) ```",
+    "shortcut": "features.codingTools",
+    "className": "CodingTools",
+    "methods": {
+      "rg": {
+        "description": "",
+        "parameters": {
+          "args": {
+            "type": "{ args: string; cwd?: string }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "Promise<string>"
+      },
+      "ls": {
+        "description": "",
+        "parameters": {
+          "args": {
+            "type": "{ args?: string; cwd?: string }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "Promise<string>"
+      },
+      "cat": {
+        "description": "",
+        "parameters": {
+          "args": {
+            "type": "{ args: string; cwd?: string }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "Promise<string>"
+      },
+      "sed": {
+        "description": "",
+        "parameters": {
+          "args": {
+            "type": "{ args: string; cwd?: string }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "Promise<string>"
+      },
+      "awk": {
+        "description": "",
+        "parameters": {
+          "args": {
+            "type": "{ args: string; cwd?: string }",
+            "description": "Parameter args"
+          }
+        },
+        "required": [
+          "args"
+        ],
+        "returns": "Promise<string>"
+      },
+      "setupToolsConsumer": {
+        "description": "",
+        "parameters": {
+          "consumer": {
+            "type": "Helper",
+            "description": "Parameter consumer"
+          }
+        },
+        "required": [
+          "consumer"
+        ],
+        "returns": "void"
+      }
+    },
+    "getters": {},
+    "events": {},
+    "state": {},
+    "options": {},
+    "envVars": []
   }
 ];
 
@@ -36922,7 +38532,7 @@ export const containerIntrospectionData = [
             "description": "The id of the feature to create."
           },
           "options": {
-            "type": "ConstructorParameters<Features[T]>[0]",
+            "type": "FeatureInputOptions<Features>[T] | Record<string, unknown>",
             "description": "The options to pass to the feature constructor."
           }
         },
@@ -36931,6 +38541,52 @@ export const containerIntrospectionData = [
         ],
         "returns": "InstanceType<Features[T]>"
       },
+      "entity": {
+        "description": "Creates a lightweight entity object with observable state, a typed event bus, and access to the container. Same id + options always returns the same cached base instance. An optional third argument auto-extends the entity with functions and getters. All extended methods and getters can access the entity (state, options, container, on/off/emit, etc.) via `this`.",
+        "parameters": {
+          "id": {
+            "type": "string",
+            "description": "Stable identifier for this entity (included in cache key)"
+          },
+          "options": {
+            "type": "TOptions",
+            "description": "Arbitrary options stored on `entity.options` (included in cache key)"
+          },
+          "extensions": {
+            "type": "Ext & ThisType<Entity<TState, TOptions, TEvents> & Ext>",
+            "description": "Optional object of functions/getters to graft onto the entity"
+          }
+        },
+        "required": [
+          "id"
+        ],
+        "returns": "Entity<TState, TOptions, TEvents> & Ext",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "// Basic entity with typed state and events\nconst counter = container.entity<{ count: number }>('counter')\ncounter.setState({ count: 0 })\ncounter.on('tick', () => counter.setState(s => ({ count: s.count + 1 })))\n\n// With options and auto-extension\nconst user = container.entity('user:42', { name: 'Alice' }, {\n greet() { return `Hello ${this.options.name}` },\n get label() { return `User: ${this.options.name}` },\n})\nuser.greet() // \"Hello Alice\""
+          }
+        ]
+      },
+      "getHelperByUUID": {
+        "description": "Look up any helper instance (feature, client, server) by its UUID. Returns undefined if the UUID is unknown or the instance was never created.",
+        "parameters": {
+          "uuid": {
+            "type": "string",
+            "description": "The `instance.uuid` value assigned at construction time"
+          }
+        },
+        "required": [
+          "uuid"
+        ],
+        "returns": "Helper | undefined",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const assistant = container.feature('assistant')\nconst { uuid } = assistant\n// ... later ...\nconst same = container.getHelperByUUID(uuid) // === assistant"
+          }
+        ]
+      },
       "start": {
         "description": "Start the container. Emits the 'started' event and sets `state.started` to true. Plugins and features can listen for this event to perform initialization.",
         "parameters": {},
@@ -37236,7 +38892,7 @@ export const containerIntrospectionData = [
       },
       "urlUtils": {
         "description": "Returns URL utility functions for parsing URIs.",
-        "returns": "{ parse: (uri: string) => url.URL | null }"
+        "returns": "{ parse: (uri: string) => url.UrlWithStringQuery }"
       },
       "paths": {
         "description": "Returns path utility functions scoped to the current working directory (join, resolve, relative, dirname, parse).",