@soleri/forge 0.0.1 → 3.0.0

package/CHANGELOG.md

@@ -0,0 +1,98 @@
+# Changelog
+
+All notable changes to Soleri Forge (formerly Agent Forge) are documented here.
+
+## [2.1.0] - 2026-02-28
+
+Feature release — knowledge pack installer. Agents can now receive pre-built domain knowledge after scaffolding.
+
+### Added
+
+- **Knowledge Pack Installer (`forge op:install_knowledge`)** — Install intelligence bundles into existing agents in a single operation. Validates bundles, copies data files, generates domain facades, patches `src/index.ts` and `src/activation/claude-md-content.ts`, and rebuilds the agent
+- **Architecture detection** — Installer detects vault+brain vs vault-only agents and generates appropriately typed facades (`brain.intelligentSearch()` vs `vault.search()`)
+- **Vault-only facade generator** — `generateVaultOnlyDomainFacade()` produces facades matching older agent patterns that use raw vault queries
+- **Source file patching** — Regex-based patching for `index.ts` (imports + facade array) and `claude-md-content.ts` (facade table rows) with fallback anchors for older agent formats
+- **Bundle validation** — Validates domain, version, and all entry fields (id, type, domain, title, severity, description, tags) before installation. Partial success supported — valid bundles install even if others fail
+- **`InstallKnowledgeResult` type** — Structured result with counts, domain lists, patched files, build output, and warnings
+- **Knowledge installer test suite** — 35 tests covering validation, bundle handling, copying, facade generation, source patching, and integration
+
+### Changed
+
+- `pascalCase()` and `capitalize()` in `src/templates/domain-facade.ts` are now exported for reuse
+- Agent-forge tests: 56 (was 21)
+- Forge operations: 5 (was 4)
+
+## [2.0.1] - 2026-02-20
+
+Patch release — 8 bug fixes found during code audit.
+
+### Fixed
+
+- **`listAgents` runtime crash** — Used `require()` in ESM module; replaced with already-imported `readFileSync`
+- **`parseResetDuration` double-counting** — Seconds regex `/(\d+)s/` matched the trailing "s" in "200ms", producing 200,200ms instead of 200ms; reordered to check `ms` first with lookbehind
+- **`process.env.HOME || '~'` fallback** — `path.join('~', ...)` doesn't expand tildes; replaced with `homedir()` from `node:os` in generated key-pool and LLM client
+- **Undefined `$MCP_FILE` in setup script** — Referenced undefined bash variable with `set -u` active; replaced with literal `~/.claude/settings.json`
+- **`rotateOnError` race condition** — Circuit breaker was tripped via fire-and-forget async; added synchronous `recordFailure()` method to `CircuitBreaker`
+- **`rotatePreemptive` misleading log** — Logged `this.activeIndex` after mutation; now captures previous index before rotation
+- **`validateEntry` silently dropping entries** — Required `tags.length > 0` but type allows empty arrays; removed length requirement
+- **Dead code** — Removed unused `personaPath` variable in `listAgents`
+
+### Added
+
+- `CircuitBreaker.recordFailure()` — Synchronous failure recording for use by KeyPool
+- Generated agent README: "Populating Your Agent" section (conversational, bulk, JSON methods)
+- Generated agent README: "Why {name}" value proposition, expanded "How to Use" with daily workflow, "Growing Your Agent" section
+
+## [2.0.0] - 2026-02-20
+
+Major release. Agents now ship with an intelligence layer (Brain) and optional LLM infrastructure — every generated agent is smarter out of the box.
+
+### Added
+
+- **Intelligence Layer (Brain)** — TF-IDF hybrid scoring across 5 dimensions: semantic similarity (40%), severity (15%), recency (15%), tag overlap (15%), domain match (15%). Auto-tags entries on capture. Detects duplicates before writing (blocks at >= 0.8, warns at >= 0.6). Adaptive weight tuning after 30+ feedback entries
+- **LLM Client** — Unified OpenAI/Anthropic caller with multi-key rotation, per-key circuit breakers (threshold 3, reset 30s), shared provider breaker (threshold 5, reset 60s), exponential backoff with jitter, and model routing. Optional — agents work without API keys
+- **Key Pool** — Multi-key management for OpenAI with preemptive quota rotation (threshold 50). Loads from `~/.{agentId}/keys.json` or falls back to env vars
+- **Model Router** — Routes LLM calls by caller/task. Reads `~/.{agentId}/model-routing.json` for custom routing rules
+- **SecretString** — Credential wrapper using ES2022 private fields. Prevents key leakage in JSON.stringify, console.log, template literals, and Node inspect
+- **Circuit Breaker** — 3-state protection (closed/open/half-open) for external service calls. Only counts retryable errors toward threshold
+- **Rate Limit Parser** — Parses OpenAI `x-ratelimit-remaining-requests`, `x-ratelimit-reset-requests`, and `retry-after` headers for quota tracking
+- **Brain ops** — `record_feedback`, `rebuild_vocabulary`, `brain_stats` on core facade
+- **`llm_status` op** — Provider availability, key pool status (per-key circuit breaker states), model routing config
+- **LLM test suite** — ~51 tests covering SecretString, CircuitBreaker states, retry, rate limits, KeyPool rotation, LLMClient availability
+- **Brain test suite** — ~38 tests covering TF-IDF scoring, auto-tagging, duplicate detection, adaptive weights
+- **Roadmap** — Each generated agent README includes an 8-item improvement roadmap: curator, intake, learning, embeddings, cross-project memory, context engine, proactive agency, plugin system
+
+### Changed
+
+- Domain facades now use Brain for search (`intelligentSearch`) and capture (`enrichAndCapture` with auto-tags and dedup) instead of raw vault queries
+- Core facade signature expanded: `createCoreFacade(vault, planner, brain, llmClient?, openaiKeyPool?, anthropicKeyPool?)`
+- Generated agents include `@anthropic-ai/sdk` as a dependency
+- Activation triggers normalized: "Hola/Adios" → "Hello/Goodbye"
+- Vault schema adds `brain_vocabulary` and `brain_feedback` tables
+- Total core ops per agent: 24 (was 20)
+- Total generated tests per 3-domain agent: ~220 (was ~120)
+- Agent-forge tests: 21 (was 19)
+- Template generators: 27 (was 22)
+- Generated files per agent: ~37 (was ~30)
+
+## [1.0.0] - 2026-02-19
+
+First stable release. Forge is a pure scaffolding tool — knowledge-agnostic, zero opinions on content. It builds the infrastructure; you fill in the expertise.
+
+### Added
+
+- **MCP Server** — Agent Forge runs as an MCP server with a single `forge` tool and 4 operations: `guide`, `preview`, `create`, `list_agents`
+- **Scaffolding Engine** — Generates 30 files per agent from 22 TypeScript template generators
+- **Knowledge Vault** — Each agent gets SQLite storage with FTS5 full-text search and BM25 ranking. Domains start empty
+- **Domain Facades** — Each knowledge domain becomes its own MCP tool with `get_patterns`, `search`, `get_entry`, `capture`, and `remove` operations
+- **Core Facade** — 20 shared operations including search, vault stats, health, identity, activation, memory, session capture, export, and planning
+- **Memory System** — Three memory types (session, lesson, preference) with FTS5 search, stored in the vault database
+- **Session Capture** — PreCompact hook auto-captures session summaries before Claude Code compacts context
+- **Planning Engine** — JSON-backed state machine with 4 plan states (draft, approved, executing, completed) and 5 task states (pending, in_progress, completed, skipped, failed)
+- **Export** — Dumps vault entries back to JSON intelligence bundles for version control and sharing
+- **Activation System** — Persona-based activation with automatic CLAUDE.md injection
+- **Project Registration** — Agents track which projects they're advising and surface context on activation
+- **Setup Script** — One-command install, build, and `claude mcp add --scope user` registration
+- **Test Generation** — 4 test suites per agent (vault, loader, facades, planner) totaling 120+ tests
+- **README Generation** — Each agent gets a complete README with quick start, domains, principles, and commands
+- **Zod Validation** — All agent configs validated at creation time with clear error messages

