@aperdomoll90/ledger-ai 1.4.0 → 1.4.2

package/dist/commands/export.js

@@ -1,21 +1,19 @@
 import { writeFileSync, mkdirSync } from 'fs';
 import { resolve, dirname } from 'path';
-import { searchNotes } from '../lib/notes.js';
+import { searchHybrid } from '../lib/search/ai-search.js';
 import { fatal, ExitCode } from '../lib/errors.js';
-export async function exportNote(config, query, outputPath) {
-    const results = await searchNotes(config.supabase, config.openai, query);
+export async function exportDocument(config, query, outputPath) {
+    const results = await searchHybrid({ supabase: config.supabase, openai: config.openai }, { query });
     if (results.length === 0) {
-        fatal('No matching notes found.', ExitCode.NOTE_NOT_FOUND);
+        fatal('No matching documents found.', ExitCode.DOCUMENT_NOT_FOUND);
     }
-    const note = results[0];
-    const upsertKey = note.metadata.upsert_key || `note-${note.id}`;
-    const filename = `${upsertKey}.md`;
+    const document = results[0];
+    const filename = `${document.name}.md`;
     const targetPath = outputPath
         ? resolve(outputPath, filename)
         : resolve(process.cwd(), filename);
     mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, note.content + '\n', 'utf-8');
-    // No hash stored — export is untracked
-    console.log(`Exported "${upsertKey}" → ${targetPath}`);
+    writeFileSync(targetPath, document.content + '\n', 'utf-8');
+    console.log(`Exported "${document.name}" → ${targetPath}`);
     console.log(targetPath);
 }

package/dist/commands/get.js

@@ -0,0 +1,9 @@
+import { getDocumentByName } from '../lib/documents/fetching.js';
+import { fatal, ExitCode } from '../lib/errors.js';
+export async function get(config, name) {
+    const document = await getDocumentByName(config.supabase, name);
+    if (!document) {
+        fatal(`Document "${name}" not found.`, ExitCode.DOCUMENT_NOT_FOUND);
+    }
+    console.log(document.content);
+}

package/dist/commands/hunt.js

