fabiana 0.1.0

package/dist/data/providers.js

@@ -0,0 +1,134 @@
+export const providers = [
+    {
+        id: 'openrouter',
+        name: 'OpenRouter',
+        description: 'One API key, 240+ models (easiest starting point)',
+        envVar: 'OPENROUTER_API_KEY',
+        authNote: 'Get one at openrouter.ai/keys',
+        models: [
+            { id: 'anthropic/claude-sonnet-4-5', name: 'Claude Sonnet 4.5' },
+            { id: 'moonshotai/kimi-k2.5', name: 'Kimi K2.5' },
+            { id: 'google/gemini-2.5-flash', name: 'Gemini 2.5 Flash' },
+            { id: 'meta-llama/llama-4-maverick', name: 'Llama 4 Maverick' },
+        ],
+    },
+    {
+        id: 'anthropic',
+        name: 'Anthropic (direct)',
+        description: 'Direct Claude access — usually cheaper and faster than OpenRouter for Claude',
+        envVar: 'ANTHROPIC_API_KEY',
+        authNote: 'Get one at console.anthropic.com',
+        models: [
+            { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6' },
+            { id: 'claude-opus-4-6', name: 'Claude Opus 4.6' },
+            { id: 'claude-haiku-4-5', name: 'Claude Haiku 4.5 (fast & cheap)' },
+        ],
+    },
+    {
+        id: 'openai',
+        name: 'OpenAI (direct)',
+        description: 'Direct GPT and o-series model access',
+        envVar: 'OPENAI_API_KEY',
+        authNote: 'Get one at platform.openai.com/api-keys',
+        models: [
+            { id: 'gpt-4o', name: 'GPT-4o' },
+            { id: 'gpt-4.1', name: 'GPT-4.1' },
+            { id: 'gpt-4o-mini', name: 'GPT-4o Mini (fast & cheap)' },
+        ],
+    },
+    {
+        id: 'google',
+        name: 'Google Gemini (direct)',
+        description: 'Fast and cost-effective, especially Gemini Flash',
+        envVar: 'GEMINI_API_KEY',
+        authNote: 'Get one at aistudio.google.com/apikey',
+        models: [
+            { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash (fast & cheap)' },
+            { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro' },
+            { id: 'gemini-2.0-flash', name: 'Gemini 2.0 Flash' },
+        ],
+    },
+    {
+        id: 'google-gemini-cli',
+        name: 'Google Gemini CLI (OAuth)',
+        description: 'Uses existing Gemini CLI login — no API key needed',
+        envVar: null,
+        authNote: "Run 'gemini' or 'gcloud auth login' first — no API key required",
+        models: [{ id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro' }],
+    },
+    {
+        id: 'google-vertex',
+        name: 'Google Vertex AI',
+        description: 'Enterprise Google Cloud access — requires GCP project with Vertex AI enabled',
+        envVar: 'GOOGLE_CLOUD_PROJECT',
+        authNote: "Run 'gcloud auth application-default login' first",
+        models: [
+            { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro' },
+            { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6 (via Vertex)' },
+        ],
+    },
+    {
+        id: 'amazon-bedrock',
+        name: 'Amazon Bedrock',
+        description: 'AWS-hosted models — Claude, Mistral, Amazon Nova, and more',
+        envVar: 'AWS_ACCESS_KEY_ID',
+        authNote: 'Use AWS_PROFILE, AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY, or IAM roles',
+        models: [
+            { id: 'anthropic.claude-sonnet-4-6', name: 'Claude Sonnet 4.6 (via Bedrock)' },
+            { id: 'amazon.nova-premier-v1:0', name: 'Amazon Nova Premier' },
+        ],
+    },
+    {
+        id: 'mistral',
+        name: 'Mistral (direct)',
+        description: 'Direct Mistral models, including Codestral and Magistral',
+        envVar: 'MISTRAL_API_KEY',
+        authNote: 'Get one at console.mistral.ai',
+        models: [
+            { id: 'magistral-medium-latest', name: 'Magistral Medium' },
+            { id: 'mistral-large-latest', name: 'Mistral Large' },
+        ],
+    },
+    {
+        id: 'groq',
+        name: 'Groq',
+        description: 'Extremely fast inference, often free for common open models',
+        envVar: 'GROQ_API_KEY',
+        authNote: 'Get one at console.groq.com',
+        models: [
+            { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B' },
+            { id: 'moonshotai/kimi-k2-instruct', name: 'Kimi K2 Instruct' },
+            { id: 'qwen-qwq-32b', name: 'Qwen QwQ 32B' },
+        ],
+    },
+    {
+        id: 'xai',
+        name: 'xAI (Grok)',
+        description: 'Grok models with vision capabilities',
+        envVar: 'XAI_API_KEY',
+        authNote: 'Get one at console.x.ai',
+        models: [
+            { id: 'grok-3', name: 'Grok 3' },
+            { id: 'grok-3-fast', name: 'Grok 3 Fast' },
+        ],
+    },
+    {
+        id: 'github-copilot',
+        name: 'GitHub Copilot',
+        description: 'Uses your existing GitHub Copilot subscription — no separate API key',
+        envVar: 'GH_TOKEN',
+        authNote: 'Use GH_TOKEN, GITHUB_TOKEN, or COPILOT_GITHUB_TOKEN',
+        models: [
+            { id: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5' },
+            { id: 'gpt-4o', name: 'GPT-4o' },
+        ],
+    },
+    {
+        id: 'azure-openai-responses',
+        name: 'Azure OpenAI',
+        description: 'OpenAI models deployed on Azure — requires an Azure OpenAI resource',
+        envVar: 'AZURE_OPENAI_API_KEY',
+        authNote: 'Requires an Azure OpenAI resource and deployment',
+        models: [{ id: 'gpt-4o', name: 'GPT-4o (via Azure)' }],
+    },
+];

package/dist/doctor.js

@@ -0,0 +1,323 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { paths, PLUGINS_DIR, DATA_DIR } from './paths.js';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import chalk from 'chalk';
+import { getModel } from '@mariozechner/pi-ai';
+import { AuthStorage, ModelRegistry } from '@mariozechner/pi-coding-agent';
+const execFileAsync = promisify(execFile);
+// ─── Output helpers ───────────────────────────────────────────────────────────
+let totalFails = 0;
+let totalWarns = 0;
+function pass(label, note = '') {
+    const text = note ? `${label} ${chalk.dim(`(${note})`)}` : label;
+    console.log(`  ${chalk.green('✓')} ${text}`);
+}
+function advisory(label, hint = '') {
+    const text = hint ? `${label} ${chalk.dim(`— ${hint}`)}` : label;
+    console.log(`  ${chalk.yellow('⚠')} ${text}`);
+    totalWarns++;
+}
+function error(label, hint = '') {
+    const text = hint ? `${label} ${chalk.dim(`— ${hint}`)}` : label;
+    console.log(`  ${chalk.red('✗')} ${text}`);
+    totalFails++;
+}
+function section(title) {
+    console.log(`\n${chalk.bold(title)}`);
+}
+// ─── Checks ──────────────────────────────────────────────────────────────────
+async function checkEnvironment() {
+    section('Environment');
+    const [major] = process.versions.node.split('.').map(Number);
+    if (major >= 22) {
+        pass(`Node ${process.versions.node}`);
+    }
+    else {
+        error(`Node ${process.versions.node}`, 'requires ≥22');
+    }
+    try {
+        await fs.access(paths.envFile);
+        pass('.env file found');
+    }
+    catch {
+        advisory('.env file not found', 'env vars must be set via export or shell profile');
+    }
+    // Read config to know which env vars are actually required
+    let providerEnvVar = null;
+    let telegramEnabled = true;
+    let slackEnabled = false;
+    try {
+        const raw = await fs.readFile(paths.configJson, 'utf-8');
+        const cfg = JSON.parse(raw);
+        telegramEnabled = cfg.channels?.telegram?.enabled ?? true;
+        slackEnabled = cfg.channels?.slack?.enabled ?? false;
+        // Look up env var for this provider
+        const { providers } = await import('./data/providers.js');
+        const p = providers.find((p) => p.id === cfg.model?.provider);
+        providerEnvVar = p?.envVar ?? null;
+    }
+    catch {
+        // Config not found — fall through, checkConfig() will report it
+    }
+    if (providerEnvVar) {
+        if (process.env[providerEnvVar]) {
+            pass(providerEnvVar);
+        }
+        else {
+            error(providerEnvVar, 'not set');
+        }
+    }
+    if (telegramEnabled) {
+        for (const key of ['TELEGRAM_BOT_TOKEN', 'TELEGRAM_CHAT_ID']) {
+            if (process.env[key]) {
+                pass(key);
+            }
+            else {
+                error(key, 'not set');
+            }
+        }
+    }
+    if (slackEnabled) {
+        if (process.env['SLACK_BOT_TOKEN']) {
+            pass('SLACK_BOT_TOKEN');
+        }
+        else {
+            error('SLACK_BOT_TOKEN', 'not set');
+        }
+    }
+}
+async function checkConfig() {
+    section('Configuration');
+    try {
+        const raw = await fs.readFile(paths.configJson, 'utf-8');
+        const cfg = JSON.parse(raw);
+        pass(paths.configJson, `model: ${cfg.model?.provider}/${cfg.model?.modelId}`);
+    }
+    catch (e) {
+        error(paths.configJson, 'not found — run `fabiana init` to set up');
+    }
+    try {
+        const raw = await fs.readFile(paths.manifestJson, 'utf-8');
+        JSON.parse(raw);
+        pass(paths.manifestJson);
+    }
+    catch (e) {
+        error(paths.manifestJson, e.message);
+    }
+    for (const file of [
+        paths.systemMd(),
+        paths.systemMd('chat'),
+        paths.systemMd('initiative'),
+        paths.systemMd('consolidate'),
+    ]) {
+        try {
+            const stat = await fs.stat(file);
+            pass(path.basename(file), `${stat.size} bytes`);
+        }
+        catch {
+            error(file, 'not found');
+        }
+    }
+}
+async function checkPiSdk() {
+    section('Pi SDK');
+    let modelId = 'unknown';
+    try {
+        const raw = await fs.readFile(paths.configJson, 'utf-8');
+        const cfg = JSON.parse(raw);
+        modelId = `${cfg.model?.provider}/${cfg.model?.modelId}`;
+        const model = getModel(cfg.model?.provider, cfg.model?.modelId);
+        if (!model) {
+            error(`Model not found: ${modelId}`);
+            return;
+        }
+        pass(`Model resolved: ${modelId}`);
+    }
+    catch (e) {
+        error(`Model check failed (${modelId})`, e.message);
+        return;
+    }
+    try {
+        AuthStorage.create();
+        new ModelRegistry(AuthStorage.create());
+        pass('AuthStorage + ModelRegistry initialized');
+    }
+    catch (e) {
+        error('Pi SDK initialization failed', e.message);
+    }
+}
+async function checkTelegram() {
+    section('Telegram');
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    if (!token) {
+        advisory('Skipped', 'TELEGRAM_BOT_TOKEN not set');
+        return;
+    }
+    try {
+        const res = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+        const data = await res.json();
+        if (data.ok) {
+            pass(`Connected as @${data.result.username}`, data.result.first_name);
+        }
+        else {
+            error('Bot API error', data.description ?? 'unknown error');
+        }
+    }
+    catch (e) {
+        error('Telegram unreachable', e.message);
+    }
+}
+async function checkExternalTools() {
+    section('External Tools');
+    try {
+        const { stdout } = await execFileAsync('gccli', ['--version'], { timeout: 5000 });
+        pass(`gccli ${stdout.trim()}`);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            advisory('gccli not installed', 'calendar plugin will not work — npm install -g @mariozechner/gccli');
+        }
+        else {
+            pass('gccli found');
+        }
+    }
+}
+async function checkPlugins() {
+    section('Plugins');
+    const pluginsConfigPath = paths.pluginsJson;
+    let pluginsConfig = {};
+    let hasConfig = false;
+    try {
+        const raw = await fs.readFile(pluginsConfigPath, 'utf-8');
+        pluginsConfig = JSON.parse(raw);
+        hasConfig = true;
+    }
+    catch {
+        // No plugins.json — all plugins enabled by default
+    }
+    try {
+        await fs.access(PLUGINS_DIR);
+    }
+    catch {
+        advisory('No plugins/ directory found');
+        return;
+    }
+    const entries = await fs.readdir(PLUGINS_DIR, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+    if (dirs.length === 0) {
+        advisory('No plugins found');
+        return;
+    }
+    for (const dir of dirs) {
+        const pluginCfg = pluginsConfig[dir];
+        const isEnabled = !hasConfig || (pluginCfg !== undefined && pluginCfg.enabled !== false);
+        const tsPath = path.join(PLUGINS_DIR, dir, 'index.ts');
+        const jsPath = path.join(PLUGINS_DIR, dir, 'index.js');
+        let entryPath = null;
+        for (const p of [tsPath, jsPath]) {
+            try {
+                await fs.access(p);
+                entryPath = p;
+                break;
+            }
+            catch { /* try next */ }
+        }
+        if (!entryPath) {
+            error(dir, 'no index.ts or index.js found');
+            continue;
+        }
+        try {
+            const mod = await import(path.resolve(entryPath));
+            const toolName = mod.tool?.name ?? dir;
+            const version = mod.metadata?.version ? `v${mod.metadata.version}` : '';
+            const label = `${toolName} ${version}`.trim();
+            if (!mod.tool) {
+                error(dir, 'missing `export const tool`');
+                continue;
+            }
+            else if (!mod.tool.execute) {
+                error(dir, 'tool.execute not defined');
+                continue;
+            }
+            else if (!isEnabled) {
+                advisory(label, `disabled in ${chalk.cyan(pluginsConfigPath)}`);
+                continue;
+            }
+            else {
+                pass(label);
+            }
+            // Check env vars declared in plugin.json
+            const manifestPath = path.join(PLUGINS_DIR, dir, 'plugin.json');
+            try {
+                const raw = await fs.readFile(manifestPath, 'utf-8');
+                const manifest = JSON.parse(raw);
+                for (const envVar of (manifest.env ?? [])) {
+                    if (process.env[envVar.key]) {
+                        pass(`  ${envVar.key}`);
+                    }
+                    else if (envVar.required) {
+                        error(`  ${envVar.key}`, envVar.description);
+                    }
+                    else {
+                        advisory(`  ${envVar.key} not set`, envVar.description);
+                    }
+                }
+            }
+            catch {
+                // No plugin.json — skip env checks
+            }
+        }
+        catch (e) {
+            error(dir, e.message);
+        }
+    }
+}
+async function checkDataDirectories() {
+    section('Data Directories');
+    const required = [
+        path.join(DATA_DIR, 'memory'),
+        path.join(DATA_DIR, 'agent-todo', 'pending'),
+        path.join(DATA_DIR, 'agent-todo', 'scheduled'),
+        path.join(DATA_DIR, 'agent-todo', 'completed'),
+        path.join(DATA_DIR, 'logs'),
+    ];
+    for (const dir of required) {
+        try {
+            await fs.access(dir);
+            pass(dir);
+        }
+        catch {
+            advisory(dir, 'missing — will be created on first run');
+        }
+    }
+}
+// ─── Entry point ─────────────────────────────────────────────────────────────
+export async function runDoctor() {
+    console.log(`\n${chalk.magenta('🌸 Fabiana Doctor')}`);
+    console.log(chalk.dim('━'.repeat(50)));
+    await checkEnvironment();
+    await checkConfig();
+    await checkPiSdk();
+    await checkTelegram();
+    await checkExternalTools();
+    await checkPlugins();
+    await checkDataDirectories();
+    console.log(`\n${chalk.dim('━'.repeat(50))}`);
+    if (totalFails > 0) {
+        const errPart = chalk.red(`${totalFails} error(s)`);
+        const warnPart = totalWarns > 0 ? `, ${chalk.yellow(`${totalWarns} warning(s)`)}` : '';
+        console.log(`${chalk.red('✗')} ${errPart}${warnPart} — fix the errors above before starting Fabiana`);
+        process.exit(1);
+    }
+    else if (totalWarns > 0) {
+        console.log(`${chalk.yellow('⚠')} ${chalk.yellow(`${totalWarns} warning(s)`)} — Fabiana will start but some features may not work`);
+        console.log(`\n  ${chalk.bold('Ready to go:')}  fabiana start`);
+    }
+    else {
+        console.log(`${chalk.green('✓')} ${chalk.green('All checks passed')} — Fabiana is ready!`);
+        console.log(`\n  ${chalk.bold('Start her up:')}  ${chalk.cyan('fabiana start')}`);
+    }
+    console.log('');
+}

package/dist/loaders/context.js

@@ -0,0 +1,72 @@
+import fs from 'fs/promises';
+import { paths } from '../paths.js';
+export async function loadContext(mode, incomingMessage, conversationState) {
+    const timestamp = new Date().toISOString();
+    const identity = await readFile(paths.memory('identity.md'), '(No identity file yet)');
+    const core = await readFile(paths.memory('core.md'), '(No core memory yet)');
+    const recentMemory = await readFile(paths.memory('recent', 'this-week.md'), '(No recent memory yet)');
+    return { mode, identity, core, recentMemory, incomingMessage, timestamp, conversationState };
+}
+async function readFile(filePath, fallback) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return fallback;
+    }
+}
+export function buildPrompt(ctx) {
+    const base = `# Session Start — ${ctx.timestamp}
+**Mode**: ${ctx.mode}
+
+---
+
+## 🧠 Memory
+
+### Identity
+${ctx.identity}
+
+### Core State
+${ctx.core}
+
+### Recent (This Week)
+${ctx.recentMemory}`;
+    if (ctx.mode === 'chat' && ctx.incomingMessage) {
+        return `${base}
+
+---
+
+## 💬 Incoming Message
+
+> ${ctx.incomingMessage}`;
+    }
+    if (ctx.mode === 'external-reply' && ctx.conversationState && ctx.incomingMessage) {
+        return `${base}
+
+---
+
+## 🗣️ External Conversation
+
+**ID**: ${ctx.conversationState.id}
+**With**: ${ctx.conversationState.externalDisplayName} (${ctx.conversationState.externalUserId})
+**Purpose**: ${ctx.conversationState.purpose}
+**Channel**: ${ctx.conversationState.channel}
+
+### Incoming Message
+
+> ${ctx.incomingMessage}`;
+    }
+    if (ctx.mode === 'external-outreach' && ctx.conversationState) {
+        return `${base}
+
+---
+
+## 🗣️ External Conversation Context
+
+**ID**: ${ctx.conversationState.id}
+**With**: ${ctx.conversationState.externalDisplayName} (${ctx.conversationState.externalUserId})
+**Purpose**: ${ctx.conversationState.purpose}
+**Channel**: ${ctx.conversationState.channel}`;
+    }
+    return base;
+}

package/dist/loaders/plugins.js

@@ -0,0 +1,102 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { PLUGINS_DIR, paths } from '../paths.js';
+export class PluginLoader {
+    pluginsDir;
+    enabledPlugins = null;
+    constructor(pluginsDir = PLUGINS_DIR) {
+        this.pluginsDir = path.resolve(pluginsDir);
+    }
+    async loadAll() {
+        const tools = [];
+        try {
+            await fs.access(this.pluginsDir);
+        }
+        catch {
+            console.log(`[PLUGINS] No plugins directory found at ${this.pluginsDir}`);
+            return tools;
+        }
+        const entries = await fs.readdir(this.pluginsDir, { withFileTypes: true });
+        const pluginDirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+        if (pluginDirs.length === 0) {
+            console.log('[PLUGINS] No plugins found');
+            return tools;
+        }
+        console.log(`[PLUGINS] Scanning ${pluginDirs.length} plugin(s)...`);
+        for (const dir of pluginDirs) {
+            if (this.enabledPlugins && !this.enabledPlugins.has(dir)) {
+                console.log(`[PLUGINS] ⊘ ${dir} (disabled)`);
+                continue;
+            }
+            try {
+                const tsPath = path.join(this.pluginsDir, dir, 'index.ts');
+                const jsPath = path.join(this.pluginsDir, dir, 'index.js');
+                let pluginPath;
+                try {
+                    await fs.access(tsPath);
+                    pluginPath = tsPath;
+                }
+                catch {
+                    try {
+                        await fs.access(jsPath);
+                        pluginPath = jsPath;
+                    }
+                    catch {
+                        console.log(`[PLUGINS] ⚠️  ${dir} (no index.ts or index.js found)`);
+                        continue;
+                    }
+                }
+                const module = await import(pluginPath);
+                if (!module.tool) {
+                    console.log(`[PLUGINS] ⚠️  ${dir} (no tool export found)`);
+                    continue;
+                }
+                const tool = module.tool;
+                const metadata = module.metadata;
+                if (!tool.name || !tool.description || !tool.execute) {
+                    console.log(`[PLUGINS] ⚠️  ${dir} (invalid tool definition)`);
+                    continue;
+                }
+                tools.push(tool);
+                const version = metadata?.version ? `v${metadata.version}` : '';
+                console.log(`[PLUGINS] ✓ ${tool.name} ${version}`.trim());
+            }
+            catch (err) {
+                console.log(`[PLUGINS] ✗ ${dir} (${err.message})`);
+            }
+        }
+        return tools;
+    }
+    async loadPluginConfig(configPath = paths.pluginsJson) {
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            const enabled = Object.entries(config)
+                .filter(([, pluginCfg]) => pluginCfg.enabled !== false)
+                .map(([name]) => name);
+            this.enabledPlugins = new Set(enabled);
+            console.log(`[PLUGINS] Loaded config: ${enabled.length} enabled`);
+        }
+        catch {
+            // No config file or invalid — load all plugins
+        }
+    }
+}
+export async function loadPlugins(pluginsDir) {
+    const loader = new PluginLoader(pluginsDir);
+    await loader.loadPluginConfig();
+    return loader.loadAll();
+}
+export async function loadPluginsConfig(configPath = paths.pluginsJson) {
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+export async function savePluginsConfig(config, configPath = paths.pluginsJson) {
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
+}

package/dist/paths.js

@@ -0,0 +1,28 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+export const FABIANA_HOME = process.env.FABIANA_HOME ?? join(homedir(), '.fabiana');
+export const CONFIG_DIR = join(FABIANA_HOME, 'config');
+export const DATA_DIR = join(FABIANA_HOME, 'data');
+export const PLUGINS_DIR = join(FABIANA_HOME, 'plugins');
+export const paths = {
+    configJson: join(CONFIG_DIR, 'config.json'),
+    manifestJson: join(CONFIG_DIR, 'manifest.json'),
+    pluginsJson: join(CONFIG_DIR, 'plugins.json'),
+    stateJson: join(CONFIG_DIR, 'state.json'),
+    systemMd: (suffix) => suffix ? join(CONFIG_DIR, `system-${suffix}.md`) : join(CONFIG_DIR, 'system.md'),
+    memory: (...parts) => join(DATA_DIR, 'memory', ...parts),
+    logs: (filename) => join(DATA_DIR, 'logs', filename),
+    sessions: join(DATA_DIR, 'sessions'),
+    agentTodo: join(DATA_DIR, 'agent-todo'),
+    conversations: join(DATA_DIR, 'conversations'),
+    envFile: join(FABIANA_HOME, '.env'),
+};
+// Default plugins bundled with the package.
+// Dev:  src/paths.ts → __dir = src/ → no src/plugins/ → falls back to ../plugins (root)
+// Prod: dist/paths.js → __dir = dist/ → dist/plugins/ exists → uses dist/plugins/
+const __dir = fileURLToPath(new URL('.', import.meta.url));
+const distPlugins = join(__dir, 'plugins');
+const srcPlugins = join(__dir, '..', 'plugins');
+export const BUNDLED_PLUGINS_DIR = existsSync(distPlugins) ? distPlugins : srcPlugins;