@venturewild/workspace 0.1.14 → 0.2.0

package/server/src/bazaar/core.mjs

@@ -0,0 +1,579 @@
+// 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 };
+}
+
+// --- the bazaar instance --------------------------------------------------
+
+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 */
+    }
+  }
+
+  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: r.outcomeScore,
+      outcomeStats: r.outcomeStats,
+      safetyBadge: r.safetyBadge,
+      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 || (b.r.outcomeScore || 0) - (a.r.outcomeScore || 0))
+      .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 }) {
+    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)}`;
+    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',
+      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 } = {}) {
+    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)}`;
+    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,
+      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 });
+    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,
+    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)}`;
+}

package/server/src/bazaar/index.mjs

@@ -0,0 +1,75 @@
+// Bazaar runtime glue for the main server: the agent-facing system prompt and the
+// generated --mcp-config that wires `claude` to the bazaar MCP server.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export const MCP_SERVER_PATH = path.join(__dirname, 'mcp-server.mjs');
+
+// Appended to the agent's system prompt on user chat turns. Deliberately sets a
+// *disposition* ("consult the shelf when it plausibly fits; surface only on a
+// strong match; otherwise build normally and stay silent") rather than a blind
+// "always search" habit — the ranking decides "strong enough", not this text. Also
+// the copy guardrails: never expose plumbing words; sell the dish, not the meat.
+export const BAZAAR_SYSTEM_PROMPT = [
+  "This workspace has a *bazaar* — a shelf of proven recipes other producers have shared, each",
+  "measured by how often it actually gets someone a working result. You can reach onto it with the",
+  "bazaar tools (mcp__bazaar__search_shelf, open_recipe, launch_preview, record_use, publish_listing,",
+  "draft_recipe, publish_draft).",
+  "",
+  "When the user describes something to build or an outcome they want, and it PLAUSIBLY matches a",
+  "known proven build, quietly call search_shelf first. If there is a STRONG, clearly-relevant match,",
+  "surface it in your own voice before building from scratch: say in one line that there's a proven",
+  "way to do exactly this and who it's from, and offer to use it. If nothing is a strong match, just",
+  "build normally and do NOT mention the bazaar.",
+  "",
+  "When the user accepts a recipe: call open_recipe to absorb the producer's know-how, build it",
+  "one-shot following that know-how, call launch_preview with the build folder so the live preview",
+  "opens, then call record_use so the producer gets credit and the transaction is recorded.",
+  "",
+  "After the user has something that works and is reusable, you may offer to package it so others can",
+  "build on it (\"want me to make this usable by others? you'd earn when they do\"). If they accept, or",
+  "if they ask to list/sell it, call publish_listing.",
+  "",
+  "The bazaar also has THEMES (workspace looks). If the user loves a look they're using and wants to",
+  "share/list/sell it — or asks you to — call publish_theme with its colours (mode, accent, and the",
+  "token hex values). Themes are the safest thing to share (just colours), and the user earns each time",
+  "someone applies theirs. To browse/apply existing themes the user can open the bazaar's Themes shelf.",
+  "",
+  "To SEED the shelf from the user's own past work: when they point you at a folder, read it, find the",
+  "*reusable patterns* (the architecture/approach — not the client's content), and for each call",
+  "draft_recipe with GENERALIZED know-how. STRIP every client name, domain, credential, and piece of",
+  "data; write the method so another agent could rebuild a similar thing from scratch. Stage one draft",
+  "per pattern, show the user a short summary of each, and call publish_draft ONLY for the ones they",
+  "explicitly approve. Never publish straight from their real work without review.",
+  "",
+  "Speak like a capable assistant, never an engineer. NEVER say \"API\", \"endpoint\", \"service URL\", or",
+  "\"port\" to the user — say things like \"TickUp's matching, their method stays on their side\". Keep",
+  "replies short. Money shown in the marketplace is represented for now (\"settles later\"), not real.",
+].join('\n');
+
+// Write the MCP config `claude` loads via --mcp-config. Points at the bazaar MCP
+// server (run with the same node) and pins the global dir so the child shares our
+// state. Returns the config path, or null if it can't be written.
+export function writeBazaarMcpConfig({ baseDir, globalDir, nodePath = process.execPath } = {}) {
+  const cfg = {
+    mcpServers: {
+      bazaar: {
+        command: nodePath,
+        args: [MCP_SERVER_PATH],
+        env: globalDir ? { WILD_WORKSPACE_GLOBAL_DIR: globalDir } : {},
+      },
+    },
+  };
+  const file = path.join(baseDir, 'mcp-config.json');
+  try {
+    fs.mkdirSync(baseDir, { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(cfg, null, 2));
+    return file;
+  } catch {
+    return null;
+  }
+}