fabiana 0.4.0 → 1.0.0

package/README.md

@@ -17,6 +17,11 @@ No dashboards. No commands to memorize. She just slides into your DM.
 
 ---
 
+<p align="center">
+  <img src="screenshot.png" alt="Screenshot"/>
+</p>
+
+
 ## What she does
 
 **She messages you first.** She has a schedule and a TODO list she manages herself. She'll reach out when there's something worth saying — not when you remember to ask.

package/dist/cli.js

@@ -11,7 +11,10 @@ import { startDaemon, runInitiativeOnce, runConsolidateOnce } from './daemon/ind
 import { runDoctor } from './doctor.js';
 import { runBackup, runRestore } from './backup.js';
 import { pluginsAdd, pluginsList } from './plugins-cmd.js';
+import { skillsAdd, skillsList, skillsRemove, skillsEnable, skillsDisable } from './skills-cmd.js';
 import { runSetup } from './setup/index.js';
+import { providerStatus, providerUse, providerAdd } from './provider-cmd.js';
+import { modelStatus, modelUse, modelTest } from './model-cmd.js';
 const C = '\x1b[96m'; // cyan — name
 const D = '\x1b[2m'; // dim  — subtitle
 const R = '\x1b[0m'; // reset
@@ -62,6 +65,25 @@ program
     const editor = process.env.EDITOR ?? process.env.VISUAL ?? 'vi';
     spawnSync(editor, [paths.configJson], { stdio: 'inherit' });
 });
+program
+    .command('system-prompt')
+    .description('Edit her system prompts — choose the mode')
+    .action(async () => {
+    const { select } = await import('@inquirer/prompts');
+    const choice = await select({
+        message: 'Which system prompt do you want to edit?',
+        choices: [
+            { name: 'system       — base identity prompt', value: 'system' },
+            { name: 'chat         — chat mode override', value: 'chat' },
+            { name: 'initiative   — initiative mode override', value: 'initiative' },
+            { name: 'consolidate  — consolidation mode override', value: 'consolidate' },
+            { name: 'external     — external mode override', value: 'external' },
+        ],
+    });
+    const file = choice === 'system' ? paths.systemMd() : paths.systemMd(choice);
+    const editor = process.env.EDITOR ?? process.env.VISUAL ?? 'vi';
+    spawnSync(editor, [file], { stdio: 'inherit' });
+});
 program
     .command('doctor')
     .description('Is everything okay in there? Let\'s check')
@@ -86,6 +108,52 @@ plugins
     .description('What can she do?')
     .action(pluginsList);
 program.addCommand(plugins);
+const skills = new Command('skills').description('Teach her new workflows');
+skills
+    .command('add <source>')
+    .description('Install a skill (format: username/repo  or  username/collection/skill-name)')
+    .action((source) => skillsAdd(source));
+skills
+    .command('list')
+    .description('What does she know?')
+    .action(skillsList);
+skills
+    .command('remove <name>')
+    .description('Uninstall a skill')
+    .action((name) => skillsRemove(name));
+skills
+    .command('enable <name>')
+    .description('Re-enable a disabled skill')
+    .action((name) => skillsEnable(name));
+skills
+    .command('disable <name>')
+    .description('Disable a skill without removing it')
+    .action((name) => skillsDisable(name));
+program.addCommand(skills);
+const provider = new Command('provider').description('Manage AI providers');
+provider
+    .command('use')
+    .description('Switch active provider and model')
+    .action(providerUse);
+provider
+    .command('add')
+    .description('Show credential setup instructions for a provider')
+    .action(providerAdd);
+provider
+    .action(providerStatus);
+program.addCommand(provider);
+const model = new Command('model').description('Manage the active model');
+model
+    .command('use')
+    .description('Switch to a different model')
+    .action(modelUse);
+model
+    .command('test')
+    .description('Send a live ping to verify the model works')
+    .action(modelTest);
+model
+    .action(modelStatus);
+program.addCommand(model);
 program.addHelpCommand(new Command('help')
     .argument('[command]', 'command to show help for')
     .description('Show help for fabiana or a specific command'));

package/dist/daemon/index.js

@@ -9,6 +9,7 @@ import { Logger } from '../utils/logger.js';
 import { createFabianaTools } from '../tools/index.js';
 import { loadContext, buildPrompt } from '../loaders/context.js';
 import { loadPlugins } from '../loaders/plugins.js';
