profclaw 2.0.0 → 2.3.0

package/dist/feeds/feed-engine.js

@@ -0,0 +1,600 @@
+/**
+ * RSS/Atom Feed Engine
+ *
+ * Fetches, parses, and stores articles from RSS/Atom feeds.
+ * Provides deduplication, categorization, and AI summarization integration.
+ *
+ * Fully dynamic - categories, sources, and bundles can be extended at runtime.
+ * No hardcoded limitations on feed types, categories, or article counts.
+ *
+ * Used by cron jobs to power "morning AI news digest" and similar automations.
+ */
+import { getClient } from '../storage/index.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('FeedEngine');
+// Pre-configured feed bundles (starter packs - users and agents can add more at runtime)
+export const FEED_BUNDLES = {
+    'ai-news': [
+        { name: 'OpenAI Blog', url: 'https://openai.com/blog/rss.xml', category: 'ai' },
+        { name: 'Anthropic News', url: 'https://www.anthropic.com/rss.xml', category: 'ai' },
+        { name: 'Hugging Face Blog', url: 'https://huggingface.co/blog/feed.xml', category: 'ai' },
+        { name: 'TechCrunch AI', url: 'https://techcrunch.com/category/artificial-intelligence/feed/', category: 'ai' },
+        { name: 'The Verge AI', url: 'https://www.theverge.com/rss/ai-artificial-intelligence/index.xml', category: 'ai' },
+        { name: 'MIT Tech Review', url: 'https://www.technologyreview.com/feed/', category: 'ai' },
+    ],
+    'dev-news': [
+        { name: 'Hacker News (Best)', url: 'https://hnrss.org/best', category: 'dev' },
+        { name: 'Lobsters', url: 'https://lobste.rs/rss', category: 'dev' },
+        { name: 'Dev.to Top', url: 'https://dev.to/feed', category: 'dev' },
+    ],
+    'security': [
+        { name: 'Krebs on Security', url: 'https://krebsonsecurity.com/feed/', category: 'security' },
+        { name: 'The Hacker News', url: 'https://feeds.feedburner.com/TheHackersNews', category: 'security' },
+        { name: 'Schneier on Security', url: 'https://www.schneier.com/feed/', category: 'security' },
+    ],
+};
+/**
+ * Register a custom feed bundle at runtime.
+ * Agents and users can call this to extend the available bundles.
+ */
+export function registerFeedBundle(name, feeds) {
+    FEED_BUNDLES[name] = feeds;
+    log.info(`Registered feed bundle: ${name} (${feeds.length} feeds)`);
+}
+// Database initialization
+const FEEDS_TABLE = `
+CREATE TABLE IF NOT EXISTS feed_sources (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  url TEXT NOT NULL UNIQUE,
+  category TEXT NOT NULL DEFAULT 'general',
+  tags TEXT NOT NULL DEFAULT '[]',
+  enabled INTEGER NOT NULL DEFAULT 1,
+  poll_interval_ms INTEGER NOT NULL DEFAULT 3600000,
+  last_polled_at TEXT,
+  last_error TEXT,
+  article_count INTEGER NOT NULL DEFAULT 0,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  user_id TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+const ARTICLES_TABLE = `
+CREATE TABLE IF NOT EXISTS feed_articles (
+  id TEXT PRIMARY KEY,
+  feed_id TEXT NOT NULL REFERENCES feed_sources(id) ON DELETE CASCADE,
+  title TEXT NOT NULL,
+  url TEXT NOT NULL,
+  summary TEXT,
+  content TEXT,
+  author TEXT,
+  published_at TEXT,
+  fetched_at TEXT NOT NULL DEFAULT (datetime('now')),
+  ai_summary TEXT,
+  digested_at TEXT,
+  content_hash TEXT NOT NULL,
+  UNIQUE(feed_id, content_hash)
+)`;
+const ARTICLES_INDEX = `CREATE INDEX IF NOT EXISTS idx_articles_feed_date ON feed_articles(feed_id, fetched_at DESC)`;
+const ARTICLES_URL_INDEX = `CREATE INDEX IF NOT EXISTS idx_articles_url ON feed_articles(url)`;
+let tablesInitialized = false;
+async function ensureTables() {
+    if (tablesInitialized)
+        return;
+    const client = getClient();
+    await client.execute(FEEDS_TABLE);
+    await client.execute(ARTICLES_TABLE);
+    await client.execute(ARTICLES_INDEX);
+    await client.execute(ARTICLES_URL_INDEX);
+    tablesInitialized = true;
+}
+// Feed CRUD
+export async function addFeed(params) {
+    await ensureTables();
+    const client = getClient();
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+    await client.execute({
+        sql: `INSERT INTO feed_sources (id, name, url, category, tags, poll_interval_ms, metadata, user_id, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+            id, params.name, params.url,
+            params.category || 'general',
+            JSON.stringify(params.tags || []),
+            params.pollIntervalMs || 3600000,
+            JSON.stringify(params.metadata || {}),
+            params.userId || null,
+            now, now,
+        ],
+    });
+    log.info(`Added feed: ${params.name} (${params.url})`);
+    return {
+        id,
+        name: params.name,
+        url: params.url,
+        category: params.category || 'general',
+        tags: params.tags || [],
+        enabled: true,
+        pollIntervalMs: params.pollIntervalMs || 3600000,
+        articleCount: 0,
+        metadata: params.metadata || {},
+        userId: params.userId,
+        createdAt: new Date(now),
+        updatedAt: new Date(now),
+    };
+}
+export async function addFeedBundle(bundleName, userId) {
+    const bundle = FEED_BUNDLES[bundleName];
+    if (!bundle) {
+        throw new Error(`Unknown feed bundle: ${bundleName}. Available: ${Object.keys(FEED_BUNDLES).join(', ')}`);
+    }
+    const results = [];
+    for (const feed of bundle) {
+        try {
+            const source = await addFeed({ ...feed, userId });
+            results.push(source);
+        }
+        catch (error) {
+            // Skip duplicates silently
+            if (error instanceof Error && error.message.includes('UNIQUE')) {
+                log.debug(`Feed already exists: ${feed.url}`);
+            }
+            else {
+                log.error(`Failed to add feed ${feed.name}:`, error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+    return results;
+}
+export async function listFeeds(filters) {
+    await ensureTables();
+    const client = getClient();
+    let sql = 'SELECT * FROM feed_sources WHERE 1=1';
+    const args = [];
+    if (filters?.category) {
+        sql += ' AND category = ?';
+        args.push(filters.category);
+    }
+    if (filters?.tag) {
+        // Search within JSON array
+        sql += ' AND tags LIKE ?';
+        args.push(`%"${filters.tag}"%`);
+    }
+    if (filters?.enabled !== undefined) {
+        sql += ' AND enabled = ?';
+        args.push(filters.enabled ? 1 : 0);
+    }
+    if (filters?.userId) {
+        sql += ' AND user_id = ?';
+        args.push(filters.userId);
+    }
+    sql += ' ORDER BY name ASC';
+    const result = await client.execute({ sql, args });
+    return result.rows.map(mapFeedRow);
+}
+export async function getFeed(id) {
+    await ensureTables();
+    const client = getClient();
+    const result = await client.execute({ sql: 'SELECT * FROM feed_sources WHERE id = ?', args: [id] });
+    return result.rows.length > 0 ? mapFeedRow(result.rows[0]) : null;
+}
+export async function updateFeed(id, updates) {
+    await ensureTables();
+    const client = getClient();
+    const sets = [];
+    const args = [];
+    if (updates.name !== undefined) {
+        sets.push('name = ?');
+        args.push(updates.name);
+    }
+    if (updates.category !== undefined) {
+        sets.push('category = ?');
+        args.push(updates.category);
+    }
+    if (updates.tags !== undefined) {
+        sets.push('tags = ?');
+        args.push(JSON.stringify(updates.tags));
+    }
+    if (updates.pollIntervalMs !== undefined) {
+        sets.push('poll_interval_ms = ?');
+        args.push(updates.pollIntervalMs);
+    }
+    if (updates.metadata !== undefined) {
+        sets.push('metadata = ?');
+        args.push(JSON.stringify(updates.metadata));
+    }
+    if (sets.length === 0)
+        return;
+    sets.push('updated_at = datetime("now")');
+    args.push(id);
+    await client.execute({
+        sql: `UPDATE feed_sources SET ${sets.join(', ')} WHERE id = ?`,
+        args,
+    });
+}
+export async function removeFeed(id) {
+    await ensureTables();
+    const client = getClient();
+    const result = await client.execute({ sql: 'DELETE FROM feed_sources WHERE id = ?', args: [id] });
+    return result.rowsAffected > 0;
+}
+export async function toggleFeed(id, enabled) {
+    await ensureTables();
+    const client = getClient();
+    await client.execute({
+        sql: 'UPDATE feed_sources SET enabled = ?, updated_at = datetime("now") WHERE id = ?',
+        args: [enabled ? 1 : 0, id],
+    });
+}
+// Feed polling and parsing
+/**
+ * Parse an RSS/Atom XML feed into articles.
+ * Lightweight regex-based parser - no external dependencies needed.
+ */
+export function parseFeedXml(xml) {
+    const articles = [];
+    const isAtom = xml.includes('<feed') && xml.includes('xmlns="http://www.w3.org/2005/Atom"');
+    if (isAtom) {
+        const entryRegex = /<entry>([\s\S]*?)<\/entry>/gi;
+        let match;
+        while ((match = entryRegex.exec(xml)) !== null) {
+            const entry = match[1];
+            const title = extractTag(entry, 'title');
+            const link = extractAtomLink(entry);
+            const summary = extractTag(entry, 'summary') || extractTag(entry, 'content');
+            const author = extractTag(entry, 'name');
+            const published = extractTag(entry, 'published') || extractTag(entry, 'updated');
+            if (title && link) {
+                articles.push({
+                    title: decodeHtmlEntities(title),
+                    url: link,
+                    summary: summary ? decodeHtmlEntities(stripHtml(summary)).slice(0, 500) : undefined,
+                    author: author ? decodeHtmlEntities(author) : undefined,
+                    publishedAt: published || undefined,
+                });
+            }
+        }
+    }
+    else {
+        const itemRegex = /<item>([\s\S]*?)<\/item>/gi;
+        let match;
+        while ((match = itemRegex.exec(xml)) !== null) {
+            const item = match[1];
+            const title = extractTag(item, 'title');
+            const link = extractTag(item, 'link');
+            const description = extractTag(item, 'description');
+            const contentEncoded = extractTag(item, 'content:encoded');
+            const author = extractTag(item, 'dc:creator') || extractTag(item, 'author');
+            const pubDate = extractTag(item, 'pubDate');
+            if (title && link) {
+                articles.push({
+                    title: decodeHtmlEntities(title),
+                    url: link.trim(),
+                    summary: description ? decodeHtmlEntities(stripHtml(description)).slice(0, 500) : undefined,
+                    content: contentEncoded ? decodeHtmlEntities(stripHtml(contentEncoded)).slice(0, 2000) : undefined,
+                    author: author ? decodeHtmlEntities(author) : undefined,
+                    publishedAt: pubDate || undefined,
+                });
+            }
+        }
+    }
+    return articles;
+}
+/**
+ * Poll a single feed source and store new articles.
+ */
+export async function pollFeed(feedId) {
+    await ensureTables();
+    const client = getClient();
+    const feedResult = await client.execute({ sql: 'SELECT * FROM feed_sources WHERE id = ?', args: [feedId] });
+    if (feedResult.rows.length === 0) {
+        return { newArticles: 0, errors: 'Feed not found' };
+    }
+    const feed = mapFeedRow(feedResult.rows[0]);
+    let newArticles = 0;
+    try {
+        const response = await fetch(feed.url, {
+            headers: {
+                'User-Agent': 'profClaw/2.0 Feed Reader',
+                'Accept': 'application/rss+xml, application/atom+xml, application/xml, text/xml',
+            },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const xml = await response.text();
+        const parsed = parseFeedXml(xml);
+        for (const article of parsed) {
+            const contentHash = hashString(`${feed.id}:${article.url}:${article.title}`);
+            try {
+                await client.execute({
+                    sql: `INSERT OR IGNORE INTO feed_articles
+                (id, feed_id, title, url, summary, content, author, published_at, fetched_at, content_hash)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)`,
+                    args: [
+                        crypto.randomUUID(),
+                        feedId,
+                        article.title,
+                        article.url,
+                        article.summary || null,
+                        article.content || null,
+                        article.author || null,
+                        article.publishedAt || null,
+                        contentHash,
+                    ],
+                });
+                newArticles++;
+            }
+            catch {
+                // Duplicate - skip
+            }
+        }
+        await client.execute({
+            sql: `UPDATE feed_sources SET
+              last_polled_at = datetime('now'),
+              last_error = NULL,
+              article_count = article_count + ?,
+              updated_at = datetime('now')
+            WHERE id = ?`,
+            args: [newArticles, feedId],
+        });
+        log.info(`Polled ${feed.name}: ${newArticles} new articles from ${parsed.length} total`);
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        await client.execute({
+            sql: `UPDATE feed_sources SET last_polled_at = datetime('now'), last_error = ?, updated_at = datetime('now') WHERE id = ?`,
+            args: [errMsg, feedId],
+        });
+        log.error(`Feed poll failed for ${feed.name}:`, error instanceof Error ? error : new Error(errMsg));
+        return { newArticles: 0, errors: errMsg };
+    }
+    return { newArticles };
+}
+/**
+ * Poll all enabled feeds that are due for polling.
+ */
+export async function pollAllFeeds() {
+    const feeds = await listFeeds({ enabled: true });
+    let total = 0;
+    let newArticles = 0;
+    let errors = 0;
+    for (const feed of feeds) {
+        if (feed.lastPolledAt) {
+            const timeSincePoll = Date.now() - feed.lastPolledAt.getTime();
+            if (timeSincePoll < feed.pollIntervalMs)
+                continue;
+        }
+        total++;
+        const result = await pollFeed(feed.id);
+        newArticles += result.newArticles;
+        if (result.errors)
+            errors++;
+        // Small delay between feeds to be nice to servers
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    log.info(`Feed poll complete: ${total} feeds polled, ${newArticles} new articles, ${errors} errors`);
+    return { total, newArticles, errors };
+}
+/**
+ * Get recent articles for a digest.
+ * All filters are optional - the engine imposes no limits by default.
+ */
+export async function getDigestArticles(options) {
+    await ensureTables();
+    const client = getClient();
+    const since = options?.since || new Date(Date.now() - 24 * 60 * 60 * 1000);
+    const limit = options?.limit || 50;
+    let sql = `
+    SELECT a.*
+    FROM feed_articles a
+    JOIN feed_sources f ON a.feed_id = f.id
+    WHERE a.fetched_at >= ?
+  `;
+    const args = [since.toISOString()];
+    if (options?.category) {
+        sql += ' AND f.category = ?';
+        args.push(options.category);
+    }
+    if (options?.tag) {
+        sql += ' AND f.tags LIKE ?';
+        args.push(`%"${options.tag}"%`);
+    }
+    if (options?.feedId) {
+        sql += ' AND a.feed_id = ?';
+        args.push(options.feedId);
+    }
+    if (options?.undigestedOnly) {
+        sql += ' AND a.digested_at IS NULL';
+    }
+    sql += ' ORDER BY a.fetched_at DESC LIMIT ?';
+    args.push(limit);
+    const result = await client.execute({ sql, args });
+    return result.rows.map(mapArticleRow);
+}
+/**
+ * Mark articles as digested (included in a delivered digest).
+ */
+export async function markAsDigested(articleIds) {
+    if (articleIds.length === 0)
+        return;
+    await ensureTables();
+    const client = getClient();
+    // Batch in groups of 100 for safety
+    for (let i = 0; i < articleIds.length; i += 100) {
+        const batch = articleIds.slice(i, i + 100);
+        const placeholders = batch.map(() => '?').join(',');
+        await client.execute({
+            sql: `UPDATE feed_articles SET digested_at = datetime('now') WHERE id IN (${placeholders})`,
+            args: batch,
+        });
+    }
+}
+/**
+ * Get feed statistics.
+ */
+export async function getFeedStats() {
+    await ensureTables();
+    const client = getClient();
+    const total = await client.execute('SELECT COUNT(*) as count FROM feed_sources');
+    const enabled = await client.execute('SELECT COUNT(*) as count FROM feed_sources WHERE enabled = 1');
+    const articles = await client.execute('SELECT COUNT(*) as count FROM feed_articles');
+    const today = await client.execute(`SELECT COUNT(*) as count FROM feed_articles WHERE fetched_at >= datetime('now', '-1 day')`);
+    const catResult = await client.execute('SELECT category, COUNT(*) as count FROM feed_sources GROUP BY category');
+    const byCategory = {};
+    for (const row of catResult.rows) {
+        byCategory[row.category] = row.count;
+    }
+    return {
+        totalFeeds: total.rows[0].count,
+        enabledFeeds: enabled.rows[0].count,
+        totalArticles: articles.rows[0].count,
+        articlesToday: today.rows[0].count,
+        byCategory,
+    };
+}
+/**
+ * List all distinct categories currently in use.
+ */
+export async function listCategories() {
+    await ensureTables();
+    const client = getClient();
+    const result = await client.execute('SELECT DISTINCT category FROM feed_sources ORDER BY category');
+    return result.rows.map((r) => r.category);
+}
+/**
+ * Auto-discover feed URL from a website.
+ * Fetches the page and looks for RSS/Atom link tags.
+ */
+export async function discoverFeedUrl(websiteUrl) {
+    try {
+        const response = await fetch(websiteUrl, {
+            headers: { 'User-Agent': 'profClaw/2.0 Feed Discovery' },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok)
+            return null;
+        const html = await response.text();
+        // Look for <link rel="alternate" type="application/rss+xml" href="..." />
+        const rssMatch = html.match(/<link[^>]*type="application\/(?:rss|atom)\+xml"[^>]*href="([^"]+)"/i);
+        if (rssMatch) {
+            const href = rssMatch[1];
+            // Resolve relative URLs
+            if (href.startsWith('http'))
+                return href;
+            const base = new URL(websiteUrl);
+            return new URL(href, base).toString();
+        }
+        // Fallback: try common feed paths
+        const commonPaths = ['/feed', '/rss', '/rss.xml', '/feed.xml', '/atom.xml', '/blog/rss.xml'];
+        for (const path of commonPaths) {
+            try {
+                const feedUrl = new URL(path, websiteUrl).toString();
+                const feedResp = await fetch(feedUrl, {
+                    method: 'HEAD',
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (feedResp.ok)
+                    return feedUrl;
+            }
+            catch {
+                // Try next
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// Helper functions
+function extractTag(xml, tagName) {
+    const cdataRegex = new RegExp(`<${tagName}[^>]*>\\s*<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>\\s*<\\/${tagName}>`, 'i');
+    const cdataMatch = cdataRegex.exec(xml);
+    if (cdataMatch)
+        return cdataMatch[1].trim();
+    const regex = new RegExp(`<${tagName}[^>]*>([\\s\\S]*?)<\\/${tagName}>`, 'i');
+    const match = regex.exec(xml);
+    return match ? match[1].trim() : null;
+}
+function extractAtomLink(entry) {
+    const linkRegex = /<link[^>]*href="([^"]*)"[^>]*(?:rel="alternate")?[^>]*\/?>/gi;
+    let match;
+    let bestLink = null;
+    while ((match = linkRegex.exec(entry)) !== null) {
+        const fullTag = match[0];
+        const href = match[1];
+        if (fullTag.includes('rel="alternate"') || !bestLink) {
+            bestLink = href;
+        }
+    }
+    return bestLink;
+}
+function stripHtml(html) {
+    return html.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+}
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&#x27;/g, "'")
+        .replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code)));
+}
+function hashString(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        const char = input.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+}
+function mapFeedRow(row) {
+    let tags = [];
+    try {
+        tags = JSON.parse(row.tags || '[]');
+    }
+    catch { /* empty */ }
+    let metadata = {};
+    try {
+        metadata = JSON.parse(row.metadata || '{}');
+    }
+    catch { /* empty */ }
+    return {
+        id: row.id,
+        name: row.name,
+        url: row.url,
+        category: row.category || 'general',
+        tags,
+        enabled: row.enabled === 1,
+        pollIntervalMs: row.poll_interval_ms || 3600000,
+        lastPolledAt: row.last_polled_at ? new Date(row.last_polled_at) : undefined,
+        lastError: row.last_error,
+        articleCount: row.article_count || 0,
+        metadata,
+        userId: row.user_id,
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+    };
+}
+function mapArticleRow(row) {
+    return {
+        id: row.id,
+        feedId: row.feed_id,
+        title: row.title,
+        url: row.url,
+        summary: row.summary,
+        content: row.content,
+        author: row.author,
+        publishedAt: row.published_at ? new Date(row.published_at) : undefined,
+        fetchedAt: new Date(row.fetched_at),
+        aiSummary: row.ai_summary,
+        digestedAt: row.digested_at ? new Date(row.digested_at) : undefined,
+        contentHash: row.content_hash,
+    };
+}
+//# sourceMappingURL=feed-engine.js.map

package/dist/feeds/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Feed Engine - Public API
+ *
+ * Fully dynamic feed system - no hardcoded limitations.
+ * Categories, sources, and bundles can all be extended at runtime.
+ */
+export { addFeed, addFeedBundle, listFeeds, getFeed, updateFeed, removeFeed, toggleFeed, pollFeed, pollAllFeeds, getDigestArticles, markAsDigested, getFeedStats, listCategories, discoverFeedUrl, parseFeedXml, registerFeedBundle, FEED_BUNDLES, } from './feed-engine.js';
+export type { FeedSource, FeedArticle, FeedDigest, FeedBundleEntry, CreateFeedParams, } from './feed-engine.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/feeds/index.js

@@ -0,0 +1,8 @@
+/**
+ * Feed Engine - Public API
+ *
+ * Fully dynamic feed system - no hardcoded limitations.
+ * Categories, sources, and bundles can all be extended at runtime.
+ */
+export { addFeed, addFeedBundle, listFeeds, getFeed, updateFeed, removeFeed, toggleFeed, pollFeed, pollAllFeeds, getDigestArticles, markAsDigested, getFeedStats, listCategories, discoverFeedUrl, parseFeedXml, registerFeedBundle, FEED_BUNDLES, } from './feed-engine.js';
+//# sourceMappingURL=index.js.map

package/dist/gateway/router.js

@@ -606,7 +606,12 @@ export class GatewayRouter {
         return getAgentRegistry().getActiveAdapters();
     }
     async getAgentHealth(agentId) {
-        const adapter = getAgentRegistry().getAdapter(agentId);
+        const registry = getAgentRegistry();
+        // Look up by ID first, then fall back to matching by type
+        let adapter = registry.getAdapter(agentId);
+        if (!adapter) {
+            adapter = registry.getActiveAdapters().find(a => a.type === agentId);
+        }
         if (!adapter) {
             return {
                 healthy: false,

package/dist/hooks/built-in/audit-log.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Built-in Hook: Audit Log
+ *
+ * Logs all tool executions after they complete (`afterToolCall`).
+ * Records: timestamp, sessionId, toolName, sanitized args, success/failure,
+ * and duration (if startedAt is provided via metadata).
+ */
+import type { Hook } from '../registry.js';
+export declare const auditLogHook: Hook;
+export default auditLogHook;
+//# sourceMappingURL=audit-log.d.ts.map