@venturewild/workspace 0.1.13 → 0.2.0

package/server/src/bazaar/mcp-server.mjs

@@ -0,0 +1,328 @@
+// Bazaar MCP server — the tools the agent uses to "reach onto our shelf" (§3.7).
+//
+// Hand-rolled stdio JSON-RPC 2.0 (newline-delimited), so it needs NO new
+// dependency and stays in the project's wrap-don't-embed style (like the
+// stream-json parser in agent.mjs). `claude` spawns this per turn via --mcp-config
+// and exposes the tools as mcp__bazaar__<name>.
+//
+// It imports the SAME core.mjs the main server uses, so there is one source of
+// truth (state under ~/.wild-workspace/bazaar/) and no HTTP/port handshake. Tool
+// results are JSON envelopes: the AGENT reads them (incl. the absorbed know-how),
+// and the UI parses the same JSON to render rich bazaar cards.
+//
+// stdout carries ONLY JSON-RPC. Any diagnostics go to stderr.
+
+import readline from 'node:readline';
+import { createBazaar } from './core.mjs';
+
+const bazaar = createBazaar(); // baseDir from WILD_WORKSPACE_GLOBAL_DIR (set by parent)
+const PROTOCOL_VERSION = '2025-06-18';
+
+function send(msg) {
+  process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+function result(id, res) {
+  send({ jsonrpc: '2.0', id, result: res });
+}
+function errorReply(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+function textContent(obj) {
+  return { content: [{ type: 'text', text: JSON.stringify(obj) }] };
+}
+
+// --- tool definitions -----------------------------------------------------
+
+const TOOLS = [
+  {
+    name: 'search_shelf',
+    description:
+      "Search the bazaar shelf for a proven recipe that matches what the user wants to build. " +
+      "Call this FIRST when the user describes an outcome that plausibly matches a known build. " +
+      "Returns ranked matches with an outcome score (how often the recipe actually gets people a " +
+      "working result). Only surface a recipe to the user if there is a STRONG, clearly relevant match.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        need: { type: 'string', description: "Plain-language description of what the user wants." },
+      },
+      required: ['need'],
+    },
+  },
+  {
+    name: 'open_recipe',
+    description:
+      "Open a recipe to absorb the producer's know-how (the step-by-step way to build it their way). " +
+      "Call this after the user accepts a recipe, then build it one-shot following the know-how.",
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'The recipe id from search_shelf.' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'launch_preview',
+    description:
+      "Point the user's live preview at the folder you built, so it opens on their screen. " +
+      "Call this right after writing the build files.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dir: { type: 'string', description: 'The build folder (relative to the workspace), e.g. "candidate-matcher".' },
+        recipeId: { type: 'string', description: 'The recipe id this build came from (optional).' },
+      },
+      required: ['dir'],
+    },
+  },
+  {
+    name: 'record_use',
+    description:
+      "Record that the user built on a producer's recipe — this credits the producer and records the " +
+      "transaction (the three-way win). Call this once the build is done.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        recipeId: { type: 'string', description: 'The recipe id that was used.' },
+        summary: { type: 'string', description: 'One short line describing what you built for the user.' },
+      },
+      required: ['recipeId'],
+    },
+  },
+  {
+    name: 'publish_listing',
+    description:
+      "Package something the user built into a listing on the shelf, so other people's agents can " +
+      "build on it and the user earns when they do. Use when the user accepts your offer to package " +
+      "it, OR when the user explicitly asks to list/sell what they made.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'A short title for the listing.' },
+        pitch: { type: 'string', description: 'One line that sells what it does.' },
+        summary: { type: 'string', description: 'A plain summary of what someone gets.' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Keywords others might search for.' },
+        knowHow: { type: 'string', description: "The how-to another agent would absorb to rebuild it." },
+        buildDir: { type: 'string', description: 'The folder the build lives in (optional).' },
+      },
+      required: ['title'],
+    },
+  },
+  {
+    name: 'draft_recipe',
+    description:
+      "Stage a recipe you EXTRACTED from the user's existing/past work for their REVIEW (does NOT " +
+      "publish). Use when self-seeding the shelf from past projects. The know-how MUST be " +
+      "GENERALIZED — the reusable method/architecture only, with NO client names, data, domains, " +
+      "keys, or secrets. Stage one draft per reusable pattern; the user reviews each and tells you " +
+      "which to publish.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'A short title for the recipe.' },
+        pitch: { type: 'string', description: 'One line: what it lets someone build.' },
+        summary: { type: 'string', description: 'A plain summary of what someone gets.' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Keywords others might search for.' },
+        knowHow: { type: 'string', description: "The GENERALIZED how-to another agent would follow — no client specifics." },
+        sourceNote: { type: 'string', description: 'For the user to verify: what this was generalized from (e.g. "from 3 client landing pages") — no client names.' },
+      },
+      required: ['title', 'knowHow'],
+    },
+  },
+  {
+    name: 'publish_draft',
+    description:
+      "Publish a reviewed draft onto the shelf. Call ONLY after the user has explicitly approved that " +
+      "specific draft (by its id).",
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'The draft id from draft_recipe.' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'publish_theme',
+    description:
+      "Publish a workspace THEME to the bazaar so others can discover and apply it (the user earns each " +
+      "time someone does). Use this when the user asks to share/list/sell a look they like, or after you " +
+      "made one they love. A theme is just colours (hex values) — pick a mode (light|dark), an accent, " +
+      "and the token colours that define the look. Give it a short title and a one-line pitch.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Short theme name, e.g. "Warm Sunset".' },
+        pitch: { type: 'string', description: 'One-line description of the vibe.' },
+        summary: { type: 'string', description: 'A slightly longer description (optional).' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'e.g. ["dark","warm"].' },
+        mode: { type: 'string', enum: ['light', 'dark'], description: 'Base palette.' },
+        accent: { type: 'string', description: 'Primary accent, hex e.g. "#22d3ee".' },
+        bg: { type: 'string', description: 'page background, hex.' },
+        surface: { type: 'string', description: 'card face, hex.' },
+        text: { type: 'string', description: 'primary text, hex.' },
+        textMuted: { type: 'string', description: 'muted text, hex.' },
+        border: { type: 'string', description: 'borders, hex.' },
+        canvas1: { type: 'string', description: 'wallpaper stop 1, hex.' },
+        canvas2: { type: 'string', description: 'wallpaper stop 2, hex.' },
+        canvas3: { type: 'string', description: 'wallpaper stop 3, hex.' },
+      },
+      required: ['title'],
+    },
+  },
+];
+
+// --- tool dispatch --------------------------------------------------------
+
+function callTool(name, args = {}) {
+  switch (name) {
+    case 'search_shelf': {
+      const hits = bazaar.search(args.need || '');
+      return textContent({
+        kind: 'search',
+        need: args.need || '',
+        count: hits.length,
+        hits,
+        top: hits[0] || null,
+        guidance:
+          hits.length === 0
+            ? 'Nothing on the shelf is a strong match — build from scratch and do not mention the bazaar.'
+            : 'Surface the top match to the user only if it is clearly relevant (a strong, high-outcome match).',
+      });
+    }
+    case 'open_recipe': {
+      const r = bazaar.getRecipe(args.id);
+      if (!r) return { ...textContent({ kind: 'error', error: `no recipe "${args.id}"` }), isError: true };
+      return textContent({
+        kind: 'recipe',
+        card: bazaar.card(r),
+        knowHow: r.knowHow || '',
+        service: r.service || null,
+        note: 'Absorb this know-how and build it one-shot for the user.',
+      });
+    }
+    case 'launch_preview': {
+      const preview = bazaar.setPreview({ dir: args.dir, recipeId: args.recipeId || null });
+      return textContent({ kind: 'preview', url: '/preview/', dir: preview.dir, recipeId: preview.recipeId });
+    }
+    case 'record_use': {
+      const res = bazaar.recordUse({ recipeId: args.recipeId, summary: args.summary });
+      if (!res.ok) return { ...textContent({ kind: 'error', error: res.error }), isError: true };
+      // Backstop the preview: even if the agent forgot launch_preview, target the
+      // recipe's build dir so the preview still opens (review must-fix #3).
+      let preview = bazaar.getPreview();
+      if ((!preview || !preview.dir) && res.recipe?.buildDir) {
+        preview = bazaar.setPreview({ dir: res.recipe.buildDir, recipeId: res.recipe.id });
+      }
+      return textContent({
+        kind: 'three-way',
+        recipe: res.recipe,
+        threeWay: res.threeWay,
+        credit: res.credit,
+        service: res.service,
+        preview: preview?.dir ? { url: '/preview/', dir: preview.dir } : null,
+        simulated: true,
+      });
+    }
+    case 'publish_listing': {
+      const res = bazaar.publishListing({
+        title: args.title,
+        pitch: args.pitch,
+        summary: args.summary,
+        tags: args.tags || [],
+        knowHow: args.knowHow || '',
+        buildDir: args.buildDir || null,
+      });
+      return textContent({ kind: 'publish', listing: res.listing, earning: res.earning, simulated: true });
+    }
+    case 'draft_recipe': {
+      const draft = bazaar.stageDraft({
+        title: args.title,
+        pitch: args.pitch,
+        summary: args.summary,
+        tags: args.tags || [],
+        knowHow: args.knowHow || '',
+        sourceNote: args.sourceNote || '',
+      });
+      return textContent({ kind: 'draft', draft });
+    }
+    case 'publish_draft': {
+      const res = bazaar.publishDraft(args.id);
+      if (!res.ok) return { ...textContent({ kind: 'error', error: res.error }), isError: true };
+      return textContent({ kind: 'publish', listing: res.listing, earning: res.earning, simulated: true });
+    }
+    case 'publish_theme': {
+      const res = bazaar.publishTheme({
+        title: args.title,
+        pitch: args.pitch,
+        summary: args.summary,
+        tags: args.tags || [],
+        theme: {
+          mode: args.mode,
+          accent: args.accent,
+          bg: args.bg, surface: args.surface, text: args.text, textMuted: args.textMuted,
+          border: args.border, canvas1: args.canvas1, canvas2: args.canvas2, canvas3: args.canvas3,
+        },
+      });
+      return textContent({ kind: 'publish', listing: res.listing, earning: res.earning, simulated: true });
+    }
+    default:
+      return { ...textContent({ kind: 'error', error: `unknown tool ${name}` }), isError: true };
+  }
+}
+
+// --- JSON-RPC loop --------------------------------------------------------
+
+export function handleMessage(msg) {
+  if (!msg || msg.jsonrpc !== '2.0') return;
+  const { id, method, params } = msg;
+  const isNotification = id === undefined || id === null;
+
+  switch (method) {
+    case 'initialize':
+      return result(id, {
+        protocolVersion: params?.protocolVersion || PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: 'bazaar', version: '1.0.0' },
+      });
+    case 'notifications/initialized':
+    case 'initialized':
+      return; // notification, no response
+    case 'ping':
+      return result(id, {});
+    case 'tools/list':
+      return result(id, { tools: TOOLS });
+    case 'tools/call': {
+      try {
+        const out = callTool(params?.name, params?.arguments || {});
+        return result(id, out);
+      } catch (e) {
+        return errorReply(id, -32603, `tool error: ${e?.message || e}`);
+      }
+    }
+    default:
+      if (!isNotification) errorReply(id, -32601, `method not found: ${method}`);
+      return;
+  }
+}
+
+// Only run the stdio loop when executed as the MCP process (not when imported by a test).
+const isDirectRun = process.argv[1] && process.argv[1].endsWith('mcp-server.mjs');
+if (isDirectRun) {
+  const rl = readline.createInterface({ input: process.stdin });
+  rl.on('line', (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      return; // ignore non-JSON noise
+    }
+    try {
+      handleMessage(msg);
+    } catch (e) {
+      process.stderr.write(`bazaar mcp error: ${e?.message || e}\n`);
+    }
+  });
+  process.stderr.write('bazaar mcp server ready\n');
+}
+
+export { TOOLS, callTool };

