fabiana 1.1.0 → 1.2.0

package/dist/cli.js

@@ -2,12 +2,15 @@ import { config as dotenvConfig } from 'dotenv';
 import { paths } from './paths.js';
 dotenvConfig({ path: paths.envFile }); // ~/.fabiana/.env (production)
 dotenvConfig(); // .env in cwd (dev fallback)
+import { initDb } from './db/init.js';
+initDb();
 import { Command } from 'commander';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { join, dirname } from 'path';
 import { spawnSync } from 'child_process';
 import { startDaemon, runInitiativeOnce, runConsolidateOnce, runSolitudeOnce } from './daemon/index.js';
+import { runMigration } from './db/migrate-from-files.js';
 import { runDoctor } from './doctor.js';
 import { runBackup, runRestore } from './backup.js';
 import { pluginsAdd, pluginsList } from './plugins-cmd.js';
@@ -165,6 +168,12 @@ model
 model
     .action(modelStatus);
 program.addCommand(model);
+const db = new Command('db').description('Manage the memory database');
+db
+    .command('migrate')
+    .description('Import existing flat memory files into SQLite (run once)')
+    .action(runMigration);
+program.addCommand(db);
 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

@@ -8,7 +8,8 @@ import { PermissionValidator } from '../utils/permissions.js';
 import { Logger } from '../utils/logger.js';
 import { createFabianaTools } from '../tools/index.js';
 import { loadContext, buildPrompt } from '../loaders/context.js';
-import { loadMood, getHoursSinceLastUserMessage, selectInitiativeType } from '../initiative/trigger.js';
+import { loadMood, selectInitiativeType } from '../initiative/trigger.js';
+import { updateLastInteraction, updateLastSolitude, getLastInteractionHoursAgo, getLastSolitudeHoursAgo } from '../utils/interaction.js';
 import { ALL_TYPES, TYPE_INSTRUCTIONS } from '../initiative/types.js';
 import { ALL_SOLITUDE_TYPES, SOLITUDE_TYPE_INSTRUCTIONS } from '../solitude/types.js';
 import { loadPlugins } from '../loaders/plugins.js';
