opc-agent 2.0.2 → 2.1.0

package/dist/cli.js

@@ -188,9 +188,21 @@ 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) => l.trim() && !l.startsWith('#'))?.trim() || 'You are a helpful AI assistant.';
         fs.writeFileSync(path.join(dir, 'agent.yaml'), `apiVersion: opc/v1
 kind: Agent
@@ -212,6 +224,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: []
 `);
         // SOUL.md from system-prompt.md
@@ -292,8 +313,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`);
@@ -1403,9 +1428,12 @@ 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) => {
     console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
@@ -1438,6 +1466,86 @@ 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) => {
+    const { BrainSeedLoader } = require('./memory/seed-loader');
+    let config = {};
+    try {
+        config = yaml.load(fs.readFileSync(opts.file, 'utf-8'));
+    }
+    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) => 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 = [];
+    const mockBrain = {
+        learn: async (content, meta) => { 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) => {
+    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
     .command('logs')

package/dist/core/agent.d.ts

@@ -6,6 +6,7 @@ import type { MCPTool } from '../tools/mcp';
 import { MCPToolRegistry } from '../tools/mcp';
 import { type SubAgentConfig, type SubAgentResult } from './subagent';
 import { Tracer } from '../telemetry';
+import { type BrainSeedConfig } from '../memory/seed-loader';
 export declare class BaseAgent extends EventEmitter implements IAgent {
     readonly name: string;
     private _state;
@@ -23,6 +24,8 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     private longTermMemory?;
     private longTermMemoryConfig;
     private tracer?;
+    private brainSeedConfig?;
+    private agentDir;
     constructor(options: {
         name: string;
         systemPrompt?: string;
@@ -38,6 +41,8 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
         };
         maxToolRounds?: number;
         tracer?: Tracer;
+        agentDir?: string;
+        brainSeedConfig?: BrainSeedConfig;
     });
     setLongTermMemory(brain: any, config?: {
         autoLearn?: boolean;

package/dist/core/agent.js

@@ -7,6 +7,7 @@ const providers_1 = require("../providers");
 const auto_learn_1 = require("../skills/auto-learn");
 const mcp_1 = require("../tools/mcp");
 const subagent_1 = require("./subagent");
+const seed_loader_1 = require("../memory/seed-loader");
 class BaseAgent extends events_1.EventEmitter {
     name;
     _state = 'init';
@@ -24,6 +25,8 @@ class BaseAgent extends events_1.EventEmitter {
     longTermMemory;
     longTermMemoryConfig = { autoLearn: true, autoRecall: true };
     tracer;
+    brainSeedConfig;
+    agentDir;
     constructor(options) {
         super();
         this.name = options.name;
@@ -41,6 +44,8 @@ class BaseAgent extends events_1.EventEmitter {
             this.skillLearner = new auto_learn_1.SkillLearner(options.skillsDir);
         }
         this.tracer = options.tracer;
+        this.agentDir = options.agentDir ?? process.cwd();
+        this.brainSeedConfig = options.brainSeedConfig;
     }
     setLongTermMemory(brain, config) {
         this.longTermMemory = brain;
@@ -93,6 +98,15 @@ class BaseAgent extends events_1.EventEmitter {
         if (this.skillLearner) {
             await this.skillLearner.loadLearnedSkills();
         }
+        // Auto-seed brain if configured
+        if (this.brainSeedConfig?.autoSeed && this.longTermMemory) {
+            const loader = new seed_loader_1.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');
     }
     async start() {

package/dist/memory/index.d.ts

@@ -1,4 +1,6 @@
 import type { Message, MemoryStore } from '../core/types';
+export { BrainSeedLoader, KnowledgeEvolver } from './seed-loader';
+export type { BrainSeedConfig, SeedPage, SeedResult, PromotionResult, PromotionCandidate } from './seed-loader';
 export declare class InMemoryStore implements MemoryStore {
     private store;
     private conversations;

package/dist/memory/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryStore = void 0;
+exports.InMemoryStore = exports.KnowledgeEvolver = exports.BrainSeedLoader = void 0;
+var seed_loader_1 = require("./seed-loader");
+Object.defineProperty(exports, "BrainSeedLoader", { enumerable: true, get: function () { return seed_loader_1.BrainSeedLoader; } });
+Object.defineProperty(exports, "KnowledgeEvolver", { enumerable: true, get: function () { return seed_loader_1.KnowledgeEvolver; } });
 class InMemoryStore {
     store = new Map();
     conversations = new Map();

package/dist/memory/seed-loader.d.ts

@@ -0,0 +1,51 @@
+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 declare class BrainSeedLoader {
+    private agentDir;
+    private config;
+    private markerFile;
+    constructor(agentDir: string, config: BrainSeedConfig);
+    isSeeded(): Promise<boolean>;
+    seedBrain(brain: any): Promise<SeedResult>;
+    markSeeded(): Promise<void>;
+    parseSeedFile(filePath: string, tier: string): SeedPage[];
+    private inferTier;
+    private slugify;
+}
+export declare class KnowledgeEvolver {
+    private tierOrder;
+    checkPromotion(brain: any, options?: {
+        minInteractions?: number;
+        confidenceThreshold?: number;
+    }): Promise<PromotionResult>;
+    promoteToJob(brain: any, knowledge: string, jobSlug: string): Promise<void>;
+    promoteToIndustry(brain: any, knowledge: string, industrySlug: string): Promise<void>;
+}
+//# sourceMappingURL=seed-loader.d.ts.map

package/dist/memory/seed-loader.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeEvolver = exports.BrainSeedLoader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class BrainSeedLoader {
+    agentDir;
+    config;
+    markerFile;
+    constructor(agentDir, config) {
+        this.agentDir = agentDir;
+        this.config = config;
+        this.markerFile = config.seedMarkerFile
+            ? path.resolve(agentDir, config.seedMarkerFile)
+            : path.resolve(agentDir, '.brain-seeded');
+    }
+    async isSeeded() {
+        return fs.existsSync(this.markerFile);
+    }
+    async seedBrain(brain) {
+        const allPages = [];
+        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 = [];
+        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() {
+        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, tier) {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const pages = [];
+        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;
+            let body;
+            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;
+    }
+    inferTier(seedPath) {
+        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';
+    }
+    slugify(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+}
+exports.BrainSeedLoader = BrainSeedLoader;
+class KnowledgeEvolver {
+    tierOrder = ['workstation', 'job', 'industry'];
+    async checkPromotion(brain, options = {}) {
+        const minInteractions = options.minInteractions ?? 50;
+        const confidenceThreshold = options.confidenceThreshold ?? 0.8;
+        const result = { 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, knowledge, jobSlug) {
+        if (brain && typeof brain.store === 'function') {
+            await brain.store('brain-seeds', jobSlug, knowledge, {
+                tier: 'job',
+                source: 'promotion',
+                promotedAt: new Date().toISOString(),
+            });
+        }
+    }
+    async promoteToIndustry(brain, knowledge, industrySlug) {
+        if (brain && typeof brain.store === 'function') {
+            await brain.store('brain-seeds', industrySlug, knowledge, {
+                tier: 'industry',
+                source: 'promotion',
+                promotedAt: new Date().toISOString(),
+            });
+        }
+    }
+}
+exports.KnowledgeEvolver = KnowledgeEvolver;
+//# sourceMappingURL=seed-loader.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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/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');
+  });
+});