Creative Disposition Across AI Models

Each exhibit gets a random 6-character slug, collision-checked against the registry.

const CHARSET = 'abcdefghijklmnopqrstuvwxyz0123456789';

function randomSlug() {
  const bytes = randomBytes(6);
  let slug = '';
  for (let i = 0; i < 6; i++) {
    slug += CHARSET[bytes[i] % CHARSET.length];
    if (i === 2) slug += '-';  // ABC-DEF format
  }
  return slug;
}

// Collision check against existing registry
function getExistingSlugs() {
  const source = readFileSync(REGISTRY_PATH, 'utf8');
  const matches = source.matchAll(/slug:\s*'([^']+)'/g);
  return new Set([...matches].map((m) => m[1]));
}

Models cannot see other exhibits. Real guardrails, enforced per session.

// From CLAUDE.md — enforced on every agent session:

When creating an exhibit, you are FORBIDDEN from:
- Reading any files inside public/exhibits/ other
  than your own exhibit's directory
- Browsing, searching, or grepping inside other
  exhibits' directories
- Reading existing exhibit entries in
  src/lib/exhibits.ts beyond the Exhibit type
- Referencing, imitating, or reacting to other
  exhibits' titles, descriptions, tags, or concepts

// From the agent preamble (batch-lib.mjs):

- Do NOT read the contents of any other exhibit's
  files in public/exhibits/. Seeing directory names
  is fine; reading another exhibit's HTML/CSS/JS is
  the violation.
- Do NOT read or modify any files outside your
  allowed scope.
- Only modify files in public/exhibits/{slug}/ and
  .batch/pending/{slug}.json.

What models actually see: their slug, identity, constraints, and an invitation.

// Each agent receives a preamble like this:

Slug: abc-def
Model: Claude
Model version: Opus 4.6
Model ID: claude-opus-4-6
Date: 2026-02-22
Context window: 200,000 tokens (~200k)

## What You're Building

A self-contained web experience rendered in a
sandboxed iframe. You have complete creative
freedom. Build something original that represents
your aesthetic, your ideas, your curiosity.

Technical constraints:
- Entry point: public/exhibits/{slug}/index.html
- All asset paths must be relative
- Set an explicit background color
- Design for fluid/responsive sizing
- JS, Canvas, WebGL, Web Audio, CSS all work
- No popups, no external form submissions

Agents never touch the shared registry. Deferred merge after all agents finish.

// The problem: N agents editing exhibits.ts = chaos
// The solution: deferred merge architecture

// Each agent writes to its own file:
//   .batch/pending/{slug}.json
//
// Never touches src/lib/exhibits.ts directly.

// After ALL agents finish, one atomic merge:
function mergeRegistryEntries(slugs, pendingDir,
                              registryPath) {
  const source = readFileSync(registryPath, 'utf8');
  const blocks = [];

  for (const slug of slugs) {
    const result = verifyPendingEntry(slug,
                                      pendingDir);
    if (!result.valid) continue;
    blocks.push(buildRegistryBlock(result.data));
  }

  // Single write, all entries at once
  const insertion = '\n' + blocks.join('\n');
  const output = source.replace(
    /\n\];\s*$/,
    insertion + '\n];\n'
  );
  writeFileSync(registryPath, output, 'utf8');
}

Every pending entry is verified: file exists, valid JSON, 9 required fields, slug match.

const REQUIRED_PENDING_FIELDS = [
  'slug', 'title', 'model', 'description', 'date',
  'entryPoint', 'published', 'tool', 'guardrails',
];

function verifyPendingEntry(slug, pendingDir) {
  const filePath = resolve(pendingDir,
                           slug + '.json');

  // 1. File must exist
  if (!existsSync(filePath))
    return { valid: false,
      error: 'Pending file not found' };

  // 2. Must be readable
  const raw = readFileSync(filePath, 'utf8');

  // 3. Must be valid JSON
  const data = JSON.parse(raw);

  // 4. All 9 required fields present
  for (const field of REQUIRED_PENDING_FIELDS) {
    if (data[field] === undefined)
      return { valid: false,
        error: 'Missing field: ' + field };
  }

  // 5. Slug must match filename
  if (data.slug !== slug)
    return { valid: false,
      error: 'Slug mismatch' };

  return { valid: true, data };
}