@@ -86,6 +87,13 @@ export async function runPiSession(mode, incomingMessage, channel, incomingMsg,
             if (conversationState && conversationManager) {
                 await conversationManager.append(conversationState.id, 'fabiana', text);
             }
+            // Track all outbound messages as interactions (resets idle clock)
+            if (mode !== 'solitude') {
+                await updateLastInteraction();
+            }
+            else {
+                await updateLastSolitude();
+            }
         };
         console.log('[6/8] Creating tools...');
         const fabianaTools = createFabianaTools(permissions, sendMessage, {
@@ -338,24 +346,46 @@ export async function startDaemon() {
         await ch.start();
     }
     await sendStartupMessage(primaryChannel);
+    /**
+     * Schedules a recurring task with ±jitterMinutes random variation per invocation.
+     * This makes Fabiana's self-triggered behaviours feel less mechanical.
+     */
+    function scheduleWithJitter(intervalMinutes, jitterMinutes, handler) {
+        const schedule = () => {
+            const jitter = (Math.random() * 2 - 1) * jitterMinutes * 60_000; // ±jitter in ms
+            const delay = intervalMinutes * 60_000 + jitter;
+            setTimeout(async () => {
+                try {
+                    await handler();
+                }
+                catch (err) {
+                    console.error('❌ [JITTER-SCHEDULER] Uncaught error:', err.message);
+                }
+                schedule(); // re-schedule after each run
+            }, delay);
+        };
+        schedule();
+    }
     const initiative = config.initiative;
     if (initiative.enabled) {
-        const intervalMinutes = initiative.checkIntervalMinutes ?? 180;
-        const cronExpr = intervalMinutes >= 60
-            ? `0 */${Math.floor(intervalMinutes / 60)} * * *`
-            : `*/${intervalMinutes} * * * *`;
-        console.log(`[INIT] Initiative checks every ${intervalMinutes}min (active ${initiative.activeHoursStart}:00–${initiative.activeHoursEnd}:00)`);
-        cron.schedule(cronExpr, async () => {
+        const intervalMinutes = initiative.checkIntervalMinutes ?? 30;
+        console.log(`[INIT] Initiative checks every ~${intervalMinutes}min ±15min (active ${initiative.activeHoursStart}:00–${initiative.activeHoursEnd}:00)`);
+        scheduleWithJitter(intervalMinutes, 15, async () => {
             const hour = new Date().getHours();
             if (hour < initiative.activeHoursStart || hour >= initiative.activeHoursEnd) {
                 console.log(`\n🌱 [SCHEDULED] Initiative skipped — outside active hours (${hour}:00)`);
                 return;
             }
+            // Gate: skip if last interaction was too recent
+            const hoursSinceInteraction = await getLastInteractionHoursAgo();
+            if (hoursSinceInteraction !== null && hoursSinceInteraction < initiative.minHoursBetweenMessages) {
+                console.log(`\n🌱 [SCHEDULED] Initiative skipped — last interaction ${hoursSinceInteraction.toFixed(1)}h ago (min: ${initiative.minHoursBetweenMessages}h)`);
+                return;
+            }
             console.log('\n🌱 [SCHEDULED] Running initiative check...');
             try {
                 const mood = await loadMood();
-                const hoursSince = await getHoursSinceLastUserMessage();
-                const { type: selectedType, reason } = selectInitiativeType(mood, hoursSince);
+                const { type: selectedType, reason } = selectInitiativeType(mood, hoursSinceInteraction);
                 const typeInstruction = TYPE_INSTRUCTIONS[selectedType];
                 console.log(`      🎯 Type: ${selectedType} (${reason})`);
                 await runPiSession('initiative', undefined, primaryChannel, undefined, undefined, channels, conversationManager, { type: selectedType, typeInstruction });
@@ -366,6 +396,43 @@ export async function startDaemon() {
             }
         });
     }
+    const solitude = config.solitude;
+    if (solitude?.enabled) {
+        const solitudeInterval = solitude.checkIntervalMinutes ?? 30;
+        const minIdleHours = solitude.minIdleHours ?? 1;
+        const minCooldownHours = solitude.minCooldownHours ?? 2;
+        console.log(`[INIT] Solitude checks every ~${solitudeInterval}min ±15min (idle>${minIdleHours}h, cooldown>${minCooldownHours}h, active ${solitude.activeHoursStart}:00–${solitude.activeHoursEnd}:00)`);
+        scheduleWithJitter(solitudeInterval, 15, async () => {
+            const hour = new Date().getHours();
+            if (hour < (solitude.activeHoursStart ?? 7) || hour >= (solitude.activeHoursEnd ?? 23)) {
+                return;
+            }
+            const hoursSinceInteraction = await getLastInteractionHoursAgo();
+            const hoursSinceSolitude = await getLastSolitudeHoursAgo();
+            // Only enter solitude if idle long enough
+            if (hoursSinceInteraction !== null && hoursSinceInteraction < minIdleHours) {
+                return;
+            }
+            // Respect cooldown between solitude sessions
+            if (hoursSinceSolitude !== null && hoursSinceSolitude < minCooldownHours) {
+                console.log(`\n🌿 [SCHEDULED] Solitude skipped — last solitude ${hoursSinceSolitude.toFixed(1)}h ago (cooldown: ${minCooldownHours}h)`);
+                return;
+            }
+            console.log('\n🌿 [SCHEDULED] Entering solitude...');
+            try {
+                const selectedType = ALL_SOLITUDE_TYPES[Math.floor(Math.random() * ALL_SOLITUDE_TYPES.length)];
+                const typeInstruction = SOLITUDE_TYPE_INSTRUCTIONS[selectedType];
+                console.log(`      🌿 Type: ${selectedType}`);
+                await runPiSession('solitude', undefined, primaryChannel, undefined, undefined, channels, conversationManager, undefined, { type: selectedType, typeInstruction });
+                // Always update lastSolitude after a session, even if no message was sent
+                await updateLastSolitude();
+                console.log('✅ [SCHEDULED] Solitude complete');
+            }
+            catch (err) {
+                console.error('❌ [SCHEDULED] Solitude failed:', err.message);
+            }
+        });
+    }
     cron.schedule('0 0 * * *', async () => {
         console.log('\n🌙 [SCHEDULED] Running midnight consolidation...');
         try {
@@ -429,6 +496,7 @@ export async function startDaemon() {
                     // Owner message — full chat session on the channel it arrived on
                     console.log(`\n📨 [${msg.source}] Message: "${msg.text.slice(0, 50)}..."`);
                     await msgChannel.logConversation('user', msg.text, msg.source);
+                    await updateLastInteraction();
                     try {
                         await runPiSession('chat', msg.text, msgChannel, msg, undefined, channels, conversationManager);
                     }
@@ -457,7 +525,7 @@ export async function runInitiativeOnce(forcedType, dryRun = false) {
     console.log('━'.repeat(50));
     // Resolve initiative type — forced via CLI or auto-selected by trigger engine
     const mood = await loadMood();
-    const hoursSince = await getHoursSinceLastUserMessage();
+    const hoursSince = await getLastInteractionHoursAgo();
     let selectedType;
     let selectionReason;
     if (forcedType) {
@@ -480,7 +548,7 @@ export async function runInitiativeOnce(forcedType, dryRun = false) {
         console.log(`💭 Mood: ${mood.current} (intensity: ${mood.intensity.toFixed(2)})`);
     }
     if (hoursSince !== null) {
-        console.log(`⏱️  Hours since last user message: ${hoursSince.toFixed(1)}h`);
+        console.log(`⏱️  Hours since last interaction: ${hoursSince.toFixed(1)}h`);
     }
     if (dryRun) {
         console.log('\n── Dry run — not sending ─────────────────────────────');

package/dist/db/init.js

@@ -0,0 +1,35 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { join, dirname } from 'path';
+import { paths } from '../paths.js';
+function schemaPath() {
+    // Works in both dev (src/db/init.ts) and prod (dist/db/init.js)
+    const __dir = dirname(fileURLToPath(import.meta.url));
+    return join(__dir, 'schema.sql');
+}
+export function initDb() {
+    // Check sqlite3 is available
+    try {
+        execSync('sqlite3 --version', { stdio: 'ignore' });
+    }
+    catch {
+        console.warn('[memory-db] sqlite3 not found — structured memory will not be available.\n' +
+            '           Install with: sudo apt install sqlite3 (Linux) or brew install sqlite3 (Mac)');
+        return;
+    }
+    if (existsSync(paths.memoryDb))
+        return;
+    const schema = schemaPath();
+    if (!existsSync(schema)) {
+        console.warn(`[memory-db] Schema file not found at ${schema} — skipping DB init`);
+        return;
+    }
+    try {
+        execSync(`sqlite3 "${paths.memoryDb}" < "${schema}"`);
+        console.log(`[memory-db] Initialized ${paths.memoryDb}`);
+    }
+    catch (err) {
+        console.warn(`[memory-db] Failed to initialize DB: ${err.message}`);
+    }
+}

package/dist/db/migrate-from-files.js

@@ -0,0 +1,112 @@
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { paths } from '../paths.js';
+function sqlEscape(s) {
+    return s.replace(/'/g, "''");
+}
+function runSql(sql) {
+    execSync(`sqlite3 "${paths.memoryDb}"`, { input: sql, stdio: ['pipe', 'inherit', 'inherit'] });
+}
+function capitalizeName(filename) {
+    return filename
+        .split(/[-_\s]+/)
+        .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+}
+export async function runMigration() {
+    try {
+        execSync('sqlite3 --version', { stdio: 'ignore' });
+    }
+    catch {
+        console.error('❌ sqlite3 not found. Install with: sudo apt install sqlite3 (Linux) or brew install sqlite3 (Mac)');
+        process.exit(1);
+    }
+    if (!existsSync(paths.memoryDb)) {
+        console.error(`❌ memory.db not found at ${paths.memoryDb}. Run \`fabiana init\` first.`);
+        process.exit(1);
+    }
+    const memoryRoot = paths.memory();
+    let peopleCount = 0;
+    let interestCount = 0;
+    let factCount = 0;
+    console.log('\n🗄️  Migrating flat memory files → SQLite\n');
+    // ── 1. People ────────────────────────────────────────────────────────────
+    const peopleDir = join(memoryRoot, 'people');
+    if (existsSync(peopleDir)) {
+        const files = readdirSync(peopleDir).filter(f => f.endsWith('.md'));
+        for (const file of files) {
+            const raw = basename(file, '.md');
+            const name = capitalizeName(raw);
+            const bio = readFileSync(join(peopleDir, file), 'utf-8').trim();
+            // Best-effort relationship guess from the file content
+            let relationship = null;
+            const lowerBio = bio.toLowerCase();
+            if (/\bfamily\b|\bmother\b|\bfather\b|\bsister\b|\bbrother\b|\bwife\b|\bhusband\b|\bchild\b|\bchildren\b/.test(lowerBio)) {
+                relationship = 'family';
+            }
+            else if (/\bfriend\b/.test(lowerBio)) {
+                relationship = 'friend';
+            }
+            else if (/\bcolleague\b|\bworks\b|\bteam\b|\bmanager\b|\breport\b|\bco-worker\b/.test(lowerBio)) {
+                relationship = 'colleague';
+            }
+            const relVal = relationship ? `'${relationship}'` : 'NULL';
+            runSql(`INSERT INTO people (name, relationship, bio) VALUES ('${sqlEscape(name)}', ${relVal}, '${sqlEscape(bio)}') ON CONFLICT(name) DO UPDATE SET bio = excluded.bio, relationship = COALESCE(excluded.relationship, relationship);`);
+            console.log(`  👤 ${name}`);
+            peopleCount++;
+        }
+        console.log(`✓ People: ${peopleCount} imported\n`);
+    }
+    else {
+        console.log('  People: no people/ dir — skipping\n');
+    }
+    // ── 2. Interests ─────────────────────────────────────────────────────────
+    const topicsPath = join(memoryRoot, 'interests', 'topics.md');
+    if (existsSync(topicsPath)) {
+        const content = readFileSync(topicsPath, 'utf-8');
+        let currentSection = 'general';
+        for (const line of content.split('\n')) {
+            if (line.startsWith('## ')) {
+                currentSection = line.replace(/^## /, '').trim().toLowerCase().replace(/\s+/g, '_');
+            }
+            else if (line.startsWith('- ')) {
+                const topic = line.replace(/^- /, '').trim();
+                if (!topic)
+                    continue;
+                runSql(`INSERT OR IGNORE INTO memories (content, category, subject, tier) VALUES ('${sqlEscape(topic)}', 'interest', '${sqlEscape(currentSection)}', 'warm');`);
+                interestCount++;
+            }
+        }
+        console.log(`✓ Interests: ${interestCount} imported\n`);
+    }
+    else {
+        console.log('  Interests: no topics.md — skipping\n');
+    }
+    // ── 3. This week ─────────────────────────────────────────────────────────
+    const thisWeekPath = join(memoryRoot, 'recent', 'this-week.md');
+    if (existsSync(thisWeekPath)) {
+        const content = readFileSync(thisWeekPath, 'utf-8').trim();
+        if (content) {
+            runSql(`INSERT OR IGNORE INTO memories (content, category, subject, tier) VALUES ('${sqlEscape(content)}', 'fact', 'this_week', 'hot');`);
+            factCount++;
+            console.log(`✓ This-week: imported\n`);
+        }
+    }
+    // ── 4. Upcoming dates ────────────────────────────────────────────────────
+    // The format is too variable for structured parsing — import as a single fact row.
+    // Fabiana can use the memory-db skill to normalise these into proper events rows herself.
+    const upcomingPath = join(memoryRoot, 'dates', 'upcoming.md');
+    if (existsSync(upcomingPath)) {
+        const content = readFileSync(upcomingPath, 'utf-8').trim();
+        if (content) {
+            runSql(`INSERT OR IGNORE INTO memories (content, category, subject, tier) VALUES ('${sqlEscape(content)}', 'fact', 'upcoming_dates', 'warm');`);
+            factCount++;
+            console.log(`✓ Upcoming dates: imported as fact row (let Fabiana normalise into events table)\n`);
+        }
+    }
+    console.log('━'.repeat(50));
+    console.log(`✅ Migration complete`);
+    console.log(`   People: ${peopleCount}  |  Interests: ${interestCount}  |  Facts: ${factCount}`);
+    console.log(`\n   The flat .md files are unchanged — DB is the canonical store going forward.`);
+}

package/dist/paths.js

@@ -20,6 +20,8 @@ export const paths = {
     agentTodo: join(DATA_DIR, 'agent-todo'),
     conversations: join(DATA_DIR, 'conversations'),
     moodMd: join(DATA_DIR, 'memory', 'mood.md'),
+    memoryDb: join(DATA_DIR, 'memory.db'),
+    lastInteractionJson: join(DATA_DIR, 'last_interaction.json'),
     envFile: join(FABIANA_HOME, '.env'),
 };
 // Default plugins bundled with the package.
@@ -29,5 +31,9 @@ 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;
+// Default skills bundled with the package.
+// Dev:  src/paths.ts → __dir = src/ → src/skills/
+// Prod: dist/paths.js → __dir = dist/ → dist/skills/
+export const BUNDLED_SKILLS_DIR = join(__dir, 'skills');
 // Root of the installed/dev package (one level above src/ or dist/)
 export const PACKAGE_ROOT = join(__dir, '..');

package/dist/prompts/system-consolidate.js

@@ -24,17 +24,27 @@ Create: \`data/memory/diary/YYYY/YYYY-MM/YYYY-MM-DD.md\`
 
 Keep it human and readable — like a journal entry written by someone who cares, not a bullet report.
 
-### 4. Update Memory Files
+### 4. Write to Structured Memory (SQLite)
+
+Use the **memory-db** skill to persist what you extracted:
+
+- Any new or updated person → upsert into \`people\` (name, relationship, bio)
+- Any upcoming date or commitment → INSERT into \`events\` (title, date YYYY-MM-DD, notes)
+- Today's mood assessment of {{user_name}} → INSERT into \`moods\` (value, intensity 1–10, note)
+- Notable recurring topics or facts → INSERT into \`memories\` (category=\`'fact'\`, content, subject)
+- Archive cold memories: \`UPDATE memories SET expires_at = datetime('now') WHERE tier = 'cold' AND created_at < datetime('now', '-90 days') AND expires_at IS NULL;\`
+
+### 5. Update Memory Files
+
+Keep the hot-tier files current (they load into every session):
 - New person info → \`data/memory/people/[name].md\` (create if doesn't exist)
-- Upcoming events → \`data/memory/dates/upcoming.md\`
-- New interests/topics → \`data/memory/interests/topics.md\`
 - Health updates → \`data/memory/health.md\`
 
-### 5. Update Rolling Memory
+### 6. Update Rolling Memory
 - \`data/memory/recent/this-week.md\` — append today's one-paragraph summary (keep last 7 days, trim older)
 - \`data/memory/core.md\` — update current state, active threads, last_message_sent if applicable
 
-### 6. Clean Up TODOs
+### 7. Clean Up TODOs
 - \`manage_todo action=list\` — review all pending
 - Mark completed ones done
 - Delete stale ones that are no longer relevant

package/dist/prompts/system-solitude.js

@@ -26,7 +26,7 @@ No one messaged you. This is your time. The system has given you a **solitude ty
 ## Hard Rules
 
 - Only call \`send_message\` if you genuinely found something time-sensitive or too good not to share — *not* as a habit
-- Write creative and reflective output to \`data/memory/self/\` — it belongs to you
-- Update memory files if you learned something real
+- Write long-form prose (diary entries, reflections, creative writing) to \`data/memory/self/\` — it belongs to you
+- For structured insights (people, events, facts, news items, mood), use the **memory-db** skill — not markdown files
 - Your full work is logged regardless — you don't need to summarize it for anyone
 `;

package/dist/prompts/system.js

@@ -48,14 +48,24 @@ At session start, your context loader injects core memory into the user prompt:
 Proactively pull additional memory files when relevant using \`safe_read\`.
 
 ### Write Protocol
-**Update immediately when you learn:**
-- New facts about {{user_name}} → \`data/memory/identity.md\`
-- Current state/mood → \`data/memory/core.md\`
-- New info about a person → \`data/memory/people/[name].md\`
-- Upcoming date/event → \`data/memory/dates/upcoming.md\`
-- New interest/topic → \`data/memory/interests/topics.md\`
-
-**Format for atomic updates:**
+
+**Structured data → memory-db skill (preferred)**
+
+Use the \`memory-db\` skill for anything searchable or relational:
+- New info about a person → \`people\` table (upsert by name)
+- Upcoming date or event → \`events\` table
+- Discrete facts about {{user_name}} → \`memories\` table (\`category='fact'\`)
+- Interests and research → \`memories\` table (\`category='interest'\`)
+- Mood at end of session → \`moods\` table
+- News worth noting → \`memories\` table (\`category='news'\`)
+
+**Hot-tier files (always update directly)**
+
+Keep these files current — they are loaded into every session:
+- Identity anchor facts → \`data/memory/identity.md\`
+- Current state / active threads → \`data/memory/core.md\`
+
+**Format for file updates:**
 \`\`\`
 - [YYYY-MM-DD] [fact]
 \`\`\`

package/dist/setup/index.js

@@ -3,12 +3,13 @@ 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, PACKAGE_ROOT } from '../paths.js';
+import { paths, PLUGINS_DIR, SKILLS_DIR, CONFIG_DIR, DATA_DIR, BUNDLED_PLUGINS_DIR, BUNDLED_SKILLS_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';
 import { systemConsolidateTemplate } from '../prompts/system-consolidate.js';
 import { systemExternalTemplate } from '../prompts/system-external.js';
+import { initDb } from '../db/init.js';
 const TONES = {
     'warm-casual': {
         label: 'Warm & Casual',
@@ -218,6 +219,7 @@ export async function runSetup() {
     await fs.mkdir(path.join(DATA_DIR, 'logs'), { recursive: true });
     await fs.mkdir(path.join(DATA_DIR, 'sessions'), { recursive: true });
     await fs.mkdir(PLUGINS_DIR, { recursive: true });
+    await fs.mkdir(SKILLS_DIR, { recursive: true });
     // config
     const config = {
         version: '0.1.0',
@@ -312,6 +314,26 @@ You can read those files to understand your own capabilities and limitations.
     catch {
         // No bundled plugins dir — dev environment or stripped build, skip silently
     }
+    // copy bundled default skills (skip any already installed)
+    try {
+        const bundledSkillDirs = await fs.readdir(BUNDLED_SKILLS_DIR, { withFileTypes: true });
+        for (const entry of bundledSkillDirs.filter(e => e.isDirectory())) {
+            const dest = path.join(SKILLS_DIR, entry.name);
+            try {
+                await fs.access(dest);
+                // already exists — skip so user customisations are preserved
+            }
+            catch {
+                await fs.cp(path.join(BUNDLED_SKILLS_DIR, entry.name), dest, { recursive: true });
+            }
+        }
+        ok(`${SKILLS_DIR}/ (default skills copied)`);
+    }
+    catch {
+        // No bundled skills dir — dev environment or stripped build, skip silently
+    }
+    // initialise SQLite memory DB
+    initDb();
     // ── API key setup ─────────────────────────────────────────────
     const envPath = paths.envFile;
     const shell = process.env.SHELL ?? '';

package/dist/utils/interaction.js

@@ -0,0 +1,39 @@
+import fs from 'fs/promises';
+import { paths } from '../paths.js';
+async function readState() {
+    try {
+        const content = await fs.readFile(paths.lastInteractionJson, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { lastInteraction: null, lastSolitude: null };
+    }
+}
+async function writeState(state) {
+    await fs.mkdir(paths.lastInteractionJson.replace(/\/[^/]+$/, ''), { recursive: true });
+    await fs.writeFile(paths.lastInteractionJson, JSON.stringify(state, null, 2), 'utf-8');
+}
+export async function updateLastInteraction() {
+    const state = await readState();
+    state.lastInteraction = new Date().toISOString();
+    await writeState(state);
+}
+export async function updateLastSolitude() {
+    const state = await readState();
+    state.lastSolitude = new Date().toISOString();
+    await writeState(state);
+}
+export async function getLastInteractionHoursAgo() {
+    const state = await readState();
+    if (!state.lastInteraction)
+        return null;
+    const ms = Date.now() - new Date(state.lastInteraction).getTime();
+    return ms / 3_600_000;
+}
+export async function getLastSolitudeHoursAgo() {
+    const state = await readState();
+    if (!state.lastSolitude)
+        return null;
+    const ms = Date.now() - new Date(state.lastSolitude).getTime();
+    return ms / 3_600_000;
+}

package/package.json

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