opc-agent 1.3.1 → 1.3.2

package/dist/cli.js

@@ -61,6 +61,7 @@ const workflow_1 = require("./core/workflow");
 const versioning_1 = require("./core/versioning");
 const providers_1 = require("./providers");
 const knowledge_1 = require("./core/knowledge");
+const marketplace_1 = require("./marketplace");
 const program = new commander_1.Command();
 const color = {
     green: (s) => `\x1b[32m${s}\x1b[0m`,
@@ -683,23 +684,51 @@ kbCmd.command('clear').action(() => {
     kb.clear();
     console.log(`${icon.success} Knowledge base cleared.`);
 });
-// 📦 Package commands ───────────────────────────────────
+// 📦 Marketplace commands ───────────────────────────────────
 program
     .command('publish')
     .description('Package agent for distribution')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
     .option('-o, --output <dir>', 'Output directory', '.')
     .option('--include-kb', 'Include knowledge base')
-    .action(async () => {
-    console.log(`\n${icon.package} Agent packaging coming soon.\n`);
+    .action(async (opts) => {
+    try {
+        console.log(`\n${icon.package} Packaging agent...\n`);
+        const result = await (0, marketplace_1.publishAgent)({
+            oadPath: opts.file,
+            outputDir: opts.output,
+            includeKnowledge: opts.includeKb,
+        });
+        console.log(`${icon.success} Published: ${color.bold(result.archivePath)}`);
+        console.log(`   Name:    ${result.manifest.name}`);
+        console.log(`   Version: ${result.manifest.version}`);
+        console.log(`   Files:   ${result.manifest.files.length}`);
+        console.log();
+    }
+    catch (err) {
+        console.error(`${icon.error} Publish failed:`, err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
 });
 program
     .command('install')
     .description('Install agent from package')
     .argument('<source>', 'Package file path or URL')
     .option('-d, --dir <dir>', 'Install directory')
-    .action(async () => {
-    console.log(`\n${icon.package} Agent install coming soon.\n`);
+    .action(async (source, opts) => {
+    try {
+        console.log(`\n${icon.package} Installing agent from ${color.bold(source)}...\n`);
+        const result = await (0, marketplace_1.installAgent)({ source, targetDir: opts.dir });
+        console.log(`${icon.success} Installed: ${color.bold(result.manifest.name)} v${result.manifest.version}`);
+        console.log(`   Directory: ${result.dir}`);
+        console.log(`\n${color.bold('Next steps:')}`);
+        console.log(`   cd ${result.dir}`);
+        console.log(`   opc run\n`);
+    }
+    catch (err) {
+        console.error(`${icon.error} Install failed:`, err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
 });
 // 🔌 Plugin commands ────────────────────────────────────────
 const pluginCmd = program.command('plugin').description('Manage plugins');
@@ -809,118 +838,5 @@ program
         process.exit(1);
     }
 });
-// ── Brain command ────────────────────────────────────────────
-program
-    .command('brain')
-    .description('Show agent memory/brain status from DeepBrain')
-    .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`);
-    try {
-        const res = await fetch(`${opts.url}/api/stats`);
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status} ${res.statusText}`);
-        const stats = (await res.json());
-        const rows = [
-            ['Total Pages', String(stats.totalPages ?? stats.pages ?? '-')],
-            ['Total Chunks', String(stats.totalChunks ?? stats.chunks ?? '-')],
-            ['Memory Tiers', String(stats.memoryTiers ?? stats.tiers ?? '-')],
-            ['Index Size', stats.indexSize ?? '-'],
-            ['Last Updated', stats.lastUpdated ?? stats.updatedAt ?? '-'],
-        ];
-        const maxKey = Math.max(...rows.map(([k]) => k.length));
-        for (const [key, val] of rows) {
-            console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
-        }
-        console.log();
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
-            console.log(`  ${icon.warn} Cannot connect to DeepBrain at ${opts.url}`);
-            console.log(`  ${color.dim('Is the server running? Start with: deepbrain serve')}\n`);
-        }
-        else {
-            console.error(`  ${icon.error} ${msg}\n`);
-        }
-    }
-});
-// ── Logs command ─────────────────────────────────────────────
-program
-    .command('logs')
-    .description('Show recent agent traces')
-    .option('-n, --limit <n>', 'Number of spans to show', '20')
-    .option('-f, --follow', 'Keep watching for new spans')
-    .action(async (opts) => {
-    const { TraceCollector } = await Promise.resolve().then(() => __importStar(require('./traces')));
-    const collector = new TraceCollector();
-    const limit = parseInt(opts.limit) || 20;
-    const printSpans = (spans) => {
-        const slice = spans.slice(-limit);
-        if (slice.length === 0) {
-            console.log(`  ${icon.info} No traces yet. Interact with the agent to generate traces.`);
-            return;
-        }
-        for (const span of slice) {
-            const duration = span.endTime
-                ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
-                : 'ongoing';
-            const statusIcon = span.status === 'ok' ? icon.success : span.status === 'error' ? icon.error : color.dim('○');
-            const time = span.startTime.toLocaleTimeString();
-            console.log(`  ${statusIcon} ${color.dim(time)} ${color.bold(span.name)} ${color.dim(duration)}`);
-        }
-    };
-    console.log(`\n${icon.gear} ${color.bold('Agent Traces')}\n`);
-    const spans = collector.getBufferedSpans();
-    printSpans(spans);
-    if (opts.follow) {
-        console.log(`\n  ${color.dim('Watching for new traces... (Ctrl+C to stop)')}\n`);
-        let lastCount = spans.length;
-        const interval = setInterval(() => {
-            const current = collector.getBufferedSpans();
-            if (current.length > lastCount) {
-                const newSpans = current.slice(lastCount);
-                printSpans(newSpans);
-                lastCount = current.length;
-            }
-        }, 1000);
-        process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
-    }
-    else {
-        console.log();
-    }
-});
-// ── Score command ────────────────────────────────────────────
-program
-    .command('score')
-    .description('Show agent performance score')
-    .action(async () => {
-    console.log(`\n${icon.gear} ${color.bold('Agent Performance Score')}\n`);
-    try {
-        const engine = new analytics_engine_1.AnalyticsEngine('.');
-        const stats = engine.getStats();
-        if (!stats || stats.totalMessages === 0) {
-            console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
-            return;
-        }
-        const errorRate = stats.totalMessages > 0 ? (stats.totalErrors / stats.totalMessages) : 0;
-        const rows = [
-            ['Total Messages', String(stats.totalMessages)],
-            ['Total LLM Calls', String(stats.totalLLMCalls)],
-            ['Total Tool Uses', String(stats.totalToolUses)],
-            ['Avg Response Time', `${stats.avgResponseTimeMs}ms`],
-            ['Error Rate', `${(errorRate * 100).toFixed(1)}%`],
-            ['Token Usage', `${stats.totalTokens.total} tokens (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`],
-        ];
-        const maxKey = Math.max(...rows.map(([k]) => k.length));
-        for (const [key, val] of rows) {
-            console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
-        }
-        console.log();
-    }
-    catch {
-        console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
-    }
-});
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/core/dashboard.d.ts

@@ -0,0 +1,35 @@
+export interface DashboardConfig {
+    /** Enable the dashboard (default: false) */
+    enabled: boolean;
+    /** HTTP port (default: 4100) */
+    port?: number;
+    /** Bind address (default: 127.0.0.1 for security) */
+    host?: string;
+    /** Enable CORS (default: false) */
+    cors?: boolean;
+}
+interface SessionSummary {
+    id: string;
+    channel: string;
+    messages: number;
+    lastActive: number;
+    status: 'active' | 'idle' | 'closed';
+}
+export declare class Dashboard {
+    private app;
+    private server;
+    private config;
+    private startTime;
+    private stats;
+    constructor(config: DashboardConfig);
+    private setupRoutes;
+    private getState;
+    trackSession(session: SessionSummary): void;
+    trackToolCall(toolName: string): void;
+    trackChannel(name: string, connected: boolean, messages?: number): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private renderHTML;
+}
+export {};
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/core/dashboard.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dashboard = void 0;
+const express_1 = __importDefault(require("express"));
+// ─── Dashboard Server ────────────────────────────────────────
+class Dashboard {
+    app = (0, express_1.default)();
+    server = null;
+    config;
+    startTime = Date.now();
+    stats = {
+        sessions: new Map(),
+        toolInvocations: new Map(),
+        channelStats: new Map(),
+    };
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            port: config.port ?? 4100,
+            host: config.host ?? '127.0.0.1',
+            cors: config.cors ?? false,
+        };
+        this.setupRoutes();
+    }
+    setupRoutes() {
+        if (this.config.cors) {
+            this.app.use((_req, res, next) => {
+                res.header('Access-Control-Allow-Origin', '*');
+                res.header('Access-Control-Allow-Headers', 'Content-Type');
+                next();
+            });
+        }
+        this.app.use(express_1.default.json());
+        // Health check
+        this.app.get('/api/health', (_req, res) => {
+            res.json({ status: 'ok', uptime: Date.now() - this.startTime });
+        });
+        // Overview state
+        this.app.get('/api/state', (_req, res) => {
+            res.json(this.getState());
+        });
+        // Sessions
+        this.app.get('/api/sessions', (_req, res) => {
+            res.json([...this.stats.sessions.values()]);
+        });
+        // Tools
+        this.app.get('/api/tools', (_req, res) => {
+            const tools = [];
+            for (const [name, stat] of this.stats.toolInvocations) {
+                tools.push({ name, type: 'builtin', enabled: true, invocations: stat.count, lastUsed: stat.lastUsed });
+            }
+            res.json(tools);
+        });
+        // Channels
+        this.app.get('/api/channels', (_req, res) => {
+            const channels = [];
+            for (const [name, stat] of this.stats.channelStats) {
+                channels.push({ name, type: name, connected: stat.connected, messageCount: stat.messages });
+            }
+            res.json(channels);
+        });
+        // Simple HTML dashboard
+        this.app.get('/', (_req, res) => {
+            res.send(this.renderHTML());
+        });
+    }
+    getState() {
+        return {
+            agent: { name: 'opc-agent', version: '1.3.0', status: 'running', uptime: Date.now() - this.startTime },
+            sessions: [...this.stats.sessions.values()],
+            tools: [...this.stats.toolInvocations.entries()].map(([name, s]) => ({
+                name, type: 'builtin', enabled: true, invocations: s.count, lastUsed: s.lastUsed,
+            })),
+            channels: [...this.stats.channelStats.entries()].map(([name, s]) => ({
+                name, type: name, connected: s.connected, messageCount: s.messages,
+            })),
+            memory: { provider: 'unknown', entries: 0 },
+            modelAuth: { providers: [] },
+        };
+    }
+    // ─── Event Tracking ──────────────────────────────────────
+    trackSession(session) {
+        this.stats.sessions.set(session.id, session);
+    }
+    trackToolCall(toolName) {
+        const existing = this.stats.toolInvocations.get(toolName) ?? { count: 0, lastUsed: 0 };
+        existing.count++;
+        existing.lastUsed = Date.now();
+        this.stats.toolInvocations.set(toolName, existing);
+    }
+    trackChannel(name, connected, messages) {
+        const existing = this.stats.channelStats.get(name) ?? { connected: false, messages: 0 };
+        existing.connected = connected;
+        if (messages !== undefined)
+            existing.messages = messages;
+        this.stats.channelStats.set(name, existing);
+    }
+    // ─── Lifecycle ───────────────────────────────────────────
+    async start() {
+        if (!this.config.enabled)
+            return;
+        return new Promise((resolve) => {
+            this.server = this.app.listen(this.config.port, this.config.host, () => {
+                console.log(`[dashboard] http://${this.config.host}:${this.config.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server)
+                this.server.close(() => resolve());
+            else
+                resolve();
+        });
+    }
+    renderHTML() {
+        return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>OPC Agent Dashboard</title>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:system-ui,-apple-system,sans-serif;background:#0a0a0f;color:#e0e0e0;padding:24px}
+h1{font-size:1.5rem;margin-bottom:20px;color:#7c9aff}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px}
+.card{background:#14141f;border:1px solid #2a2a3a;border-radius:12px;padding:20px}
+.card h2{font-size:0.85rem;text-transform:uppercase;letter-spacing:1px;color:#888;margin-bottom:12px}
+.stat{font-size:2rem;font-weight:700;color:#7c9aff}
+.sub{font-size:0.8rem;color:#666;margin-top:4px}
+#data{margin-top:20px;font-family:monospace;font-size:0.75rem;color:#555;white-space:pre-wrap}
+</style></head><body>
+<h1>⚡ OPC Agent Dashboard</h1>
+<div class="grid">
+  <div class="card"><h2>Status</h2><div class="stat" id="status">Loading…</div><div class="sub" id="uptime"></div></div>
+  <div class="card"><h2>Sessions</h2><div class="stat" id="sessions">-</div></div>
+  <div class="card"><h2>Tools</h2><div class="stat" id="tools">-</div></div>
+  <div class="card"><h2>Channels</h2><div class="stat" id="channels">-</div></div>
+</div>
+<div id="data"></div>
+<script>
+async function poll(){try{const r=await fetch('/api/state');const d=await r.json();
+document.getElementById('status').textContent=d.agent.status;
+document.getElementById('uptime').textContent='Uptime: '+Math.floor(d.agent.uptime/1000)+'s';
+document.getElementById('sessions').textContent=d.sessions.length;
+document.getElementById('tools').textContent=d.tools.length;
+document.getElementById('channels').textContent=d.channels.length;
+document.getElementById('data').textContent=JSON.stringify(d,null,2);
+}catch(e){document.getElementById('status').textContent='offline'}}
+poll();setInterval(poll,5000);
+</script></body></html>`;
+    }
+}
+exports.Dashboard = Dashboard;
+//# sourceMappingURL=dashboard.js.map

package/dist/core/priority.d.ts

@@ -0,0 +1,52 @@
+export interface PriorityConfig {
+    /** Enable priority mode (default: false) */
+    enabled: boolean;
+    /** Provider-specific priority settings */
+    providers?: PriorityProviderConfig[];
+    /** Default priority tier */
+    defaultTier?: PriorityTier;
+}
+export type PriorityTier = 'standard' | 'fast' | 'batch';
+export interface PriorityProviderConfig {
+    provider: string;
+    tier: PriorityTier;
+    /** Custom endpoint override for priority routing */
+    endpoint?: string;
+    /** Supported models for this tier */
+    models?: string[];
+}
+interface PriorityHeaders {
+    [key: string]: string;
+}
+export declare class PriorityRouter {
+    private config;
+    private runtimeTier;
+    constructor(config: PriorityConfig);
+    /** Toggle fast mode on/off at runtime */
+    toggle(): PriorityTier;
+    /** Set specific tier */
+    setTier(tier: PriorityTier): void;
+    /** Get current tier */
+    getTier(): PriorityTier;
+    /** Check if fast mode is active */
+    isFast(): boolean;
+    /**
+     * Get priority headers for a provider + model combination.
+     * Returns empty object if provider doesn't support priority or model isn't eligible.
+     */
+    getHeaders(provider: string, model: string): PriorityHeaders;
+    /**
+     * Get effective endpoint for a provider, allowing priority-specific routing.
+     */
+    getEndpoint(provider: string, defaultEndpoint: string): string;
+    private getEffectiveTier;
+    private isModelEligible;
+    /** Status summary for dashboard / CLI */
+    status(): {
+        tier: PriorityTier;
+        enabled: boolean;
+        providers: string[];
+    };
+}
+export {};
+//# sourceMappingURL=priority.d.ts.map

package/dist/core/priority.js

@@ -0,0 +1,102 @@
+"use strict";
+// ─── Priority / Fast Mode ────────────────────────────────────
+// Route requests through provider priority tiers for lower latency.
+// Toggle via config or runtime command.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityRouter = void 0;
+// Known priority-capable providers and their routing
+const PROVIDER_PRIORITY_MAP = {
+    openai: {
+        headerKey: 'X-OpenAI-Processing-Priority',
+        headerValue: { fast: 'priority', standard: 'auto', batch: 'batch' },
+        supportedModels: ['gpt-5', 'gpt-5.4', 'gpt-4.1', 'codex-*', 'o3-*', 'o4-mini*'],
+    },
+    anthropic: {
+        headerKey: 'anthropic-priority',
+        headerValue: { fast: 'high', standard: 'normal', batch: 'low' },
+        supportedModels: ['claude-opus-*', 'claude-sonnet-*', 'claude-4*'],
+    },
+    google: {
+        headerKey: 'X-Goog-Priority',
+        headerValue: { fast: 'high', standard: 'normal', batch: 'low' },
+        supportedModels: ['gemini-2.5-*', 'gemini-3-*'],
+    },
+};
+class PriorityRouter {
+    config;
+    runtimeTier;
+    constructor(config) {
+        this.config = config;
+        this.runtimeTier = config.defaultTier ?? 'standard';
+    }
+    /** Toggle fast mode on/off at runtime */
+    toggle() {
+        this.runtimeTier = this.runtimeTier === 'fast' ? 'standard' : 'fast';
+        return this.runtimeTier;
+    }
+    /** Set specific tier */
+    setTier(tier) {
+        this.runtimeTier = tier;
+    }
+    /** Get current tier */
+    getTier() {
+        return this.runtimeTier;
+    }
+    /** Check if fast mode is active */
+    isFast() {
+        return this.runtimeTier === 'fast';
+    }
+    /**
+     * Get priority headers for a provider + model combination.
+     * Returns empty object if provider doesn't support priority or model isn't eligible.
+     */
+    getHeaders(provider, model) {
+        if (!this.config.enabled)
+            return {};
+        const tier = this.getEffectiveTier(provider);
+        if (tier === 'standard')
+            return {};
+        const providerMap = PROVIDER_PRIORITY_MAP[provider.toLowerCase()];
+        if (!providerMap)
+            return {};
+        // Check model eligibility
+        if (!this.isModelEligible(providerMap.supportedModels, model))
+            return {};
+        return { [providerMap.headerKey]: providerMap.headerValue[tier] };
+    }
+    /**
+     * Get effective endpoint for a provider, allowing priority-specific routing.
+     */
+    getEndpoint(provider, defaultEndpoint) {
+        const providerConfig = this.config.providers?.find((p) => p.provider.toLowerCase() === provider.toLowerCase());
+        if (providerConfig?.endpoint && this.runtimeTier === 'fast') {
+            return providerConfig.endpoint;
+        }
+        return defaultEndpoint;
+    }
+    getEffectiveTier(provider) {
+        // Check provider-specific override first
+        const providerConfig = this.config.providers?.find((p) => p.provider.toLowerCase() === provider.toLowerCase());
+        if (providerConfig)
+            return providerConfig.tier;
+        return this.runtimeTier;
+    }
+    isModelEligible(patterns, model) {
+        return patterns.some((pattern) => {
+            if (pattern.endsWith('*')) {
+                return model.startsWith(pattern.slice(0, -1));
+            }
+            return model === pattern;
+        });
+    }
+    /** Status summary for dashboard / CLI */
+    status() {
+        return {
+            tier: this.runtimeTier,
+            enabled: this.config.enabled,
+            providers: Object.keys(PROVIDER_PRIORITY_MAP),
+        };
+    }
+}
+exports.PriorityRouter = PriorityRouter;
+//# sourceMappingURL=priority.js.map

package/dist/deploy/hermes.js

@@ -113,32 +113,32 @@ function deployToHermes(options) {
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
     files.push('settings.json');
     // .env template
-    const envContent = `# Hermes Agent Environment
-HERMES_CHARACTER=${oad.metadata.name}
-HERMES_MODEL=${oad.spec.model}
-HERMES_PROVIDER=${oad.spec.provider?.default ?? 'openai'}
-# Add your API keys below:
-# OPENAI_API_KEY=
-# DEEPSEEK_API_KEY=
+    const envContent = `# Hermes Agent Environment
+HERMES_CHARACTER=${oad.metadata.name}
+HERMES_MODEL=${oad.spec.model}
+HERMES_PROVIDER=${oad.spec.provider?.default ?? 'openai'}
+# Add your API keys below:
+# OPENAI_API_KEY=
+# DEEPSEEK_API_KEY=
 `;
     fs.writeFileSync(path.join(outputDir, '.env.hermes'), envContent, 'utf-8');
     files.push('.env.hermes');
     // README
-    const readme = `# ${oad.metadata.name} - Hermes Agent
-
-Converted from OAD format using \`opc deploy --target hermes\`.
-
-## Usage
-
-1. Copy \`character.json\` to your Hermes agents directory
-2. Configure \`.env.hermes\` with your API keys
-3. Start Hermes with this character
-
-## Files
-
-- \`character.json\` - Agent character definition
-- \`settings.json\` - Runtime settings
-- \`.env.hermes\` - Environment template
+    const readme = `# ${oad.metadata.name} - Hermes Agent
+
+Converted from OAD format using \`opc deploy --target hermes\`.
+
+## Usage
+
+1. Copy \`character.json\` to your Hermes agents directory
+2. Configure \`.env.hermes\` with your API keys
+3. Start Hermes with this character
+
+## Files
+
+- \`character.json\` - Agent character definition
+- \`settings.json\` - Runtime settings
+- \`.env.hermes\` - Environment template
 `;
     fs.writeFileSync(path.join(outputDir, 'README.md'), readme, 'utf-8');
     files.push('README.md');

package/dist/deploy/openclaw.js

@@ -41,27 +41,27 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function generateIdentityMd(oad) {
     const m = oad.metadata;
-    return `# IDENTITY.md
-
-- **Name:** ${m.name}
-- **Version:** ${m.version}
-- **Description:** ${m.description ?? 'An AI agent'}
-- **Author:** ${m.author ?? 'Unknown'}
-- **License:** ${m.license}
+    return `# IDENTITY.md
+
+- **Name:** ${m.name}
+- **Version:** ${m.version}
+- **Description:** ${m.description ?? 'An AI agent'}
+- **Author:** ${m.author ?? 'Unknown'}
+- **License:** ${m.license}
 `;
 }
 function generateSoulMd(oad) {
     const prompt = oad.spec.systemPrompt ?? 'You are a helpful AI assistant.';
-    return `# SOUL.md - ${oad.metadata.name}
-
-## System Prompt
-
-${prompt}
-
-## Model Configuration
-
-- **Model:** ${oad.spec.model}
-- **Provider:** ${oad.spec.provider?.default ?? 'deepseek'}
+    return `# SOUL.md - ${oad.metadata.name}
+
+## System Prompt
+
+${prompt}
+
+## Model Configuration
+
+- **Model:** ${oad.spec.model}
+- **Provider:** ${oad.spec.provider?.default ?? 'deepseek'}
 `;
 }
 function generateAgentsMd(oad) {
@@ -100,26 +100,35 @@ function generateAgentsMd(oad) {
         md += `Default memory settings.\n`;
     }
     md += `\n`;
+    // DTV
+    if (dtv) {
+        md += `## Trust & Value\n\n`;
+        md += `- Trust Level: ${dtv.trust?.level ?? 'sandbox'}\n`;
+        if (dtv.value?.metrics?.length) {
+            md += `- Metrics: ${dtv.value.metrics.join(', ')}\n`;
+        }
+        md += `\n`;
+    }
     return md;
 }
 function generateUserMd(oad) {
-    return `# USER.md
-
-- **Name:** (your name)
-- **Role:** User
-- **Notes:** Configure this file with your preferences for ${oad.metadata.name}.
+    return `# USER.md
+
+- **Name:** (your name)
+- **Role:** User
+- **Notes:** Configure this file with your preferences for ${oad.metadata.name}.
 `;
 }
 function generateMemoryMd(oad) {
-    return `# MEMORY.md - ${oad.metadata.name}
-
-## Persistent Knowledge
-
-(Agent will store learned information here)
-
-## User Preferences
-
-(Discovered user preferences will be noted here)
+    return `# MEMORY.md - ${oad.metadata.name}
+
+## Persistent Knowledge
+
+(Agent will store learned information here)
+
+## User Preferences
+
+(Discovered user preferences will be noted here)
 `;
 }
 function generateOpenClawConfig(oad, agentDir) {