@soleri/forge 0.0.1 → 4.0.0

package/dist/templates/brain.js

@@ -0,0 +1,478 @@
+/**
+ * Generates the brain.ts source file for a new agent.
+ * The Brain provides a local, zero-dependency intelligence layer:
+ * TF-IDF scoring, auto-tagging, duplicate detection, and search feedback.
+ */
+export function generateBrain() {
+    return BRAIN_TEMPLATE;
+}
+const BRAIN_TEMPLATE = [
+    "import type { Vault } from '../vault/vault.js';",
+    "import type { SearchResult } from '../vault/vault.js';",
+    "import type { IntelligenceEntry } from '../intelligence/types.js';",
+    '',
+    '// ─── Types ───────────────────────────────────────────────────────────',
+    '',
+    'export interface ScoringWeights {',
+    '  semantic: number;',
+    '  severity: number;',
+    '  recency: number;',
+    '  tagOverlap: number;',
+    '  domainMatch: number;',
+    '}',
+    '',
+    'export interface ScoreBreakdown {',
+    '  semantic: number;',
+    '  severity: number;',
+    '  recency: number;',
+    '  tagOverlap: number;',
+    '  domainMatch: number;',
+    '  total: number;',
+    '}',
+    '',
+    'export interface RankedResult {',
+    '  entry: IntelligenceEntry;',
+    '  score: number;',
+    '  breakdown: ScoreBreakdown;',
+    '}',
+    '',
+    'export interface SearchOptions {',
+    '  domain?: string;',
+    '  type?: string;',
+    '  severity?: string;',
+    '  limit?: number;',
+    '  tags?: string[];',
+    '}',
+    '',
+    'export interface CaptureResult {',
+    '  captured: boolean;',
+    '  id: string;',
+    '  autoTags: string[];',
+    '  duplicate?: { id: string; similarity: number };',
+    '  blocked?: boolean;',
+    '}',
+    '',
+    'export interface BrainStats {',
+    '  vocabularySize: number;',
+    '  feedbackCount: number;',
+    '  weights: ScoringWeights;',
+    '}',
+    '',
+    'export interface QueryContext {',
+    '  query: string;',
+    '  domain?: string;',
+    '  tags?: string[];',
+    '}',
+    '',
+    'type SparseVector = Map<string, number>;',
+    '',
+    '// ─── Stopwords ─────────────────────────────────────────────────────',
+    '',
+    'const STOPWORDS = new Set([',
+    "  'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',",
+    "  'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',",
+    "  'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',",
+    "  'should', 'may', 'might', 'shall', 'can', 'need', 'must', 'it', 'its',",
+    "  'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'we', 'they',",
+    "  'me', 'him', 'her', 'us', 'them', 'my', 'your', 'his', 'our', 'their',",
+    "  'what', 'which', 'who', 'whom', 'when', 'where', 'why', 'how', 'all',",
+    "  'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some', 'such',",
+    "  'no', 'not', 'only', 'same', 'so', 'than', 'too', 'very', 'just',",
+    "  'because', 'if', 'then', 'else', 'about', 'up', 'out', 'into',",
+    ']);',
+    '',
+    '// ─── Text Processing (pure functions) ────────────────────────────',
+    '',
+    'function tokenize(text: string): string[] {',
+    '  return text',
+    '    .toLowerCase()',
+    "    .replace(/[^a-z0-9\\s-]/g, ' ')",
+    '    .split(/\\s+/)',
+    '    .filter((t) => t.length > 2 && !STOPWORDS.has(t));',
+    '}',
+    '',
+    'function calculateTf(tokens: string[]): SparseVector {',
+    '  const tf: SparseVector = new Map();',
+    '  for (const token of tokens) {',
+    '    tf.set(token, (tf.get(token) ?? 0) + 1);',
+    '  }',
+    '  // Normalize by document length',
+    '  const len = tokens.length || 1;',
+    '  for (const [term, count] of tf) {',
+    '    tf.set(term, count / len);',
+    '  }',
+    '  return tf;',
+    '}',
+    '',
+    'function calculateTfIdf(tokens: string[], vocabulary: Map<string, number>): SparseVector {',
+    '  const tf = calculateTf(tokens);',
+    '  const tfidf: SparseVector = new Map();',
+    '  for (const [term, tfValue] of tf) {',
+    '    const idf = vocabulary.get(term) ?? 0;',
+    '    if (idf > 0) {',
+    '      tfidf.set(term, tfValue * idf);',
+    '    }',
+    '  }',
+    '  return tfidf;',
+    '}',
+    '',
+    'function cosineSimilarity(a: SparseVector, b: SparseVector): number {',
+    '  let dot = 0;',
+    '  let normA = 0;',
+    '  let normB = 0;',
+    '  for (const [term, valA] of a) {',
+    '    normA += valA * valA;',
+    '    const valB = b.get(term);',
+    '    if (valB !== undefined) {',
+    '      dot += valA * valB;',
+    '    }',
+    '  }',
+    '  for (const [, valB] of b) {',
+    '    normB += valB * valB;',
+    '  }',
+    '  const denom = Math.sqrt(normA) * Math.sqrt(normB);',
+    '  return denom === 0 ? 0 : dot / denom;',
+    '}',
+    '',
+    'function jaccardSimilarity(a: string[], b: string[]): number {',
+    '  if (a.length === 0 && b.length === 0) return 0;',
+    '  const setA = new Set(a);',
+    '  const setB = new Set(b);',
+    '  let intersection = 0;',
+    '  for (const item of setA) {',
+    '    if (setB.has(item)) intersection++;',
+    '  }',
+    '  const union = new Set([...a, ...b]).size;',
+    '  return union === 0 ? 0 : intersection / union;',
+    '}',
+    '',
+    '// ─── Severity scoring ──────────────────────────────────────────────',
+    '',
+    'const SEVERITY_SCORES: Record<string, number> = {',
+    '  critical: 1.0,',
+    '  warning: 0.7,',
+    '  suggestion: 0.4,',
+    '};',
+    '',
+    '// ─── Brain Class ─────────────────────────────────────────────────',
+    '',
+    'const DEFAULT_WEIGHTS: ScoringWeights = {',
+    '  semantic: 0.40,',
+    '  severity: 0.15,',
+    '  recency: 0.15,',
+    '  tagOverlap: 0.15,',
+    '  domainMatch: 0.15,',
+    '};',
+    '',
+    'const WEIGHT_BOUND = 0.15;',
+    'const FEEDBACK_THRESHOLD = 30;',
+    'const DUPLICATE_BLOCK_THRESHOLD = 0.8;',
+    'const DUPLICATE_WARN_THRESHOLD = 0.6;',
+    'const RECENCY_HALF_LIFE_DAYS = 365;',
+    '',
+    'export class Brain {',
+    '  private vault: Vault;',
+    '  private vocabulary: Map<string, number> = new Map();',
+    '  private weights: ScoringWeights = { ...DEFAULT_WEIGHTS };',
+    '',
+    '  constructor(vault: Vault) {',
+    '    this.vault = vault;',
+    '    this.rebuildVocabulary();',
+    '    this.recomputeWeights();',
+    '  }',
+    '',
+    '  intelligentSearch(query: string, options?: SearchOptions): RankedResult[] {',
+    '    const limit = options?.limit ?? 10;',
+    '    // Get raw FTS5 results with higher limit for re-ranking',
+    '    const rawResults = this.vault.search(query, {',
+    '      domain: options?.domain,',
+    '      type: options?.type,',
+    '      severity: options?.severity,',
+    '      limit: Math.max(limit * 3, 30),',
+    '    });',
+    '',
+    '    if (rawResults.length === 0) return [];',
+    '',
+    '    const queryTokens = tokenize(query);',
+    '    const queryTags = options?.tags ?? [];',
+    '    const queryDomain = options?.domain;',
+    '    const now = Math.floor(Date.now() / 1000);',
+    '',
+    '    const ranked = rawResults.map((result) => {',
+    '      const entry = result.entry;',
+    '      const breakdown = this.scoreEntry(entry, queryTokens, queryTags, queryDomain, now);',
+    '      return { entry, score: breakdown.total, breakdown };',
+    '    });',
+    '',
+    '    ranked.sort((a, b) => b.score - a.score);',
+    '    return ranked.slice(0, limit);',
+    '  }',
+    '',
+    "  enrichAndCapture(entry: Partial<IntelligenceEntry> & { id: string; type: IntelligenceEntry['type']; domain: string; title: string; severity: IntelligenceEntry['severity']; description: string }): CaptureResult {",
+    '    // Auto-tag',
+    '    const autoTags = this.generateTags(entry.title, entry.description, entry.context);',
+    '    const mergedTags = Array.from(new Set([...(entry.tags ?? []), ...autoTags]));',
+    '',
+    '    // Duplicate detection: compare against top 50 FTS5 matches for the title',
+    '    const duplicate = this.detectDuplicate(entry.title, entry.domain);',
+    '',
+    '    if (duplicate && duplicate.similarity >= DUPLICATE_BLOCK_THRESHOLD) {',
+    '      return {',
+    '        captured: false,',
+    '        id: entry.id,',
+    '        autoTags,',
+    '        duplicate,',
+    '        blocked: true,',
+    '      };',
+    '    }',
+    '',
+    '    // Proceed with capture',
+    '    const fullEntry: IntelligenceEntry = {',
+    '      id: entry.id,',
+    '      type: entry.type,',
+    '      domain: entry.domain,',
+    '      title: entry.title,',
+    '      severity: entry.severity,',
+    '      description: entry.description,',
+    '      context: entry.context,',
+    '      example: entry.example,',
+    '      counterExample: entry.counterExample,',
+    '      why: entry.why,',
+    '      tags: mergedTags,',
+    '      appliesTo: entry.appliesTo,',
+    '    };',
+    '',
+    '    this.vault.add(fullEntry);',
+    '    this.updateVocabularyIncremental(fullEntry);',
+    '',
+    '    const result: CaptureResult = {',
+    '      captured: true,',
+    '      id: entry.id,',
+    '      autoTags,',
+    '    };',
+    '',
+    '    if (duplicate && duplicate.similarity >= DUPLICATE_WARN_THRESHOLD) {',
+    '      result.duplicate = duplicate;',
+    '    }',
+    '',
+    '    return result;',
+    '  }',
+    '',
+    "  recordFeedback(query: string, entryId: string, action: 'accepted' | 'dismissed'): void {",
+    '    const db = this.vault.getDb();',
+    "    db.prepare('INSERT INTO brain_feedback (query, entry_id, action) VALUES (?, ?, ?)').run(query, entryId, action);",
+    '    this.recomputeWeights();',
+    '  }',
+    '',
+    '  getRelevantPatterns(context: QueryContext): RankedResult[] {',
+    '    return this.intelligentSearch(context.query, {',
+    '      domain: context.domain,',
+    '      tags: context.tags,',
+    '    });',
+    '  }',
+    '',
+    '  rebuildVocabulary(): void {',
+    '    const entries = this.vault.list({ limit: 100000 });',
+    '    const docCount = entries.length;',
+    '    if (docCount === 0) {',
+    '      this.vocabulary.clear();',
+    '      this.persistVocabulary();',
+    '      return;',
+    '    }',
+    '',
+    '    const termDocFreq = new Map<string, number>();',
+    '    for (const entry of entries) {',
+    "      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');",
+    '      const tokens = new Set(tokenize(text));',
+    '      for (const token of tokens) {',
+    '        termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);',
+    '      }',
+    '    }',
+    '',
+    '    this.vocabulary.clear();',
+    '    for (const [term, df] of termDocFreq) {',
+    '      const idf = Math.log((docCount + 1) / (df + 1)) + 1;',
+    '      this.vocabulary.set(term, idf);',
+    '    }',
+    '',
+    '    this.persistVocabulary();',
+    '  }',
+    '',
+    '  getStats(): BrainStats {',
+    '    const db = this.vault.getDb();',
+    "    const feedbackCount = (db.prepare('SELECT COUNT(*) as count FROM brain_feedback').get() as { count: number }).count;",
+    '    return {',
+    '      vocabularySize: this.vocabulary.size,',
+    '      feedbackCount,',
+    '      weights: { ...this.weights },',
+    '    };',
+    '  }',
+    '',
+    '  getVocabularySize(): number {',
+    '    return this.vocabulary.size;',
+    '  }',
+    '',
+    '  // ─── Private methods ─────────────────────────────────────────────',
+    '',
+    '  private scoreEntry(',
+    '    entry: IntelligenceEntry,',
+    '    queryTokens: string[],',
+    '    queryTags: string[],',
+    '    queryDomain: string | undefined,',
+    '    now: number',
+    '  ): ScoreBreakdown {',
+    '    // 1. Semantic (TF-IDF cosine similarity)',
+    '    let semantic = 0;',
+    '    if (this.vocabulary.size > 0 && queryTokens.length > 0) {',
+    "      const entryText = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');",
+    '      const entryTokens = tokenize(entryText);',
+    '      const queryVec = calculateTfIdf(queryTokens, this.vocabulary);',
+    '      const entryVec = calculateTfIdf(entryTokens, this.vocabulary);',
+    '      semantic = cosineSimilarity(queryVec, entryVec);',
+    '    }',
+    '',
+    '    // 2. Severity',
+    '    const severity = SEVERITY_SCORES[entry.severity] ?? 0.4;',
+    '',
+    '    // 3. Recency (exponential decay over 1 year)',
+    '    const entryAge = now - (entry as unknown as { created_at?: number }).created_at!;',
+    '    const halfLifeSeconds = RECENCY_HALF_LIFE_DAYS * 86400;',
+    '    const recency = entryAge > 0 ? Math.exp(-0.693 * entryAge / halfLifeSeconds) : 1;',
+    '',
+    '    // 4. Tag overlap (Jaccard)',
+    '    const tagOverlap = queryTags.length > 0 ? jaccardSimilarity(queryTags, entry.tags) : 0;',
+    '',
+    '    // 5. Domain match',
+    '    const domainMatch = queryDomain && entry.domain === queryDomain ? 1.0 : 0;',
+    '',
+    '    const total =',
+    '      this.weights.semantic * semantic +',
+    '      this.weights.severity * severity +',
+    '      this.weights.recency * recency +',
+    '      this.weights.tagOverlap * tagOverlap +',
+    '      this.weights.domainMatch * domainMatch;',
+    '',
+    '    return { semantic, severity, recency, tagOverlap, domainMatch, total };',
+    '  }',
+    '',
+    '  private generateTags(title: string, description: string, context?: string): string[] {',
+    "    const text = [title, description, context ?? ''].join(' ');",
+    '    const tokens = tokenize(text);',
+    '    if (tokens.length === 0) return [];',
+    '',
+    '    // Score tokens by TF-IDF',
+    '    const tf = calculateTf(tokens);',
+    '    const scored: Array<[string, number]> = [];',
+    '    for (const [term, tfValue] of tf) {',
+    '      const idf = this.vocabulary.get(term) ?? 1;',
+    '      scored.push([term, tfValue * idf]);',
+    '    }',
+    '',
+    '    scored.sort((a, b) => b[1] - a[1]);',
+    '    return scored.slice(0, 5).map(([term]) => term);',
+    '  }',
+    '',
+    '  private detectDuplicate(title: string, domain: string): { id: string; similarity: number } | null {',
+    '    let candidates: SearchResult[];',
+    '    try {',
+    '      candidates = this.vault.search(title, { domain, limit: 50 });',
+    '    } catch {',
+    '      return null;',
+    '    }',
+    '    if (candidates.length === 0) return null;',
+    '',
+    '    const titleTokens = tokenize(title);',
+    '    if (titleTokens.length === 0) return null;',
+    '    const titleVec = calculateTfIdf(titleTokens, this.vocabulary);',
+    '    if (titleVec.size === 0) {',
+    '      // Fallback: use raw TF for comparison when vocabulary is empty',
+    '      const titleTf = calculateTf(titleTokens);',
+    '      let bestMatch: { id: string; similarity: number } | null = null;',
+    '      for (const candidate of candidates) {',
+    '        const candidateTokens = tokenize(candidate.entry.title);',
+    '        const candidateTf = calculateTf(candidateTokens);',
+    '        const sim = cosineSimilarity(titleTf, candidateTf);',
+    '        if (!bestMatch || sim > bestMatch.similarity) {',
+    '          bestMatch = { id: candidate.entry.id, similarity: sim };',
+    '        }',
+    '      }',
+    '      return bestMatch;',
+    '    }',
+    '',
+    '    let bestMatch: { id: string; similarity: number } | null = null;',
+    '    for (const candidate of candidates) {',
+    "      const candidateText = [candidate.entry.title, candidate.entry.description].join(' ');",
+    '      const candidateTokens = tokenize(candidateText);',
+    '      const candidateVec = calculateTfIdf(candidateTokens, this.vocabulary);',
+    '      const sim = cosineSimilarity(titleVec, candidateVec);',
+    '      if (!bestMatch || sim > bestMatch.similarity) {',
+    '        bestMatch = { id: candidate.entry.id, similarity: sim };',
+    '      }',
+    '    }',
+    '    return bestMatch;',
+    '  }',
+    '',
+    '  private updateVocabularyIncremental(entry: IntelligenceEntry): void {',
+    "    const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');",
+    '    const tokens = new Set(tokenize(text));',
+    '    const totalDocs = this.vault.stats().totalEntries;',
+    '',
+    '    for (const token of tokens) {',
+    '      const currentDocCount = (this.vocabulary.has(token)) ? Math.round((totalDocs) / Math.exp(this.vocabulary.get(token)! - 1)) + 1 : 1;',
+    '      const newIdf = Math.log((totalDocs + 1) / (currentDocCount + 1)) + 1;',
+    '      this.vocabulary.set(token, newIdf);',
+    '    }',
+    '',
+    '    this.persistVocabulary();',
+    '  }',
+    '',
+    '  private persistVocabulary(): void {',
+    '    const db = this.vault.getDb();',
+    "    db.exec('DELETE FROM brain_vocabulary');",
+    '    if (this.vocabulary.size === 0) return;',
+    "    const insert = db.prepare('INSERT INTO brain_vocabulary (term, idf, doc_count) VALUES (?, ?, ?)');",
+    '    const tx = db.transaction(() => {',
+    '      for (const [term, idf] of this.vocabulary) {',
+    '        insert.run(term, idf, 1);',
+    '      }',
+    '    });',
+    '    tx();',
+    '  }',
+    '',
+    '  private recomputeWeights(): void {',
+    '    const db = this.vault.getDb();',
+    "    const feedbackCount = (db.prepare('SELECT COUNT(*) as count FROM brain_feedback').get() as { count: number }).count;",
+    '    if (feedbackCount < FEEDBACK_THRESHOLD) {',
+    '      this.weights = { ...DEFAULT_WEIGHTS };',
+    '      return;',
+    '    }',
+    '',
+    '    // Count accepted vs dismissed feedback',
+    '    const accepted = (db.prepare("SELECT COUNT(*) as count FROM brain_feedback WHERE action = \'accepted\'").get() as { count: number }).count;',
+    '    const acceptRate = feedbackCount > 0 ? accepted / feedbackCount : 0.5;',
+    '',
+    '    // High accept rate -> increase semantic weight, decrease others',
+    '    // Low accept rate -> decrease semantic weight, increase others',
+    '    const semanticDelta = (acceptRate - 0.5) * WEIGHT_BOUND * 2;',
+    '',
+    '    const newWeights = { ...DEFAULT_WEIGHTS };',
+    '    newWeights.semantic = clamp(DEFAULT_WEIGHTS.semantic + semanticDelta, DEFAULT_WEIGHTS.semantic - WEIGHT_BOUND, DEFAULT_WEIGHTS.semantic + WEIGHT_BOUND);',
+    '',
+    '    // Redistribute remaining weight evenly across other dimensions',
+    '    const remaining = 1.0 - newWeights.semantic;',
+    '    const otherSum = DEFAULT_WEIGHTS.severity + DEFAULT_WEIGHTS.recency + DEFAULT_WEIGHTS.tagOverlap + DEFAULT_WEIGHTS.domainMatch;',
+    '    const scale = remaining / otherSum;',
+    '    newWeights.severity = DEFAULT_WEIGHTS.severity * scale;',
+    '    newWeights.recency = DEFAULT_WEIGHTS.recency * scale;',
+    '    newWeights.tagOverlap = DEFAULT_WEIGHTS.tagOverlap * scale;',
+    '    newWeights.domainMatch = DEFAULT_WEIGHTS.domainMatch * scale;',
+    '',
+    '    this.weights = newWeights;',
+    '  }',
+    '}',
+    '',
+    'function clamp(value: number, min: number, max: number): number {',
+    '  return Math.max(min, Math.min(max, value));',
+    '}',
+].join('\n');
+//# sourceMappingURL=brain.js.map

