opc-agent 2.0.1 → 2.1.0

package/src/cli.ts

@@ -170,11 +170,25 @@ program
       fs.mkdirSync(dir, { recursive: true });
       fs.mkdirSync(path.join(dir, 'src', 'skills'), { recursive: true });
       fs.mkdirSync(path.join(dir, 'data'), { recursive: true });
+      fs.mkdirSync(path.join(dir, 'brain-seeds'), { recursive: true });
 
       // Get system prompt content
       const systemPromptContent = roleData.files['system-prompt.md'] || roleData.files['prompts/system.md'] || '';
 
-      // agent.yaml with role system prompt
+      // Generate brain-seeds/ files from role data
+      const brainSeedContent = roleData.files['brain-seed.md'] || '';
+      const industryMatch = brainSeedContent ? brainSeedContent.match(/# Industry Knowledge[\s\S]*?(?=# Job Knowledge|# Workstation Knowledge|$)/i) : null;
+      const jobMatch = brainSeedContent ? brainSeedContent.match(/# Job Knowledge[\s\S]*?(?=# Industry Knowledge|# Workstation Knowledge|$)/i) : null;
+      const workstationMatch = brainSeedContent ? brainSeedContent.match(/# Workstation Knowledge[\s\S]*?(?=# Industry Knowledge|# Job Knowledge|$)/i) : null;
+
+      fs.writeFileSync(path.join(dir, 'brain-seeds', 'industry.md'), industryMatch?.[0]?.trim() || `# Industry Knowledge\n\n## Overview\n\nAdd industry-specific knowledge for your domain.\n`);
+      fs.writeFileSync(path.join(dir, 'brain-seeds', 'job.md'), jobMatch?.[0]?.trim() || `# Job Knowledge\n\n## Core Skills\n\nAdd role-specific knowledge for ${roleDisplayName}.\n`);
+      // workstation.md: public workstation knowledge (tools, workflows, best practices)
+      // Company-specific knowledge belongs to Desk (closed-source), not here.
+      const workstationSeedFromRole = workstationMatch?.[0]?.trim() || '';
+      fs.writeFileSync(path.join(dir, 'brain-seeds', 'workstation.md'), workstationSeedFromRole || `# Workstation Knowledge\n\n## Tools & Environment\n\nCommon tools and setup for this workstation role.\n\n## Workflows\n\nStandard operating procedures and workflows.\n\n## Best Practices\n\nIndustry best practices for this role.\n`);
+
+      // agent.yaml with role system prompt and brain seeds
       const firstLine = systemPromptContent.split('\n').find((l: string) => l.trim() && !l.startsWith('#'))?.trim() || 'You are a helpful AI assistant.';
       fs.writeFileSync(
         path.join(dir, 'agent.yaml'),
@@ -198,6 +212,15 @@ spec:
     longTerm:
       provider: deepbrain
       database: ./data/brain.db
+  brain:
+    seeds:
+      - brain-seeds/industry.md
+      - brain-seeds/job.md
+      - brain-seeds/workstation.md
+    autoSeed: true
+    evolve:
+      enabled: true
+      direction: bottom-up
   skills: []
 `,
       );
@@ -317,8 +340,12 @@ export class EchoSkill extends BaseSkill {
       console.log(`   ${icon.file} agent.yaml       - Agent definition with role system prompt`);
       console.log(`   ${icon.file} SOUL.md          - Role personality (${systemPromptContent.split('\n').length} lines)`);
       console.log(`   ${icon.file} CONTEXT.md       - Role context & documentation`);
+      console.log(`   ${icon.file} brain-seeds/     - 3-tier brain seed knowledge`);
+      console.log(`     ${color.dim('├')} industry.md    - Industry knowledge`);
+      console.log(`     ${color.dim('├')} job.md         - Job/role knowledge`);
+      console.log(`     ${color.dim('└')} workstation.md - Workstation knowledge`);
       if (roleData.files['brain-seed.md']) {
-        console.log(`   ${icon.file} data/brain-seed.md - Role brain seed knowledge`);
+        console.log(`   ${icon.file} data/brain-seed.md - Role brain seed knowledge (legacy)`);
       }
       console.log(`   ${icon.file} src/index.ts     - Entry point`);
       console.log(`   ${icon.file} package.json     - Dependencies`);
@@ -1516,9 +1543,13 @@ program
 
 // ── Brain command ────────────────────────────────────────────
 
-program
+const brainCmd = program
   .command('brain')
-  .description('Show agent memory/brain status from DeepBrain')
+  .description('Manage agent brain (memory, seeds, evolve)');
+
+brainCmd
+  .command('status')
+  .description('Show brain stats (pages, tiers, last evolve)')
   .option('--url <url>', 'DeepBrain server URL', 'http://localhost:3333')
   .action(async (opts: { url: string }) => {
     console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
@@ -1549,6 +1580,89 @@ program
     }
   });
 
+brainCmd
+  .command('seed')
+  .description('Import brain seed files into memory')
+  .option('-f, --file <file>', 'OAD file', 'agent.yaml')
+  .option('--status', 'Check if seeds have been imported')
+  .option('--reset', 'Re-import seeds (clear marker and re-seed)')
+  .action(async (opts: { file: string; status?: boolean; reset?: boolean }) => {
+    const { BrainSeedLoader } = require('./memory/seed-loader');
+    let config: any = {};
+    try { config = yaml.load(fs.readFileSync(opts.file, 'utf-8')) as any; } catch { /* ignore */ }
+    const brainConfig = config?.spec?.brain;
+    if (!brainConfig?.seeds?.length) {
+      console.log(`${icon.info} No brain seeds configured in ${opts.file}.`);
+      console.log(`  Add spec.brain.seeds to your agent.yaml.`);
+      return;
+    }
+
+    const loader = new BrainSeedLoader(process.cwd(), {
+      seeds: brainConfig.seeds,
+      autoSeed: brainConfig.autoSeed !== false,
+    });
+
+    if (opts.status) {
+      const seeded = await loader.isSeeded();
+      console.log(`\n  Brain seed status: ${seeded ? color.green('seeded ✔') : color.yellow('not seeded')}`);
+      console.log(`  Seeds configured: ${brainConfig.seeds.map((s: string) => color.cyan(s)).join(', ')}\n`);
+      return;
+    }
+
+    if (opts.reset) {
+      const markerPath = path.resolve(process.cwd(), '.brain-seeded');
+      if (fs.existsSync(markerPath)) {
+        fs.unlinkSync(markerPath);
+        console.log(`  ${icon.success} Cleared seed marker.`);
+      }
+    }
+
+    if (await loader.isSeeded() && !opts.reset) {
+      console.log(`${icon.info} Brain already seeded. Use --reset to re-import.`);
+      return;
+    }
+
+    console.log(`\n${icon.gear} Importing brain seeds...\n`);
+    // Use a simple mock brain that logs imports (real usage would connect to DeepBrain)
+    const pages: string[] = [];
+    const mockBrain = {
+      learn: async (content: string, meta: any) => { pages.push(meta?.slug || 'unknown'); },
+    };
+    const result = await loader.seedBrain(mockBrain);
+    await loader.markSeeded();
+
+    console.log(`  ${icon.success} Imported ${color.bold(String(result.imported))} pages from ${brainConfig.seeds.length} seed files.`);
+    for (const p of result.pages) {
+      console.log(`    ${color.dim('•')} ${p}`);
+    }
+    console.log();
+  });
+
+brainCmd
+  .command('evolve')
+  .description('Trigger manual knowledge evolution cycle')
+  .option('--dry-run', 'Show what would be promoted without doing it')
+  .action(async (opts: { dryRun?: boolean }) => {
+    const { KnowledgeEvolver } = require('./memory/seed-loader');
+    const evolver = new KnowledgeEvolver();
+    console.log(`\n${icon.gear} ${color.bold('Knowledge Evolution')}\n`);
+    console.log(`  ${icon.info} Checking for promotion candidates...`);
+    // Would connect to real brain in production
+    const result = await evolver.checkPromotion(null);
+    if (result.candidates.length === 0) {
+      console.log(`  ${icon.info} No knowledge ready for promotion yet.\n`);
+    } else {
+      for (const c of result.candidates) {
+        console.log(`  ${color.cyan(c.slug)} → ${c.fromTier} → ${c.toTier} (confidence: ${(c.confidence * 100).toFixed(0)}%)`);
+      }
+      if (opts.dryRun) {
+        console.log(`\n  ${icon.info} Dry run — no changes made.\n`);
+      } else {
+        console.log(`\n  ${icon.success} Promoted ${result.promoted} knowledge entries.\n`);
+      }
+    }
+  });
+
 // ── Logs command ─────────────────────────────────────────────
 
 program

package/src/core/agent.ts

@@ -8,6 +8,7 @@ import { MCPToolRegistry } from '../tools/mcp';
 import { SubAgentManager, type SubAgentConfig, type SubAgentResult } from './subagent';
 import { Tracer } from '../telemetry';
 import type { Span as TelemetrySpan } from '../telemetry';
+import { BrainSeedLoader, type BrainSeedConfig } from '../memory/seed-loader';
 
 export class BaseAgent extends EventEmitter implements IAgent {
   readonly name: string;
@@ -26,6 +27,8 @@ export class BaseAgent extends EventEmitter implements IAgent {
   private longTermMemory?: any;
   private longTermMemoryConfig: { autoLearn: boolean; autoRecall: boolean } = { autoLearn: true, autoRecall: true };
   private tracer?: Tracer;
+  private brainSeedConfig?: BrainSeedConfig;
+  private agentDir: string;
 
   constructor(options: {
     name: string;
@@ -42,6 +45,8 @@ export class BaseAgent extends EventEmitter implements IAgent {
     };
     maxToolRounds?: number;
     tracer?: Tracer;
+    agentDir?: string;
+    brainSeedConfig?: BrainSeedConfig;
   }) {
     super();
     this.name = options.name;
@@ -59,6 +64,8 @@ export class BaseAgent extends EventEmitter implements IAgent {
       this.skillLearner = new SkillLearner(options.skillsDir);
     }
     this.tracer = options.tracer;
+    this.agentDir = options.agentDir ?? process.cwd();
+    this.brainSeedConfig = options.brainSeedConfig;
   }
 
   setLongTermMemory(brain: any, config?: { autoLearn?: boolean; autoRecall?: boolean }): void {
@@ -125,6 +132,17 @@ export class BaseAgent extends EventEmitter implements IAgent {
     if (this.skillLearner) {
       await this.skillLearner.loadLearnedSkills();
     }
+
+    // Auto-seed brain if configured
+    if (this.brainSeedConfig?.autoSeed && this.longTermMemory) {
+      const loader = new BrainSeedLoader(this.agentDir, this.brainSeedConfig);
+      if (!await loader.isSeeded()) {
+        const result = await loader.seedBrain(this.longTermMemory);
+        this.emit('brain:seeded', result);
+        await loader.markSeeded();
+      }
+    }
+
     this.transition('ready');
   }
 

package/src/index.ts

@@ -128,6 +128,10 @@ export type { Span as TraceSpan, SpanEvent as TraceSpanEvent, TraceExporter as I
 export { Tracer, ConsoleExporter, FileExporter, OTLPHttpExporter, generateTraceId, generateSpanId } from './telemetry';
 export type { Span, SpanEvent, Metric, TraceExporter } from './telemetry';
 
+// v1.3.1 — Sub-agent management
+export { SubAgentManager } from './core/subagent';
+export type { SubAgentConfig, SubAgentResult } from './core/subagent';
+
 // v1.4.0 modules
 export { Scheduler, parseCron, cronMatches } from './core/scheduler';
 export type { CronJob, JobHandler } from './core/scheduler';

package/src/memory/index.ts

@@ -1,5 +1,8 @@
 import type { Message, MemoryStore } from '../core/types';
 
+export { BrainSeedLoader, KnowledgeEvolver } from './seed-loader';
+export type { BrainSeedConfig, SeedPage, SeedResult, PromotionResult, PromotionCandidate } from './seed-loader';
+
 export class InMemoryStore implements MemoryStore {
   private store: Map<string, unknown> = new Map();
   private conversations: Map<string, Message[]> = new Map();

package/src/memory/seed-loader.ts

@@ -0,0 +1,212 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface BrainSeedConfig {
+  seeds: string[];
+  autoSeed: boolean;
+  seedMarkerFile?: string;
+  evolve?: {
+    enabled: boolean;
+    direction: 'bottom-up' | 'top-down';
+  };
+}
+
+export interface SeedPage {
+  slug: string;
+  content: string;
+  tier: string;
+}
+
+export interface SeedResult {
+  imported: number;
+  pages: string[];
+}
+
+export interface PromotionCandidate {
+  slug: string;
+  content: string;
+  fromTier: string;
+  toTier: string;
+  confidence: number;
+}
+
+export interface PromotionResult {
+  candidates: PromotionCandidate[];
+  promoted: number;
+}
+
+export class BrainSeedLoader {
+  private markerFile: string;
+
+  constructor(private agentDir: string, private config: BrainSeedConfig) {
+    this.markerFile = config.seedMarkerFile
+      ? path.resolve(agentDir, config.seedMarkerFile)
+      : path.resolve(agentDir, '.brain-seeded');
+  }
+
+  async isSeeded(): Promise<boolean> {
+    return fs.existsSync(this.markerFile);
+  }
+
+  async seedBrain(brain: any): Promise<SeedResult> {
+    const allPages: SeedPage[] = [];
+
+    for (const seedPath of this.config.seeds) {
+      const fullPath = path.resolve(this.agentDir, seedPath);
+      if (!fs.existsSync(fullPath)) continue;
+
+      const tier = this.inferTier(seedPath);
+      const pages = this.parseSeedFile(fullPath, tier);
+      allPages.push(...pages);
+    }
+
+    const importedSlugs: string[] = [];
+    for (const page of allPages) {
+      if (brain && typeof brain.store === 'function') {
+        await brain.store('brain-seeds', page.slug, page.content, {
+          tier: page.tier,
+          source: 'brain-seed',
+        });
+      } else if (brain && typeof brain.learn === 'function') {
+        await brain.learn(page.content, {
+          tags: ['brain-seed', page.tier],
+          slug: page.slug,
+        });
+      }
+      importedSlugs.push(page.slug);
+    }
+
+    return { imported: importedSlugs.length, pages: importedSlugs };
+  }
+
+  async markSeeded(): Promise<void> {
+    const dir = path.dirname(this.markerFile);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(this.markerFile, JSON.stringify({
+      seededAt: new Date().toISOString(),
+      seeds: this.config.seeds,
+    }, null, 2));
+  }
+
+  parseSeedFile(filePath: string, tier: string): SeedPage[] {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const pages: SeedPage[] = [];
+    const sections = content.split(/^## /m);
+
+    for (const section of sections) {
+      const trimmed = section.trim();
+      if (!trimmed) continue;
+
+      const newlineIdx = trimmed.indexOf('\n');
+      if (newlineIdx === -1 && sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
+        // This is preamble before any ## heading — skip or treat as intro
+        continue;
+      }
+
+      let title: string;
+      let body: string;
+
+      if (sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
+        // Preamble (before first ##)
+        continue;
+      }
+
+      if (newlineIdx === -1) {
+        title = trimmed;
+        body = '';
+      } else {
+        title = trimmed.slice(0, newlineIdx).trim();
+        body = trimmed.slice(newlineIdx + 1).trim();
+      }
+
+      const slug = `seed/${tier}/${this.slugify(title)}`;
+      pages.push({ slug, content: `## ${title}\n\n${body}`, tier });
+    }
+
+    return pages;
+  }
+
+  private inferTier(seedPath: string): string {
+    const basename = path.basename(seedPath, path.extname(seedPath)).toLowerCase();
+    if (basename.includes('industry')) return 'industry';
+    if (basename.includes('job')) return 'job';
+    if (basename.includes('workstation')) return 'workstation';
+    return 'workstation';
+  }
+
+  private slugify(text: string): string {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+}
+
+export class KnowledgeEvolver {
+  private tierOrder = ['workstation', 'job', 'industry'];
+
+  async checkPromotion(brain: any, options: {
+    minInteractions?: number;
+    confidenceThreshold?: number;
+  } = {}): Promise<PromotionResult> {
+    const minInteractions = options.minInteractions ?? 50;
+    const confidenceThreshold = options.confidenceThreshold ?? 0.8;
+
+    const result: PromotionResult = { candidates: [], promoted: 0 };
+
+    // Search for frequently referenced seed knowledge
+    if (!brain || typeof brain.search !== 'function') return result;
+
+    try {
+      const seedPages = await brain.search('brain-seeds', 'seed/', 100);
+      if (!Array.isArray(seedPages)) return result;
+
+      for (const page of seedPages) {
+        const meta = page.metadata || {};
+        const usageCount = meta.usageCount ?? 0;
+        const tier = meta.tier || 'workstation';
+
+        if (usageCount < minInteractions) continue;
+
+        const confidence = Math.min(usageCount / (minInteractions * 2), 1.0);
+        if (confidence < confidenceThreshold) continue;
+
+        const tierIdx = this.tierOrder.indexOf(tier);
+        if (tierIdx <= 0) continue; // already at highest tier or unknown
+
+        const toTier = this.tierOrder[tierIdx - 1];
+        result.candidates.push({
+          slug: page.id || page.slug,
+          content: page.content,
+          fromTier: tier,
+          toTier,
+          confidence,
+        });
+      }
+    } catch {
+      // Silent fail
+    }
+
+    return result;
+  }
+
+  async promoteToJob(brain: any, knowledge: string, jobSlug: string): Promise<void> {
+    if (brain && typeof brain.store === 'function') {
+      await brain.store('brain-seeds', jobSlug, knowledge, {
+        tier: 'job',
+        source: 'promotion',
+        promotedAt: new Date().toISOString(),
+      });
+    }
+  }
+
+  async promoteToIndustry(brain: any, knowledge: string, industrySlug: string): Promise<void> {
+    if (brain && typeof brain.store === 'function') {
+      await brain.store('brain-seeds', industrySlug, knowledge, {
+        tier: 'industry',
+        source: 'promotion',
+        promotedAt: new Date().toISOString(),
+      });
+    }
+  }
+}

package/tests/brain-seed.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { BrainSeedLoader, KnowledgeEvolver } from '../src/memory/seed-loader';
+import type { BrainSeedConfig } from '../src/memory/seed-loader';
+
+function makeTmpDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opc-seed-test-'));
+  return dir;
+}
+
+describe('BrainSeedLoader', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+    fs.mkdirSync(path.join(tmpDir, 'brain-seeds'), { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('parseSeedFile splits ## sections into pages', () => {
+    const seedFile = path.join(tmpDir, 'brain-seeds', 'industry.md');
+    fs.writeFileSync(seedFile, `# Industry Knowledge
+
+## E-commerce Basics
+
+Online retail fundamentals.
+
+## Payment Systems
+
+How payments work in e-commerce.
+
+## Logistics
+
+Shipping and fulfillment.
+`);
+    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/industry.md'], autoSeed: true });
+    const pages = loader.parseSeedFile(seedFile, 'industry');
+
+    expect(pages).toHaveLength(3);
+    expect(pages[0].slug).toBe('seed/industry/e-commerce-basics');
+    expect(pages[0].tier).toBe('industry');
+    expect(pages[0].content).toContain('E-commerce Basics');
+    expect(pages[0].content).toContain('Online retail fundamentals.');
+    expect(pages[1].slug).toBe('seed/industry/payment-systems');
+    expect(pages[2].slug).toBe('seed/industry/logistics');
+  });
+
+  it('isSeeded returns false when no marker file', async () => {
+    const loader = new BrainSeedLoader(tmpDir, { seeds: [], autoSeed: true });
+    expect(await loader.isSeeded()).toBe(false);
+  });
+
+  it('isSeeded returns true after markSeeded', async () => {
+    const loader = new BrainSeedLoader(tmpDir, { seeds: [], autoSeed: true });
+    await loader.markSeeded();
+    expect(await loader.isSeeded()).toBe(true);
+    // Check marker file content
+    const marker = JSON.parse(fs.readFileSync(path.join(tmpDir, '.brain-seeded'), 'utf-8'));
+    expect(marker.seededAt).toBeDefined();
+  });
+
+  it('seedBrain imports pages with learn()', async () => {
+    const seedFile = path.join(tmpDir, 'brain-seeds', 'job.md');
+    fs.writeFileSync(seedFile, `# Job Knowledge
+
+## Customer Handling
+
+How to handle customers.
+
+## Escalation
+
+When to escalate.
+`);
+
+    const learned: { content: string; meta: any }[] = [];
+    const mockBrain = {
+      learn: async (content: string, meta: any) => { learned.push({ content, meta }); },
+    };
+
+    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/job.md'], autoSeed: true });
+    const result = await loader.seedBrain(mockBrain);
+
+    expect(result.imported).toBe(2);
+    expect(result.pages).toContain('seed/job/customer-handling');
+    expect(result.pages).toContain('seed/job/escalation');
+    expect(learned).toHaveLength(2);
+    expect(learned[0].meta.tags).toContain('brain-seed');
+    expect(learned[0].meta.tags).toContain('job');
+  });
+
+  it('seedBrain imports pages with store()', async () => {
+    const seedFile = path.join(tmpDir, 'brain-seeds', 'industry.md');
+    fs.writeFileSync(seedFile, `## Topic One\n\nContent one.\n`);
+
+    const stored: any[] = [];
+    const mockBrain = {
+      store: async (collection: string, slug: string, content: string, meta: any) => {
+        stored.push({ collection, slug, content, meta });
+      },
+    };
+
+    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/industry.md'], autoSeed: true });
+    const result = await loader.seedBrain(mockBrain);
+
+    expect(result.imported).toBe(1);
+    expect(stored[0].collection).toBe('brain-seeds');
+    expect(stored[0].meta.tier).toBe('industry');
+    expect(stored[0].meta.source).toBe('brain-seed');
+  });
+
+  it('skips import if already seeded', async () => {
+    const seedFile = path.join(tmpDir, 'brain-seeds', 'industry.md');
+    fs.writeFileSync(seedFile, `## Topic\n\nContent.\n`);
+
+    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/industry.md'], autoSeed: true });
+    await loader.markSeeded();
+
+    expect(await loader.isSeeded()).toBe(true);
+    // seedBrain would still work if called, but the guard is in agent.ts
+  });
+
+  it('handles missing seed files gracefully', async () => {
+    const loader = new BrainSeedLoader(tmpDir, {
+      seeds: ['brain-seeds/nonexistent.md'],
+      autoSeed: true,
+    });
+
+    const mockBrain = { learn: async () => {} };
+    const result = await loader.seedBrain(mockBrain);
+    expect(result.imported).toBe(0);
+    expect(result.pages).toHaveLength(0);
+  });
+
+  it('infers tier from filename', () => {
+    // Write all three seed files
+    fs.writeFileSync(path.join(tmpDir, 'brain-seeds', 'industry.md'), '## Ind Topic\n\nContent.\n');
+    fs.writeFileSync(path.join(tmpDir, 'brain-seeds', 'job.md'), '## Job Topic\n\nContent.\n');
+    fs.writeFileSync(path.join(tmpDir, 'brain-seeds', 'workstation.md'), '## WS Topic\n\nContent.\n');
+
+    const loader = new BrainSeedLoader(tmpDir, {
+      seeds: ['brain-seeds/industry.md', 'brain-seeds/job.md', 'brain-seeds/workstation.md'],
+      autoSeed: true,
+    });
+
+    const indPages = loader.parseSeedFile(path.join(tmpDir, 'brain-seeds', 'industry.md'), 'industry');
+    const jobPages = loader.parseSeedFile(path.join(tmpDir, 'brain-seeds', 'job.md'), 'job');
+    const wsPages = loader.parseSeedFile(path.join(tmpDir, 'brain-seeds', 'workstation.md'), 'workstation');
+
+    expect(indPages[0].tier).toBe('industry');
+    expect(indPages[0].slug).toContain('seed/industry/');
+    expect(jobPages[0].tier).toBe('job');
+    expect(wsPages[0].tier).toBe('workstation');
+  });
+
+  it('uses custom seedMarkerFile', async () => {
+    const loader = new BrainSeedLoader(tmpDir, {
+      seeds: [],
+      autoSeed: true,
+      seedMarkerFile: '.custom-marker',
+    });
+    await loader.markSeeded();
+    expect(fs.existsSync(path.join(tmpDir, '.custom-marker'))).toBe(true);
+    expect(await loader.isSeeded()).toBe(true);
+  });
+});
+
+describe('KnowledgeEvolver', () => {
+  it('checkPromotion returns empty when brain is null', async () => {
+    const evolver = new KnowledgeEvolver();
+    const result = await evolver.checkPromotion(null);
+    expect(result.candidates).toHaveLength(0);
+    expect(result.promoted).toBe(0);
+  });
+
+  it('promoteToJob calls brain.store with job tier', async () => {
+    const stored: any[] = [];
+    const mockBrain = {
+      store: async (col: string, slug: string, content: string, meta: any) => {
+        stored.push({ col, slug, content, meta });
+      },
+    };
+
+    const evolver = new KnowledgeEvolver();
+    await evolver.promoteToJob(mockBrain, 'Important knowledge', 'seed/job/promoted-topic');
+
+    expect(stored).toHaveLength(1);
+    expect(stored[0].meta.tier).toBe('job');
+    expect(stored[0].meta.source).toBe('promotion');
+    expect(stored[0].slug).toBe('seed/job/promoted-topic');
+  });
+
+  it('promoteToIndustry calls brain.store with industry tier', async () => {
+    const stored: any[] = [];
+    const mockBrain = {
+      store: async (col: string, slug: string, content: string, meta: any) => {
+        stored.push({ col, slug, content, meta });
+      },
+    };
+
+    const evolver = new KnowledgeEvolver();
+    await evolver.promoteToIndustry(mockBrain, 'Cross-role knowledge', 'seed/industry/common-pattern');
+
+    expect(stored).toHaveLength(1);
+    expect(stored[0].meta.tier).toBe('industry');
+    expect(stored[0].meta.source).toBe('promotion');
+  });
+});
+
+describe('OAD spec.brain.seeds config parsing', () => {
+  it('parses brain seed config from YAML', () => {
+    const yaml = require('js-yaml');
+    const config = yaml.load(`
+apiVersion: opc/v1
+kind: Agent
+metadata:
+  name: test
+spec:
+  brain:
+    seeds:
+      - brain-seeds/industry.md
+      - brain-seeds/job.md
+      - brain-seeds/workstation.md
+    autoSeed: true
+    evolve:
+      enabled: true
+      direction: bottom-up
+`) as any;
+
+    expect(config.spec.brain.seeds).toHaveLength(3);
+    expect(config.spec.brain.autoSeed).toBe(true);
+    expect(config.spec.brain.evolve.enabled).toBe(true);
+    expect(config.spec.brain.evolve.direction).toBe('bottom-up');
+  });
+});