package/README.md

@@ -0,0 +1,199 @@
+# @soleri/forge
+
+Create production-ready MCP agents in seconds.
+
+Soleri Forge is an MCP server that scaffolds complete [Model Context Protocol](https://modelcontextprotocol.io/) agents — each with its own knowledge vault, intelligence layer, LLM client, memory system, planning engine, and activation persona. You describe what the agent should do, and Forge generates everything: source code, tests, config, and setup scripts.
+
+Forge is knowledge-agnostic. It builds the infrastructure — you fill in the expertise.
+
+Part of the [Soleri](https://soleri.dev) framework — building AI assistants that learn, remember, and grow with you.
+
+## Quick Start
+
+### 1. Register with Claude Code
+
+```bash
+claude mcp add --scope user soleri -- node /path/to/soleri/packages/forge/dist/index.js
+```
+
+### 2. Create an agent
+
+In any Claude Code session, tell Claude what agent you want:
+
+```
+I need an agent called Gaudi that advises on backend architecture.
+Domains: api-design, database, architecture, security, testing, performance.
+Principles: "Security is not optional", "Simple beats clever", "Test everything that can break".
+```
+
+Claude will use the `forge` tool to scaffold it. Under the hood:
+
+```
+forge op:preview params:{ id: "gaudi", name: "Gaudi", ... }   # See what will be created
+forge op:create  params:{ id: "gaudi", name: "Gaudi", ... }   # Scaffold the agent
+```
+
+You can also run `forge op:guide` to get a step-by-step creation flow.
+
+### 3. Build and activate
+
+```bash
+cd gaudi
+./scripts/setup.sh                # Install, build, register with Claude Code
+```
+
+Then in a new Claude Code session:
+
+```
+Hello, Gaudi!
+```
+
+Your agent is live.
+
+## What Gets Generated
+
+Every agent ships with a complete, tested architecture — and zero pre-loaded knowledge:
+
+```
+my-agent/
+  src/
+    facades/           # MCP tool dispatch (one per domain + core)
+    vault/             # SQLite + FTS5 full-text search
+    brain/             # TF-IDF intelligence layer
+    llm/               # Unified OpenAI/Anthropic client (optional)
+    intelligence/      # Domain knowledge (empty JSON bundles)
+    identity/          # Agent persona and principles
+    activation/        # CLAUDE.md injection + activation flow
+    planning/          # Multi-step plan state machine
+    __tests__/         # 6 test suites (~220 tests)
+  scripts/
+    setup.sh           # One-command install, build, register
+    copy-assets.js     # Build script for intelligence data
+```
+
+### Core Capabilities
+
+| Capability                     | What It Does                                                                                                                         |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ |
+| **Knowledge Vault**            | SQLite-backed storage with FTS5 full-text search and BM25 ranking                                                                    |
+| **Intelligence Layer (Brain)** | TF-IDF hybrid scoring across 5 dimensions, auto-tagging, duplicate detection, adaptive weight tuning                                 |
+| **LLM Client**                 | Unified OpenAI/Anthropic caller with multi-key rotation, per-key circuit breakers, model routing (optional — works without API keys) |
+| **Domain Facades**             | Each knowledge domain becomes its own MCP tool with search, capture, and pattern ops                                                 |
+| **Memory System**              | Persists session summaries, lessons learned, and preferences across sessions                                                         |
+| **Planning Engine**            | State machine for multi-step tasks: draft, approve, execute, complete                                                                |
+| **Activation**                 | Persona-based activation with `Hello!` / `Goodbye!` — injects CLAUDE.md automatically                                                |
+
+### Generated Operations
+
+Each agent exposes two types of MCP tools:
+
+**Domain tools** (`{agent}_{domain}`) — one per knowledge domain:
+
+- `get_patterns` `search` `get_entry` `capture` `remove`
+
+**Core tool** (`{agent}_core`) — shared infrastructure:
+
+- `search` `vault_stats` `list_all` `health` `identity`
+- `activate` `inject_claude_md` `setup` `register`
+- `memory_search` `memory_capture` `memory_list`
+- `session_capture` `export`
+- `create_plan` `get_plan` `approve_plan` `update_task` `complete_plan`
+- `record_feedback` `rebuild_vocabulary` `brain_stats`
+- `llm_status`
+
+Total: `(domains x 5) + 24` operations per agent.
+
+## Forge Operations
+
+Soleri Forge exposes one MCP tool (`forge`) with 5 ops:
+
+| Op                  | Purpose                                         |
+| ------------------- | ----------------------------------------------- |
+| `guide`             | Step-by-step creation flow for the AI to follow |
+| `preview`           | See what files and facades will be created      |
+| `create`            | Scaffold the complete agent project             |
+| `list_agents`       | Scan a directory for existing agents            |
+| `install_knowledge` | Install knowledge packs into an existing agent  |
+
+## Installing Knowledge Packs
+
+Agents start empty — but you don't have to populate them one entry at a time. Knowledge packs are pre-built JSON bundles containing patterns, anti-patterns, and rules for specific domains.
+
+```
+forge op:install_knowledge params:{
+  agentPath: "/path/to/gaudi",
+  bundlePath: "/path/to/knowledge-packs/bundles"
+}
+```
+
+### Bundle Format
+
+```json
+{
+  "domain": "accessibility",
+  "version": "1.0.0",
+  "entries": [
+    {
+      "id": "a11y-color-contrast",
+      "type": "pattern",
+      "domain": "accessibility",
+      "title": "Color Contrast Ratios",
+      "severity": "critical",
+      "description": "Ensure text meets WCAG AA contrast ratio...",
+      "tags": ["wcag", "contrast", "color"]
+    }
+  ]
+}
+```
+
+## Configuration
+
+```json
+{
+  "id": "gaudi",
+  "name": "Gaudi",
+  "role": "Backend Architecture Advisor",
+  "description": "Gaudi provides guidance on API design, database patterns, and system architecture.",
+  "domains": ["api-design", "database", "architecture", "security", "testing", "performance"],
+  "principles": [
+    "Security is not optional",
+    "Simple beats clever",
+    "Test everything that can break"
+  ],
+  "greeting": "Gaudi here. Let's build something solid.",
+  "outputDir": "/Users/you/projects"
+}
+```
+
+## Development
+
+```bash
+# From monorepo root
+npm install
+npm run build --workspace=@soleri/forge
+npm run test --workspace=@soleri/forge
+
+# Or from packages/forge
+npm run dev           # Run with tsx (no build needed)
+npm test              # Run tests
+```
+
+### Architecture
+
+Soleri Forge is itself an MCP server built on the same patterns it generates:
+
+- **`src/index.ts`** — MCP server entry point, registers the `forge` tool
+- **`src/facades/forge.facade.ts`** — Op dispatch for all forge operations
+- **`src/scaffolder.ts`** — Core scaffolding logic (preview, create, list)
+- **`src/knowledge-installer.ts`** — Knowledge pack installer
+- **`src/types.ts`** — Config schema and result types (Zod-validated)
+- **`src/templates/`** — 27 template generators
+
+## Requirements
+
+- Node.js 18+
+- Claude Code (for MCP registration and activation)
+
+## License
+
+Apache-2.0

package/dist/facades/forge.facade.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+interface OpDef {
+    name: string;
+    description: string;
+    schema?: z.ZodType;
+    handler: (params: Record<string, unknown>) => Promise<unknown>;
+}
+export declare const forgeOps: OpDef[];
+export {};

package/dist/facades/forge.facade.js

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { scaffold, previewScaffold, listAgents } from '../scaffolder.js';
+import { AgentConfigSchema } from '../types.js';
+import { installKnowledge } from '../knowledge-installer.js';
+export const forgeOps = [
+    {
+        name: 'preview',
+        description: 'Preview what will be created for an agent BEFORE scaffolding. ' +
+            'Show this to the user so they can confirm the structure looks right. ' +
+            'Always call preview before create.',
+        schema: AgentConfigSchema,
+        handler: async (params) => {
+            const config = AgentConfigSchema.parse(params);
+            return previewScaffold(config);
+        },
+    },
+    {
+        name: 'create',
+        description: 'Scaffold a complete MCP agent project with activation system. ' +
+            'This creates the full directory structure, source files, config, and activation module. ' +
+            'After creation: npm install && npm run build, then say "Hello, {Name}!" to activate.',
+        schema: AgentConfigSchema,
+        handler: async (params) => {
+            const config = AgentConfigSchema.parse(params);
+            return scaffold(config);
+        },
+    },
+    {
+        name: 'list_agents',
+        description: 'List all agents found in a directory. ' +
+            'Useful to see what agents already exist before creating a new one.',
+        schema: z.object({
+            directory: z.string().describe('Parent directory to scan for agent projects'),
+        }),
+        handler: async (params) => {
+            const agents = listAgents(params.directory);
+            return {
+                agents,
+                count: agents.length,
+                note: agents.length === 0 ? 'No agents found. Use create to scaffold one.' : undefined,
+            };
+        },
+    },
+    {
+        name: 'guide',
+        description: 'Get a structured guide for the AI agent to follow when helping a user create an agent. ' +
+            'This provides the recommended conversation flow and questions to ask.',
+        handler: async () => {
+            return {
+                title: 'Agent Creation Guide',
+                instructions: 'Follow these steps to help the user create a new MCP agent. Ask questions conversationally — do not dump all questions at once.',
+                steps: [
+                    {
+                        step: 1,
+                        action: 'Understand the need',
+                        ask: 'What role should this agent fill? Who will use it? What kind of guidance should it provide?',
+                        examples: [
+                            'backend architecture advisor',
+                            'QA testing patterns',
+                            'data engineering best practices',
+                        ],
+                    },
+                    {
+                        step: 2,
+                        action: 'Choose name and identity',
+                        ask: 'What should we name this agent? A good name is memorable and reflects its domain.',
+                        tips: [
+                            'Single word works best (Gaudi, Atlas, Nova)',
+                            'The name becomes the persona — it will introduce itself with this name',
+                        ],
+                    },
+                    {
+                        step: 3,
+                        action: 'Select domains',
+                        ask: 'What knowledge domains should this agent cover? Domain names should be kebab-case (e.g., api-design, database, security).',
+                        tips: [
+                            '3-6 domains is ideal',
+                            'Each domain becomes a facade (MCP tool) and an intelligence data file',
+                            'User can always add more later',
+                        ],
+                    },
+                    {
+                        step: 4,
+                        action: 'Define principles',
+                        ask: 'What are 3-5 core principles this agent should follow? These shape its personality and advice style.',
+                        examples: [
+                            'Security first — always validate inputs',
+                            'Simplicity over cleverness',
+                            'Test everything that can break',
+                        ],
+                    },
+                    {
+                        step: 5,
+                        action: 'Preview and confirm',
+                        ask: 'Call preview with the collected config. Show the user what will be created. Ask for confirmation.',
+                    },
+                    {
+                        step: 6,
+                        action: 'Create the agent',
+                        ask: 'Call create with the confirmed config. Then guide the user through npm install and npm run build. The MCP server is automatically registered in ~/.claude.json.',
+                    },
+                    {
+                        step: 7,
+                        action: 'Next steps',
+                        suggest: [
+                            'Restart Claude Code so the new MCP server is picked up',
+                            'Say "Hello, {AgentName}!" to activate the persona in any session',
+                            'The agent will check setup status and offer to inject its CLAUDE.md sections',
+                            'Add initial knowledge by creating entries in the intelligence data JSON files',
+                            'Or use the agent and capture knowledge via the capture ops as you work',
+                        ],
+                    },
+                ],
+            };
+        },
+    },
+    {
+        name: 'install_knowledge',
+        description: 'Install knowledge packs (intelligence bundles) into an existing MCP agent. ' +
+            'Copies bundle JSON files, generates domain facades for new domains, ' +
+            'patches index.ts and claude-md-content.ts, then rebuilds.',
+        schema: z.object({
+            agentPath: z.string().describe('Absolute path to the target agent project'),
+            bundlePath: z.string().describe('Path to bundles directory or single .json file'),
+            generateFacades: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Generate domain facades for new domains (default true)'),
+        }),
+        handler: async (params) => installKnowledge(params),
+    },
+];
+//# sourceMappingURL=forge.facade.js.map

package/dist/facades/forge.facade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge.facade.js","sourceRoot":"","sources":["../../src/facades/forge.facade.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { forgeOps } from './facades/forge.facade.js';
+async function main() {
+    const server = new McpServer({
+        name: 'soleri',
+        version: '3.0.0',
+    });
+    // Register the forge tool with op dispatch
+    const opNames = forgeOps.map((o) => o.name);
+    server.tool('forge', `Soleri Forge — scaffold AI agents that learn, remember, and grow.\n\nOperations: ${opNames.join(', ')}\n\nStart by calling 'guide' to get the recommended conversation flow for helping a user create an agent.`, {
+        op: z.string().describe(`Operation: ${opNames.join(' | ')}`),
+        params: z.record(z.unknown()).optional().default({}).describe('Operation parameters'),
+    }, async ({ op, params }) => {
+        const opDef = forgeOps.find((o) => o.name === op);
+        if (!opDef) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Unknown operation "${op}". Available: ${opNames.join(', ')}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        try {
+            let validatedParams = params;
+            if (opDef.schema) {
+                const result = opDef.schema.safeParse(params);
+                if (!result.success) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ success: false, error: result.error.message }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                validatedParams = result.data;
+            }
+            const data = await opDef.handler(validatedParams);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ success: true, data }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: err instanceof Error ? err.message : String(err),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    });
+    console.error('[soleri] Soleri Forge — AI agent scaffolding tool');
+    console.error(`[soleri] ${forgeOps.length} operations available`);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[soleri] Connected via stdio');
+}
+main().catch((err) => {
+    console.error('[soleri] Fatal:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/knowledge-installer.d.ts

@@ -0,0 +1,30 @@
+import type { InstallKnowledgeResult } from './types.js';
+/**
+ * Generate a domain facade for older agents that lack a Brain module.
+ * Uses vault.search() instead of brain.intelligentSearch() and
+ * vault.add() instead of brain.enrichAndCapture().
+ */
+export declare function generateVaultOnlyDomainFacade(agentId: string, domain: string): string;
+export interface InstallKnowledgeParams {
+    agentPath: string;
+    bundlePath: string;
+    generateFacades?: boolean;
+}
+export declare function installKnowledge(params: InstallKnowledgeParams): Promise<InstallKnowledgeResult>;
+/**
+ * Patch the agent's src/index.ts to add imports and facade registrations
+ * for new domains.
+ *
+ * Anchor patterns:
+ * - Import: insert before `import { createCoreFacade }`
+ * - Facade array: insert before `createCoreFacade(`
+ */
+export declare function patchIndexTs(source: string, newDomains: string[], hasBrain: boolean): string | null;
+/**
+ * Patch the agent's src/activation/claude-md-content.ts to add
+ * facade table rows for new domains.
+ *
+ * Primary anchor: line containing `| Memory search |` (newer agents)
+ * Fallback anchor: line containing `## Intent Detection` (older agents without memory/brain rows)
+ */
+export declare function patchClaudeMdContent(source: string, agentId: string, newDomains: string[]): string | null;