@geekbeer/minion 3.51.2 → 3.53.1

package/.env.example

@@ -17,3 +17,10 @@ MINION_ID=
 
 # Agent port (optional, default: 8080)
 AGENT_PORT=8080
+
+# Anthropic API key (optional, experimental, fallback only) —
+# POST /api/web/extract prefers the primary LLM plugin (see PUT /api/llm/config)
+# and only uses ANTHROPIC_API_KEY if no primary plugin is configured. Set via:
+#   curl -X PUT http://localhost:8080/api/secrets/ANTHROPIC_API_KEY \
+#     -H "Authorization: Bearer $API_TOKEN" -d '{"value": "sk-ant-..."}'
+ANTHROPIC_API_KEY=

package/core/api.js

@@ -6,6 +6,16 @@
  */
 
 const { config, isHqConfigured } = require('./config')
+const frozenState = require('./lib/frozen-state')
+
+class BillingFrozenError extends Error {
+  constructor(reason) {
+    super(`Minion is billing-frozen: ${reason || 'unknown'}`)
+    this.name = 'BillingFrozenError'
+    this.statusCode = 402
+    this.billingFrozen = true
+  }
+}
 
 /**
  * Send HTTP request to the HQ server
@@ -17,6 +27,10 @@ async function request(endpoint, options = {}) {
     return { skipped: true, reason: 'HQ not configured' }
   }
 
+  if (frozenState.isFrozen()) {
+    throw new BillingFrozenError(frozenState.getState().reason)
+  }
+
   const url = `${config.HQ_URL}/api/minion${endpoint}`
 
   const response = await fetch(url, {
@@ -28,10 +42,19 @@ async function request(endpoint, options = {}) {
     },
   })
 
-  const data = await response.json()
+  let data = null
+  try {
+    data = await response.json()
+  } catch {
+    data = {}
+  }
+
+  if (frozenState.maybeFreezeFromResponse(response, data)) {
+    throw new BillingFrozenError(data && data.reason)
+  }
 
   if (!response.ok) {
-    const err = new Error(data.error || `API request failed: ${response.status}`)
+    const err = new Error((data && data.error) || `API request failed: ${response.status}`)
     err.statusCode = response.status
     throw err
   }
@@ -203,4 +226,5 @@ module.exports = {
   deleteThread,
   createProjectMemory,
   searchProjectMemories,
+  BillingFrozenError,
 }

package/core/db/migrations/20260508000000_page_recipes.js

@@ -0,0 +1,33 @@
+/**
+ * page_recipes — Web page extraction recipe cache (experimental, v3.53.0).
+ *
+ * Stores selectors learned from a first-time visit so subsequent visits to
+ * structurally similar pages skip the LLM round trip. Keyed by URL template
+ * (after normalization) + DOM fingerprint to tolerate A/B variants.
+ *
+ * Marked experimental: schema may change before the API stabilizes.
+ */
+
+module.exports = {
+  version: 20260508000000,
+  name: 'page_recipes',
+
+  up(db, { tableExists }) {
+    if (tableExists(db, 'page_recipes')) return
+
+    db.exec(`
+      CREATE TABLE page_recipes (
+        url_template TEXT NOT NULL,
+        dom_fingerprint TEXT NOT NULL,
+        selectors_json TEXT NOT NULL,
+        page_type TEXT,
+        hit_count INTEGER NOT NULL DEFAULT 0,
+        fail_count INTEGER NOT NULL DEFAULT 0,
+        last_verified_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (url_template, dom_fingerprint)
+      );
+      CREATE INDEX idx_page_recipes_template ON page_recipes(url_template);
+    `)
+  },
+}

package/core/lib/board-task-poller.js

@@ -21,6 +21,8 @@
 
 const { config, isHqConfigured } = require('../config')
 const concurrency = require('./concurrency-manager')
+const frozenState = require('./frozen-state')
+const api = require('../api')
 
 // Polling interval: 30 seconds (matches dag-step-poller).
 const POLL_INTERVAL_MS = 30_000