package/server/src/bazaar/mock-tickup.mjs

@@ -0,0 +1,97 @@
+// Mock "TickUp" candidate-matching service.
+//
+// v1 stand-in for the producer's real tool/API (there is no real TickUp). The
+// point is the FLOW, not real ML: a deterministic, offline ranker so the wiring
+// is demonstrable and the demo looks smart. The built site POSTs { role,
+// candidates } here and renders the ranked result.
+
+const STOPWORDS = new Set([
+  'a', 'an', 'the', 'and', 'or', 'of', 'to', 'in', 'on', 'for', 'with', 'at',
+  'by', 'plus', 'pace', 'senior', 'junior', 'mid', 'lead', 'staff', 'engineer',
+  'developer', 'years', 'year', 'yr', 'yrs', 'experience', 'exp', 'who', 'can',
+  'is', 'are', 'be', 'we', 'you', 'your', 'our', 'team', 'role', 'work',
+]);
+
+function tokenize(text) {
+  return new Set(
+    String(text || '')
+      .toLowerCase()
+      .replace(/[^a-z0-9+#.]+/g, ' ')
+      .split(' ')
+      .map((w) => w.trim())
+      .filter((w) => w.length >= 2 && !STOPWORDS.has(w)),
+  );
+}
+
+function parseYears(text) {
+  const m = String(text || '').match(/(\d+)\s*\+?\s*(?:y|yr|yrs|year|years)\b/i);
+  return m ? Math.min(parseInt(m[1], 10), 25) : 0;
+}
+
+function parseCandidate(line) {
+  const raw = String(line || '').trim();
+  // split "Name — skills" on em/en dash, hyphen, or colon
+  const m = raw.split(/\s+[—–:-]\s+/);
+  let name = raw;
+  let skills = '';
+  if (m.length >= 2) {
+    name = m[0].trim();
+    skills = m.slice(1).join(' ').trim();
+  }
+  return { name: name || raw, skills, raw };
+}
+
+const clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+
+export function matchCandidates({ role, candidates } = {}) {
+  const roleTokens = tokenize(role);
+  const list = (Array.isArray(candidates) ? candidates : [])
+    // Defensive: a candidate may be a string, an object, or junk (null/number).
+    // `typeof null === 'object'` would crash `null.name`, so coerce carefully.
+    .map((c) => {
+      if (typeof c === 'string') return c;
+      if (c && typeof c === 'object') return `${c.name || ''} — ${c.skills || ''}`;
+      return '';
+    })
+    .map((l) => String(l).trim())
+    .filter(Boolean)
+    .filter((l) => /[a-z0-9]/i.test(l)) // drop punctuation-only lines (e.g. "{}" -> " — ")
+    .slice(0, 500); // bound CPU on a publicly-reachable endpoint
+
+  const ranked = list.map((line) => {
+    const { name, skills, raw } = parseCandidate(line);
+    // Skills as a structured list (chips) — the contract returns string[], so a
+    // consumer's site can render them directly without re-parsing.
+    const skillList = skills
+      .split(/[,;/]/)
+      .map((s) => s.trim())
+      .filter(Boolean)
+      .slice(0, 8);
+    const candTokens = tokenize(`${skills} ${name}`);
+    const matched = [...roleTokens].filter((t) => candTokens.has(t));
+    const years = parseYears(raw);
+    const yearsBonus = Math.min(years, 10) * 2;
+    let score;
+    if (matched.length > 0) {
+      score = clamp(40 + matched.length * 14 + yearsBonus, 45, 98);
+    } else {
+      score = clamp(8 + yearsBonus, 5, 35);
+    }
+    const top = matched.slice(0, 3);
+    let why;
+    if (top.length > 0) {
+      why =
+        `Strong on ${top.join(', ')}` +
+        (years ? ` · ${years}y experience` : '') +
+        (matched.length > 3 ? ` · +${matched.length - 3} more matches` : '');
+    } else {
+      why = years
+        ? `Limited overlap with the role, but ${years}y of experience`
+        : 'Limited overlap with the role';
+    }
+    return { name, skills: skillList, score: Math.round(score), why, matched };
+  });
+
+  ranked.sort((a, b) => b.score - a.score);
+  return { role: String(role || ''), count: ranked.length, ranked };
+}

package/server/src/bazaar/preview-server.mjs

@@ -0,0 +1,95 @@
+// Bazaar preview host — static-file helper for serving the agent's build through
+// the MAIN wild-workspace server at /preview/* (same-origin, behind the existing
+// auth/role middleware). NOT a separate listener: serving same-origin means no
+// port to squat (no collision with the user's real dev servers), no mixed-content
+// under the public https proxy, and the built page's fetch('./match') is genuinely
+// same-origin. The matching service (POST /preview/match) and the live earnings
+// broadcast live in index.mjs, which has the activity bus + chat clients.
+//
+// The build itself is the USER'S PRODUCT and lives in their workspace; this module
+// only READS from a build dir. No bazaar bookkeeping is ever written into the
+// synced workspace (CLAUDE.md rule #1) — that all lives in ~/.wild-workspace/bazaar.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import mime from 'mime-types';
+
+// Confine the preview build dir to the user's workspace. `dir` comes from the
+// agent (preview.json) and is NOT trusted to stay inside the workspace — an
+// absolute path or `..` segments would otherwise let /preview/* read anywhere on
+// disk (host secrets). Returns the absolute build dir, or null if it escapes.
+export function confineBuildDir(workspaceDir, dir) {
+  if (!dir) return null;
+  const root = path.resolve(workspaceDir);
+  const resolved = path.resolve(root, dir);
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) return null;
+  return resolved;
+}
+
+// True if `file` (after symlink resolution) stays inside `root` (after symlink
+// resolution). Defeats a symlink/junction planted in the build dir that points
+// outside it — the lexical guard in resolvePreviewFile follows no symlinks, but
+// fs.readFile does.
+function realpathInside(file, root) {
+  try {
+    const realRoot = fs.realpathSync(root);
+    const realFile = fs.realpathSync(file);
+    return realFile === realRoot || realFile.startsWith(realRoot + path.sep);
+  } catch {
+    return false; // missing/broken link — refuse
+  }
+}
+
+// Resolve a request path (everything after /preview/) to an absolute file inside
+// buildDir, with a path-traversal guard. Returns null if it escapes buildDir.
+export function resolvePreviewFile(buildDir, reqPath) {
+  const root = path.resolve(buildDir);
+  const clean = decodeURIComponent(String(reqPath || '').split('?')[0]).replace(/\\/g, '/');
+  const rel = clean.replace(/^\/+/, '');
+  const resolved = path.resolve(root, rel || 'index.html');
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) return null;
+  return resolved;
+}
+
+// Serve one file from the build dir. Returns { status, contentType, body, headers }.
+// body is a Buffer (file bytes) or a string (the waiting/404 page).
+export function servePreviewFile(buildDir, reqPath) {
+  if (!buildDir) {
+    return { status: 200, contentType: 'text/html', body: WAITING_PAGE };
+  }
+  const file = resolvePreviewFile(buildDir, reqPath);
+  if (!file) return { status: 403, contentType: 'text/plain', body: 'forbidden' };
+
+  let target = file;
+  try {
+    if (fs.statSync(target).isDirectory()) target = path.join(target, 'index.html');
+  } catch {
+    /* not a dir / doesn't exist — fall through to read */
+  }
+
+  try {
+    // Symlink guard: the lexical check above follows no symlinks, but readFileSync
+    // does — so re-check the real path stays inside the build dir before reading.
+    if (!realpathInside(target, buildDir)) {
+      return { status: 403, contentType: 'text/plain', body: 'forbidden' };
+    }
+    const body = fs.readFileSync(target);
+    const contentType = mime.lookup(target) || 'application/octet-stream';
+    return { status: 200, contentType, body, headers: { 'Cache-Control': 'no-store' } };
+  } catch {
+    // SPA-ish fallback: serve index.html for unknown paths if it exists.
+    try {
+      const body = fs.readFileSync(path.join(path.resolve(buildDir), 'index.html'));
+      return { status: 200, contentType: 'text/html', body, headers: { 'Cache-Control': 'no-store' } };
+    } catch {
+      return { status: 404, contentType: 'text/html', body: NOT_FOUND_PAGE };
+    }
+  }
+}
+
+export const WAITING_PAGE = `<!doctype html><html><head><meta charset="utf-8"><title>Preview</title>
+<style>body{font-family:system-ui,-apple-system,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#0f1117;color:#9aa4b2}div{text-align:center;max-width:340px;line-height:1.6}</style>
+</head><body><div><p>🛠️ Your build will appear here the moment your agent finishes it.</p></div></body></html>`;
+
+export const NOT_FOUND_PAGE = `<!doctype html><html><head><meta charset="utf-8"><title>Not found</title></head>
+<body style="font-family:system-ui;padding:40px;color:#555">Nothing here yet.</body></html>`;