@@ -0,0 +1,206 @@
+import { execFileSync, spawnSync } from 'child_process';
+import { isValidTrack, isValidStatus } from '../lib/hunter-types.js';
+import { getOpportunities, getOpportunityById, getUnscoredOpportunities, updateOpportunityStatus, updateOpportunityNotes, getLatestAnalytics, } from '../lib/hunter-db.js';
+// --- Formatters ---
+function formatOpportunityRow(opp) {
+    const score = opp.score !== null ? String(opp.score).padStart(3) : '  -';
+    const rec = (opp.recommendation ?? '---').padEnd(5);
+    const track = opp.track.padEnd(10);
+    const title = opp.title.length > 50 ? opp.title.slice(0, 47) + '...' : opp.title;
+    const id = opp.id.slice(0, 8);
+    return `${score}  ${rec}  ${track}  ${id}  ${title}`;
+}
+function formatOpportunityDetail(opp) {
+    const lines = [
+        `Title: ${opp.title}`,
+        `URL: ${opp.url}`,
+        `Track: ${opp.track}`,
+        `Score: ${opp.score ?? 'unscored'}`,
+        `Recommendation: ${opp.recommendation ?? '-'}`,
+        `Status: ${opp.status}`,
+        `Source: ${opp.source}`,
+        `Found: ${opp.created_at}`,
+    ];
+    if (opp.summary)
+        lines.push(`\nSummary: ${opp.summary}`);
+    if (opp.compensation_range)
+        lines.push(`Compensation: ${opp.compensation_range}`);
+    if (opp.key_requirements?.length)
+        lines.push(`Requirements: ${opp.key_requirements.join(', ')}`);
+    if (opp.reject_reasons?.length)
+        lines.push(`Reject reasons: ${opp.reject_reasons.join(', ')}`);
+    if (opp.notes)
+        lines.push(`\nNotes: ${opp.notes}`);
+    if (opp.score_breakdown) {
+        lines.push('\nScore Breakdown:');
+        const breakdown = opp.score_breakdown;
+        for (const [key, value] of Object.entries(breakdown)) {
+            if (key === 'reasoning')
+                continue;
+            lines.push(`  ${key}: ${value}`);
+        }
+        const reasoning = breakdown.reasoning;
+        if (reasoning) {
+            lines.push('\nReasoning:');
+            for (const [key, value] of Object.entries(reasoning)) {
+                lines.push(`  ${key}: ${value}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+// --- Command Handlers ---
+export async function huntStatus(supabase, options) {
+    const track = options.track && isValidTrack(options.track) ? options.track : undefined;
+    const status = options.status && isValidStatus(options.status) ? options.status : undefined;
+    const minScore = options.minScore ? parseInt(options.minScore, 10) : 60;
+    const days = options.days ? parseInt(options.days, 10) : 7;
+    const limit = options.limit ? parseInt(options.limit, 10) : 25;
+    const opportunities = await getOpportunities(supabase, {
+        track,
+        status,
+        minScore,
+        days,
+        limit,
+    });
+    if (opportunities.length === 0) {
+        console.error('No opportunities found matching filters.');
+        return;
+    }
+    console.error(`\nScore  Rec    Track       ID        Title`);
+    console.error(`-----  -----  ----------  --------  --------------------------------------------------`);
+    for (const opp of opportunities) {
+        console.error(formatOpportunityRow(opp));
+    }
+    console.error(`\n${opportunities.length} opportunities shown.`);
+}
+export async function huntShow(supabase, id) {
+    const opp = await getOpportunityById(supabase, id);
+    if (!opp) {
+        console.error(`Opportunity not found: ${id}`);
+        return;
+    }
+    console.error(formatOpportunityDetail(opp));
+}
+export async function huntApplied(supabase, id) {
+    await updateOpportunityStatus(supabase, id, 'applied');
+    console.error(`Marked ${id.slice(0, 8)} as applied.`);
+}
+export async function huntReject(supabase, id) {
+    await updateOpportunityStatus(supabase, id, 'rejected');
+    console.error(`Marked ${id.slice(0, 8)} as rejected.`);
+}
+export async function huntNote(supabase, id, text) {
+    const opp = await getOpportunityById(supabase, id);
+    if (!opp) {
+        console.error(`Opportunity not found: ${id}`);
+        return;
+    }
+    const existingNotes = opp.notes ? opp.notes + '\n' : '';
+    const timestamp = new Date().toISOString().split('T')[0];
+    await updateOpportunityNotes(supabase, id, `${existingNotes}[${timestamp}] ${text}`);
+    console.error(`Note added to ${id.slice(0, 8)}.`);
+}
+export async function huntUnscored(supabase) {
+    const unscored = await getUnscoredOpportunities(supabase);
+    if (unscored.length === 0) {
+        console.error('No unscored opportunities.');
+        return;
+    }
+    console.error(`${unscored.length} unscored opportunities waiting.`);
+    for (const opp of unscored) {
+        console.error(`  ${opp.id.slice(0, 8)}  ${opp.title.slice(0, 60)}`);
+    }
+}
+export async function huntStats(supabase) {
+    const analytics = await getLatestAnalytics(supabase);
+    if (!analytics) {
+        console.error('No analytics data yet. Run `ledger hunt analytics` first.');
+        return;
+    }
+    console.error(`\nAnalytics: ${analytics.period_start} to ${analytics.period_end}`);
+    console.error(`---------------------------------------------`);
+    console.error(`Total: ${analytics.total_found} | Freelance: ${analytics.freelance_count} | Employment: ${analytics.employment_count}`);
+    console.error(`Score 80+: ${analytics.score_80_plus} | 60-79: ${analytics.score_60_79} | 40-59: ${analytics.score_40_59} | <40: ${analytics.score_below_40}`);
+    console.error(`Applied: ${analytics.applied_count} | Won: ${analytics.won_count} | Lost: ${analytics.lost_count}`);
+    if (analytics.apply_rate !== null)
+        console.error(`Apply rate: ${(analytics.apply_rate * 100).toFixed(1)}%`);
+    if (analytics.win_rate !== null)
+        console.error(`Win rate: ${(analytics.win_rate * 100).toFixed(1)}%`);
+    if (analytics.top_reject_reasons) {
+        const reasons = Object.entries(analytics.top_reject_reasons)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5);
+        if (reasons.length > 0) {
+            console.error(`\nTop reject reasons:`);
+            for (const [reason, count] of reasons) {
+                console.error(`  ${reason}: ${count}`);
+            }
+        }
+    }
+    if (analytics.top_skills_demanded) {
+        const skills = Object.entries(analytics.top_skills_demanded)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10);
+        if (skills.length > 0) {
+            console.error(`\nTop skills demanded:`);
+            for (const [skill, count] of skills) {
+                console.error(`  ${skill}: ${count}`);
+            }
+        }
+    }
+    if (analytics.summary) {
+        console.error(`\nInsight: ${analytics.summary}`);
+    }
+}
+// --- Cron Management ---
+export function enableHunterCron(schedule) {
+    const cron = schedule ?? '*/30 8-23 * * *';
+    const cronLine = `${cron} ledger-hunter-cron`;
+    let existing = '';
+    try {
+        existing = execFileSync('crontab', ['-l'], { encoding: 'utf-8' });
+    }
+    catch {
+        // No crontab yet
+    }
+    if (existing.includes('ledger-hunter-cron') || existing.includes('hunter-cron')) {
+        console.error('Hunter cron already enabled. Disable first to update.');
+        return;
+    }
+    const newCrontab = existing.trimEnd() + '\n' + cronLine + '\n';
+    try {
+        const result = spawnSync('crontab', ['-'], { input: newCrontab, stdio: ['pipe', 'pipe', 'pipe'] });
+        if (result.status !== 0)
+            throw new Error(result.stderr?.toString() || 'crontab failed');
+        console.error(`Hunter cron enabled: ${cron}`);
+        console.error('View with `crontab -l`.');
+    }
+    catch (e) {
+        console.error(`Failed to set cron: ${e.message}`);
+        console.error(`Add manually: ${cronLine}`);
+    }
+}
+export function disableHunterCron() {
+    let existing = '';
+    try {
+        existing = execFileSync('crontab', ['-l'], { encoding: 'utf-8' });
+    }
+    catch {
+        console.error('No crontab found.');
+        return;
+    }
+    const filtered = existing
+        .split('\n')
+        .filter(line => !line.includes('hunter-cron'))
+        .join('\n');
+    try {
+        const result = spawnSync('crontab', ['-'], { input: filtered, stdio: ['pipe', 'pipe', 'pipe'] });
+        if (result.status !== 0)
+            throw new Error(result.stderr?.toString() || 'crontab failed');
+        console.error('Hunter cron disabled.');
+    }
+    catch (e) {
+        console.error(`Failed to update cron: ${e.message}`);
+    }
+}

package/dist/commands/ingest.js

@@ -1,6 +1,6 @@
 import { readFileSync, unlinkSync, readdirSync, existsSync } from 'fs';
 import { resolve, basename } from 'path';
-import { fetchPersonaNotes, findNoteByFile, searchNotes, inferDelivery } from '../lib/notes.js';
+import { fetchPersonaNotes, findNoteByFile, searchNotes, inferDomain } from '../lib/notes.js';
 import { contentHash } from '../lib/hash.js';
 import { confirm, choose } from '../lib/prompt.js';
 export async function ingest(config, options) {
@@ -20,7 +20,7 @@ export async function ingest(config, options) {
         return;
     }
     const knownFiles = new Set(existingNotes
-        .map(n => n.metadata.local_file)
+        .map(n => n.metadata.file_path)
         .filter(Boolean));
     const localFiles = readdirSync(config.memoryDir)
         .filter(f => f.endsWith('.md') && f !== 'MEMORY.md' && !knownFiles.has(f));
@@ -105,12 +105,12 @@ async function ingestFile(config, filePath, existingNotes) {
         'error',
         'general',
     ]);
-    const defaultDelivery = inferDelivery(noteType);
-    const deliveryChoice = await choose(`Delivery tier (default: ${defaultDelivery}):`, [
-        `${defaultDelivery} (default)`,
-        ...['persona', 'project', 'knowledge', 'protected'].filter(d => d !== defaultDelivery),
+    const defaultDomain = inferDomain(noteType);
+    const domainChoice = await choose(`Domain (default: ${defaultDomain}):`, [
+        `${defaultDomain} (default)`,
+        ...['system', 'persona', 'workspace', 'project'].filter(d => d !== defaultDomain),
     ]);
-    const delivery = deliveryChoice.replace(' (default)', '');
+    const domain = domainChoice.replace(' (default)', '');
     const { openai } = config;
     const embeddingResponse = await openai.embeddings.create({
         model: 'text-embedding-3-small',
@@ -126,9 +126,9 @@ async function ingestFile(config, filePath, existingNotes) {
             type: noteType,
             agent: 'ledger-ingest',
             upsert_key: upsertKey,
-            local_file: filename,
+            file_path: filename,
             content_hash: hash,
-            delivery,
+            domain,
         },
         embedding,
     })
@@ -138,7 +138,7 @@ async function ingestFile(config, filePath, existingNotes) {
         console.error(`Error adding note: ${error.message}`);
         return;
     }
-    console.error(`Added "${filename}" → Ledger (note ${data.id}, delivery: ${delivery})`);
+    console.error(`Added "${filename}" → Ledger (note ${data.id}, domain: ${domain})`);
     await askDeleteLocal(filePath, filename);
 }
 async function updateAndHash(config, noteId, content) {
@@ -185,7 +185,7 @@ async function autoIngestFile(config, filePath, existingNotes) {
         console.error(`AUTO: ${filename} — identical to existing note, skipped.`);
         return;
     }
-    // Check if a note already exists for this file (by local_file or upsert_key)
+    // Check if a note already exists for this file (by file_path or upsert_key)
     const existingNote = await findNoteByFile(config.supabase, filename);
     if (existingNote) {
         // Update existing note instead of creating a duplicate
@@ -210,6 +210,7 @@ async function autoIngestFile(config, filePath, existingNotes) {
     });
     const embedding = embeddingResponse.data[0].embedding;
     const upsertKey = filename.replace(/\.md$/, '').replace(/_/g, '-');
+    const noteDomain = inferDomain(noteType);
     const { data, error } = await config.supabase
         .from('notes')
         .insert({
@@ -218,9 +219,9 @@ async function autoIngestFile(config, filePath, existingNotes) {
             type: noteType,
             agent: 'ledger-auto-ingest',
             upsert_key: upsertKey,
-            local_file: filename,
+            file_path: filename,
             content_hash: hash,
-            delivery: inferDelivery(noteType),
+            domain: noteDomain,
         },
         embedding,
     })
@@ -230,5 +231,5 @@ async function autoIngestFile(config, filePath, existingNotes) {
         console.error(`AUTO: Error ingesting ${filename}: ${error.message}`);
         return;
     }
-    console.error(`AUTO: ${filename} → Ledger (note ${data.id}, delivery: ${inferDelivery(noteType)}).`);
+    console.error(`AUTO: ${filename} → Ledger (note ${data.id}, domain: ${noteDomain}).`);
 }

package/dist/commands/init.js

@@ -113,17 +113,17 @@ export function readCredentials() {
         return null;
     return { supabaseUrl, supabaseKey, openaiKey };
 }
-/** Connect to Supabase + OpenAI, run migrations if needed. Returns clients + note count. */
+/** Connect to Supabase + OpenAI, run migrations if needed. Returns clients + document count. */
 export async function connectAndMigrate(creds) {
     // Verify Supabase connection
     console.error('Connecting to Supabase...');
     const supabase = createClient(creds.supabaseUrl, creds.supabaseKey);
     const { error: connError } = await supabase
-        .from('notes')
+        .from('documents')
         .select('id')
         .limit(1);
     const isNew = connError !== null;
-    if (isNew && !connError.message.includes('notes')) {
+    if (isNew && !connError.message.includes('documents')) {
         throw new Error(`Connection error: ${connError.message}`);
     }
     if (isNew) {
@@ -139,17 +139,17 @@ export async function connectAndMigrate(creds) {
         await openai.embeddings.create({ model: 'text-embedding-3-small', input: 'test' });
         console.error('OpenAI key valid.\n');
     }
-    catch (e) {
-        throw new Error(`OpenAI key invalid: ${e.message}`);
+    catch (validationError) {
+        throw new Error(`OpenAI key invalid: ${validationError.message}`);
     }
     // Run migrations if new database
-    let noteCount = 0;
+    let documentCount = 0;
     if (isNew) {
         console.error('New database detected. Setting up schema...\n');
         const files = getMigrationFiles();
-        const allSql = files.map(f => {
-            const sql = readMigration(f);
-            return `-- ${f}\n${sql}`;
+        const allSql = files.map(file => {
+            const sql = readMigration(file);
+            return `-- ${file}\n${sql}`;
         }).join('\n\n');
         console.error('Run the following SQL in Supabase Dashboard > SQL Editor:\n');
         console.error('='.repeat(60));
@@ -158,22 +158,22 @@ export async function connectAndMigrate(creds) {
         console.error('');
         await ask('Press Enter after running the SQL...');
         const { error: verifyError } = await supabase
-            .from('notes')
+            .from('documents')
             .select('id')
             .limit(1);
         if (verifyError) {
-            throw new Error('Notes table not found. Make sure you ran all the SQL above.');
+            throw new Error('Documents table not found. Make sure you ran all the SQL above.');
         }
         console.error('Schema verified.\n');
     }
     else {
         const { count } = await supabase
-            .from('notes')
+            .from('documents')
             .select('*', { count: 'exact', head: true });
-        noteCount = count ?? 0;
-        console.error(`Found existing Ledger with ${noteCount} notes.\n`);
+        documentCount = count ?? 0;
+        console.error(`Found existing Ledger with ${documentCount} documents.\n`);
     }
-    return { supabase, openai, noteCount };
+    return { supabase, openai, documentCount };
 }
 // --- Standalone init command (delegates to helpers) ---
 export async function init() {
@@ -182,15 +182,13 @@ export async function init() {
     try {
         await connectAndMigrate(creds);
     }
-    catch (e) {
-        console.error(e.message);
+    catch (migrationError) {
+        console.error(migrationError.message);
         process.exit(1);
     }
-    const wantBackup = await confirm('Enable daily local backup? (Saves all notes to ~/.ledger/backups/ at 1am)');
+    const wantBackup = await confirm('Enable daily local backup? (Saves all documents to ~/.ledger/backups/ at 1am)');
     if (wantBackup) {
         enableBackupCron();
     }
     console.error('\nInit complete.');
-    console.error('Run `ledger setup <platform>` to connect an agent.');
-    console.error('Platforms: claude-code, openclaw, chatgpt');
 }

package/dist/commands/list.js

@@ -1,10 +1,24 @@
-import { opListNotes } from '../lib/notes.js';
+import { listDocuments } from '../lib/documents/fetching.js';
 export async function list(config, options) {
-    const result = await opListNotes({ supabase: config.supabase, openai: config.openai }, options.limit, options.type, options.project);
-    if (result.status === 'error') {
-        console.error(result.message);
-        process.exit(1);
+    const documents = await listDocuments(config.supabase, {
+        limit: options.limit,
+        document_type: options.type,
+        project: options.project,
+        domain: options.domain,
+    });
+    if (documents.length === 0) {
+        console.error('No documents found.');
+        process.exit(0);
     }
-    // List output goes to stdout (machine-readable)
-    console.log(result.message);
+    const formatted = documents.map(document => {
+        return [
+            `[${document.id}] ${document.name}`,
+            `  Domain: ${document.domain} | Type: ${document.document_type}${document.project ? ` | Project: ${document.project}` : ''}`,
+            `  Protection: ${document.protection} | Auto-load: ${document.is_auto_load}`,
+            document.description ? `  Description: ${document.description}` : null,
+            `  Content: ${document.content.slice(0, 150)}${document.content.length > 150 ? '...' : ''}`,
+            `  Updated: ${document.updated_at}`,
+        ].filter(Boolean).join('\n');
+    });
+    console.log(formatted.join('\n\n'));
 }

package/dist/commands/migrate.js

@@ -1,7 +1,7 @@
 import { readFileSync, existsSync, mkdirSync, cpSync, readdirSync } from 'fs';
 import { resolve, basename, join } from 'path';
 import { homedir } from 'os';
-import { searchNotes, inferDelivery } from '../lib/notes.js';
+import { searchNotes, inferDomain } from '../lib/notes.js';
 import { contentHash } from '../lib/hash.js';
 import { confirm, choose } from '../lib/prompt.js';
 export async function migrate(config) {
@@ -369,17 +369,17 @@ async function uploadNewNote(config, filename, content, hash) {
         .eq('metadata->>upsert_key', upsertKey)
         .limit(1)
         .single();
-    const delivery = inferDelivery(noteType);
+    const noteDomain = inferDomain(noteType);
     if (existing) {
         await updateNote(config, existing.id, content, {
             type: noteType,
             agent: 'ledger-migrate',
             upsert_key: upsertKey,
-            local_file: filename,
+            file_path: filename,
             content_hash: hash,
-            delivery,
+            domain: noteDomain,
         });
-        console.error(`  Updated existing note ${existing.id} (type: ${noteType}, delivery: ${delivery})`);
+        console.error(`  Updated existing note ${existing.id} (type: ${noteType}, domain: ${noteDomain})`);
         return;
     }
     const { data, error } = await config.supabase
@@ -390,9 +390,9 @@ async function uploadNewNote(config, filename, content, hash) {
             type: noteType,
             agent: 'ledger-migrate',
             upsert_key: upsertKey,
-            local_file: filename,
+            file_path: filename,
             content_hash: hash,
-            delivery,
+            domain: noteDomain,
         },
         embedding,
     })
@@ -402,7 +402,7 @@ async function uploadNewNote(config, filename, content, hash) {
         console.error(`  Error uploading: ${error.message}`);
         return;
     }
-    console.error(`  Uploaded (note ${data.id}, type: ${noteType}, delivery: ${delivery})`);
+    console.error(`  Uploaded (note ${data.id}, type: ${noteType}, domain: ${noteDomain})`);
 }
 async function uploadFeedbackNote(config, upsertKey, content) {
     const embeddingResponse = await config.openai.embeddings.create({
@@ -410,7 +410,7 @@ async function uploadFeedbackNote(config, upsertKey, content) {
         input: content,
     });
     const embedding = embeddingResponse.data[0].embedding;
-    const localFile = upsertKey.replace(/-/g, '_') + '.md';
+    const filePath = upsertKey.replace(/-/g, '_') + '.md';
     const hash = contentHash(content);
     const { data, error } = await config.supabase
         .from('notes')
@@ -420,9 +420,9 @@ async function uploadFeedbackNote(config, upsertKey, content) {
             type: 'feedback',
             agent: 'ledger-migrate',
             upsert_key: upsertKey,
-            local_file: localFile,
+            file_path: filePath,
             content_hash: hash,
-            delivery: inferDelivery('feedback'),
+            domain: inferDomain('feedback'),
         },
         embedding,
     })

package/dist/commands/onboard.js

@@ -179,8 +179,8 @@ async function createNote(config, input) {
             type,
             agent: 'ledger-onboard',
             upsert_key: upsertKey,
-            local_file: localFile,
-            delivery: 'persona',
+            file_path: localFile,
+            domain: 'persona',
             content_hash: contentHash(content),
         },
         embedding,

package/dist/commands/pull.js

@@ -15,9 +15,10 @@ export async function pull(config, options) {
     const writtenFiles = [];
     const conflicts = [];
     for (const note of notes) {
-        const localFile = note.metadata.local_file;
-        if (!localFile)
+        const noteFilePath = note.metadata.file_path;
+        if (!noteFilePath)
             continue;
+        const localFile = noteFilePath.includes('/') ? noteFilePath.split('/').pop() : noteFilePath;
         const filePath = resolve(config.memoryDir, localFile);
         const ledgerContent = note.content;
         const ledgerHash = contentHash(ledgerContent);

package/dist/commands/push.js

@@ -1,7 +1,7 @@
 import { readFileSync, existsSync } from 'fs';
 import { resolve, basename } from 'path';
-import { findNoteByFile, updateNoteContent, updateNoteHash } from '../lib/notes.js';
-import { contentHash } from '../lib/hash.js';
+import { listDocuments } from '../lib/documents/fetching.js';
+import { updateDocument } from '../lib/documents/operations.js';
 import { fatal, ExitCode } from '../lib/errors.js';
 export async function push(config, filePath) {
     const absPath = resolve(filePath);
@@ -10,12 +10,12 @@ export async function push(config, filePath) {
     }
     const filename = basename(absPath);
     const content = readFileSync(absPath, 'utf-8').trim();
-    const existing = await findNoteByFile(config.supabase, filename);
+    // Find document by file_path matching the filename
+    const documents = await listDocuments(config.supabase, { limit: 100 });
+    const existing = documents.find(document => document.file_path && basename(document.file_path) === filename);
     if (!existing) {
-        fatal(`No Ledger note matching "${filename}" found. Add it via MCP first.`, ExitCode.NOTE_NOT_FOUND);
+        fatal(`No Ledger document matching "${filename}" found. Add it via MCP first.`, ExitCode.DOCUMENT_NOT_FOUND);
     }
-    await updateNoteContent(config.supabase, config.openai, existing.id, content);
-    const hash = contentHash(content);
-    await updateNoteHash(config.supabase, existing.id, hash);
-    console.log(`Pushed ${filename} → Ledger (note ${existing.id})`);
+    await updateDocument({ supabase: config.supabase, openai: config.openai }, { id: existing.id, content, agent: 'cli' });
+    console.log(`Pushed ${filename} → Ledger (document ${existing.id}, "${existing.name}")`);
 }