seo-intel 1.5.39 → 1.5.45

package/crawler/html-extract.js

@@ -0,0 +1,127 @@
+/**
+ * Lightweight HTML extractor — pure string/regex parsing. No DOM, no browser.
+ *
+ * Powers the fetch-based light crawler (crawler/light.js) so ANY Claude user can
+ * crawl + analyze a site with zero browser environment installed. Consistent
+ * with schema-parser.js's regex approach ("no DOM parser needed").
+ *
+ * Trade-off: not as bulletproof as a full DOM parse on adversarial markup, but
+ * more than good enough for SEO/AEO metadata (title, meta, headings, links,
+ * JSON-LD, dates). The full Playwright crawler stays the heavyweight option.
+ */
+
+import { stripHtml } from './sanitize.js';
+import { parseJsonLd } from './schema-parser.js';
+
+function decodeEntities(s) {
+  return (s || '')
+    .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"').replace(/&#0?39;/g, "'").replace(/&apos;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&#(\d+);/g, (_, n) => { try { return String.fromCodePoint(+n); } catch { return ' '; } })
+    .replace(/&#x([0-9a-f]+);/gi, (_, h) => { try { return String.fromCodePoint(parseInt(h, 16)); } catch { return ' '; } })
+    .trim();
+}
+
+const collapse = (s) => decodeEntities(stripHtml(s || '').replace(/\s+/g, ' '));
+
+export function extractTitle(html) {
+  const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return m ? decodeEntities(m[1].replace(/\s+/g, ' ')) : '';
+}
+
+// Find a <meta> tag by attribute (name|property) = value, then read its content.
+function metaContent(html, attr, value) {
+  const re = new RegExp(`<meta\\b[^>]*\\b${attr}\\s*=\\s*["']${value}["'][^>]*>`, 'i');
+  const tag = html.match(re);
+  if (!tag) return '';
+  const c = tag[0].match(/\bcontent\s*=\s*["']([\s\S]*?)["']/i);
+  return c ? decodeEntities(c[1]) : '';
+}
+
+export function extractMetaDescription(html) {
+  return metaContent(html, 'name', 'description') || metaContent(html, 'property', 'og:description');
+}
+
+export function extractMetaRobots(html) {
+  return metaContent(html, 'name', 'robots').toLowerCase();
+}
+
+export function extractCanonical(html, baseUrl) {
+  const tag = html.match(/<link\b[^>]*\brel\s*=\s*["']canonical["'][^>]*>/i);
+  if (!tag) return '';
+  const h = tag[0].match(/\bhref\s*=\s*["']([^"']+)["']/i);
+  if (!h) return '';
+  try { return new URL(h[1], baseUrl).toString(); } catch { return h[1]; }
+}
+
+export function extractHeadings(html) {
+  const out = [];
+  const re = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi;
+  let m;
+  while ((m = re.exec(html)) !== null) {
+    const text = collapse(m[2]);
+    if (text) out.push({ level: Number(m[1]), text: text.slice(0, 300) });
+    if (out.length >= 300) break;
+  }
+  return out;
+}
+
+export function extractLinks(html, baseUrl) {
+  const out = [];
+  const seen = new Set();
+  let base; try { base = new URL(baseUrl); } catch { base = null; }
+  const re = /<a\b[^>]*\bhref\s*=\s*["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi;
+  let m;
+  while ((m = re.exec(html)) !== null) {
+    let href = m[1].trim();
+    if (!href) continue;
+    if (/^(#|mailto:|tel:|javascript:|data:)/i.test(href)) continue;
+    let abs;
+    try { abs = base ? new URL(href, base).toString() : href; } catch { continue; }
+    abs = abs.split('#')[0];
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    let internal = false;
+    try { internal = !!base && new URL(abs).hostname === base.hostname; } catch { /* keep false */ }
+    out.push({ href: abs, text: collapse(m[2]).slice(0, 120), internal });
+    if (out.length >= 1000) break;
+  }
+  return out;
+}
+
+/**
+ * Parse one fetched HTML document into the structured shape the rest of
+ * SEO Intel speaks (mirrors the Playwright crawler's per-page object).
+ * @param {string} html
+ * @param {string} url - the (final) URL this HTML was fetched from
+ */
+export function extractPageData(html, url) {
+  const schemas = parseJsonLd(html) || [];
+  const schemaTypes = [...new Set(schemas.map(s => s.type).filter(Boolean))];
+  let published = null, modified = null;
+  for (const s of schemas) {
+    if (!published && s.datePublished) published = s.datePublished;
+    if (!modified && s.dateModified) modified = s.dateModified;
+  }
+  const bodyText = stripHtml(html);
+  const wordCount = bodyText ? bodyText.split(/\s+/).filter(Boolean).length : 0;
+  const robots = extractMetaRobots(html);
+
+  return {
+    url,
+    title: extractTitle(html),
+    meta_desc: extractMetaDescription(html),
+    canonical: extractCanonical(html, url),
+    robots,
+    is_indexable: !/\bnoindex\b/.test(robots),
+    headings: extractHeadings(html),
+    links: extractLinks(html, url),
+    schema_types: schemaTypes,
+    schemas,
+    word_count: wordCount,
+    body_text: bodyText.slice(0, 20000),
+    published_date: published,
+    modified_date: modified,
+  };
+}

package/crawler/light.js

@@ -0,0 +1,169 @@
+/**
+ * Light crawler — fetch-based, zero-browser, zero-config, zero-signup.
+ *
+ * The "crawl for all Claude users" path: point it at a URL and it BFS-crawls
+ * same-origin pages with plain HTTP fetch (no Playwright, no browser download),
+ * returns structured SEO/AEO data entirely in memory. Nothing is persisted,
+ * nothing leaves the machine, no account required.
+ *
+ * Deliberately NOT a "massive crawl environment":
+ *   - small page budget (default 10, hard cap 50)
+ *   - same-origin only by default
+ *   - honours robots.txt + crawl-delay (no tricks)
+ *   - no JS rendering (use the full Playwright crawler for JS-heavy sites)
+ *
+ * For deep, persistent, JS-rendered crawls of a configured project, use the
+ * heavyweight crawler (`crawler/index.js` via `seo-intel crawl`).
+ */
+
+import fetch from 'node-fetch';
+import { checkRobots } from './robots.js';
+import { extractPageData } from './html-extract.js';
+import { scorePage } from '../analyses/aeo/scorer.js';
+
+const HARD_CAP = 50;
+const DEFAULT_UA = 'SEOIntelBot (+https://ukkometa.fi/seo-intel; light-crawl)';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+function normalizeStart(url) {
+  let u = url.trim();
+  if (!/^https?:\/\//i.test(u)) u = 'https://' + u;
+  return new URL(u).toString();
+}
+
+// Same-site key: hostname minus a leading "www." (and protocol-agnostic), so
+// http↔https and www↔non-www redirects don't break same-origin link following.
+function siteKey(u) {
+  try { return new URL(u).hostname.replace(/^www\./i, '').toLowerCase(); } catch { return null; }
+}
+
+/**
+ * @param {string} startUrl
+ * @param {object} [opts]
+ * @param {number} [opts.maxPages=10]      pages to fetch (clamped to HARD_CAP)
+ * @param {boolean} [opts.sameOrigin=true] only follow links on the start origin
+ * @param {boolean} [opts.includeCitability=false] run the AEO scorer per page
+ * @param {boolean} [opts.respectRobots=true] honour robots.txt + crawl-delay
+ * @param {number} [opts.timeoutMs=10000]  per-request timeout
+ * @param {number} [opts.maxDelayMs=3000]  cap on politeness delay between requests
+ * @param {(msg:string)=>void} [opts.onProgress]
+ * @returns {Promise<object>} { start, origin, pages, skipped, stats }
+ */
+export async function lightCrawl(startUrl, opts = {}) {
+  const {
+    maxPages = 10,
+    sameOrigin = true,
+    includeCitability = false,
+    respectRobots = true,
+    timeoutMs = 10000,
+    maxDelayMs = 3000,
+    onProgress,
+  } = opts;
+
+  const budget = Math.max(1, Math.min(maxPages, HARD_CAP));
+  let start;
+  try { start = normalizeStart(startUrl); } catch { throw new Error(`Invalid URL: ${startUrl}`); }
+  const origin = new URL(start).origin;
+
+  const siteRoot = siteKey(start);
+  const queue = [start];
+  const queued = new Set([start]);
+  const visited = new Set();   // FINAL (post-redirect) URLs actually processed
+  const pages = [];
+  const skipped = [];
+  const t0 = Date.now();
+
+  while (queue.length && pages.length < budget) {
+    const url = queue.shift();
+
+    if (respectRobots) {
+      let robot;
+      try { robot = await checkRobots(url); } catch { robot = { allowed: true, crawlDelayMs: 0 }; }
+      if (!robot.allowed) { skipped.push({ url, reason: 'robots_disallow' }); continue; }
+    }
+
+    let res, finalUrl = url, status = 0, html = '';
+    try {
+      res = await fetch(url, { timeout: timeoutMs, redirect: 'follow', headers: { 'User-Agent': DEFAULT_UA, Accept: 'text/html,application/xhtml+xml' } });
+      status = res.status;
+      finalUrl = res.url || url;
+      const ct = (res.headers.get('content-type') || '').toLowerCase();
+      if (res.ok && ct.includes('html')) {
+        html = await res.text();
+      } else {
+        skipped.push({ url, reason: res.ok ? `non_html (${ct || 'unknown'})` : `http_${status}`, status });
+        continue;
+      }
+    } catch (e) {
+      skipped.push({ url, reason: `fetch_error: ${e.message}` });
+      continue;
+    }
+
+    // Dedupe on the FINAL url — a redirect may collapse onto a page we already
+    // crawled (e.g. non-www start → www, then the page's own www self-link).
+    if (visited.has(finalUrl)) continue;
+    visited.add(finalUrl);
+    queued.add(finalUrl);
+
+    const data = extractPageData(html, finalUrl);
+    data.status_code = status;
+
+    if (includeCitability) {
+      try {
+        const cite = scorePage(
+          { url: data.url, title: data.title, body_text: data.body_text, word_count: data.word_count, published_date: data.published_date, modified_date: data.modified_date },
+          data.headings, [], data.schema_types, [], null
+        );
+        data.citability = { score: cite.score, tier: cite.tier, breakdown: cite.breakdown, ai_intents: cite.aiIntents };
+      } catch (e) {
+        data.citability = { error: e.message };
+      }
+    }
+
+    pages.push(data);
+    if (onProgress) onProgress(`[${pages.length}/${budget}] ${finalUrl} (${status}, ${data.word_count}w)`);
+
+    // Enqueue internal links for BFS
+    if (pages.length < budget) {
+      for (const link of data.links) {
+        if (!link.href || !/^https?:/i.test(link.href)) continue;
+        if (queued.has(link.href)) continue;
+        if (sameOrigin && siteKey(link.href) !== siteRoot) continue;
+        // skip obvious non-page assets
+        if (/\.(png|jpe?g|gif|svg|webp|ico|css|js|pdf|zip|mp4|woff2?|ttf)(\?|$)/i.test(link.href)) continue;
+        queued.add(link.href);
+        queue.push(link.href);
+      }
+    }
+
+    // Politeness delay between requests (honour robots crawl-delay, capped)
+    if (queue.length && pages.length < budget && respectRobots) {
+      let delay = 0;
+      try { delay = (await checkRobots(url)).crawlDelayMs || 0; } catch { delay = 0; }
+      if (delay) await sleep(Math.min(delay, maxDelayMs));
+    }
+  }
+
+  const indexable = pages.filter(p => p.is_indexable).length;
+  const withSchema = pages.filter(p => p.schema_types.length).length;
+  const missingTitle = pages.filter(p => !p.title).length;
+  const missingMeta = pages.filter(p => !p.meta_desc).length;
+
+  return {
+    start,
+    origin,
+    pages,
+    skipped,
+    stats: {
+      crawled: pages.length,
+      skipped: skipped.length,
+      queued_unvisited: Math.max(0, queue.length),
+      indexable,
+      with_schema: withSchema,
+      missing_title: missingTitle,
+      missing_meta_desc: missingMeta,
+      elapsed_ms: Date.now() - t0,
+    },
+  };
+}

package/db/db.js

@@ -328,6 +328,72 @@ export function updateInsightStatus(db, id, status) {
   db.prepare('UPDATE insights SET status = ? WHERE id = ?').run(status, id);
 }
 
+// ── Agentic loop write-back (F1, v1.5.42) ───────────────────────────────────
+//
+// Closes the loop's memory gap: when a draft is actually produced, the Ledger
+// should remember it. Two moves:
+//   1. recordDraftCreated  — persist a `draft_created` insight (idempotent per
+//      topic/type/lang) so "I drafted X" is durable and visible.
+//   2. markGapsInProgress  — flip matching ACTIVE gap insights to 'in_progress'
+//      so the same gap stops resurfacing in the next blog-draft pass.
+// Both are best-effort and must never break draft generation.
+
+/**
+ * Record that a draft was created targeting this project's Ledger.
+ * Idempotent: re-drafting the same (topic, content_type, lang) refreshes it.
+ * @returns {string} the fingerprint used
+ */
+export function recordDraftCreated(db, project, { topic, score = null, tier = null, wordCount = null, lang = 'en', contentType = 'blog', savedPath = null } = {}) {
+  const ts = Date.now();
+  const normTopic = (topic || 'auto').toLowerCase().trim().slice(0, 120);
+  const fp = `draft:${contentType}:${lang}:${normTopic}`.replace(/[^a-z0-9:_-]+/g, '-');
+  const data = JSON.stringify({
+    topic: topic || '(auto)', score, tier, word_count: wordCount,
+    lang, content_type: contentType, saved_path: savedPath, created_at: ts,
+  });
+  db.prepare(`
+    INSERT INTO insights (project, type, status, fingerprint, first_seen, last_seen, source_analysis_id, data)
+    VALUES (?, 'draft_created', 'active', ?, ?, ?, NULL, ?)
+    ON CONFLICT(project, type, fingerprint) DO UPDATE SET
+      last_seen = excluded.last_seen,
+      data = excluded.data
+  `).run(project, fp, ts, ts, data);
+  return fp;
+}
+
+/**
+ * Flip ACTIVE gap insights matching `topic` to 'in_progress' so the loop stops
+ * re-suggesting work that's already been drafted. Precise substring match on
+ * each gap's key term (never a loose word-split that would over-match).
+ * Only touches drafting-relevant gap types — never positioning/site_watch/etc.
+ * @returns {number} count of insights marked
+ */
+export function markGapsInProgress(db, project, topic) {
+  if (!topic || !topic.trim()) return 0;
+  const needle = topic.toLowerCase().trim();
+  const GAP_TYPES = ['keyword_gap', 'long_tail', 'content_gap', 'citability_gap', 'keyword_inventor'];
+  const placeholders = GAP_TYPES.map(() => '?').join(',');
+  const rows = db.prepare(
+    `SELECT id, data FROM insights WHERE project = ? AND status = 'active' AND type IN (${placeholders})`
+  ).all(project, ...GAP_TYPES);
+
+  const upd = db.prepare(`UPDATE insights SET status = 'in_progress', last_seen = ? WHERE id = ?`);
+  const ts = Date.now();
+  let marked = 0;
+  for (const r of rows) {
+    let keyTerm = '', fullText = '';
+    try {
+      const d = JSON.parse(r.data);
+      keyTerm = (d.keyword || d.phrase || d.topic || d.suggested_title || d.title || d.url || '').toLowerCase().trim();
+      fullText = [d.keyword, d.phrase, d.topic, d.suggested_title, d.title, d.url]
+        .filter(Boolean).join(' ').toLowerCase();
+    } catch { continue; }
+    const hit = (keyTerm && (needle.includes(keyTerm) || keyTerm.includes(needle))) || (fullText && fullText.includes(needle));
+    if (hit) { upd.run(ts, r.id); marked++; }
+  }
+  return marked;
+}
+
 export function upsertDomain(db, { domain, project, role }) {
   const now = Date.now();
   return db.prepare(`

package/lib/cron.js

@@ -0,0 +1,108 @@
+/**
+ * lib/cron.js — Install / remove the daily `seo-intel notify` cron entry.
+ *
+ * The "user forgets to check SEO" defense from v1.5.34's delivery brainstorm.
+ * Adds a single managed crontab line tagged with a marker comment so we can
+ * find and replace/remove our own entry without touching the user's other
+ * cron jobs.
+ *
+ * macOS + Linux: uses crontab(1). On macOS the first install will prompt the
+ * user to approve calendar/automation access via the system permission dialog
+ * — that's normal, nothing we can do about it.
+ *
+ * Windows: returns ok:false with a hint pointing at Task Scheduler. Out of
+ * scope for v1.5.40.
+ */
+
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+const NODE_BIN = process.execPath;
+const MARKER = '# managed-by-seo-intel';
+
+export const DEFAULT_SCHEDULE = '0 9 * * *'; // 9am every day
+
+function readCrontab() {
+  const r = spawnSync('crontab', ['-l'], { encoding: 'utf8' });
+  if (r.status === 0) return r.stdout || '';
+  // status !== 0 typically means "no crontab for user yet" — return empty
+  return '';
+}
+
+function writeCrontab(content) {
+  const text = (content || '').replace(/\n*$/, '\n'); // ensure single trailing newline
+  const r = spawnSync('crontab', ['-'], { input: text, encoding: 'utf8' });
+  if (r.status !== 0) {
+    throw new Error(`crontab write failed: ${r.stderr || 'unknown error'}`);
+  }
+}
+
+function isWindows() { return process.platform === 'win32'; }
+
+/**
+ * @returns {{ installed: boolean, line: string|null, schedule: string|null, platform: string }}
+ */
+export function getNotifyCronStatus() {
+  if (isWindows()) return { installed: false, line: null, schedule: null, platform: 'win32' };
+  const lines = readCrontab().split('\n').filter(l => l.includes(MARKER));
+  if (!lines.length) return { installed: false, line: null, schedule: null, platform: process.platform };
+  const line = lines[0];
+  // Schedule is the first 5 space-separated fields
+  const parts = line.trim().split(/\s+/);
+  const schedule = parts.slice(0, 5).join(' ');
+  return { installed: true, line, schedule, platform: process.platform };
+}
+
+/**
+ * Install (or replace) the managed cron line.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.schedule]  Cron schedule, default DEFAULT_SCHEDULE (9am daily)
+ * @param {boolean} [opts.openOnFire]  Append `--open` flag so the dashboard opens when fired
+ * @returns {{ ok: boolean, line?: string, schedule?: string, error?: string, hint?: string }}
+ */
+export function installNotifyCron({ schedule = DEFAULT_SCHEDULE, openOnFire = false } = {}) {
+  if (isWindows()) {
+    return {
+      ok: false,
+      error: 'Windows not supported — use Task Scheduler manually',
+      hint: `Create a daily task running:  ${NODE_BIN} "${join(ROOT, 'cli.js')}" notify`,
+    };
+  }
+  // Sanity-check schedule (5 fields, no shell metachars)
+  if (!/^[-*\/0-9, ]+$/.test(schedule) || schedule.trim().split(/\s+/).length !== 5) {
+    return { ok: false, error: `Invalid cron schedule "${schedule}". Expected 5 fields, e.g. "0 9 * * *".` };
+  }
+  const cmd = `cd ${ROOT} && ${NODE_BIN} cli.js notify${openOnFire ? ' --open' : ''}`;
+  const newLine = `${schedule} ${cmd}  ${MARKER}`;
+  const current = readCrontab();
+  const kept = current.split('\n').filter(l => l && !l.includes(MARKER));
+  kept.push(newLine);
+  try {
+    writeCrontab(kept.join('\n'));
+    return { ok: true, line: newLine, schedule };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+/**
+ * Remove the managed cron line (if any). Idempotent.
+ * @returns {{ ok: boolean, removed: boolean, error?: string }}
+ */
+export function removeNotifyCron() {
+  if (isWindows()) return { ok: true, removed: false }; // nothing to remove
+  const current = readCrontab();
+  const before = current.split('\n').filter(Boolean).length;
+  const kept = current.split('\n').filter(l => l && !l.includes(MARKER));
+  if (kept.length === before) return { ok: true, removed: false };
+  try {
+    writeCrontab(kept.join('\n'));
+    return { ok: true, removed: true };
+  } catch (e) {
+    return { ok: false, removed: false, error: e.message };
+  }
+}

package/lib/gate.js

@@ -65,6 +65,36 @@ const FEATURE_NAMES = {
   'intel-competitor':  'Intel Competitor Digest (AI-agent-ready)',
 };
 
+// ── Free features (v1.5.41 monetization line) ───────────────────────────────
+//
+// Analysis of YOUR OWN site is free: a capable agent commoditizes one-shot
+// analysis anyway, so we give it away to make the free tier a genuine
+// "complete SEO brain" — local, private, zero flagship tokens on grunt work.
+//
+// The paywall sits on what an agent structurally CANNOT do for itself:
+//   • Competitors — analyze, shallow, decay, headings-audit, entities,
+//                   friction, competitive, gap-intel, intel-competitor
+//   • Automation  — run (scheduler)
+//   • History     — brief ("what changed"), velocity (publish-rate over time)
+//
+// Anything listed here passes requirePro() regardless of license tier.
+const FREE_FEATURES = new Set([
+  'extract',        // local Ollama labor — the grunt work that powers the free brain
+  'aeo',            // AI citability scoring (pure function, own site)
+  'keywords',       // keyword intelligence (own site)
+  'templates',      // programmatic template detection (own site)
+  'orphans',        // orphan entity detection (own site)
+  'js-delta',       // JS rendering delta (own site, technical)
+  'blog-draft',     // AEO blog draft from the Ledger (own site, content)
+  'html',           // HTML dashboard
+  'html-all',       // HTML dashboard (all projects)
+  'gsc-insights',   // Search Console intelligence (own site)
+  'intel-audit',    // agent-ready audit digest (own site)
+  'intel-blog',     // agent-ready blog digest (own site)
+  'scan',           // one-shot single-domain audit — the first-touch "try it" command
+  'loop',           // content-loop orchestrator (own-site gaps → draft → queue)
+]);
+
 // ── CLI Gate — blocks command and shows upgrade message ──────────────────────
 
 /**
@@ -75,6 +105,7 @@ const FEATURE_NAMES = {
  * @returns {boolean}
  */
 export function requirePro(feature) {
+  if (FREE_FEATURES.has(feature)) return true;
   if (isPro()) return true;
 
   const displayName = FEATURE_NAMES[feature] || feature;
@@ -178,7 +209,8 @@ export function printLicenseStatus() {
     if (license.stale) console.log(`\x1b[33m  ⚠ License cache stale — will re-validate on next network access${RESET}`);
   } else {
     console.log(`${DIM}  SEO Intel Free${RESET}`);
-    console.log(`${DIM}  Unlimited crawl · Raw SQLite data · No AI analysis · No dashboard${RESET}`);
+    console.log(`${DIM}  Unlimited crawl · Full site analysis · Dashboard · Local & private${RESET}`);
+    console.log(`${DIM}  Solo adds: competitors · scheduled crawls · history & trends${RESET}`);
     if (license.invalidKey) {
       console.log(`\x1b[33m  ⚠ ${license.reason}${RESET}`);
     }

package/lib/intel.js

@@ -8,10 +8,14 @@
  *
  * Slices:
  *   raw         (free)  — page/keyword/heading inventory, no analysis
- *   audit       (paid)  — citability + technical + active insights
- *   blog        (paid)  — gaps + tone hints for drafting
+ *   audit       (free)  — citability + technical + active insights (your own site)
+ *   blog        (free)  — gaps + tone hints for drafting (your own site)
  *   competitor  (paid)  — competitor summary + schema landscape
  *
+ * Monetization line (v1.5.41): analysis of YOUR OWN site is free — a smart
+ * agent commoditizes one-shot analysis anyway. The paywall sits on the things
+ * an agent structurally can't do for itself: competitors, automation, history.
+ *
  * Output is a stable structured object — agents should be able to chain calls
  * without prompt gymnastics. Keep the schema additive across versions.
  */
@@ -26,7 +30,9 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
 
 export const INTEL_SLICES = ['raw', 'audit', 'blog', 'competitor'];
-export const FREE_SLICES = ['raw'];
+// Own-site slices are free; only the competitor slice (data the agent can't
+// gather on its own) requires Solo.
+export const FREE_SLICES = ['raw', 'audit', 'blog'];
 
 /**
  * @param {import('node:sqlite').DatabaseSync} db