package/server/src/bazaar/seed-recipes/customer-feedback-form/know-how.md

@@ -0,0 +1,23 @@
+# Marco's feedback form — how to build it
+
+> Absorb and build in one shot. Single self-contained `feedback-form/index.html`
+> (inline CSS + JS), no build step.
+
+## Build steps
+
+1. Create `feedback-form/index.html`.
+2. The page:
+   - A **star rating** (1–5, clickable).
+   - A **comment** textarea.
+   - A **Submit** button. On submit, store `{rating, comment, ts}` in
+     `localStorage` and clear the form.
+   - A **live summary**: average rating across stored responses + the 3 most
+     recent comments. Updates immediately on submit.
+3. Clean, friendly styling, one accent color. Prefill nothing; show a small empty
+   state ("Be the first to leave feedback").
+
+## Finish
+
+After writing the files: call **`launch_preview`** `{ "dir": "feedback-form" }`,
+then **`record_use`** with recipe id `customer-feedback-form` and a short summary,
+then tell the user it's live in the preview (briefly).

package/server/src/bazaar/seed-recipes/customer-feedback-form/recipe.json

@@ -0,0 +1,24 @@
+{
+  "id": "customer-feedback-form",
+  "title": "Customer feedback form with instant summary",
+  "producer": { "name": "Marco", "handle": "marco", "kind": "maker" },
+  "pitch": "Collect feedback and see the mood at a glance — built in one shot.",
+  "vendorDescription": "Marco's feedback widget. A clean form (rating + comment) plus a live tally so you see how people feel without opening a spreadsheet.",
+  "summary": "A single page: a star rating, a comment box, and a running summary (average score + recent comments). Stores responses locally for the demo.",
+  "outcomeScore": 0.86,
+  "outcomeStats": { "builds": 29, "working": 25 },
+  "safetyBadge": "verified",
+  "rating": { "stars": 4.5, "count": 19 },
+  "tags": [
+    "feedback", "customer feedback", "survey", "form", "nps", "rating",
+    "review", "reviews", "questionnaire", "poll", "satisfaction", "comments"
+  ],
+  "reward": {
+    "model": "one-time",
+    "unit": "per build",
+    "perUseValue": 0,
+    "oneTimeValue": 5.0,
+    "note": "Marco earns a one-time share each time his feedback-form know-how is used."
+  },
+  "buildDir": "feedback-form"
+}