package/dist/templates/brain.js.map

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

package/dist/templates/claude-md-template.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig } from '../types.js';
+/**
+ * Generates src/activation/claude-md-content.ts for a new agent.
+ * Returns the CLAUDE.md section content with activation triggers,
+ * facade tables, intent detection, and knowledge protocol.
+ *
+ * Strategy: build the markdown as plain strings, then escape into
+ * single-quoted TypeScript string literals. This avoids nested
+ * backtick/template-literal escaping nightmares entirely.
+ */
+export declare function generateClaudeMdTemplate(config: AgentConfig): string;

package/dist/templates/claude-md-template.js

@@ -0,0 +1,73 @@
+/**
+ * Generates src/activation/claude-md-content.ts for a new agent.
+ * Returns the CLAUDE.md section content with activation triggers,
+ * facade tables, intent detection, and knowledge protocol.
+ *
+ * Strategy: build the markdown as plain strings, then escape into
+ * single-quoted TypeScript string literals. This avoids nested
+ * backtick/template-literal escaping nightmares entirely.
+ */
+export function generateClaudeMdTemplate(config) {
+    const facadeId = config.id.replace(/-/g, '_');
+    const marker = `${config.id}:mode`;
+    const bt = '`'; // backtick — keeps template clean
+    // Build the raw markdown lines (plain text, no escaping needed)
+    const mdLines = [
+        `<!-- ${marker} -->`,
+        '',
+        `# ${config.name} Mode`,
+        '',
+        `## ${config.name} Integration`,
+        '',
+        `**Activate:** "Hello, ${config.name}!" \u2192 ${bt}${facadeId}_core op:activate params:{ projectPath: "." }${bt}`,
+        `**Deactivate:** "Goodbye, ${config.name}!" \u2192 ${bt}${facadeId}_core op:activate params:{ deactivate: true }${bt}`,
+        '',
+        'On activation, adopt the returned persona. Stay in character until deactivated.',
+        '',
+        '## Session Start',
+        '',
+        `On every new session: ${bt}${facadeId}_core op:register params:{ projectPath: "." }${bt}`,
+        '',
+        '## Facades',
+        '',
+        '| Need | Facade | Op |',
+        '|------|--------|----|',
+        `| Health check | ${bt}${facadeId}_core${bt} | ${bt}health${bt} |`,
+        `| Search all | ${bt}${facadeId}_core${bt} | ${bt}search${bt} |`,
+        `| Vault stats | ${bt}${facadeId}_core${bt} | ${bt}vault_stats${bt} |`,
+        `| Identity | ${bt}${facadeId}_core${bt} | ${bt}identity${bt} |`,
+    ];
+    // Domain-specific facade rows
+    for (const d of config.domains) {
+        const toolName = `${facadeId}_${d.replace(/-/g, '_')}`;
+        mdLines.push(`| ${d} patterns | ${bt}${toolName}${bt} | ${bt}get_patterns${bt} |`);
+        mdLines.push(`| Search ${d} | ${bt}${toolName}${bt} | ${bt}search${bt} |`);
+        mdLines.push(`| Capture ${d} | ${bt}${toolName}${bt} | ${bt}capture${bt} |`);
+    }
+    // Memory + Session + Export + Brain + Planning rows
+    mdLines.push(`| Memory search | ${bt}${facadeId}_core${bt} | ${bt}memory_search${bt} |`, `| Memory capture | ${bt}${facadeId}_core${bt} | ${bt}memory_capture${bt} |`, `| Memory list | ${bt}${facadeId}_core${bt} | ${bt}memory_list${bt} |`, `| Session capture | ${bt}${facadeId}_core${bt} | ${bt}session_capture${bt} |`, `| Export knowledge | ${bt}${facadeId}_core${bt} | ${bt}export${bt} |`, `| Record feedback | ${bt}${facadeId}_core${bt} | ${bt}record_feedback${bt} |`, `| Rebuild vocabulary | ${bt}${facadeId}_core${bt} | ${bt}rebuild_vocabulary${bt} |`, `| Brain stats | ${bt}${facadeId}_core${bt} | ${bt}brain_stats${bt} |`, `| LLM status | ${bt}${facadeId}_core${bt} | ${bt}llm_status${bt} |`, `| Create plan | ${bt}${facadeId}_core${bt} | ${bt}create_plan${bt} |`, `| Get plan | ${bt}${facadeId}_core${bt} | ${bt}get_plan${bt} |`, `| Approve plan | ${bt}${facadeId}_core${bt} | ${bt}approve_plan${bt} |`, `| Update task | ${bt}${facadeId}_core${bt} | ${bt}update_task${bt} |`, `| Complete plan | ${bt}${facadeId}_core${bt} | ${bt}complete_plan${bt} |`);
+    mdLines.push('', '## Intent Detection', '', '| Signal | Intent |', '|--------|--------|', '| Problem described ("broken", "janky", "weird") | FIX |', '| Need expressed ("I need", "we should have") | BUILD |', '| Quality questioned ("is this right?") | REVIEW |', '| Advice sought ("how should I", "best way") | PLAN |', '| Improvement requested ("make it faster") | IMPROVE |', '', '## Knowledge Protocol', '', 'When seeking guidance: vault before codebase before web.', '', `1. Search vault \u2014 ${bt}${facadeId}_core op:search${bt}`, '2. Codebase \u2014 only if vault has nothing', '3. Web \u2014 last resort', '', '## Knowledge Capture', '', 'When learning something that should persist, use the domain capture ops.', '', '## Session Capture', '', 'A PreCompact hook is configured to call `session_capture` before context compaction.', 'This automatically preserves session summaries as memories for future sessions.', `To manually capture: ${bt}${facadeId}_core op:session_capture params:{ summary: "..." }${bt}`, '', '## Planning', '', 'For multi-step tasks, use the planning system:', `1. Create: ${bt}${facadeId}_core op:create_plan params:{ objective: "...", scope: "...", tasks: [...] }${bt}`, `2. Approve: ${bt}${facadeId}_core op:approve_plan params:{ planId: "...", startExecution: true }${bt}`, `3. Track: ${bt}${facadeId}_core op:update_task params:{ planId: "...", taskId: "...", status: "completed" }${bt}`, `4. Complete: ${bt}${facadeId}_core op:complete_plan params:{ planId: "..." }${bt}`, '', 'Check activation response for recovered plans in `executing` state — remind the user.', '', `<!-- /${marker} -->`);
+    // Escape each markdown line for use in a single-quoted TS string literal
+    const quotedLines = mdLines.map((line) => {
+        const escaped = line.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        return `    '${escaped}',`;
+    });
+    // Build the generated TypeScript file
+    const tsLines = [
+        '/**',
+        ` * CLAUDE.md content for ${config.name}.`,
+        ' * Generated by Soleri — do not edit manually.',
+        ' */',
+        'export function getClaudeMdContent(): string {',
+        '  return [',
+        ...quotedLines,
+        "  ].join('\\n');",
+        '}',
+        '',
+        'export function getClaudeMdMarker(): string {',
+        `  return '${marker}';`,
+        '}',
+    ];
+    return tsLines.join('\n');
+}
+//# sourceMappingURL=claude-md-template.js.map

package/dist/templates/claude-md-template.js.map

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

package/dist/templates/core-facade.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from '../types.js';
+/**
+ * Generate the core facade that every agent gets — vault stats, search all,
+ * health, identity, plus activation system (activate, deactivate, inject_claude_md, setup).
+ */
+export declare function generateCoreFacade(config: AgentConfig): string;