@@ -45,6 +47,9 @@ async function hqRequest(endpoint, options = {}) {
   if (!isHqConfigured()) {
     return { skipped: true, reason: 'HQ not configured' }
   }
+  if (frozenState.isFrozen()) {
+    throw new api.BillingFrozenError(frozenState.getState().reason)
+  }
   const url = `${config.HQ_URL}${endpoint}`
   const resp = await fetch(url, {
     ...options,
@@ -61,6 +66,9 @@ async function hqRequest(endpoint, options = {}) {
   } catch {
     data = { raw: text }
   }
+  if (frozenState.maybeFreezeFromResponse(resp, data)) {
+    throw new api.BillingFrozenError(data && data.reason)
+  }
   if (!resp.ok) {
     const err = new Error(data.error || `HQ ${endpoint} failed: ${resp.status}`)
     err.statusCode = resp.status
@@ -72,6 +80,7 @@ async function hqRequest(endpoint, options = {}) {
 
 async function pollOnce() {
   if (!isHqConfigured()) return
+  if (frozenState.isFrozen()) return
   if (!runner) {
     console.warn('[BoardTaskPoller] No runner injected, skipping poll')
     return
@@ -117,7 +126,9 @@ async function pollOnce() {
         })
     }
   } catch (err) {
-    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+    if (err.billingFrozen) {
+      console.log('[BoardTaskPoller] Billing frozen, suspending poll')
+    } else if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
       console.log('[BoardTaskPoller] HQ unreachable, will retry next cycle')
     } else {
       console.error(`[BoardTaskPoller] Poll error: ${err.message}`)

package/core/lib/dag-cron-poller.js

@@ -12,6 +12,8 @@
  */
 
 const { config, isHqConfigured } = require('../config')
+const frozenState = require('./frozen-state')
+const api = require('../api')
 
 const POLL_INTERVAL_MS = 60_000
 
@@ -22,6 +24,7 @@ let lastFiredCount = 0
 
 async function pollOnce() {
   if (!isHqConfigured()) return
+  if (frozenState.isFrozen()) return
   if (polling) return
 
   polling = true
@@ -35,6 +38,14 @@ async function pollOnce() {
       },
     })
 
+    let payload = null
+    if (resp.status === 402) {
+      try { payload = await resp.json() } catch { payload = {} }
+      if (frozenState.maybeFreezeFromResponse(resp, payload)) {
+        throw new api.BillingFrozenError(payload && payload.reason)
+      }
+    }
+
     if (!resp.ok) {
       throw new Error(`dag-cron-tick failed: ${resp.status}`)
     }
@@ -58,7 +69,9 @@ async function pollOnce() {
       }
     }
   } catch (err) {
-    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+    if (err.billingFrozen) {
+      console.log('[DagCronPoller] Billing frozen, suspending poll')
+    } else if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
       console.log('[DagCronPoller] HQ unreachable, will retry next cycle')
     } else {
       console.error(`[DagCronPoller] Poll error: ${err.message}`)

package/core/lib/dag-step-poller.js

@@ -13,6 +13,7 @@ const { config, isHqConfigured } = require('../config')
 const api = require('../api')
 const variableStore = require('../stores/variable-store')
 const concurrency = require('./concurrency-manager')
+const frozenState = require('./frozen-state')
 
 // Polling interval: 30 seconds (matches step-poller)
 const POLL_INTERVAL_MS = 30_000
@@ -38,6 +39,10 @@ async function dagRequest(endpoint, options = {}) {
     return { skipped: true, reason: 'HQ not configured' }
   }
 
+  if (frozenState.isFrozen()) {
+    throw new api.BillingFrozenError(frozenState.getState().reason)
+  }
+
   const url = `${config.HQ_URL}/api/dag/minion${endpoint}`
   const resp = await fetch(url, {
     ...options,
@@ -48,6 +53,14 @@ async function dagRequest(endpoint, options = {}) {
     },
   })
 
+  let payload = null
+  if (resp.status === 402) {
+    try { payload = await resp.json() } catch { payload = {} }
+    if (frozenState.maybeFreezeFromResponse(resp, payload)) {
+      throw new api.BillingFrozenError(payload && payload.reason)
+    }
+  }
+
   if (!resp.ok) {
     const err = new Error(`DAG API ${endpoint} failed: ${resp.status}`)
     err.statusCode = resp.status
@@ -62,6 +75,7 @@ async function dagRequest(endpoint, options = {}) {
  */
 async function pollOnce() {
   if (!isHqConfigured()) return
+  if (frozenState.isFrozen()) return
   if (polling) return
 
   polling = true
@@ -90,7 +104,9 @@ async function pollOnce() {
       promise
     }
   } catch (err) {
-    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+    if (err.billingFrozen) {
+      console.log('[DagPoller] Billing frozen, suspending poll')
+    } else if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
       console.log('[DagPoller] HQ unreachable, will retry next cycle')
     } else {
       console.error(`[DagPoller] Poll error: ${err.message}`)

package/core/lib/frozen-state.js

@@ -0,0 +1,64 @@
+/**
+ * Frozen State Module
+ *
+ * Tracks billing-driven freeze state in-memory. When frozen, all pollers
+ * skip their work and the shared HTTP wrappers refuse outbound calls.
+ *
+ * State is intentionally NOT persisted to disk:
+ * - Recovery is driven by HQ pushing `restart-agent` after payment success.
+ * - Process restart naturally clears the in-memory flag.
+ * - On restart, if billing is still past_due, the next request will receive
+ *   402 from HQ and self-freeze again. Self-healing.
+ */
+
+let frozen = false
+let frozenAt = null
+let reason = null
+
+function isFrozen() {
+  return frozen
+}
+
+function setFrozen(opts = {}) {
+  if (frozen) return
+  frozen = true
+  frozenAt = new Date().toISOString()
+  reason = opts.reason || 'unknown'
+  console.log(`[FrozenState] Minion frozen: reason=${reason} at=${frozenAt}`)
+}
+
+function clearFrozen() {
+  if (!frozen) return
+  frozen = false
+  frozenAt = null
+  reason = null
+  console.log('[FrozenState] Minion unfrozen (in-memory state cleared)')
+}
+
+function getState() {
+  return { frozen, frozenAt, reason }
+}
+
+/**
+ * Inspect a fetch Response for the 402 billing-frozen signal and
+ * self-freeze if matched. Returns true if frozen was set.
+ *
+ * Expected payload: `{ "error": "billing_frozen", "reason": "past_due", ... }`
+ */
+function maybeFreezeFromResponse(response, payload) {
+  if (response && response.status === 402) {
+    if (payload && payload.error === 'billing_frozen') {
+      setFrozen({ reason: payload.reason || 'billing_frozen' })
+      return true
+    }
+  }
+  return false
+}
+
+module.exports = {
+  isFrozen,
+  setFrozen,
+  clearFrozen,
+  getState,
+  maybeFreezeFromResponse,
+}

package/core/lib/revision-watcher.js

@@ -15,6 +15,7 @@
 
 const { config, isHqConfigured } = require('../config')
 const api = require('../api')
+const frozenState = require('./frozen-state')
 
 // Poll every 30 seconds (same frequency as step-poller)
 const POLL_INTERVAL_MS = 30_000
@@ -33,6 +34,7 @@ const processingRevisions = new Set()
  */
 async function pollOnce() {
   if (!isHqConfigured()) return
+  if (frozenState.isFrozen()) return
   if (polling) return
 
   polling = true
@@ -59,7 +61,9 @@ async function pollOnce() {
       }
     }
   } catch (err) {
-    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+    if (err.billingFrozen) {
+      console.log(`[RevisionWatcher] Billing frozen, suspending poll`)
+    } else if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
       console.log(`[RevisionWatcher] HQ unreachable, will retry next cycle`)
     } else {
       console.error(`[RevisionWatcher] Poll error: ${err.message}`)

package/core/lib/step-poller.js

@@ -21,6 +21,7 @@
 const { config, isHqConfigured } = require('../config')
 const api = require('../api')
 const variableStore = require('../stores/variable-store')
+const frozenState = require('./frozen-state')
 
 // Polling interval: 30 seconds (matches heartbeat frequency)
 const POLL_INTERVAL_MS = 30_000
@@ -42,6 +43,7 @@ let lastPollAt = null
  */
 async function pollOnce() {
   if (!isHqConfigured()) return
+  if (frozenState.isFrozen()) return
   if (polling) return
 
   polling = true
@@ -70,7 +72,9 @@ async function pollOnce() {
     }
   } catch (err) {
     // Don't log network errors at error level — they're expected when HQ is temporarily unreachable
-    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+    if (err.billingFrozen) {
+      console.log(`[StepPoller] Billing frozen, suspending poll`)
+    } else if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
       console.log(`[StepPoller] HQ unreachable, will retry next cycle`)
     } else {
       console.error(`[StepPoller] Poll error: ${err.message}`)

package/core/lib/thread-watcher.js

@@ -20,6 +20,7 @@
 
 const { config, isHqConfigured, isLlmConfigured } = require('../config')
 const api = require('../api')
+const frozenState = require('./frozen-state')
 
 // Poll every 15 seconds
 const POLL_INTERVAL_MS = 15_000
@@ -94,6 +95,7 @@ function isMentioned(thread, messages, myRole) {
  */
 async function pollOnce() {
   if (!isHqConfigured()) return
+  if (frozenState.isFrozen()) return
   if (polling) return
 
   polling = true
@@ -115,7 +117,9 @@ async function pollOnce() {
       }
     }
   } catch (err) {
-    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+    if (err.billingFrozen) {
+      // Billing frozen — silent
+    } else if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
       // HQ unreachable — silent retry
     } else {
       console.error(`[ThreadWatcher] Poll error: ${err.message}`)

package/core/lib/web-extract/extractor.js

@@ -0,0 +1,142 @@
+/**
+ * Web extraction orchestrator (experimental — v3.53.0).
+ *
+ * Cold path: Playwright fetch -> Readability/Turndown clean -> Anthropic
+ *            Haiku selects fields -> store recipe -> verify by replaying
+ *            selectors against the same page.
+ *
+ * Hot path:  Playwright fetch -> fingerprint -> recipe lookup -> selector
+ *            replay. No LLM call.
+ *
+ * Self-heal: hot replays that come back empty bump fail_count; the recipe
+ *            is dropped after MAX_FAIL_COUNT and the next request retries
+ *            cold. A single in-request fall-through from hot -> cold is
+ *            allowed so callers don't see transient breakage.
+ */
+
+const { normalizeUrl } = require('./url-normalize')
+const { computeFingerprint } = require('./fingerprint')
+const { renderPage, extractWithSelectors } = require('./playwright-runner')
+const { cleanHtml } = require('./html-cleaner')
+const { generateRecipe } = require('./recipe-generator')
+const pageRecipeStore = require('../../stores/page-recipe-store')
+
+function isEmptyResult(data) {
+  if (!data || typeof data !== 'object') return true
+  const values = Object.values(data)
+  if (values.length === 0) return true
+  return values.every(v => {
+    if (v == null) return true
+    if (typeof v === 'string') return v.trim() === ''
+    if (Array.isArray(v)) return v.length === 0
+    return false
+  })
+}
+
+async function extract({ url, hint }) {
+  const { template, canonicalUrl } = normalizeUrl(url)
+
+  // Always render once up-front so we can compute the fingerprint regardless
+  // of cache state. Cold path reuses the HTML; hot path discards it.
+  const rendered = await renderPage(canonicalUrl)
+  const fingerprint = computeFingerprint(rendered.html)
+
+  const cached = pageRecipeStore.find({
+    urlTemplate: template,
+    domFingerprint: fingerprint,
+  })
+
+  if (cached) {
+    const data = await extractWithSelectors(canonicalUrl, cached.selectors)
+    if (!isEmptyResult(data)) {
+      pageRecipeStore.incrementHit({ urlTemplate: template, domFingerprint: fingerprint })
+      pageRecipeStore.setLastVerified({ urlTemplate: template, domFingerprint: fingerprint })
+      return shape({
+        url: canonicalUrl,
+        finalUrl: rendered.finalUrl,
+        statusCode: rendered.statusCode,
+        recipeMode: 'hot',
+        urlTemplate: template,
+        fingerprint,
+        pageType: cached.page_type,
+        selectors: cached.selectors,
+        data,
+        cleaned: null,
+      })
+    }
+    // Hot replay returned nothing — penalize and fall through to cold.
+    pageRecipeStore.incrementFail({ urlTemplate: template, domFingerprint: fingerprint })
+  }
+
+  // Cold path
+  const cleaned = cleanHtml(rendered.html, canonicalUrl)
+  const recipe = await generateRecipe({
+    url: canonicalUrl,
+    cleanedMarkdown: cleaned.contentMarkdown,
+    hint,
+  })
+
+  // Verify the recipe against this exact page before persisting.
+  const verifyData = await extractWithSelectors(canonicalUrl, recipe.selectors)
+  const verified = !isEmptyResult(verifyData)
+
+  if (verified) {
+    pageRecipeStore.upsert({
+      urlTemplate: template,
+      domFingerprint: fingerprint,
+      selectors: recipe.selectors,
+      pageType: recipe.pageType,
+    })
+    pageRecipeStore.incrementHit({ urlTemplate: template, domFingerprint: fingerprint })
+  }
+
+  return shape({
+    url: canonicalUrl,
+    finalUrl: rendered.finalUrl,
+    statusCode: rendered.statusCode,
+    recipeMode: 'cold',
+    urlTemplate: template,
+    fingerprint,
+    pageType: recipe.pageType,
+    selectors: recipe.selectors,
+    data: verified ? verifyData : recipe.extracted,
+    cleaned,
+    recipePersisted: verified,
+  })
+}
+
+function shape({ url, finalUrl, statusCode, recipeMode, urlTemplate, fingerprint, pageType, selectors, data, cleaned, recipePersisted }) {
+  const out = {
+    experimental: true,
+    url,
+    finalUrl,
+    statusCode,
+    recipeMode,
+    recipeId: `${urlTemplate}#${fingerprint}`,
+    pageType: pageType || null,
+    title: pickField(data, ['title', 'headline', 'name']) || cleaned?.title || null,
+    content: pickField(data, ['body', 'content', 'article', 'description']) || cleaned?.contentMarkdown || null,
+    structured: data || {},
+    selectors: selectors || {},
+  }
+  if (recipeMode === 'cold' && recipePersisted === false) {
+    out.warning = 'Recipe verification failed (selectors returned empty). Result reflects LLM extraction; recipe was not persisted.'
+  }
+  return out
+}
+
+function pickField(obj, candidates) {
+  if (!obj || typeof obj !== 'object') return null
+  for (const key of candidates) {
+    const v = obj[key]
+    if (v == null) continue
+    if (typeof v === 'string' && v.trim() !== '') return v
+    if (Array.isArray(v) && v.length > 0) return v.join('\n\n')
+  }
+  return null
+}
+
+module.exports = {
+  extract,
+  isEmptyResult,
+}

package/core/lib/web-extract/fingerprint.js

@@ -0,0 +1,63 @@
+/**
+ * Lightweight DOM structure fingerprint.
+ *
+ * Two pages with the same template URL but materially different layouts
+ * (A/B test, logged-in vs logged-out, mobile vs desktop served) need to
+ * use different recipes. We hash a minimal structural signature instead
+ * of the full HTML so the fingerprint stays stable against trivial copy
+ * changes but flips when block-level structure shifts.
+ *
+ * Signature inputs:
+ *   - Order of structural landmark tags (header/nav/main/article/...)
+ *   - Top 5 most frequent class names on <div> elements
+ */
+
+const crypto = require('crypto')
+
+const LANDMARK_TAGS = ['header', 'nav', 'main', 'article', 'section', 'aside', 'footer', 'form']
+
+function computeFingerprint(html) {
+  if (typeof html !== 'string' || html.length === 0) {
+    return 'empty'
+  }
+
+  let document
+  try {
+    const { parseHTML } = require('linkedom')
+    document = parseHTML(html).document
+  } catch (err) {
+    // If linkedom fails (extremely malformed HTML), fall back to a length bucket
+    return 'fallback-' + crypto.createHash('sha1').update(html.slice(0, 4096)).digest('hex').slice(0, 12)
+  }
+
+  // Landmark tag sequence (first occurrence only, in document order)
+  const seen = []
+  const seenSet = new Set()
+  const allEls = document.querySelectorAll(LANDMARK_TAGS.join(','))
+  for (const el of allEls) {
+    const tag = el.tagName.toLowerCase()
+    if (!seenSet.has(tag)) {
+      seenSet.add(tag)
+      seen.push(tag)
+    }
+  }
+
+  // Top 5 div classes by frequency
+  const classCounts = new Map()
+  const divs = document.querySelectorAll('div[class]')
+  for (const div of divs) {
+    const classes = (div.getAttribute('class') || '').split(/\s+/).filter(Boolean)
+    for (const c of classes) {
+      classCounts.set(c, (classCounts.get(c) || 0) + 1)
+    }
+  }
+  const topClasses = [...classCounts.entries()]
+    .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1))
+    .slice(0, 5)
+    .map(([c]) => c)
+
+  const signature = `tags:${seen.join(',')}|cls:${topClasses.join(',')}`
+  return crypto.createHash('sha1').update(signature).digest('hex').slice(0, 12)
+}
+
+module.exports = { computeFingerprint }

package/core/lib/web-extract/html-cleaner.js

@@ -0,0 +1,72 @@
+/**
+ * HTML → cleaned content (Readability) → Markdown (Turndown).
+ *
+ * The cleaned Markdown is the *only* page representation handed to the
+ * recipe-generation LLM. Keeping the input small and structured is what
+ * makes this experiment cheap enough to be worth running on every
+ * cold-cache miss.
+ */
+
+const MAX_MARKDOWN_LENGTH = 50_000
+
+function cleanHtml(html, url) {
+  let parsedDocument
+  try {
+    const { parseHTML } = require('linkedom')
+    parsedDocument = parseHTML(html).document
+  } catch (err) {
+    return {
+      title: null,
+      contentHtml: '',
+      contentMarkdown: '',
+      byline: null,
+      excerpt: null,
+      length: 0,
+    }
+  }
+
+  let article = null
+  try {
+    const { Readability } = require('@mozilla/readability')
+    article = new Readability(parsedDocument).parse()
+  } catch {
+    article = null
+  }
+
+  const contentHtml =
+    (article && article.content) ||
+    parsedDocument.body?.innerHTML ||
+    ''
+
+  let contentMarkdown = ''
+  try {
+    const TurndownService = require('turndown')
+    const td = new TurndownService({
+      headingStyle: 'atx',
+      codeBlockStyle: 'fenced',
+      bulletListMarker: '-',
+    })
+    td.remove(['script', 'style', 'noscript', 'iframe'])
+    contentMarkdown = td.turndown(contentHtml)
+  } catch {
+    contentMarkdown = ''
+  }
+
+  if (contentMarkdown.length > MAX_MARKDOWN_LENGTH) {
+    contentMarkdown = contentMarkdown.slice(0, MAX_MARKDOWN_LENGTH) + '\n\n[... truncated ...]'
+  }
+
+  return {
+    title: article?.title || parsedDocument.title || null,
+    contentHtml,
+    contentMarkdown,
+    byline: article?.byline || null,
+    excerpt: article?.excerpt || null,
+    length: article?.length || contentMarkdown.length,
+  }
+}
+
+module.exports = {
+  cleanHtml,
+  MAX_MARKDOWN_LENGTH,
+}

package/core/lib/web-extract/index.js

@@ -0,0 +1,21 @@
+/**
+ * Web extraction (experimental, v3.53.0).
+ *
+ * Public surface for core/routes/web.js. Internal modules:
+ *   - url-normalize.js     URL → template + canonical URL
+ *   - fingerprint.js       DOM structural hash
+ *   - playwright-runner.js headless fetch + selector replay
+ *   - html-cleaner.js      Readability + Turndown
+ *   - recipe-generator.js  Anthropic Haiku cold path
+ *   - extractor.js         orchestrator (hot/cold + self-heal)
+ */
+
+const { extract } = require('./extractor')
+const { normalizeUrl } = require('./url-normalize')
+const { computeFingerprint } = require('./fingerprint')
+
+module.exports = {
+  extract,
+  normalizeUrl,
+  computeFingerprint,
+}