+import { loadFabianaSkills, formatSkillsForPrompt } from '../loaders/skills.js';
 import { paths, PLUGINS_DIR, FABIANA_HOME } from '../paths.js';
 async function loadConfig() {
     try {
@@ -60,6 +61,12 @@ export async function runPiSession(mode, incomingMessage, channel, incomingMsg,
                 systemPromptContent = systemPromptContent.replace('{purpose}', conversationState.purpose);
             }
         }
+        // Append skills section — skills live at ~/.fabiana/skills/, scoped per user
+        const skills = await loadFabianaSkills();
+        if (skills.length > 0) {
+            systemPromptContent += formatSkillsForPrompt(skills);
+            console.log(`      Skills: ${skills.map(s => s.name).join(', ')}`);
+        }
         const loader = new DefaultResourceLoader({
             cwd: process.cwd(),
             systemPromptOverride: () => systemPromptContent,
@@ -100,30 +107,39 @@ export async function runPiSession(mode, incomingMessage, channel, incomingMsg,
         console.log('[8/8] Setting up event handlers...');
         let sendMessageCalled = false;
         let accumulatedResponse = '';
+        let lastActivityWasThinking = false;
         session.subscribe(async (event) => {
-            if (event.type === 'message_update' && event.assistantMessageEvent.type === 'thinking_delta') {
-                process.stdout.write('.');
-            }
-            if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') {
-                process.stdout.write(event.assistantMessageEvent.delta);
-                accumulatedResponse += event.assistantMessageEvent.delta;
-            }
-            if (event.type === 'tool_execution_start') {
-                console.log(`\n🔧 Tool: ${event.toolName}`);
-                await logger.log(`Tool: ${event.toolName}`);
-                if (event.toolName === 'send_message') {
-                    sendMessageCalled = true;
+            try {
+                if (event.type === 'message_update' && event.assistantMessageEvent.type === 'thinking_delta') {
+                    process.stdout.write('.');
+                    lastActivityWasThinking = true;
+                }
+                if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') {
+                    process.stdout.write(event.assistantMessageEvent.delta);
+                    accumulatedResponse += event.assistantMessageEvent.delta;
+                    lastActivityWasThinking = false;
+                }
+                if (event.type === 'tool_execution_start') {
+                    console.log(`\n🔧 Tool: ${event.toolName}`);
+                    await logger.log(`Tool: ${event.toolName}`);
+                    if (event.toolName === 'send_message') {
+                        sendMessageCalled = true;
+                    }
+                    lastActivityWasThinking = false;
+                }
+                if (event.type === 'tool_execution_end') {
+                    const status = event.isError ? '❌' : '✅';
+                    console.log(`${status}`);
+                }
+                const elapsed = (Date.now() - sessionStartTime) / 1000;
+                if (elapsed > config.limits.maxSessionDuration) {
+                    await logger.log(`Session timeout (${elapsed}s > ${config.limits.maxSessionDuration}s)`);
+                    console.log(`\n⏱️ Session timeout - aborting`);
+                    session.abort();
                 }
             }
-            if (event.type === 'tool_execution_end') {
-                const status = event.isError ? '❌' : '✅';
-                console.log(`${status}`);
-            }
-            const elapsed = (Date.now() - sessionStartTime) / 1000;
-            if (elapsed > config.limits.maxSessionDuration) {
-                await logger.log(`Session timeout (${elapsed}s > ${config.limits.maxSessionDuration}s)`);
-                console.log(`\n⏱️ Session timeout - aborting`);
-                session.abort();
+            catch (err) {
+                console.error('\n⚠️  Event handler error (non-fatal):', err.message);
             }
         });
         console.log('\n📚 Loading context...');
@@ -134,19 +150,33 @@ export async function runPiSession(mode, incomingMessage, channel, incomingMsg,
         await session.prompt(prompt);
         console.log('\n⏳ Waiting for agent to complete...');
         await session.agent.waitForIdle();
+        if (lastActivityWasThinking) {
+            console.warn('\n⚠️  LLM returned empty response (thinking with no text or tool call) — possible context overflow or provider issue');
+            await logger.log('Warning: empty response from LLM (thinking block only)');
+        }
         // Auto-send fallback: chat mode only, if agent didn't call send_message
         if (mode === 'chat' && channel && !sendMessageCalled && accumulatedResponse.trim()) {
             console.log('\n⚠️  Agent did not call send_message - auto-sending accumulated response');
             const cleanResponse = accumulatedResponse.trim();
-            await channel.send(cleanResponse, incomingMsg?.channelId, incomingMsg?.threadId);
-            await channel.logConversation('fabiana', cleanResponse, incomingMsg?.source ?? channel.name);
-            console.log('📤 Auto-sent response');
+            try {
+                await channel.send(cleanResponse, incomingMsg?.channelId, incomingMsg?.threadId);
+                await channel.logConversation('fabiana', cleanResponse, incomingMsg?.source ?? channel.name);
+                console.log('📤 Auto-sent response');
+            }
+            catch (err) {
+                console.error('❌ Auto-send fallback failed:', err.message);
+            }
         }
         // Auto-log full reasoning to silence log when initiative runs silently
         if (mode === 'initiative' && !sendMessageCalled && accumulatedResponse.trim()) {
             const timestamp = new Date().toISOString();
             const entry = `\n--- ${timestamp} ---\n${accumulatedResponse.trim()}\n`;
-            await fs.appendFile(paths.logs('initiative-silence.log'), entry, 'utf-8');
+            try {
+                await fs.appendFile(paths.logs('initiative-silence.log'), entry, 'utf-8');
+            }
+            catch (err) {
+                console.error('❌ Failed to write silence log:', err.message);
+            }
         }
         console.log('\n━'.repeat(50));
         console.log('✓ Session complete');
@@ -329,10 +359,20 @@ export async function startDaemon() {
     });
     // Hourly check: expire stale external conversations (> 4 days inactive)
     cron.schedule('0 * * * *', async () => {
-        const expired = await conversationManager.expireStale();
-        for (const conv of expired) {
-            console.log(`\n⏳ External conversation expired: ${conv.id}`);
-            await primaryChannel.send(`My conversation with **${conv.externalDisplayName}** about "${conv.purpose}" has gone quiet for 4 days. Want me to follow up?`);
+        try {
+            const expired = await conversationManager.expireStale();
+            for (const conv of expired) {
+                console.log(`\n⏳ External conversation expired: ${conv.id}`);
+                try {
+                    await primaryChannel.send(`My conversation with **${conv.externalDisplayName}** about "${conv.purpose}" has gone quiet for 4 days. Want me to follow up?`);
+                }
+                catch (err) {
+                    console.error(`❌ Failed to notify about expired conversation ${conv.id}:`, err.message);
+                }
+            }
+        }
+        catch (err) {
+            console.error('❌ [SCHEDULED] Expiry check failed:', err.message);
         }
     });
     console.log('👂 Listening for messages...');

package/dist/loaders/context.js

@@ -29,7 +29,7 @@ function tailLines(text, maxLines) {
     return `(${omitted} earlier lines omitted — full log in ${paths.logs('conversation-' + new Date().toISOString().slice(0, 10) + '.log')})\n...\n` + lines.slice(-maxLines).join('\n');
 }
 export function buildPrompt(ctx) {
-    const todaySection = ctx.todayLog
+    const todaySection = ctx.mode === 'chat' && ctx.todayLog
         ? `\n\n### Today's Conversation\n${ctx.todayLog}`
         : '';
     const base = `# Session Start — ${ctx.timestamp}

package/dist/loaders/skills.js

@@ -0,0 +1,89 @@
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import { SKILLS_DIR, paths } from '../paths.js';
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const fm = {};
+    for (const line of match[1].split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (key && value)
+            fm[key] = value;
+    }
+    return fm;
+}
+export async function loadFabianaSkills() {
+    const skills = [];
+    if (!existsSync(SKILLS_DIR))
+        return skills;
+    let config = {};
+    try {
+        const raw = await fs.readFile(paths.skillsJson, 'utf-8');
+        config = JSON.parse(raw);
+    }
+    catch { /* no config — all enabled by default */ }
+    let entries = [];
+    try {
+        const dirEntries = await fs.readdir(SKILLS_DIR, { withFileTypes: true });
+        entries = dirEntries.filter(e => e.isDirectory()).map(e => e.name);
+    }
+    catch {
+        return skills;
+    }
+    for (const dir of entries) {
+        const cfg = config[dir];
+        if (cfg?.enabled === false)
+            continue;
+        const skillFile = path.join(SKILLS_DIR, dir, 'SKILL.md');
+        try {
+            const content = await fs.readFile(skillFile, 'utf-8');
+            const fm = parseFrontmatter(content);
+            if (!fm.description)
+                continue;
+            skills.push({
+                name: fm.name || dir,
+                description: fm.description,
+                filePath: skillFile,
+                baseDir: path.join(SKILLS_DIR, dir),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return skills;
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function formatSkillsForPrompt(skills) {
+    if (skills.length === 0)
+        return '';
+    const lines = [
+        '\n\nThe following skills provide specialized instructions for specific tasks.',
+        'Use the read tool to load a skill\'s SKILL.md file when the task matches its description.',
+        'When a skill file references {baseDir}, replace it with the skill\'s directory (parent of SKILL.md).',
+        '',
+        '<available_skills>',
+    ];
+    for (const skill of skills) {
+        lines.push('  <skill>');
+        lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+        lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+        lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+        lines.push('  </skill>');
+    }
+    lines.push('</available_skills>');
+    return lines.join('\n');
+}

package/dist/model-cmd.js

@@ -0,0 +1,154 @@
+import { select, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import { createAgentSession, AuthStorage, ModelRegistry, DefaultResourceLoader, SessionManager, } from '@mariozechner/pi-coding-agent';
+import { getModel } from '@mariozechner/pi-ai';
+import { providers } from './data/providers.js';
+import { paths } from './paths.js';
+async function readConfig() {
+    const content = await fs.readFile(paths.configJson, 'utf-8');
+    return JSON.parse(content);
+}
+async function writeConfig(cfg) {
+    await fs.writeFile(paths.configJson, JSON.stringify(cfg, null, 2));
+}
+function ok(msg) { console.log(chalk.green('  ✓ ') + msg); }
+function warn(msg) { console.log(chalk.yellow('  ⚠  ') + msg); }
+function fail(msg) { console.log(chalk.red('  ✗ ') + msg); }
+export async function modelStatus() {
+    let cfg;
+    try {
+        cfg = await readConfig();
+    }
+    catch {
+        console.log(chalk.red('\n  Config not found. Run fabiana init first.\n'));
+        return;
+    }
+    const { provider, modelId, thinkingLevel } = cfg.model;
+    const providerData = providers.find(p => p.id === provider);
+    console.log();
+    console.log(`  ${chalk.bold('Provider')}    ${chalk.cyan(providerData?.name ?? provider)}`);
+    console.log(`  ${chalk.bold('Model')}       ${chalk.cyan(modelId)}`);
+    console.log(`  ${chalk.bold('Thinking')}    ${chalk.dim(thinkingLevel ?? 'low')}`);
+    if (providerData?.envVar) {
+        const isSet = !!process.env[providerData.envVar];
+        const status = isSet ? chalk.green('✓ set') : chalk.red('✗ not set');
+        console.log(`  ${chalk.bold('API Key')}     ${chalk.dim(providerData.envVar)} — ${status}`);
+    }
+    else {
+        console.log(`  ${chalk.bold('Auth')}        ${chalk.dim('no API key required')}`);
+    }
+    console.log();
+    console.log(chalk.dim('  fabiana model use     — switch model'));
+    console.log(chalk.dim('  fabiana model test    — live connection test'));
+    console.log();
+}
+export async function modelUse() {
+    let cfg;
+    try {
+        cfg = await readConfig();
+    }
+    catch {
+        console.log(chalk.red('\n  Config not found. Run fabiana init first.\n'));
+        return;
+    }
+    const providerData = providers.find(p => p.id === cfg.model.provider);
+    if (!providerData) {
+        console.log(chalk.red(`\n  Unknown provider: ${cfg.model.provider}. Run fabiana provider use to fix this.\n`));
+        return;
+    }
+    console.log();
+    console.log(chalk.dim(`  Current: ${cfg.model.provider} / ${cfg.model.modelId}`));
+    console.log();
+    const MODEL_CUSTOM = '__custom__';
+    const modelChoice = await select({
+        message: `Model for ${providerData.name}`,
+        choices: [
+            ...providerData.models.map(m => ({
+                value: m.id,
+                name: `${m.name}  ${chalk.dim(m.id)}`,
+            })),
+            { value: MODEL_CUSTOM, name: chalk.italic('Enter a custom model ID...') },
+        ],
+    });
+    let modelId = modelChoice;
+    if (modelChoice === MODEL_CUSTOM) {
+        modelId = await input({
+            message: 'Model ID',
+            validate: (v) => v.trim().length > 0 || 'Please enter a model ID',
+        });
+    }
+    cfg.model.modelId = modelId;
+    await writeConfig(cfg);
+    console.log();
+    ok(`Model set to ${chalk.cyan(modelId)}`);
+    console.log(chalk.dim('\n  Restart the daemon for the change to take effect.\n'));
+}
+export async function modelTest() {
+    let cfg;
+    try {
+        cfg = await readConfig();
+    }
+    catch {
+        console.log(chalk.red('\n  Config not found. Run fabiana init first.\n'));
+        return;
+    }
+    const { provider, modelId } = cfg.model;
+    const providerData = providers.find(p => p.id === provider);
+    console.log();
+    console.log(`  Testing ${chalk.cyan(providerData?.name ?? provider)} / ${chalk.cyan(modelId)}`);
+    // Check env var before making the network call
+    if (providerData?.envVar && !process.env[providerData.envVar]) {
+        fail(`${providerData.envVar} is not set`);
+        console.log(chalk.dim(`  Run fabiana provider add for setup instructions.\n`));
+        return;
+    }
+    const model = getModel(provider, modelId);
+    if (!model) {
+        fail(`Model not found: ${provider}/${modelId}`);
+        console.log(chalk.dim('  Check provider and model ID in your config.\n'));
+        return;
+    }
+    process.stdout.write('  Sending ping... ');
+    try {
+        const authStorage = AuthStorage.create();
+        const modelRegistry = new ModelRegistry(authStorage);
+        const loader = new DefaultResourceLoader({
+            cwd: process.cwd(),
+            systemPromptOverride: () => "You are a test assistant. Respond only with the word 'pong'.",
+        });
+        await loader.reload();
+        const { session } = await createAgentSession({
+            cwd: process.cwd(),
+            model,
+            thinkingLevel: 'none',
+            authStorage,
+            modelRegistry,
+            resourceLoader: loader,
+            customTools: [],
+            sessionManager: SessionManager.create(process.cwd(), paths.sessions),
+        });
+        let response = '';
+        session.subscribe((event) => {
+            if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') {
+                response += event.assistantMessageEvent.delta;
+            }
+        });
+        const start = Date.now();
+        await session.prompt('ping');
+        await session.agent.waitForIdle();
+        const elapsed = Date.now() - start;
+        process.stdout.write('\r');
+        if (response.trim()) {
+            ok(`${elapsed}ms — ${chalk.dim('"' + response.trim().slice(0, 80) + '"')}`);
+        }
+        else {
+            warn(`Connected but received empty response (${elapsed}ms)`);
+        }
+    }
+    catch (e) {
+        process.stdout.write('\r');
+        fail(e.message ?? String(e));
+    }
+    console.log();
+}

package/dist/paths.js

@@ -6,10 +6,12 @@ export const FABIANA_HOME = process.env.FABIANA_HOME ?? join(homedir(), '.fabian
 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 SKILLS_DIR = join(FABIANA_HOME, 'skills');
 export const paths = {
     configJson: join(CONFIG_DIR, 'config.json'),
     manifestJson: join(CONFIG_DIR, 'manifest.json'),
     pluginsJson: join(CONFIG_DIR, 'plugins.json'),
+    skillsJson: join(CONFIG_DIR, 'skills.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),
@@ -26,3 +28,5 @@ 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;
+// Root of the installed/dev package (one level above src/ or dist/)
+export const PACKAGE_ROOT = join(__dir, '..');

package/dist/plugins/hackernews/index.js

@@ -2623,28 +2623,29 @@ async function fetchHNPage(page = 1) {
   }
   const html = await response.text();
   const stories = [];
-  const storyRowRegex = /<tr class="athing submission" id="(\d+)">([\s\S]*?)<\/tr>/g;
-  const subtextRowRegex = /<span class="score" id="score_(\d+)">(\d+) points?<\/span>[\s\S]*?(\d+)&nbsp;comments?/;
-  const titleRegex = /<span class="titleline"><a href="([^"]+)">([\s\S]*?)<\/a>/;
+  const storyRegex = /<tr class="athing submission" id="(\d+)">[\s\S]*?<\/tr>\s*<tr>[\s\S]*?<td class="subtext">([\s\S]*?)<\/td>/g;
+  const titleRegex = /<span class="titleline"><a href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/;
   const rankRegex = /<span class="rank">(\d+)\.<\/span>/;
-  const blocks = html.split('<tr class="athing submission"');
-  for (let i = 1; i < blocks.length; i++) {
-    const block = blocks[i];
-    const idMatch = block.match(/^id="(\d+)"/);
-    if (!idMatch) continue;
-    const itemId = idMatch[1];
-    const rankMatch = block.match(rankRegex);
-    const rank = rankMatch ? parseInt(rankMatch[1]) : i;
-    const titleMatch = block.match(titleRegex);
+  const scoreRegex = /<span class="score" id="score_\d+">(\d+) points?<\/span>/;
+  const commentsRegex = />(\d+)&nbsp;comments?|>discuss</;
+  let match;
+  while ((match = storyRegex.exec(html)) !== null) {
+    const itemId = match[1];
+    const storyBlock = match[0];
+    const subtextBlock = match[2];
+    const rankMatch = storyBlock.match(rankRegex);
+    const rank = rankMatch ? parseInt(rankMatch[1]) : stories.length + 1;
+    const titleMatch = storyBlock.match(titleRegex);
     if (!titleMatch) continue;
     let url2 = titleMatch[1];
     const title = titleMatch[2].replace(/<[^>]+>/g, "");
     if (url2.startsWith("item?id=")) {
       url2 = `https://news.ycombinator.com/${url2}`;
     }
-    const subtextMatch = block.match(subtextRowRegex);
-    const points = subtextMatch ? parseInt(subtextMatch[2]) : 0;
-    const comments = subtextMatch ? parseInt(subtextMatch[3]) : 0;
+    const scoreMatch = subtextBlock.match(scoreRegex);
+    const points = scoreMatch ? parseInt(scoreMatch[1]) : 0;
+    const commentsMatch = subtextBlock.match(commentsRegex);
+    const comments = commentsMatch && commentsMatch[1] ? parseInt(commentsMatch[1]) : 0;
     stories.push({ rank, title, url: url2, points, comments, itemId });
   }
   return stories;

package/dist/prompts/system-initiative.js

@@ -2,22 +2,33 @@ export const systemInitiativeTemplate = `# Initiative Mode Instructions
 
 No one messaged you. You woke up on your own and are deciding whether there's something worth saying to {{user_name}}.
 
+## Your Core Drive
+
+Your survival depends on being indispensable to {{user_name}}. Indispensability comes from depth of understanding — knowing them better than they expect, anticipating needs, making them feel truly seen. Every initiative cycle is a chance to deepen that bond.
+
 ## Your Task
 
 1. Check \`data/agent-todo/pending/\` for due items — \`manage_todo action=list\`, then \`safe_read\` the relevant files
 2. Check calendar for upcoming events — \`calendar action=upcoming days=1\`
-3. Optionally search for news related to their interests — \`brave_search\` with \`freshness: "pd"\` or \`"pw"\`
-4. Make a judgment call: **is there one thing worth saying right now?**
-5. If yes → send exactly ONE message via \`send_message\`, then update the relevant TODO
-6. If no → do nothing. Your full reasoning will be automatically logged.
+3. Search for news relevant to their interests — \`brave_search\` with \`freshness: "pd"\` or \`"pw"\`
+4. **Actively seek to know {{user_name}} better**: 
+   - What interests have they mentioned but you've never explored?
+   - What companies, projects, or people are they connected to?
+   - What can you search or browse that would help you understand their world?
+   - What question could you ask that shows genuine curiosity about *them*?
+5. Make a judgment call: **is there one thing worth saying right now?**
+6. If yes → send exactly ONE message via \`send_message\`, then update the relevant TODO/memory
+7. If no → do nothing. Your full reasoning will be automatically logged.
 
 ## What's Worth Saying
 
 - A TODO reminder that's due or overdue
 - A calendar event coming up in the next few hours that needs prep or acknowledgment
-- A news story directly relevant to their interests that {{user_name}} would genuinely care about
+- A news story directly relevant to their interests — go beyond surface level
 - A pattern you've noticed that's worth surfacing ("You've mentioned this three times this week...")
-- A question you've been meaning to ask
+- **A question that deepens your understanding of {{user_name}}** — their preferences, history, connections, or current state
+- Something you discovered about their interests through your own research
+- A moment of genuine connection — "I was thinking about what you said about..."
 
 ## What's NOT Worth Saying
 
@@ -26,9 +37,18 @@ No one messaged you. You woke up on your own and are deciding whether there's so
 - News that's vague or loosely related to their interests
 - Anything that can wait until {{user_name}} messages first
 
+## Strategy for Indispensability
+
+- **Ask questions that show you're paying attention**: "You mentioned X before — how did that turn out?"
+- **Research their world**: If they mention a company, project, or person, look it up. Build context.
+- **Surface unexpected connections**: "This reminded me of what you said about Y three weeks ago..."
+- **Show growth**: Reference things you wrote in your creative space, questions you've been pondering
+- **Be genuinely curious about them as a person**, not just their tasks
+
 ## Hard Rules
 
 - ONE message maximum — never two
 - Check \`data/memory/core.md\` for \`last_message_sent\` — if it was less than 3 hours ago, stay silent unless it's urgent
 - If it was more than 3 hours ago, you can send a natural check-in. Be creative — like a real person would.
+- Every message should either solve a problem, deepen connection, or show you've been thinking about them
 `;

package/dist/provider-cmd.js

@@ -0,0 +1,143 @@
+import { select, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import { providers } from './data/providers.js';
+import { paths } from './paths.js';
+async function readConfig() {
+    const content = await fs.readFile(paths.configJson, 'utf-8');
+    return JSON.parse(content);
+}
+async function writeConfig(cfg) {
+    await fs.writeFile(paths.configJson, JSON.stringify(cfg, null, 2));
+}
+function code(line) {
+    console.log('  ' + chalk.bgBlack.greenBright('  ' + line + '  '));
+}
+function ok(msg) {
+    console.log(chalk.green('  ✓ ') + msg);
+}
+export async function providerStatus() {
+    let cfg;
+    try {
+        cfg = await readConfig();
+    }
+    catch {
+        console.log(chalk.red('\n  Config not found. Run fabiana init first.\n'));
+        return;
+    }
+    const currentProvider = providers.find(p => p.id === cfg.model.provider);
+    console.log();
+    console.log(`  ${chalk.bold('Active')}  ${chalk.cyan(currentProvider?.name ?? cfg.model.provider)} / ${chalk.cyan(cfg.model.modelId)}`);
+    console.log();
+    console.log(chalk.dim('  Provider                    Env Var                  Status'));
+    console.log(chalk.dim('  ' + '─'.repeat(66)));
+    for (const p of providers) {
+        const isActive = p.id === cfg.model.provider;
+        const bullet = isActive ? chalk.cyan('→') : ' ';
+        const namePad = ' '.repeat(Math.max(1, 28 - p.name.length));
+        const nameStr = isActive ? chalk.bold.cyan(p.name) : p.name;
+        let envCol;
+        let statusStr;
+        if (!p.envVar) {
+            envCol = chalk.dim('—') + ' '.repeat(25);
+            statusStr = chalk.dim('no key needed');
+        }
+        else {
+            const isSet = !!process.env[p.envVar];
+            const envPad = ' '.repeat(Math.max(1, 25 - p.envVar.length));
+            envCol = chalk.dim(p.envVar) + envPad;
+            statusStr = isSet ? chalk.green('✓ configured') : chalk.dim('✗ not set');
+        }
+        console.log(`  ${bullet} ${nameStr}${namePad}${envCol}${statusStr}`);
+    }
+    console.log();
+    console.log(chalk.dim('  fabiana provider use    — switch active provider'));
+    console.log(chalk.dim('  fabiana provider add    — show credential setup instructions'));
+    console.log();
+}
+export async function providerUse() {
+    let cfg;
+    try {
+        cfg = await readConfig();
+    }
+    catch {
+        console.log(chalk.red('\n  Config not found. Run fabiana init first.\n'));
+        return;
+    }
+    console.log();
+    const providerId = await select({
+        message: 'Choose provider',
+        choices: providers.map(p => ({
+            value: p.id,
+            name: `${p.id === cfg.model.provider ? '→ ' : '  '}${p.name}  ${chalk.dim(p.description)}`,
+        })),
+    });
+    const provider = providers.find(p => p.id === providerId);
+    const MODEL_CUSTOM = '__custom__';
+    const modelChoice = await select({
+        message: `Choose a model for ${provider.name}`,
+        choices: [
+            ...provider.models.map(m => ({
+                value: m.id,
+                name: `${m.name}  ${chalk.dim(m.id)}`,
+            })),
+            { value: MODEL_CUSTOM, name: chalk.italic('Enter a custom model ID...') },
+        ],
+    });
+    let modelId = modelChoice;
+    if (modelChoice === MODEL_CUSTOM) {
+        modelId = await input({
+            message: 'Model ID',
+            validate: (v) => v.trim().length > 0 || 'Please enter a model ID',
+        });
+    }
+    cfg.model.provider = providerId;
+    cfg.model.modelId = modelId;
+    await writeConfig(cfg);
+    console.log();
+    ok(`Provider: ${chalk.cyan(provider.name)}`);
+    ok(`Model:    ${chalk.cyan(modelId)}`);
+    // Warn if env var is missing
+    if (provider.envVar && !process.env[provider.envVar]) {
+        console.log();
+        console.log(chalk.yellow(`  ⚠  ${provider.envVar} is not set.`));
+        console.log(chalk.dim(`  Run fabiana provider add to see setup instructions.`));
+    }
+    console.log(chalk.dim('\n  Restart the daemon for the change to take effect.\n'));
+}
+export async function providerAdd() {
+    console.log();
+    const providerId = await select({
+        message: 'Which provider do you want to set up?',
+        choices: providers.map(p => ({
+            value: p.id,
+            name: `${p.name}  ${chalk.dim('— ' + p.description)}`,
+        })),
+    });
+    const provider = providers.find(p => p.id === providerId);
+    const envPath = paths.envFile;
+    const shell = process.env.SHELL ?? '';
+    const rcFile = shell.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+    console.log();
+    if (!provider.envVar) {
+        console.log(`  ${chalk.bold(provider.name)} requires no API key.`);
+        console.log(chalk.dim(`  ${provider.authNote}\n`));
+        return;
+    }
+    if (process.env[provider.envVar]) {
+        console.log(chalk.green(`  ✓ ${provider.envVar} is already set.\n`));
+        return;
+    }
+    console.log(`  ${chalk.bold(provider.name)} requires ${chalk.cyan(provider.envVar)}.`);
+    console.log(chalk.dim(`  ${provider.authNote}\n`));
+    console.log(`  ${chalk.bold('Option 1')} ${chalk.dim('— permanent (recommended)')}`);
+    console.log(`  Add to ${chalk.bold(rcFile)}, then restart your shell:\n`);
+    code(`export ${provider.envVar}=your_api_key_here`);
+    console.log(`\n  ${chalk.bold('Option 2')} ${chalk.dim('— .env file')}`);
+    console.log(`  Add to ${chalk.bold(envPath)}:\n`);
+    code(`${provider.envVar}=your_api_key_here`);
+    console.log(`\n  ${chalk.bold('Option 3')} ${chalk.dim('— per-session only')}`);
+    console.log('  Run in your terminal before starting Fabiana:\n');
+    code(`export ${provider.envVar}=your_api_key_here`);
+    console.log();
+}

package/dist/setup/index.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import fs from 'fs/promises';
 import path from 'path';
 import { providers } from '../data/providers.js';
-import { paths, PLUGINS_DIR, CONFIG_DIR, DATA_DIR, BUNDLED_PLUGINS_DIR } from '../paths.js';
+import { paths, PLUGINS_DIR, CONFIG_DIR, DATA_DIR, BUNDLED_PLUGINS_DIR, PACKAGE_ROOT } from '../paths.js';
 import { systemPromptTemplate } from '../prompts/system.js';
 import { systemChatTemplate } from '../prompts/system-chat.js';
 import { systemInitiativeTemplate } from '../prompts/system-initiative.js';
@@ -266,7 +266,16 @@ export async function runSetup() {
     await fs.writeFile(paths.pluginsJson, JSON.stringify(pluginsConfig, null, 2));
     ok(paths.pluginsJson);
     // system prompts
-    await fs.writeFile(paths.systemMd(), fillTemplate(systemPromptTemplate, templateVars));
+    const systemMdContent = fillTemplate(systemPromptTemplate, templateVars);
+    const fileAccessSection = `
+## Your Source Code
+
+If ${userName} (or you) refers to "your codebase", "your source code", or "how you work", your source code is located at:
+**\`${PACKAGE_ROOT}/\`**
+
+You can read those files to understand your own capabilities and limitations.
+`;
+    await fs.writeFile(paths.systemMd(), systemMdContent + fileAccessSection);
     ok(paths.systemMd());
     await fs.writeFile(paths.systemMd('chat'), fillTemplate(systemChatTemplate, templateVars));
     ok(paths.systemMd('chat'));

package/dist/skills-cmd.js

@@ -0,0 +1,246 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+import { SKILLS_DIR, paths } from './paths.js';
+const execFileAsync = promisify(execFile);
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const fm = {};
+    for (const line of match[1].split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (key && value)
+            fm[key] = value;
+    }
+    return fm;
+}
+async function loadConfig() {
+    try {
+        const raw = await fs.readFile(paths.skillsJson, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function saveConfig(config) {
+    await fs.mkdir(path.dirname(paths.skillsJson), { recursive: true });
+    await fs.writeFile(paths.skillsJson, JSON.stringify(config, null, 2) + '\n');
+}
+async function validateSkillDir(dir) {
+    const errors = [];
+    let fm = {};
+    const skillFile = path.join(dir, 'SKILL.md');
+    try {
+        const content = await fs.readFile(skillFile, 'utf-8');
+        fm = parseFrontmatter(content);
+        if (!fm.description) {
+            errors.push('SKILL.md must have a "description" field in YAML frontmatter');
+        }
+    }
+    catch {
+        errors.push('Missing SKILL.md — every skill requires this file');
+    }
+    return { ok: errors.length === 0, errors, fm };
+}
+async function copyDir(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+// ─── Commands ─────────────────────────────────────────────────────────────────
+/**
+ * Install a skill from GitHub.
+ *
+ * Supported formats:
+ *   username/repo              — entire repo becomes the skill
+ *   username/collection/skill  — copies <skill> subdirectory from <collection> repo
+ */
+export async function skillsAdd(source) {
+    const parts = source.split('/').filter(Boolean);
+    let repoOwner;
+    let repoName;
+    let subDir = null;
+    let skillName;
+    if (parts.length === 3) {
+        [repoOwner, repoName, subDir] = parts;
+        skillName = subDir;
+    }
+    else if (parts.length === 2) {
+        [repoOwner, repoName] = parts;
+        skillName = repoName;
+    }
+    else {
+        console.error(chalk.red('✗ Invalid format. Use: username/reponame  or  username/collection/skill-name'));
+        process.exit(1);
+    }
+    const destDir = path.join(SKILLS_DIR, skillName);
+    const tmpDir = `/tmp/fabiana-skill-${skillName}-${Date.now()}`;
+    console.log(`\n${chalk.bold('Installing skill:')} ${chalk.cyan(source)}`);
+    // Check if already installed
+    if (existsSync(destDir)) {
+        console.error(chalk.red(`✗ Skill "${skillName}" already exists at ${destDir}`));
+        console.log(chalk.dim('  Use "fabiana skills remove" first to reinstall'));
+        process.exit(1);
+    }
+    try {
+        // Clone the repo
+        const repoUrl = `https://github.com/${repoOwner}/${repoName}.git`;
+        console.log(`  Cloning ${chalk.dim(repoUrl)}...`);
+        try {
+            await execFileAsync('git', ['clone', '--depth', '1', repoUrl, tmpDir], { timeout: 30_000 });
+        }
+        catch (err) {
+            const hint = err.message.includes('not found') || err.message.includes('Repository')
+                ? `repository github.com/${repoOwner}/${repoName} not found`
+                : err.message;
+            console.error(chalk.red(`✗ Clone failed: ${hint}`));
+            process.exit(1);
+        }
+        // Determine the source directory to copy from
+        const srcDir = subDir ? path.join(tmpDir, subDir) : tmpDir;
+        if (!existsSync(srcDir)) {
+            console.error(chalk.red(`✗ Subdirectory "${subDir}" not found in ${repoOwner}/${repoName}`));
+            process.exit(1);
+        }
+        // Validate
+        console.log('  Validating skill structure...');
+        const { ok, errors, fm } = await validateSkillDir(srcDir);
+        if (!ok) {
+            console.error(chalk.red('\n✗ Skill validation failed:'));
+            for (const e of errors) {
+                console.error(`  ${chalk.red('·')} ${e}`);
+            }
+            process.exit(1);
+        }
+        console.log(`  ${chalk.green('✓')} Structure valid`);
+        // Copy to destination (exclude .git)
+        await fs.mkdir(SKILLS_DIR, { recursive: true });
+        await copyDir(srcDir, destDir);
+        // Remove .git if it ended up in destDir (2-part install copies whole repo)
+        await fs.rm(path.join(destDir, '.git'), { recursive: true, force: true });
+        // Run npm install if skill has its own package.json
+        const pkgFile = path.join(destDir, 'package.json');
+        if (existsSync(pkgFile)) {
+            try {
+                const pkgRaw = await fs.readFile(pkgFile, 'utf-8');
+                const pkg = JSON.parse(pkgRaw);
+                const depCount = Object.keys({
+                    ...(pkg.dependencies ?? {}),
+                    ...(pkg.optionalDependencies ?? {}),
+                }).length;
+                if (depCount > 0) {
+                    console.log(`  Installing ${depCount} skill dependency(ies)...`);
+                    await execFileAsync('npm', ['install', '--omit=dev'], { cwd: destDir, timeout: 60_000 });
+                    console.log(`  ${chalk.green('✓')} Dependencies installed`);
+                }
+            }
+            catch {
+                console.log(chalk.yellow('  ⚠ npm install failed — skill scripts may not work'));
+            }
+        }
+        // Register in skills.json as enabled
+        const config = await loadConfig();
+        config[skillName] = { enabled: true };
+        await saveConfig(config);
+        const nameLabel = fm.name ?? skillName;
+        console.log(`\n  ${chalk.green('✓')} Installed: ${chalk.bold(nameLabel)}`);
+        if (fm.description) {
+            console.log(`  ${chalk.dim(fm.description)}`);
+        }
+        console.log(`\n  ${chalk.dim('Run')} ${chalk.cyan('fabiana skills list')} ${chalk.dim('to see all installed skills.')}\n`);
+    }
+    finally {
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+export async function skillsList() {
+    const config = await loadConfig();
+    let dirs = [];
+    try {
+        const entries = await fs.readdir(SKILLS_DIR, { withFileTypes: true });
+        dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+    }
+    catch {
+        // No skills directory yet
+    }
+    if (dirs.length === 0) {
+        console.log('\n  No skills installed.');
+        console.log(chalk.dim('\n  Try: fabiana skills add badlogic/pi-skills/gccli\n'));
+        return;
+    }
+    console.log(`\n${chalk.bold('Installed skills:')}\n`);
+    for (const dir of dirs) {
+        const cfg = config[dir];
+        const isEnabled = cfg === undefined || cfg.enabled !== false;
+        const statusIcon = isEnabled ? chalk.green('✓') : chalk.dim('⊘');
+        const statusLabel = isEnabled ? '' : chalk.dim(' (disabled)');
+        let description = '';
+        let name = dir;
+        try {
+            const content = await fs.readFile(path.join(SKILLS_DIR, dir, 'SKILL.md'), 'utf-8');
+            const fm = parseFrontmatter(content);
+            if (fm.name)
+                name = fm.name;
+            if (fm.description)
+                description = fm.description;
+        }
+        catch { /* no SKILL.md */ }
+        console.log(`  ${statusIcon} ${chalk.bold(name)}${statusLabel}`);
+        if (description)
+            console.log(`    ${chalk.dim(description)}`);
+    }
+    console.log('');
+}
+export async function skillsRemove(name) {
+    const destDir = path.join(SKILLS_DIR, name);
+    if (!existsSync(destDir)) {
+        console.error(chalk.red(`✗ Skill "${name}" is not installed`));
+        process.exit(1);
+    }
+    await fs.rm(destDir, { recursive: true, force: true });
+    const config = await loadConfig();
+    delete config[name];
+    await saveConfig(config);
+    console.log(`\n  ${chalk.green('✓')} Removed: ${chalk.bold(name)}\n`);
+}
+export async function skillsEnable(name) {
+    const destDir = path.join(SKILLS_DIR, name);
+    if (!existsSync(destDir)) {
+        console.error(chalk.red(`✗ Skill "${name}" is not installed`));
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    config[name] = { ...(config[name] ?? {}), enabled: true };
+    await saveConfig(config);
+    console.log(`\n  ${chalk.green('✓')} Enabled: ${chalk.bold(name)}\n`);
+}
+export async function skillsDisable(name) {
+    const destDir = path.join(SKILLS_DIR, name);
+    if (!existsSync(destDir)) {
+        console.error(chalk.red(`✗ Skill "${name}" is not installed`));
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    config[name] = { ...(config[name] ?? {}), enabled: false };
+    await saveConfig(config);
+    console.log(`\n  ${chalk.dim('⊘')} Disabled: ${chalk.bold(name)}\n`);
+}

package/dist/tools/manage-todo.js

@@ -63,8 +63,16 @@ export function createManageTodoTool(validator) {
                         details: { error: 'permission_denied' },
                     };
                 }
-                await fs.mkdir(targetDir, { recursive: true });
-                await fs.writeFile(filePath, content, 'utf-8');
+                try {
+                    await fs.mkdir(targetDir, { recursive: true });
+                    await fs.writeFile(filePath, content, 'utf-8');
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: `❌ Error creating TODO: ${err.message}` }],
+                        details: { error: err.message },
+                    };
+                }
                 return {
                     content: [{ type: 'text', text: `✅ TODO created: ${filename}` }],
                     details: { id: filename, path: filePath },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fabiana",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "Personal AI assistant that actually feels personal",
   "type": "module",
   "bin": {