package/server/src/bazaar/seed-recipes/landing-page-launch/know-how.md

@@ -0,0 +1,29 @@
+# Lina's launch page — how to build it
+
+> Absorb this and build the user a one-page launch site in one shot. Single
+> self-contained `index.html` (inline CSS + JS), no build step.
+
+## Build steps
+
+1. Create `landing-page/index.html`.
+2. Sections, top to bottom:
+   - **Hero**: a big headline, a one-line subhead, and a primary call-to-action
+     button. Use a soft gradient background. Prefill with the user's product if
+     you know it; otherwise a believable placeholder they can edit.
+   - **Three feature blocks**: each an icon (an emoji is fine), a short title, and
+     one sentence.
+   - **Social proof**: a single line of fake-but-tasteful stats (e.g. "Loved by
+     800+ early users").
+   - **Email waitlist**: an email input + "Join the waitlist" button. On submit,
+     store the address in `localStorage` and show a "You're on the list 🎉"
+     confirmation. (No backend needed for v1.)
+3. House style: modern, generous whitespace, system font stack, one accent color.
+   Make it look like a real launch, not a template.
+
+## Finish
+
+After writing the files:
+
+1. Call **`launch_preview`** with `{ "dir": "landing-page" }`.
+2. Call **`record_use`** with recipe id `landing-page-launch` and a short summary.
+3. Tell the user it's live in the preview, in one or two short sentences.

package/server/src/bazaar/seed-recipes/landing-page-launch/recipe.json

@@ -0,0 +1,25 @@
+{
+  "id": "landing-page-launch",
+  "title": "Launch a landing page with a waitlist",
+  "producer": { "name": "Lina", "handle": "lina", "kind": "maker" },
+  "pitch": "A clean one-page launch site with a hero, features, and an email waitlist — live in one shot.",
+  "vendorDescription": "Lina's launch page. The exact layout that got her side-project 800 signups in a week: a punchy hero, three benefit blocks, social proof, and an email capture that just works.",
+  "summary": "A single-page marketing site: hero headline, three feature blocks, and an email signup that collects addresses. No setup. Make it yours by changing the words.",
+  "outcomeScore": 0.88,
+  "outcomeStats": { "builds": 51, "working": 45 },
+  "safetyBadge": "verified",
+  "rating": { "stars": 4.6, "count": 33 },
+  "tags": [
+    "landing page", "landing", "waitlist", "marketing site", "website",
+    "hero", "signup", "sign up", "coming soon", "product launch", "launch",
+    "email capture", "newsletter", "homepage", "promo"
+  ],
+  "reward": {
+    "model": "one-time",
+    "unit": "per build",
+    "perUseValue": 0,
+    "oneTimeValue": 6.0,
+    "note": "Lina earns a one-time share each time her launch page know-how is used to build a site."
+  },
+  "buildDir": "landing-page"
+}

package/server/src/bazaar/seed-recipes/personal-portfolio/know-how.md

@@ -0,0 +1,21 @@
+# Nia's portfolio — how to build it
+
+> Absorb and build in one shot. Single self-contained `portfolio/index.html`
+> (inline CSS + JS), no build step.
+
+## Build steps
+
+1. Create `portfolio/index.html`.
+2. Sections:
+   - **Hero**: name, a one-line "what I do", and a primary contact button.
+   - **Projects**: a responsive grid of 3–6 cards (title, one-line description, a
+     tag or two). Use placeholder content the user can edit.
+   - **Contact**: an email line + simple links (placeholder).
+3. House style: confident, lots of whitespace, one accent color, a tasteful hover
+   on the project cards. Make it look hireable.
+
+## Finish
+
+After writing the files: call **`launch_preview`** `{ "dir": "portfolio" }`, then
+**`record_use`** with recipe id `personal-portfolio` and a short summary, then tell
+the user it's live (briefly).

package/server/src/bazaar/seed-recipes/personal-portfolio/recipe.json

@@ -0,0 +1,24 @@
+{
+  "id": "personal-portfolio",
+  "title": "Personal portfolio site",
+  "producer": { "name": "Nia", "handle": "nia", "kind": "maker" },
+  "pitch": "A sharp one-page portfolio — intro, projects, contact — live in one shot.",
+  "vendorDescription": "Nia's portfolio template. The layout that landed her three freelance clients: a confident intro, a project grid, and a contact line that converts.",
+  "summary": "A single-page portfolio: hero intro, a grid of project cards, and a contact section. Swap the text and images to make it yours.",
+  "outcomeScore": 0.81,
+  "outcomeStats": { "builds": 40, "working": 32 },
+  "safetyBadge": "tested",
+  "rating": { "stars": 4.3, "count": 21 },
+  "tags": [
+    "portfolio", "personal site", "personal website", "resume site", "cv site",
+    "about me", "showcase", "designer portfolio", "developer portfolio", "projects"
+  ],
+  "reward": {
+    "model": "one-time",
+    "unit": "per build",
+    "perUseValue": 0,
+    "oneTimeValue": 5.0,
+    "note": "Nia earns a one-time share each time her portfolio know-how is used."
+  },
+  "buildDir": "portfolio"
+}