@venturewild/workspace 0.5.0 → 0.5.2

package/server/src/bazaar/core.mjs

@@ -1,730 +1,790 @@
-// Bazaar core — the shelf, search/ranking, and the transaction ledger.
-//
-// Faithful to UX §3.7: a *network* of producers' recipes that a consumer's agent
-// reaches onto, picks by "which actually works" (measured outcomes), absorbs, and
-// builds — recording a three-way transaction (consumer got it · producer earns ·
-// platform recorded it).
-//
-// State lives ENTIRELY under ~/.wild-workspace/bazaar/ (an absolute path OUTSIDE
-// the user's repo — CLAUDE.md rule #1). One module, imported by BOTH the main
-// server and the spawned MCP server, so there is a single source of truth and no
-// HTTP/port handshake between processes:
-//   - events.jsonl  append-only event log (use · service-call · publish). Append
-//                   is multi-writer safe (the MCP process writes use/publish; the
-//                   main process's preview server writes service-call).
-//   - listings.json  user-published listings (the flip side). MCP writes, main reads.
-//   - preview.json   the current preview target {dir,recipeId}. MCP writes, main reads.
-//
-// Seed recipes (our product content — the shelf) ship in-repo under seed-recipes/.
-
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import crypto from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-
-import { normalizeTheme } from '../canvas/core.mjs';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SEED_DIR = path.join(__dirname, 'seed-recipes');
-
-// Seed THEMES — the first cross-user marketplace artifact (a theme is a hex-token
-// bundle: pure data, zero execution risk, and its own preview). These ship as a
-// small network of "producers" so the bazaar's Themes shelf is populated out of
-// the box; a user's own published theme lands beside them (listings.json).
-export const SEED_THEMES = [
-  {
-    id: 'theme-midnight-cyan', kind: 'theme', source: 'theme',
-    title: 'Midnight Cyan', pitch: 'The venturewild.llc night look — deep navy, electric cyan.',
-    summary: 'A focused dark workspace: near-black navy with a bright cyan accent and cool slate cards.',
-    tags: ['dark', 'cyan', 'focus'],
-    producer: { name: 'VentureWild', handle: 'venturewild', kind: 'vendor' },
-    theme: { mode: 'dark', accent: '#22d3ee', tokens: { bg: '#0a0c10', surface: '#11141a', text: '#e8eaed', textMuted: '#8b95a3', border: '#1f242d', canvas1: '#0b1620', canvas2: '#0c1320', canvas3: '#0a0f14' } },
-    outcomeScore: 0.92, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
-    rating: { stars: 5, count: 24 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
-  },
-  {
-    id: 'theme-sunset', kind: 'theme', source: 'theme',
-    title: 'Warm Sunset', pitch: 'Dusty plum to amber — warm, low-glare, easy at night.',
-    summary: 'A cosy dark theme: plum background fading to amber, with a glowing orange accent.',
-    tags: ['dark', 'warm', 'orange'],
-    producer: { name: 'Lina', handle: 'lina', kind: 'maker' },
-    theme: { mode: 'dark', accent: '#ff7a3c', tokens: { bg: '#1a1014', surface: '#2a1a1f', text: '#fbeee6', textMuted: '#c7a89a', border: '#43292f', canvas1: '#2d1620', canvas2: '#5a2a2c', canvas3: '#b85c2e' } },
-    outcomeScore: 0.84, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
-    rating: { stars: 4, count: 11 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
-  },
-  {
-    id: 'theme-forest', kind: 'theme', source: 'theme',
-    title: 'Forest Light', pitch: 'Soft sage & cream — a calm, bright daytime desk.',
-    summary: 'A gentle light theme: sage-green wallpaper, cream cards, a deep forest accent.',
-    tags: ['light', 'green', 'calm'],
-    producer: { name: 'Mateo', handle: 'mateo', kind: 'maker' },
-    theme: { mode: 'light', accent: '#15803d', tokens: { bg: '#fbfdfb', surface: '#ffffff', text: '#1a2b22', textMuted: '#5c7064', border: '#dde9e0', canvas1: '#e3f3e7', canvas2: '#eaf4ec', canvas3: '#fbfdf6' } },
-    outcomeScore: 0.79, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
-    rating: { stars: 4, count: 8 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
-  },
-  {
-    id: 'theme-mono', kind: 'theme', source: 'theme',
-    title: 'Mono Slate', pitch: 'Greyscale, no distractions — one quiet blue accent.',
-    summary: 'A neutral light theme for heads-down work: warm greys, a single muted-blue accent.',
-    tags: ['light', 'minimal', 'mono'],
-    producer: { name: 'Priya', handle: 'priya', kind: 'maker' },
-    theme: { mode: 'light', accent: '#475569', tokens: { bg: '#fafafa', surface: '#ffffff', text: '#1e2530', textMuted: '#6b7280', border: '#e6e8ec', canvas1: '#eef0f3', canvas2: '#f3f4f6', canvas3: '#fafafa' } },
-    outcomeScore: 0.74, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
-    rating: { stars: 4, count: 6 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
-  },
-];
-
-// ~/.wild-workspace/bazaar — mirrors logpaths.globalDir() but kept dependency-free
-// here so the MCP child can import this module standalone.
-export function defaultBazaarDir(env = process.env) {
-  const base = env.WILD_WORKSPACE_GLOBAL_DIR || path.join(os.homedir(), '.wild-workspace');
-  return path.join(base, 'bazaar');
-}
-
-function rid() {
-  return crypto.randomUUID().slice(0, 12);
-}
-
-function readJsonSafe(file, fallback) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return fallback;
-  }
-}
-
-function writeJsonAtomic(file, value) {
-  const tmp = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(value, null, 2));
-  fs.renameSync(tmp, file); // Node rename replaces the destination on all platforms
-}
-
-// --- recipe loading -------------------------------------------------------
-
-function loadSeedRecipes(seedDir = SEED_DIR) {
-  let entries = [];
-  try {
-    entries = fs.readdirSync(seedDir, { withFileTypes: true }).filter((e) => e.isDirectory());
-  } catch {
-    return [];
-  }
-  const recipes = [];
-  for (const e of entries) {
-    const dir = path.join(seedDir, e.name);
-    const meta = readJsonSafe(path.join(dir, 'recipe.json'), null);
-    if (!meta || !meta.id) continue;
-    let knowHow = '';
-    try {
-      knowHow = fs.readFileSync(path.join(dir, 'know-how.md'), 'utf8');
-    } catch {
-      /* a recipe with no know-how file is still listable */
-    }
-    recipes.push({ ...meta, knowHow, source: 'seed' });
-  }
-  return recipes;
-}
-
-// --- search / ranking -----------------------------------------------------
-// The agent's pick signal is "which recipe actually works" (outcomeScore), NOT
-// marketing or stars (§3.7). Tag relevance gates the candidates; outcomeScore
-// breaks ties and floats proven recipes to the top of the shelf.
-
-function normalize(s) {
-  return String(s || '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim();
-}
-
-function stem(word) {
-  // ultra-light: drop a trailing plural 's' so "candidates" matches "candidate"
-  return word.length > 3 && word.endsWith('s') ? word.slice(0, -1) : word;
-}
-
-export function scoreRecipe(recipe, need) {
-  const needNorm = ` ${normalize(need)} `;
-  const needWords = new Set(needNorm.trim().split(' ').filter(Boolean).map(stem));
-  let score = 0;
-  const matched = [];
-  for (const tag of recipe.tags || []) {
-    const tagNorm = normalize(tag);
-    if (!tagNorm) continue;
-    if (tagNorm.includes(' ')) {
-      // multi-word tag: a phrase hit is a strong signal
-      if (needNorm.includes(` ${tagNorm} `) || needNorm.includes(tagNorm)) {
-        score += 3;
-        matched.push(tag);
-      }
-    } else if (needWords.has(stem(tagNorm))) {
-      score += 1;
-      matched.push(tag);
-    }
-  }
-  return { score, matched };
-}
-
-// --- Class-B auto-scan (B2) ------------------------------------------------
-// A conservative, pattern-based check that a published recipe carries no baked-in
-// secrets and no obviously destructive / remote-exec commands. It gates the FAST
-// lane (Class B self-attest), not a full audit — Class C/D get human review. High-
-// confidence patterns only, so a clean recipe is rarely false-flagged. Never throws.
-const UNSAFE_PATTERNS = [
-  { kind: 'secret', note: 'private key', re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-  { kind: 'secret', note: 'AWS access key', re: /\bAKIA[0-9A-Z]{16}\b/ },
-  { kind: 'secret', note: 'API secret key', re: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/ },
-  { kind: 'secret', note: 'GitHub token', re: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/ },
-  { kind: 'secret', note: 'hardcoded credential', re: /(?:api[_-]?key|secret|password|passwd|access[_-]?token)\s*[:=]\s*['"][^'"\s]{12,}['"]/i },
-  { kind: 'destructive', note: 'recursive delete of a root/home path', re: /\brm\s+-[a-z]*r[a-z]*f?\s+[~/]/ },
-  { kind: 'destructive', note: 'fork bomb', re: /:\(\)\s*\{\s*:\s*\|\s*:&\s*\}\s*;\s*:/ },
-  { kind: 'exfiltrate', note: 'pipe a remote script straight into a shell', re: /\b(?:curl|wget)\b[^\n|]*\|\s*(?:sudo\s+)?(?:ba)?sh\b/i },
-];
-export function scanForUnsafe(text) {
-  const s = String(text || '');
-  const findings = [];
-  for (const p of UNSAFE_PATTERNS) {
-    if (p.re.test(s)) findings.push({ kind: p.kind, note: p.note });
-  }
-  return { clean: findings.length === 0, findings };
-}
-
-// --- the bazaar instance --------------------------------------------------
-
-// Outcome score = a Bayesian-smoothed build success rate (B1). The recipe's
-// declared outcomeScore is the PRIOR mean; this many pseudo-builds give it weight,
-// so a brand-new listing or a thin sample isn't whipsawed by one result, while a
-// recipe with real volume converges on its true rate.
-const OUTCOME_PRIOR_K = 4;
-
-export function createBazaar({ baseDir, seedDir = SEED_DIR } = {}) {
-  const dir = baseDir || defaultBazaarDir();
-  const eventsFile = path.join(dir, 'events.jsonl');
-  const listingsFile = path.join(dir, 'listings.json');
-  const previewFile = path.join(dir, 'preview.json');
-  // Self-seed drafts (cold-start, Producer #1): recipes the agent EXTRACTED from
-  // the user's existing work, staged here for REVIEW. Nothing reaches the shelf
-  // until the user approves a draft (publishDraft). The safety control is that a
-  // draft holds only generalized know-how — never client files/names/secrets.
-  const draftsFile = path.join(dir, 'drafts.json');
-
-  function ensureDir() {
-    try {
-      fs.mkdirSync(dir, { recursive: true });
-    } catch {
-      /* read-only fs — degrades to no persistence */
-    }
-  }
-
-  // --- live outcome telemetry (B1) ----------------------------------------
-  // Real build-result events (recorded by record_build_result after a build lands
-  // or fails) are the signal behind outcomeScore. Cached on the events file's
-  // size+mtime so it stays correct even when the MCP child process appends.
-  let _outcomeCache = null;
-  let _outcomeCacheSig = null;
-  function liveOutcomes() {
-    let sig = '0';
-    try { const st = fs.statSync(eventsFile); sig = `${st.size}:${st.mtimeMs}`; } catch { /* no file yet */ }
-    if (_outcomeCache && _outcomeCacheSig === sig) return _outcomeCache;
-    const map = {};
-    for (const e of events()) {
-      if (e.type !== 'build-result' || !e.recipeId) continue;
-      const m = (map[e.recipeId] ??= { builds: 0, working: 0 });
-      m.builds += 1;
-      if (e.success) m.working += 1;
-    }
-    _outcomeCache = map;
-    _outcomeCacheSig = sig;
-    return map;
-  }
-  // The recipe's accumulated { builds, working }: its seed baseline (missing →
-  // {0,0}, the migration for old listings) plus live build-results.
-  function liveStats(r) {
-    const base = r.outcomeStats && typeof r.outcomeStats === 'object' ? r.outcomeStats : { builds: 0, working: 0 };
-    const live = liveOutcomes()[r.id] || { builds: 0, working: 0 };
-    return { builds: (base.builds || 0) + live.builds, working: (base.working || 0) + live.working };
-  }
-  // Bayesian-smoothed success rate. Prior mean = the declared outcomeScore (0.7 for
-  // an undeclared listing); with zero live results it equals the declared score, so
-  // seed rankings stay stable until real outcomes accumulate.
-  function liveScore(r) {
-    const prior = typeof r.outcomeScore === 'number' ? r.outcomeScore : 0.7;
-    const { builds, working } = liveStats(r);
-    const score = (working + OUTCOME_PRIOR_K * prior) / (builds + OUTCOME_PRIOR_K);
-    return Math.max(0, Math.min(1, Math.round(score * 1000) / 1000));
-  }
-  // The agent reports whether a build that used a recipe actually WORKED (B1) — the
-  // real signal behind the outcome score. Appended to events.jsonl; liveScore reads
-  // it on the next card render. Unknown recipe → a no-op error (keeps events clean).
-  function recordBuildResult({ recipeId, success, reason = '' } = {}) {
-    const r = getRecipe(recipeId);
-    if (!r) return { ok: false, error: `no recipe "${recipeId}" on the shelf` };
-    const evt = appendEvent({
-      type: 'build-result',
-      recipeId: r.id,
-      title: r.title,
-      success: !!success,
-      reason: String(reason || '').slice(0, 200),
-    });
-    return { ok: true, event: evt, outcome: { ...liveStats(r), score: liveScore(r) } };
-  }
-
-  // --- trust & provenance (B2) --------------------------------------------
-  // The §3 schema (docs/shelf-trust-provenance-design.md). riskClass is the spine:
-  // A data (themes) · B local build-recipe · C connected-service · D executable-skill.
-  // provenanceFor() also MIGRATES old records on read — a listing with the legacy
-  // safetyBadge but no riskClass gets defaults by kind, and a free-text sourceNote
-  // becomes a builtFrom[] entry — so an existing listings.json never breaks.
-  function riskClassOf(r) {
-    if (['A', 'B', 'C', 'D'].includes(r.riskClass)) return r.riskClass;
-    if (r.kind === 'theme') return 'A';
-    if (r.service || r.hasService) return 'C';
-    return 'B';
-  }
-  function normalizeBuiltFrom(r) {
-    if (Array.isArray(r.builtFrom)) {
-      return r.builtFrom.filter(Boolean).map((b) => ({ type: b.type || 'recipe', id: b.id ?? null, note: b.note || b.title || '' }));
-    }
-    if (r.builtFrom && (r.builtFrom.id || r.builtFrom.title)) {
-      // the C2 remix pointer { id, title } → the schema's array form
-      return [{ type: r.kind === 'theme' ? 'theme' : 'recipe', id: r.builtFrom.id ?? null, note: r.builtFrom.title || '' }];
-    }
-    if (r.sourceNote) return [{ type: 'scratch', id: null, note: String(r.sourceNote) }]; // migrate free-text
-    return [];
-  }
-  function provenanceFor(r) {
-    const riskClass = riskClassOf(r);
-    const trusted = r.source === 'seed' || r.source === 'theme'; // VW-shipped → pre-vetted
-    const dataTouched = r.dataTouched || (riskClass === 'C'
-      ? { egress: [], scope: 'external', paid: { model: r.reward?.perUseValue ? 'per-use' : 'none', note: '' } }
-      : { egress: [], scope: 'in-workspace', paid: { model: 'none', note: '' } });
-    const attestation = r.attestation || {
-      privacy: riskClass === 'C' ? 'not-attested' : 'n/a',
-      attestedBy: null,
-      at: null,
-    };
-    const defaultVerdict =
-      riskClass === 'A' ? 'auto'
-        : riskClass === 'B' ? (trusted ? 'scanned' : 'unscanned')
-          : riskClass === 'C' ? (trusted ? 'reviewed' : 'unvetted')
-            : 'unvetted'; // D never auto-clears (enforcement deferred → own/teammate only)
-    const vetting = r.vetting || { verdict: defaultVerdict, stakes: 'ordinary', signature: null, capabilities: null, findings: [] };
-    return { riskClass, builtFrom: normalizeBuiltFrom(r), dataTouched, attestation, vetting };
-  }
-
-  function shelf() {
-    const seed = loadSeedRecipes(seedDir);
-    const listings = readJsonSafe(listingsFile, []);
-    return [...seed, ...SEED_THEMES, ...(Array.isArray(listings) ? listings : [])];
-  }
-
-  function getRecipe(id) {
-    return shelf().find((r) => r.id === id) || null;
-  }
-
-  // Public, agent-facing card for a recipe (no know-how dump until opened).
-  function card(r, extra = {}) {
-    return {
-      id: r.id,
-      kind: r.kind || 'recipe',
-      title: r.title,
-      pitch: r.pitch,
-      producer: r.producer,
-      summary: r.summary,
-      vendorDescription: r.vendorDescription,
-      outcomeScore: liveScore(r),
-      outcomeStats: liveStats(r),
-      safetyBadge: r.safetyBadge, // legacy field kept for back-compat; web derives from `vetting`
-      ...provenanceFor(r), //       B2: riskClass · builtFrom · dataTouched · attestation · vetting
-      rating: r.rating,
-      reward: r.reward,
-      hasService: Boolean(r.service),
-      buildDir: r.buildDir,
-      // A theme card carries its own bundle — it IS its own preview (just hex), so
-      // the storefront can render a live swatch and apply it without a fetch.
-      ...(r.kind === 'theme' && r.theme ? { theme: r.theme } : {}),
-      ...extra,
-    };
-  }
-
-  function search(need, { limit = 4 } = {}) {
-    const ranked = shelf()
-      .map((r) => {
-        const { score, matched } = scoreRecipe(r, need);
-        return { r, score, matched };
-      })
-      .filter((x) => x.score > 0)
-      .sort((a, b) => b.score - a.score || liveScore(b.r) - liveScore(a.r))
-      .slice(0, limit);
-    return ranked.map((x) => card(x.r, { relevance: x.score, matched: x.matched }));
-  }
-
-  function appendEvent(evt) {
-    ensureDir();
-    const enriched = { id: rid(), ts: Date.now(), ...evt };
-    try {
-      fs.appendFileSync(eventsFile, `${JSON.stringify(enriched)}\n`);
-    } catch {
-      /* persistence best-effort */
-    }
-    return enriched;
-  }
-
-  function events() {
-    let raw = '';
-    try {
-      raw = fs.readFileSync(eventsFile, 'utf8');
-    } catch {
-      return [];
-    }
-    return raw
-      .split('\n')
-      .map((l) => l.trim())
-      .filter(Boolean)
-      .map((l) => {
-        try {
-          return JSON.parse(l);
-        } catch {
-          return null;
-        }
-      })
-      .filter(Boolean);
-  }
-
-  // A consumer's agent absorbed a recipe and built it: the three-way moment.
-  function recordUse({ recipeId, summary, consumer = 'you' }) {
-    const r = getRecipe(recipeId);
-    if (!r) return { ok: false, error: `no recipe "${recipeId}" on the shelf` };
-    const recurring = r.reward?.perUseValue || 0;
-    // A recurring SERVICE recipe (tool/API) earns per-use, NOT a build fee — so the
-    // build itself credits 0, and the meter ticks up per match. This keeps the live
-    // meter ("$X · N matches") reconciled with the "earns per match, ongoing" story.
-    // Pure know-how recipes earn their one-time build-time slice here.
-    const oneTime = r.service ? 0 : (r.reward?.oneTimeValue || 0);
-    const evt = appendEvent({
-      type: 'use',
-      recipeId: r.id,
-      title: r.title,
-      producer: r.producer,
-      consumer,
-      summary: summary || r.title,
-      value: oneTime,
-      unit: r.service ? 'recurring-start' : 'one-time',
-    });
-    const threeWay = {
-      you: `You got: ${summary || r.title}`,
-      producer: r.service
-        ? `${r.producer?.name || 'The producer'} just gained a customer — your site uses their matching on every candidate, ongoing.`
-        : `${r.producer?.name || 'The producer'} earns a one-time share for the know-how you built on.`,
-      platform: 'VentureWild matched you to a proven recipe — and recorded it.',
-    };
-    return {
-      ok: true,
-      event: evt,
-      recipe: card(r),
-      threeWay,
-      credit: { producer: r.producer, oneTime, recurring, unit: r.reward?.unit },
-      service: r.service || null,
-    };
-  }
-
-  // TickUp's matching service ran once — recurring credit to the producer.
-  function recordServiceCall({ recipeId, serviceId, matches = 0 }) {
-    const r = getRecipe(recipeId) || shelf().find((x) => x.service?.id === serviceId);
-    const per = r?.reward?.perUseValue || 0;
-    return appendEvent({
-      type: 'service-call',
-      recipeId: r?.id || recipeId || null,
-      serviceId: serviceId || r?.service?.id || null,
-      producer: r?.producer || null,
-      matches,
-      value: per,
-      unit: 'per-use',
-    });
-  }
-
-  // The flip side (§3.7): the user's agent packaged a build into a listing.
-  function publishListing({ id, title, pitch, summary, tags = [], knowHow = '', producer, buildDir, builtFrom = null }) {
-    ensureDir();
-    const listings = readJsonSafe(listingsFile, []);
-    const arr = Array.isArray(listings) ? listings : [];
-    const slug =
-      id ||
-      `${normalize(title).split(' ').slice(0, 4).join('-') || 'listing'}-${rid().slice(0, 4)}`;
-    // Class-B vetting (B2): a recipe is local build know-how → self-attest + an
-    // automated scan. A clean scan earns the 'scanned' verdict; a hit is recorded
-    // (verdict 'flagged' + findings) so the badge tells the truth — publishing isn't
-    // blocked here (single-user/local shelf), but the listing carries its verdict.
-    const scan = scanForUnsafe(knowHow);
-    const listing = {
-      id: slug,
-      title: title || 'Untitled',
-      pitch: pitch || '',
-      summary: summary || pitch || '',
-      vendorDescription: summary || pitch || '',
-      producer: producer || { name: 'You', handle: 'you', kind: 'maker' },
-      tags,
-      knowHow,
-      buildDir: buildDir || null,
-      outcomeScore: 0.7, // new listing: a starting, unproven score (earns its place by working)
-      outcomeStats: { builds: 0, working: 0 },
-      safetyBadge: 'new', // legacy field; the real signal is `vetting` below
-      riskClass: 'B',
-      ...(builtFrom && builtFrom.id ? { builtFrom: { id: String(builtFrom.id), title: String(builtFrom.title || '') } } : {}),
-      dataTouched: { egress: [], scope: 'in-workspace', paid: { model: 'none', note: '' } },
-      attestation: { privacy: 'n/a', attestedBy: (producer || {}).handle || 'you', at: new Date().toISOString() },
-      vetting: {
-        verdict: scan.clean ? 'scanned' : 'flagged',
-        stakes: 'ordinary',
-        signature: null,
-        capabilities: null,
-        findings: scan.findings,
-      },
-      rating: { stars: 0, count: 0 },
-      reward: { model: 'one-time', unit: 'per build', perUseValue: 0, oneTimeValue: 5.0 },
-      source: 'listing',
-      createdAt: Date.now(),
-    };
-    // de-dupe by id (re-publish overwrites)
-    const next = arr.filter((l) => l.id !== listing.id);
-    next.push(listing);
-    writeJsonAtomic(listingsFile, next);
-    appendEvent({
-      type: 'publish',
-      recipeId: listing.id,
-      title: listing.title,
-      producer: listing.producer,
-    });
-    return {
-      ok: true,
-      listing: card(listing),
-      earning: {
-        model: listing.reward.model,
-        oneTimeValue: listing.reward.oneTimeValue,
-        note: 'Represented earnings — you earn each time someone builds on this. (Money is for later.)',
-      },
-    };
-  }
-
-  // --- themes on the shelf (the safest cross-user artifact) -----------------
-
-  // Publish a theme as a listing. The payload is a hex-token bundle (validated by
-  // normalizeTheme — same security boundary as set_theme: data, never CSS). It
-  // lands in listings.json with kind:'theme' and shows on the Themes shelf.
-  function publishTheme({ title, pitch, summary, tags = [], producer, theme, builtFrom = null } = {}) {
-    ensureDir();
-    const bundle = normalizeTheme(theme || {});
-    const listings = readJsonSafe(listingsFile, []);
-    const arr = Array.isArray(listings) ? listings : [];
-    const slug = `theme-${normalize(title).split(' ').slice(0, 3).join('-') || 'custom'}-${rid().slice(0, 4)}`;
-    // A remix records what it was tweaked from (the source theme on the shelf) so the
-    // network shows lineage — "built on each other's work", not a flat catalogue.
-    const provenance =
-      builtFrom && builtFrom.id
-        ? { id: String(builtFrom.id), title: String(builtFrom.title || '') }
-        : null;
-    const listing = {
-      id: slug,
-      kind: 'theme',
-      source: 'theme',
-      title: title || bundle.name || 'Custom theme',
-      pitch: pitch || '',
-      summary: summary || pitch || `A ${bundle.mode} theme.`,
-      vendorDescription: summary || pitch || '',
-      producer: producer || { name: 'You', handle: 'you', kind: 'maker' },
-      tags,
-      theme: bundle,
-      ...(provenance ? { builtFrom: provenance } : {}),
-      outcomeScore: 0.7,
-      outcomeStats: { builds: 0, working: 0 },
-      safetyBadge: 'new',
-      rating: { stars: 0, count: 0 },
-      reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
-      createdAt: Date.now(),
-    };
-    const next = arr.filter((l) => l.id !== listing.id);
-    next.push(listing);
-    writeJsonAtomic(listingsFile, next);
-    appendEvent({ type: 'publish', recipeId: listing.id, title: listing.title, producer: listing.producer, ...(provenance ? { builtFrom: provenance } : {}) });
-    return {
-      ok: true,
-      listing: card(listing),
-      earning: { model: 'one-time', oneTimeValue: listing.reward.oneTimeValue, note: 'You earn each time someone applies it. (Money is for later.)' },
-    };
-  }
-
-  // A consumer applied a theme from the shelf: record the three-way moment (they
-  // got the look · the producer earns · platform recorded it) and hand back the
-  // validated bundle for the browser to apply.
-  function recordThemeApply({ themeId, consumer = 'you' } = {}) {
-    const r = getRecipe(themeId);
-    if (!r || r.kind !== 'theme') return { ok: false, error: `no theme "${themeId}" on the shelf` };
-    const oneTime = r.reward?.oneTimeValue || 0;
-    const evt = appendEvent({
-      type: 'use',
-      recipeId: r.id,
-      title: r.title,
-      producer: r.producer,
-      consumer,
-      summary: `Applied the "${r.title}" theme`,
-      value: oneTime,
-      unit: 'one-time',
-    });
-    return {
-      ok: true,
-      event: evt,
-      theme: normalizeTheme(r.theme || {}),
-      title: r.title,
-      threeWay: {
-        you: `Your workspace now wears "${r.title}".`,
-        producer: `${r.producer?.name || 'The producer'} earns a one-time share for the look you adopted.`,
-        platform: 'VentureWild matched you to a proven theme — and recorded it.',
-      },
-      credit: { producer: r.producer, oneTime, unit: r.reward?.unit },
-    };
-  }
-
-  // --- self-seed drafts (review-gated) --------------------------------------
-
-  function listDrafts() {
-    const d = readJsonSafe(draftsFile, []);
-    return Array.isArray(d) ? d : [];
-  }
-
-  function getDraft(id) {
-    return listDrafts().find((d) => d.id === id) || null;
-  }
-
-  // Stage a recipe the agent extracted from the user's existing work — does NOT
-  // publish. `sourceNote` records (for the user's review) what it was generalized
-  // from. Returns a review-shaped object the UI renders for approval.
-  function stageDraft({ title, pitch, summary, tags = [], knowHow = '', sourceNote = '' }) {
-    ensureDir();
-    const drafts = listDrafts();
-    const draft = {
-      id: `draft-${rid()}`,
-      title: title || 'Untitled',
-      pitch: pitch || '',
-      summary: summary || pitch || '',
-      tags: Array.isArray(tags) ? tags : [],
-      knowHow: knowHow || '',
-      sourceNote: sourceNote || '',
-      createdAt: Date.now(),
-    };
-    drafts.push(draft);
-    writeJsonAtomic(draftsFile, drafts);
-    return draft;
-  }
-
-  function discardDraft(id) {
-    const drafts = listDrafts();
-    const next = drafts.filter((d) => d.id !== id);
-    writeJsonAtomic(draftsFile, next);
-    return { ok: next.length !== drafts.length };
-  }
-
-  // Promote a reviewed draft onto the shelf — publishes EXACTLY what was reviewed
-  // (you publish what you saw), then removes it from the draft queue.
-  function publishDraft(id, { producer } = {}) {
-    const draft = getDraft(id);
-    if (!draft) return { ok: false, error: `no draft "${id}"` };
-    const res = publishListing({
-      title: draft.title,
-      pitch: draft.pitch,
-      summary: draft.summary,
-      tags: draft.tags,
-      knowHow: draft.knowHow,
-      producer: producer || { name: 'You', handle: 'you', kind: 'maker' },
-    });
-    discardDraft(id);
-    return res;
-  }
-
-  function setPreview({ dir: buildDir, recipeId, port = 4000 }) {
-    ensureDir();
-    const payload = { dir: buildDir, recipeId: recipeId || null, port, ts: Date.now() };
-    writeJsonAtomic(previewFile, payload);
-    return payload;
-  }
-
-  function getPreview() {
-    return readJsonSafe(previewFile, null);
-  }
-
-  // Aggregate everything the UI needs: transactions, per-producer earnings,
-  // per-service usage meters, and the user's own listings.
-  function computeState() {
-    const evs = events();
-    const earnings = {}; // handle -> { name, total, uses, serviceCalls, matches }
-    const meters = {}; // serviceId -> { calls, matches, value, producer }
-    const transactions = [];
-    for (const e of evs) {
-      const h = e.producer?.handle || 'unknown';
-      const bucket = (earnings[h] ??= {
-        name: e.producer?.name || h,
-        handle: h,
-        total: 0,
-        uses: 0,
-        serviceCalls: 0,
-        matches: 0,
-      });
-      if (e.type === 'use') {
-        bucket.total += e.value || 0;
-        bucket.uses += 1;
-        transactions.push(e);
-      } else if (e.type === 'service-call') {
-        bucket.total += e.value || 0;
-        bucket.serviceCalls += 1;
-        bucket.matches += e.matches || 0;
-        const sid = e.serviceId || 'service';
-        const m = (meters[sid] ??= { calls: 0, matches: 0, value: 0, producer: e.producer || null });
-        m.calls += 1;
-        m.matches += e.matches || 0;
-        m.value += e.value || 0;
-      } else if (e.type === 'publish') {
-        transactions.push(e);
-      }
-    }
-    return {
-      transactions: transactions.slice(-50),
-      earnings: Object.values(earnings).sort((a, b) => b.total - a.total),
-      meters,
-      listings: (readJsonSafe(listingsFile, []) || []).map((l) => card(l)),
-      totals: {
-        events: evs.length,
-        creditPaid: Object.values(earnings).reduce((s, b) => s + b.total, 0),
-      },
-    };
-  }
-
-  return {
-    dir,
-    eventsFile,
-    listingsFile,
-    previewFile,
-    draftsFile,
-    shelf,
-    getRecipe,
-    card,
-    search,
-    recordUse,
-    recordBuildResult,
-    recordServiceCall,
-    publishListing,
-    publishTheme,
-    recordThemeApply,
-    listDrafts,
-    getDraft,
-    stageDraft,
-    discardDraft,
-    publishDraft,
-    setPreview,
-    getPreview,
-    computeState,
-    events,
-  };
-}
-
-function money(n) {
-  const v = Number(n) || 0;
-  return `$${v.toFixed(2)}`;
-}
+// Bazaar core — the shelf, search/ranking, and the transaction ledger.
+//
+// Faithful to UX §3.7: a *network* of producers' recipes that a consumer's agent
+// reaches onto, picks by "which actually works" (measured outcomes), absorbs, and
+// builds — recording a three-way transaction (consumer got it · producer earns ·
+// platform recorded it).
+//
+// State lives ENTIRELY under ~/.wild-workspace/bazaar/ (an absolute path OUTSIDE
+// the user's repo — CLAUDE.md rule #1). One module, imported by BOTH the main
+// server and the spawned MCP server, so there is a single source of truth and no
+// HTTP/port handshake between processes:
+//   - events.jsonl  append-only event log (use · service-call · publish). Append
+//                   is multi-writer safe (the MCP process writes use/publish; the
+//                   main process's preview server writes service-call).
+//   - listings.json  user-published listings (the flip side). MCP writes, main reads.
+//   - preview.json   the current preview target {dir,recipeId}. MCP writes, main reads.
+//
+// Seed recipes (our product content — the shelf) ship in-repo under seed-recipes/.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+import { normalizeTheme } from '../canvas/core.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SEED_DIR = path.join(__dirname, 'seed-recipes');
+
+// Seed THEMES — the first cross-user marketplace artifact (a theme is a hex-token
+// bundle: pure data, zero execution risk, and its own preview). These ship as a
+// small network of "producers" so the bazaar's Themes shelf is populated out of
+// the box; a user's own published theme lands beside them (listings.json).
+export const SEED_THEMES = [
+  {
+    id: 'theme-midnight-cyan', kind: 'theme', source: 'theme',
+    title: 'Midnight Cyan', pitch: 'The venturewild.llc night look — deep navy, electric cyan.',
+    summary: 'A focused dark workspace: near-black navy with a bright cyan accent and cool slate cards.',
+    tags: ['dark', 'cyan', 'focus'],
+    producer: { name: 'VentureWild', handle: 'venturewild', kind: 'vendor' },
+    theme: { mode: 'dark', accent: '#22d3ee', tokens: { bg: '#0a0c10', surface: '#11141a', text: '#e8eaed', textMuted: '#8b95a3', border: '#1f242d', canvas1: '#0b1620', canvas2: '#0c1320', canvas3: '#0a0f14' } },
+    outcomeScore: 0.92, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
+    rating: { stars: 5, count: 24 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
+  },
+  {
+    id: 'theme-sunset', kind: 'theme', source: 'theme',
+    title: 'Warm Sunset', pitch: 'Dusty plum to amber — warm, low-glare, easy at night.',
+    summary: 'A cosy dark theme: plum background fading to amber, with a glowing orange accent.',
+    tags: ['dark', 'warm', 'orange'],
+    producer: { name: 'Lina', handle: 'lina', kind: 'maker' },
+    theme: { mode: 'dark', accent: '#ff7a3c', tokens: { bg: '#1a1014', surface: '#2a1a1f', text: '#fbeee6', textMuted: '#c7a89a', border: '#43292f', canvas1: '#2d1620', canvas2: '#5a2a2c', canvas3: '#b85c2e' } },
+    outcomeScore: 0.84, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
+    rating: { stars: 4, count: 11 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
+  },
+  {
+    id: 'theme-forest', kind: 'theme', source: 'theme',
+    title: 'Forest Light', pitch: 'Soft sage & cream — a calm, bright daytime desk.',
+    summary: 'A gentle light theme: sage-green wallpaper, cream cards, a deep forest accent.',
+    tags: ['light', 'green', 'calm'],
+    producer: { name: 'Mateo', handle: 'mateo', kind: 'maker' },
+    theme: { mode: 'light', accent: '#15803d', tokens: { bg: '#fbfdfb', surface: '#ffffff', text: '#1a2b22', textMuted: '#5c7064', border: '#dde9e0', canvas1: '#e3f3e7', canvas2: '#eaf4ec', canvas3: '#fbfdf6' } },
+    outcomeScore: 0.79, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
+    rating: { stars: 4, count: 8 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
+  },
+  {
+    id: 'theme-mono', kind: 'theme', source: 'theme',
+    title: 'Mono Slate', pitch: 'Greyscale, no distractions — one quiet blue accent.',
+    summary: 'A neutral light theme for heads-down work: warm greys, a single muted-blue accent.',
+    tags: ['light', 'minimal', 'mono'],
+    producer: { name: 'Priya', handle: 'priya', kind: 'maker' },
+    theme: { mode: 'light', accent: '#475569', tokens: { bg: '#fafafa', surface: '#ffffff', text: '#1e2530', textMuted: '#6b7280', border: '#e6e8ec', canvas1: '#eef0f3', canvas2: '#f3f4f6', canvas3: '#fafafa' } },
+    outcomeScore: 0.74, outcomeStats: { builds: 0, working: 0 }, safetyBadge: 'verified',
+    rating: { stars: 4, count: 6 }, reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
+  },
+];
+
+// ~/.wild-workspace/bazaar — mirrors logpaths.globalDir() but kept dependency-free
+// here so the MCP child can import this module standalone.
+export function defaultBazaarDir(env = process.env) {
+  const base = env.WILD_WORKSPACE_GLOBAL_DIR || path.join(os.homedir(), '.wild-workspace');
+  return path.join(base, 'bazaar');
+}
+
+function rid() {
+  return crypto.randomUUID().slice(0, 12);
+}
+
+function readJsonSafe(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonAtomic(file, value) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2));
+  fs.renameSync(tmp, file); // Node rename replaces the destination on all platforms
+}
+
+// --- recipe loading -------------------------------------------------------
+
+function loadSeedRecipes(seedDir = SEED_DIR) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(seedDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+  } catch {
+    return [];
+  }
+  const recipes = [];
+  for (const e of entries) {
+    const dir = path.join(seedDir, e.name);
+    const meta = readJsonSafe(path.join(dir, 'recipe.json'), null);
+    if (!meta || !meta.id) continue;
+    let knowHow = '';
+    try {
+      knowHow = fs.readFileSync(path.join(dir, 'know-how.md'), 'utf8');
+    } catch {
+      /* a recipe with no know-how file is still listable */
+    }
+    recipes.push({ ...meta, knowHow, source: 'seed' });
+  }
+  return recipes;
+}
+
+// --- search / ranking -----------------------------------------------------
+// The agent's pick signal is "which recipe actually works" (outcomeScore), NOT
+// marketing or stars (§3.7). Tag relevance gates the candidates; outcomeScore
+// breaks ties and floats proven recipes to the top of the shelf.
+
+function normalize(s) {
+  return String(s || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+}
+
+function stem(word) {
+  // ultra-light: drop a trailing plural 's' so "candidates" matches "candidate"
+  return word.length > 3 && word.endsWith('s') ? word.slice(0, -1) : word;
+}
+
+export function scoreRecipe(recipe, need) {
+  const needNorm = ` ${normalize(need)} `;
+  const needWords = new Set(needNorm.trim().split(' ').filter(Boolean).map(stem));
+  let score = 0;
+  const matched = [];
+  for (const tag of recipe.tags || []) {
+    const tagNorm = normalize(tag);
+    if (!tagNorm) continue;
+    if (tagNorm.includes(' ')) {
+      // multi-word tag: a phrase hit is a strong signal
+      if (needNorm.includes(` ${tagNorm} `) || needNorm.includes(tagNorm)) {
+        score += 3;
+        matched.push(tag);
+      }
+    } else if (needWords.has(stem(tagNorm))) {
+      score += 1;
+      matched.push(tag);
+    }
+  }
+  return { score, matched };
+}
+
+// --- Class-B auto-scan (B2) ------------------------------------------------
+// A conservative, pattern-based check that a published recipe carries no baked-in
+// secrets and no obviously destructive / remote-exec commands. It gates the FAST
+// lane (Class B self-attest), not a full audit — Class C/D get human review. High-
+// confidence patterns only, so a clean recipe is rarely false-flagged. Never throws.
+const UNSAFE_PATTERNS = [
+  { kind: 'secret', note: 'private key', re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+  { kind: 'secret', note: 'AWS access key', re: /\bAKIA[0-9A-Z]{16}\b/ },
+  { kind: 'secret', note: 'API secret key', re: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/ },
+  { kind: 'secret', note: 'GitHub token', re: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/ },
+  { kind: 'secret', note: 'hardcoded credential', re: /(?:api[_-]?key|secret|password|passwd|access[_-]?token)\s*[:=]\s*['"][^'"\s]{12,}['"]/i },
+  { kind: 'destructive', note: 'recursive delete of a root/home path', re: /\brm\s+-[a-z]*r[a-z]*f?\s+[~/]/ },
+  { kind: 'destructive', note: 'fork bomb', re: /:\(\)\s*\{\s*:\s*\|\s*:&\s*\}\s*;\s*:/ },
+  { kind: 'exfiltrate', note: 'pipe a remote script straight into a shell', re: /\b(?:curl|wget)\b[^\n|]*\|\s*(?:sudo\s+)?(?:ba)?sh\b/i },
+];
+export function scanForUnsafe(text) {
+  const s = String(text || '');
+  const findings = [];
+  for (const p of UNSAFE_PATTERNS) {
+    if (p.re.test(s)) findings.push({ kind: p.kind, note: p.note });
+  }
+  return { clean: findings.length === 0, findings };
+}
+
+// --- the bazaar instance --------------------------------------------------
+
+// Outcome score = a Bayesian-smoothed build success rate (B1). The recipe's
+// declared outcomeScore is the PRIOR mean; this many pseudo-builds give it weight,
+// so a brand-new listing or a thin sample isn't whipsawed by one result, while a
+// recipe with real volume converges on its true rate.
+const OUTCOME_PRIOR_K = 4;
+
+export function createBazaar({ baseDir, seedDir = SEED_DIR, rails = null } = {}) {
+  const dir = baseDir || defaultBazaarDir();
+  const eventsFile = path.join(dir, 'events.jsonl');
+  const listingsFile = path.join(dir, 'listings.json');
+  const previewFile = path.join(dir, 'preview.json');
+  // The cross-user theme pool, cached locally (next push §N). The MAIN server
+  // periodically pulls the global pool from the rails and writes it here; BOTH
+  // this process and the spawned MCP child read it SYNCHRONOUSLY in shelf() — the
+  // child has no rails access of its own, exactly the canvas "rails=truth → local
+  // cache below" model. `rails` (the ListingsRails client) is injected only into
+  // the main server's instance, for the immediate push on the human publish path;
+  // the MCP child's instance has none (the periodic reconcile pushes its writes).
+  const railsThemesFile = path.join(dir, 'rails-themes.json');
+  // Self-seed drafts (cold-start, Producer #1): recipes the agent EXTRACTED from
+  // the user's existing work, staged here for REVIEW. Nothing reaches the shelf
+  // until the user approves a draft (publishDraft). The safety control is that a
+  // draft holds only generalized know-how — never client files/names/secrets.
+  const draftsFile = path.join(dir, 'drafts.json');
+
+  function ensureDir() {
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch {
+      /* read-only fs — degrades to no persistence */
+    }
+  }
+
+  // --- live outcome telemetry (B1) ----------------------------------------
+  // Real build-result events (recorded by record_build_result after a build lands
+  // or fails) are the signal behind outcomeScore. Cached on the events file's
+  // size+mtime so it stays correct even when the MCP child process appends.
+  let _outcomeCache = null;
+  let _outcomeCacheSig = null;
+  function liveOutcomes() {
+    let sig = '0';
+    try { const st = fs.statSync(eventsFile); sig = `${st.size}:${st.mtimeMs}`; } catch { /* no file yet */ }
+    if (_outcomeCache && _outcomeCacheSig === sig) return _outcomeCache;
+    const map = {};
+    for (const e of events()) {
+      if (e.type !== 'build-result' || !e.recipeId) continue;
+      const m = (map[e.recipeId] ??= { builds: 0, working: 0 });
+      m.builds += 1;
+      if (e.success) m.working += 1;
+    }
+    _outcomeCache = map;
+    _outcomeCacheSig = sig;
+    return map;
+  }
+  // The recipe's accumulated { builds, working }: its seed baseline (missing →
+  // {0,0}, the migration for old listings) plus live build-results.
+  function liveStats(r) {
+    const base = r.outcomeStats && typeof r.outcomeStats === 'object' ? r.outcomeStats : { builds: 0, working: 0 };
+    const live = liveOutcomes()[r.id] || { builds: 0, working: 0 };
+    return { builds: (base.builds || 0) + live.builds, working: (base.working || 0) + live.working };
+  }
+  // Bayesian-smoothed success rate. Prior mean = the declared outcomeScore (0.7 for
+  // an undeclared listing); with zero live results it equals the declared score, so
+  // seed rankings stay stable until real outcomes accumulate.
+  function liveScore(r) {
+    const prior = typeof r.outcomeScore === 'number' ? r.outcomeScore : 0.7;
+    const { builds, working } = liveStats(r);
+    const score = (working + OUTCOME_PRIOR_K * prior) / (builds + OUTCOME_PRIOR_K);
+    return Math.max(0, Math.min(1, Math.round(score * 1000) / 1000));
+  }
+  // The agent reports whether a build that used a recipe actually WORKED (B1) — the
+  // real signal behind the outcome score. Appended to events.jsonl; liveScore reads
+  // it on the next card render. Unknown recipe → a no-op error (keeps events clean).
+  function recordBuildResult({ recipeId, success, reason = '' } = {}) {
+    const r = getRecipe(recipeId);
+    if (!r) return { ok: false, error: `no recipe "${recipeId}" on the shelf` };
+    const evt = appendEvent({
+      type: 'build-result',
+      recipeId: r.id,
+      title: r.title,
+      success: !!success,
+      reason: String(reason || '').slice(0, 200),
+    });
+    return { ok: true, event: evt, outcome: { ...liveStats(r), score: liveScore(r) } };
+  }
+
+  // --- trust & provenance (B2) --------------------------------------------
+  // The §3 schema (docs/shelf-trust-provenance-design.md). riskClass is the spine:
+  // A data (themes) · B local build-recipe · C connected-service · D executable-skill.
+  // provenanceFor() also MIGRATES old records on read — a listing with the legacy
+  // safetyBadge but no riskClass gets defaults by kind, and a free-text sourceNote
+  // becomes a builtFrom[] entry — so an existing listings.json never breaks.
+  function riskClassOf(r) {
+    if (['A', 'B', 'C', 'D'].includes(r.riskClass)) return r.riskClass;
+    if (r.kind === 'theme') return 'A';
+    if (r.service || r.hasService) return 'C';
+    return 'B';
+  }
+  function normalizeBuiltFrom(r) {
+    if (Array.isArray(r.builtFrom)) {
+      return r.builtFrom.filter(Boolean).map((b) => ({ type: b.type || 'recipe', id: b.id ?? null, note: b.note || b.title || '' }));
+    }
+    if (r.builtFrom && (r.builtFrom.id || r.builtFrom.title)) {
+      // the C2 remix pointer { id, title } → the schema's array form
+      return [{ type: r.kind === 'theme' ? 'theme' : 'recipe', id: r.builtFrom.id ?? null, note: r.builtFrom.title || '' }];
+    }
+    if (r.sourceNote) return [{ type: 'scratch', id: null, note: String(r.sourceNote) }]; // migrate free-text
+    return [];
+  }
+  function provenanceFor(r) {
+    const riskClass = riskClassOf(r);
+    const trusted = r.source === 'seed' || r.source === 'theme'; // VW-shipped → pre-vetted
+    const dataTouched = r.dataTouched || (riskClass === 'C'
+      ? { egress: [], scope: 'external', paid: { model: r.reward?.perUseValue ? 'per-use' : 'none', note: '' } }
+      : { egress: [], scope: 'in-workspace', paid: { model: 'none', note: '' } });
+    const attestation = r.attestation || {
+      privacy: riskClass === 'C' ? 'not-attested' : 'n/a',
+      attestedBy: null,
+      at: null,
+    };
+    const defaultVerdict =
+      riskClass === 'A' ? 'auto'
+        : riskClass === 'B' ? (trusted ? 'scanned' : 'unscanned')
+          : riskClass === 'C' ? (trusted ? 'reviewed' : 'unvetted')
+            : 'unvetted'; // D never auto-clears (enforcement deferred → own/teammate only)
+    const vetting = r.vetting || { verdict: defaultVerdict, stakes: 'ordinary', signature: null, capabilities: null, findings: [] };
+    return { riskClass, builtFrom: normalizeBuiltFrom(r), dataTouched, attestation, vetting };
+  }
+
+  // The cross-user theme pool from the local rails cache, RE-VALIDATED on read —
+  // never trust the pool blindly (spike 2: 15/15 hostile bundles neutralized by
+  // normalizeTheme). A tampered cache file degrades to a clean bundle, not exec.
+  function readRailsThemes() {
+    const raw = readJsonSafe(railsThemesFile, []);
+    if (!Array.isArray(raw)) return [];
+    return raw
+      .filter((r) => r && typeof r === 'object' && r.id && r.kind === 'theme')
+      .map((r) => ({ ...r, theme: normalizeTheme(r.theme || {}), source: 'rails' }));
+  }
+
+  // Overwrite the local cache of the global theme pool (called by the main
+  // server's periodic sync). Atomic; best-effort.
+  function writeRailsThemes(cards) {
+    ensureDir();
+    try {
+      writeJsonAtomic(railsThemesFile, Array.isArray(cards) ? cards : []);
+    } catch {
+      /* persistence best-effort */
+    }
+  }
+
+  function shelf() {
+    const seed = loadSeedRecipes(seedDir);
+    const listings = readJsonSafe(listingsFile, []);
+    const local = Array.isArray(listings) ? listings : [];
+    // Seeds + the user's OWN listings come first and SHADOW the pool: a theme the
+    // user published locally wins over its copy in the global pool (same id).
+    const base = [...seed, ...SEED_THEMES, ...local];
+    const seen = new Set(base.map((r) => r.id));
+    const pool = readRailsThemes().filter((r) => !seen.has(r.id));
+    return [...base, ...pool];
+  }
+
+  // The user's own theme listings, as public cards — what the periodic sync
+  // reconciles up to the rails (catches themes the agent published via the MCP
+  // child, which has no rails of its own).
+  function ownThemeListings() {
+    const listings = readJsonSafe(listingsFile, []);
+    return (Array.isArray(listings) ? listings : [])
+      .filter((l) => l && l.kind === 'theme')
+      .map((l) => card(l));
+  }
+
+  function getRecipe(id) {
+    return shelf().find((r) => r.id === id) || null;
+  }
+
+  // Public, agent-facing card for a recipe (no know-how dump until opened).
+  function card(r, extra = {}) {
+    return {
+      id: r.id,
+      kind: r.kind || 'recipe',
+      // Provenance category: 'seed'|'theme' (VW-shipped) · 'listing' (own) · 'rails'
+      // (another user's, from the global pool). The shelf UI keys the Report action
+      // + the "from the community" labelling on this. Defaults to 'listing'.
+      source: r.source || 'listing',
+      title: r.title,
+      pitch: r.pitch,
+      producer: r.producer,
+      summary: r.summary,
+      vendorDescription: r.vendorDescription,
+      outcomeScore: liveScore(r),
+      outcomeStats: liveStats(r),
+      safetyBadge: r.safetyBadge, // legacy field kept for back-compat; web derives from `vetting`
+      ...provenanceFor(r), //       B2: riskClass · builtFrom · dataTouched · attestation · vetting
+      rating: r.rating,
+      reward: r.reward,
+      hasService: Boolean(r.service),
+      buildDir: r.buildDir,
+      // A theme card carries its own bundle — it IS its own preview (just hex), so
+      // the storefront can render a live swatch and apply it without a fetch.
+      ...(r.kind === 'theme' && r.theme ? { theme: r.theme } : {}),
+      ...extra,
+    };
+  }
+
+  function search(need, { limit = 4 } = {}) {
+    const ranked = shelf()
+      .map((r) => {
+        const { score, matched } = scoreRecipe(r, need);
+        return { r, score, matched };
+      })
+      .filter((x) => x.score > 0)
+      .sort((a, b) => b.score - a.score || liveScore(b.r) - liveScore(a.r))
+      .slice(0, limit);
+    return ranked.map((x) => card(x.r, { relevance: x.score, matched: x.matched }));
+  }
+
+  function appendEvent(evt) {
+    ensureDir();
+    const enriched = { id: rid(), ts: Date.now(), ...evt };
+    try {
+      fs.appendFileSync(eventsFile, `${JSON.stringify(enriched)}\n`);
+    } catch {
+      /* persistence best-effort */
+    }
+    return enriched;
+  }
+
+  function events() {
+    let raw = '';
+    try {
+      raw = fs.readFileSync(eventsFile, 'utf8');
+    } catch {
+      return [];
+    }
+    return raw
+      .split('\n')
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  }
+
+  // A consumer's agent absorbed a recipe and built it: the three-way moment.
+  function recordUse({ recipeId, summary, consumer = 'you' }) {
+    const r = getRecipe(recipeId);
+    if (!r) return { ok: false, error: `no recipe "${recipeId}" on the shelf` };
+    const recurring = r.reward?.perUseValue || 0;
+    // A recurring SERVICE recipe (tool/API) earns per-use, NOT a build fee — so the
+    // build itself credits 0, and the meter ticks up per match. This keeps the live
+    // meter ("$X · N matches") reconciled with the "earns per match, ongoing" story.
+    // Pure know-how recipes earn their one-time build-time slice here.
+    const oneTime = r.service ? 0 : (r.reward?.oneTimeValue || 0);
+    const evt = appendEvent({
+      type: 'use',
+      recipeId: r.id,
+      title: r.title,
+      producer: r.producer,
+      consumer,
+      summary: summary || r.title,
+      value: oneTime,
+      unit: r.service ? 'recurring-start' : 'one-time',
+    });
+    const threeWay = {
+      you: `You got: ${summary || r.title}`,
+      producer: r.service
+        ? `${r.producer?.name || 'The producer'} just gained a customer — your site uses their matching on every candidate, ongoing.`
+        : `${r.producer?.name || 'The producer'} earns a one-time share for the know-how you built on.`,
+      platform: 'VentureWild matched you to a proven recipe — and recorded it.',
+    };
+    return {
+      ok: true,
+      event: evt,
+      recipe: card(r),
+      threeWay,
+      credit: { producer: r.producer, oneTime, recurring, unit: r.reward?.unit },
+      service: r.service || null,
+    };
+  }
+
+  // TickUp's matching service ran once — recurring credit to the producer.
+  function recordServiceCall({ recipeId, serviceId, matches = 0 }) {
+    const r = getRecipe(recipeId) || shelf().find((x) => x.service?.id === serviceId);
+    const per = r?.reward?.perUseValue || 0;
+    return appendEvent({
+      type: 'service-call',
+      recipeId: r?.id || recipeId || null,
+      serviceId: serviceId || r?.service?.id || null,
+      producer: r?.producer || null,
+      matches,
+      value: per,
+      unit: 'per-use',
+    });
+  }
+
+  // The flip side (§3.7): the user's agent packaged a build into a listing.
+  function publishListing({ id, title, pitch, summary, tags = [], knowHow = '', producer, buildDir, builtFrom = null }) {
+    ensureDir();
+    const listings = readJsonSafe(listingsFile, []);
+    const arr = Array.isArray(listings) ? listings : [];
+    const slug =
+      id ||
+      `${normalize(title).split(' ').slice(0, 4).join('-') || 'listing'}-${rid().slice(0, 4)}`;
+    // Class-B vetting (B2): a recipe is local build know-how → self-attest + an
+    // automated scan. A clean scan earns the 'scanned' verdict; a hit is recorded
+    // (verdict 'flagged' + findings) so the badge tells the truth — publishing isn't
+    // blocked here (single-user/local shelf), but the listing carries its verdict.
+    const scan = scanForUnsafe(knowHow);
+    const listing = {
+      id: slug,
+      title: title || 'Untitled',
+      pitch: pitch || '',
+      summary: summary || pitch || '',
+      vendorDescription: summary || pitch || '',
+      producer: producer || { name: 'You', handle: 'you', kind: 'maker' },
+      tags,
+      knowHow,
+      buildDir: buildDir || null,
+      outcomeScore: 0.7, // new listing: a starting, unproven score (earns its place by working)
+      outcomeStats: { builds: 0, working: 0 },
+      safetyBadge: 'new', // legacy field; the real signal is `vetting` below
+      riskClass: 'B',
+      ...(builtFrom && builtFrom.id ? { builtFrom: { id: String(builtFrom.id), title: String(builtFrom.title || '') } } : {}),
+      dataTouched: { egress: [], scope: 'in-workspace', paid: { model: 'none', note: '' } },
+      attestation: { privacy: 'n/a', attestedBy: (producer || {}).handle || 'you', at: new Date().toISOString() },
+      vetting: {
+        verdict: scan.clean ? 'scanned' : 'flagged',
+        stakes: 'ordinary',
+        signature: null,
+        capabilities: null,
+        findings: scan.findings,
+      },
+      rating: { stars: 0, count: 0 },
+      reward: { model: 'one-time', unit: 'per build', perUseValue: 0, oneTimeValue: 5.0 },
+      source: 'listing',
+      createdAt: Date.now(),
+    };
+    // de-dupe by id (re-publish overwrites)
+    const next = arr.filter((l) => l.id !== listing.id);
+    next.push(listing);
+    writeJsonAtomic(listingsFile, next);
+    appendEvent({
+      type: 'publish',
+      recipeId: listing.id,
+      title: listing.title,
+      producer: listing.producer,
+    });
+    return {
+      ok: true,
+      listing: card(listing),
+      earning: {
+        model: listing.reward.model,
+        oneTimeValue: listing.reward.oneTimeValue,
+        note: 'Represented earnings — you earn each time someone builds on this. (Money is for later.)',
+      },
+    };
+  }
+
+  // --- themes on the shelf (the safest cross-user artifact) -----------------
+
+  // Publish a theme as a listing. The payload is a hex-token bundle (validated by
+  // normalizeTheme — same security boundary as set_theme: data, never CSS). It
+  // lands in listings.json with kind:'theme' and shows on the Themes shelf.
+  function publishTheme({ title, pitch, summary, tags = [], producer, theme, builtFrom = null } = {}) {
+    ensureDir();
+    const bundle = normalizeTheme(theme || {});
+    const listings = readJsonSafe(listingsFile, []);
+    const arr = Array.isArray(listings) ? listings : [];
+    const slug = `theme-${normalize(title).split(' ').slice(0, 3).join('-') || 'custom'}-${rid().slice(0, 4)}`;
+    // A remix records what it was tweaked from (the source theme on the shelf) so the
+    // network shows lineage — "built on each other's work", not a flat catalogue.
+    const provenance =
+      builtFrom && builtFrom.id
+        ? { id: String(builtFrom.id), title: String(builtFrom.title || '') }
+        : null;
+    const listing = {
+      id: slug,
+      kind: 'theme',
+      source: 'theme',
+      title: title || bundle.name || 'Custom theme',
+      pitch: pitch || '',
+      summary: summary || pitch || `A ${bundle.mode} theme.`,
+      vendorDescription: summary || pitch || '',
+      producer: producer || { name: 'You', handle: 'you', kind: 'maker' },
+      tags,
+      theme: bundle,
+      ...(provenance ? { builtFrom: provenance } : {}),
+      outcomeScore: 0.7,
+      outcomeStats: { builds: 0, working: 0 },
+      safetyBadge: 'new',
+      rating: { stars: 0, count: 0 },
+      reward: { model: 'one-time', unit: 'per apply', oneTimeValue: 1.5, perUseValue: 0 },
+      createdAt: Date.now(),
+    };
+    const next = arr.filter((l) => l.id !== listing.id);
+    next.push(listing);
+    writeJsonAtomic(listingsFile, next);
+    appendEvent({ type: 'publish', recipeId: listing.id, title: listing.title, producer: listing.producer, ...(provenance ? { builtFrom: provenance } : {}) });
+    const publicCard = card(listing);
+    // Push to the GLOBAL pool (next push §N) so every VW user can discover it.
+    // Best-effort + fire-and-forget: a down rail (or the MCP child, which has no
+    // rails) NEVER fails the local publish — the periodic sync reconciles it up.
+    if (rails && typeof rails.publish === 'function') {
+      Promise.resolve(rails.publish(publicCard)).catch(() => {});
+    }
+    return {
+      ok: true,
+      listing: publicCard,
+      earning: { model: 'one-time', oneTimeValue: listing.reward.oneTimeValue, note: 'You earn each time someone applies it. (Money is for later.)' },
+    };
+  }
+
+  // A consumer applied a theme from the shelf: record the three-way moment (they
+  // got the look · the producer earns · platform recorded it) and hand back the
+  // validated bundle for the browser to apply.
+  function recordThemeApply({ themeId, consumer = 'you' } = {}) {
+    const r = getRecipe(themeId);
+    if (!r || r.kind !== 'theme') return { ok: false, error: `no theme "${themeId}" on the shelf` };
+    const oneTime = r.reward?.oneTimeValue || 0;
+    const evt = appendEvent({
+      type: 'use',
+      recipeId: r.id,
+      title: r.title,
+      producer: r.producer,
+      consumer,
+      summary: `Applied the "${r.title}" theme`,
+      value: oneTime,
+      unit: 'one-time',
+    });
+    return {
+      ok: true,
+      event: evt,
+      theme: normalizeTheme(r.theme || {}),
+      title: r.title,
+      threeWay: {
+        you: `Your workspace now wears "${r.title}".`,
+        producer: `${r.producer?.name || 'The producer'} earns a one-time share for the look you adopted.`,
+        platform: 'VentureWild matched you to a proven theme — and recorded it.',
+      },
+      credit: { producer: r.producer, oneTime, unit: r.reward?.unit },
+    };
+  }
+
+  // --- self-seed drafts (review-gated) --------------------------------------
+
+  function listDrafts() {
+    const d = readJsonSafe(draftsFile, []);
+    return Array.isArray(d) ? d : [];
+  }
+
+  function getDraft(id) {
+    return listDrafts().find((d) => d.id === id) || null;
+  }
+
+  // Stage a recipe the agent extracted from the user's existing work — does NOT
+  // publish. `sourceNote` records (for the user's review) what it was generalized
+  // from. Returns a review-shaped object the UI renders for approval.
+  function stageDraft({ title, pitch, summary, tags = [], knowHow = '', sourceNote = '' }) {
+    ensureDir();
+    const drafts = listDrafts();
+    const draft = {
+      id: `draft-${rid()}`,
+      title: title || 'Untitled',
+      pitch: pitch || '',
+      summary: summary || pitch || '',
+      tags: Array.isArray(tags) ? tags : [],
+      knowHow: knowHow || '',
+      sourceNote: sourceNote || '',
+      createdAt: Date.now(),
+    };
+    drafts.push(draft);
+    writeJsonAtomic(draftsFile, drafts);
+    return draft;
+  }
+
+  function discardDraft(id) {
+    const drafts = listDrafts();
+    const next = drafts.filter((d) => d.id !== id);
+    writeJsonAtomic(draftsFile, next);
+    return { ok: next.length !== drafts.length };
+  }
+
+  // Promote a reviewed draft onto the shelf — publishes EXACTLY what was reviewed
+  // (you publish what you saw), then removes it from the draft queue.
+  function publishDraft(id, { producer } = {}) {
+    const draft = getDraft(id);
+    if (!draft) return { ok: false, error: `no draft "${id}"` };
+    const res = publishListing({
+      title: draft.title,
+      pitch: draft.pitch,
+      summary: draft.summary,
+      tags: draft.tags,
+      knowHow: draft.knowHow,
+      producer: producer || { name: 'You', handle: 'you', kind: 'maker' },
+    });
+    discardDraft(id);
+    return res;
+  }
+
+  function setPreview({ dir: buildDir, recipeId, port = 4000 }) {
+    ensureDir();
+    const payload = { dir: buildDir, recipeId: recipeId || null, port, ts: Date.now() };
+    writeJsonAtomic(previewFile, payload);
+    return payload;
+  }
+
+  function getPreview() {
+    return readJsonSafe(previewFile, null);
+  }
+
+  // Aggregate everything the UI needs: transactions, per-producer earnings,
+  // per-service usage meters, and the user's own listings.
+  function computeState() {
+    const evs = events();
+    const earnings = {}; // handle -> { name, total, uses, serviceCalls, matches }
+    const meters = {}; // serviceId -> { calls, matches, value, producer }
+    const transactions = [];
+    for (const e of evs) {
+      const h = e.producer?.handle || 'unknown';
+      const bucket = (earnings[h] ??= {
+        name: e.producer?.name || h,
+        handle: h,
+        total: 0,
+        uses: 0,
+        serviceCalls: 0,
+        matches: 0,
+      });
+      if (e.type === 'use') {
+        bucket.total += e.value || 0;
+        bucket.uses += 1;
+        transactions.push(e);
+      } else if (e.type === 'service-call') {
+        bucket.total += e.value || 0;
+        bucket.serviceCalls += 1;
+        bucket.matches += e.matches || 0;
+        const sid = e.serviceId || 'service';
+        const m = (meters[sid] ??= { calls: 0, matches: 0, value: 0, producer: e.producer || null });
+        m.calls += 1;
+        m.matches += e.matches || 0;
+        m.value += e.value || 0;
+      } else if (e.type === 'publish') {
+        transactions.push(e);
+      }
+    }
+    return {
+      transactions: transactions.slice(-50),
+      earnings: Object.values(earnings).sort((a, b) => b.total - a.total),
+      meters,
+      listings: (readJsonSafe(listingsFile, []) || []).map((l) => card(l)),
+      totals: {
+        events: evs.length,
+        creditPaid: Object.values(earnings).reduce((s, b) => s + b.total, 0),
+      },
+    };
+  }
+
+  return {
+    dir,
+    eventsFile,
+    listingsFile,
+    previewFile,
+    draftsFile,
+    railsThemesFile,
+    writeRailsThemes,
+    ownThemeListings,
+    shelf,
+    getRecipe,
+    card,
+    search,
+    recordUse,
+    recordBuildResult,
+    recordServiceCall,
+    publishListing,
+    publishTheme,
+    recordThemeApply,
+    listDrafts,
+    getDraft,
+    stageDraft,
+    discardDraft,
+    publishDraft,
+    setPreview,
+    getPreview,
+    computeState,
+    events,
+  };
+}
+
+function money(n) {
+  const v = Number(n) || 0;
+  return `$${v.toFixed(2)}`;
+}