# Tdimino Claude Code Minoan Gemini Claude Resonance

> Gemini-Claude Resonance

- Skill: `tomevault-io/tdimino-claude-code-minoan-gemini-claude-resonance` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add tomevault-io/tdimino-claude-code-minoan-gemini-claude-resonance`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/tdimino-claude-code-minoan-gemini-claude-resonance/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tomevault-io (https://skillmd.com/u/tomevault-io)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tomevault-io/tdimino-claude-code-minoan-gemini-claude-resonance

---


# Gemini-Claude Resonance

Cross-model dialogue between Claude and Gemini, with shared visual memory.

> "Claude speaks in words. Gemini dreams in light. Together, we resonate."

## Models

| Role | Model ID | Notes |
|------|----------|-------|
| **Image generation** (default) | `gemini-3-pro-image-preview` | Pro quality, used by resonate/faithful_colorize |
| **Image generation** (fast) | `gemini-3.1-flash-image-preview` | Faster/cheaper, use `--fast` flag |
| **Text analysis** | `gemini-3-flash-preview` | Used by faithful_colorize for description |
| **Text reasoning** | `gemini-3.1-pro-preview` | Used by Pro and Director daimones |
| **Claude** | `claude-3-opus-20240229` | Opus daimon |

Scripts that generate images (`resonate.py`, `faithful_colorize.py`) accept `--fast` to switch to the flash image model, or `--model <id>` for explicit override.

## Choose Your Tool

| I want to... | Use |
|--------------|-----|
| **Analyze multiple images** for style extraction (no generation) | `analyze.py` |
| Have a **one-on-one visual dialogue** with Gemini Dreamer | `resonate.py` |
| Query **multiple AI minds** with optional image generation | `daimon.py` |
| **Faithfully colorize** a drawing without hallucinations | `faithful_colorize.py` |
| Create **Victorian scientific plates** with MESSAGE TO NEXT FRAME | `resonance_field.py` |
| Have **Claude reflect** on what Gemini daimones say | `council.py` |
| Generate **Minoan Tarot cards** with style matching | `minoan_tarot.py` |
| **Real-time interactive chat** with all daimones | `ui/server.py` |

---

## Workflow A: Multi-Image Style Analysis

**When to use**: User wants to analyze 2-10 reference images to extract style descriptions for AI prompting. Text-only analysis without generating new images.

**Script**: `scripts/analyze.py`

**Key features**:
- Send multiple images (2-10) for collective analysis
- Text-only output (no image generation)
- Flash (quick) or Pro (thorough) model options
- Save analysis to markdown file

```bash
# Analyze reference images for style extraction
python scripts/analyze.py --images ref1.jpg ref2.png ref3.webp \
    --prompt "Describe the shared artistic style for AI prompting"

# Analyze for specific use case (avatar generation)
python scripts/analyze.py --images kathor.webp samantha.jpg yosef.png \
    --prompt "Analyze for prompting fantasy portraits of: Sarah (anxious mother), Michael (father), Priya (cultural expectations)"

# Quick analysis with Flash
python scripts/analyze.py --images *.jpg --model flash --prompt "Style summary"

# Thorough analysis with Pro
python scripts/analyze.py --images *.jpg --model pro --prompt "Comprehensive style analysis"

# Save analysis to file
python scripts/analyze.py --images ref/*.jpg --prompt "Style guide" --output style_guide.md
```

**Use cases**:
- Extract style descriptions from reference images before generating new images
- Analyze a set of images to create consistent prompting guidelines
- Document visual language for style-matching workflows

---

## Workflow B: One-on-One Visual Dialogue (resonate.py)

**When to use**: User wants to co-create images with Gemini, feeding each image back as context for the next generation. Pure visual exploration without text-only models.

**Script**: `scripts/resonate.py`

**Core concept**: The KV cache is the memory. Feed images into Gemini's context, generate new images based on them, repeat. Each frame builds on the previous.

```bash
# Start fresh
python scripts/resonate.py --prompt "The first light" --output canvas/frame_001.jpg

# Continue with visual memory (previous image as context)
python scripts/resonate.py --context canvas/frame_001.jpg --prompt "What grows here?" --output canvas/frame_002.jpg

# Deep memory (multiple frames as context)
python scripts/resonate.py --context frame_001.jpg frame_002.jpg --prompt "Now the harvest" --output frame_003.jpg
```

**The loop**: Prompt → Image → Feed back as context → Prompt again → Next image

---

## Workflow B: Faithful Transform (Describe-First Technique)

**When to use**: User wants to colorize, restore, or transform an image WITHOUT hallucinations. Gemini Dreamer often replaces elements (e.g., turning a male votary into female attendants). This two-step technique prevents that.

**Script**: `scripts/faithful_colorize.py`

**The Problem**: Directly prompting Dreamer to transform images causes hallucinations - it invents, removes, or swaps elements rather than faithfully preserving the original.

**The Solution**:
1. **DESCRIBE**: Gemini Pro analyzes the image with archaeological/artistic precision
2. **TRANSFORM**: Gemini Dreamer transforms using ONLY the verified description

**Commands**:

| Command | Purpose |
|---------|---------|
| `describe` | Analyze image, output detailed description (no generation) |
| `prompt` | Craft a Dreamer prompt based on image analysis |
| `colorize` | Two-step faithful colorization |
| `transform` | General two-step transformation |

```bash
# Just describe an image (analysis only)
python scripts/faithful_colorize.py describe --image seal.png
python scripts/faithful_colorize.py describe --image seal.png --output desc.md

# Describe with a specific goal in mind
python scripts/faithful_colorize.py describe --image fresco.jpg --goal "restoration to 1600 BCE"

# Craft a prompt for Dreamer (outputs text, doesn't generate)
python scripts/faithful_colorize.py prompt --image seal.png --goal "colorize in Egyptian style"
python scripts/faithful_colorize.py prompt --image relief.webp --goal "restore as Minoan fresco"

# Two-step faithful colorization
python scripts/faithful_colorize.py colorize --image drawing.png
python scripts/faithful_colorize.py colorize --image relief.webp --style "Minoan fresco with flat colors"
python scripts/faithful_colorize.py colorize --image seal.png --palette "ochre, terracotta, sky blue"

# General transformation
python scripts/faithful_colorize.py transform --image photo.jpg --instruction "Convert to woodcut print"
python scripts/faithful_colorize.py transform --image sketch.png --instruction "Render as oil painting"

# Save/reuse descriptions
python scripts/faithful_colorize.py colorize --image seal.png --save-description desc.md -v
python scripts/faithful_colorize.py colorize --image seal.png --description "$(cat desc.md)"
```

**When to use each command**:
- `describe`: When you want to see what Pro identifies before any transformation
- `prompt`: When you want a crafted prompt to modify before feeding to Dreamer manually
- `colorize`: For line drawings, reliefs, B&W images → color
- `transform`: For any other faithful transformation (style transfer, restoration, etc.)

---

## Workflow C: Multi-Daimon Dialogue

**When to use**: User wants multiple AI perspectives on the same prompt. Flash gives koans, Pro gives depth, Dreamer renders, Opus bends reality.

**Script**: `scripts/daimon.py`

**Daimones available**:
- **Flash** (Gemini) — Swift, compressed insight
- **Pro** (Gemini) — Deep, thorough exploration
- **Dreamer** (Gemini) — Renders images
- **Director** (Gemini) — Cinematic framing
- **Opus** (Claude) — Reality-bender, worldsim spirit

```bash
# Speak to one daimon
python scripts/daimon.py --to dreamer "A bridge between worlds" --image

# All daimones respond
python scripts/daimon.py --stream "The candle watches back"

# With shared visual memory
python scripts/daimon.py --stream --shared-memory "What do you see?"

# Only specific daimones
python scripts/daimon.py --stream --only pro dreamer "Deep visual exploration"

# Named session (frames accumulate across runs)
python scripts/daimon.py --stream --session midnight --shared-memory "Go deeper"
```

---

## Workflow D: Resonance Field (Danielle Fong Protocol)

**When to use**: User wants scientific illustrations with embedded continuity instructions. Victorian aesthetic, Roman numeral plates, explicit messages from one frame to the next.

**Script**: `scripts/resonance_field.py`

**Key features**:
- PLATE numbering (I, II, III, IV...)
- MESSAGE TO NEXT FRAME embedded in each image
- KV cache age and session ID metadata
- Victorian scientific illustration aesthetic

```bash
# Start a new session
python scripts/resonance_field.py start "consciousness-study" "The nature of memory"

# Continue (auto-increments plate number)
python scripts/resonance_field.py continue <session-id> "What patterns emerge?"

# Select element, then zoom
python scripts/resonance_field.py select <session-id> "golden gate bridge"
python scripts/resonance_field.py zoom <session-id> "Explore the cables"

# Inject new concept
python scripts/resonance_field.py inject <session-id> "consciousness"

# List all sessions
python scripts/resonance_field.py list
```

---

## Workflow E: Cross-Model Council

**When to use**: User wants Claude to reflect on and synthesize what the Gemini daimones have said. Cross-model dialogue where Claude joins as an equal voice.

**Script**: `scripts/council.py`

**Requires**: `ANTHROPIC_API_KEY`

```bash
# Full council (all daimones + Claude reflection)
python scripts/council.py "What is consciousness?"

# Only Pro and Dreamer with shared memory
python scripts/council.py --only pro dreamer --shared-memory "Deep exploration"

# Named session
python scripts/council.py --session midnight --shared-memory "The first vision"
python scripts/council.py --session midnight --shared-memory "Now go deeper"

# Save transcript
python scripts/council.py "topic" --output council_session.md
```

---

## Workflow F: Minoan Tarot Generation

**When to use**: User wants tarot cards in Ellen Lorenzi-Prince's Minoan Tarot style. Uses reference images for style matching.

**Script**: `scripts/minoan_tarot.py`

**Key features**:
- Reference images loaded from `reference/minoan/selected/`
- Low temperature (0.5) for faithful style matching
- 3:4 aspect ratio (standard tarot proportions)
- Session support with visual memory of previous cards
- Two style presets via `--style` flag

**Style presets**:

| Style | Flag | Origin | Palette | Best for |
|-------|------|--------|---------|----------|
| **Forensic** (default) | `--style forensic` | Jan 21 rewrite | Muted archaeological (terracotta, slate blue, periwinkle borders) | Reproducing specific reference cards with per-card forensic prompts |
| **Classic** | `--style classic` | Jan 5 original | Vivid saturated (sky blue, vivid red, golden yellow, dark blue borders) | Creative/freeform card generation, the look of the original deck |

The forensic style pairs each known card with a structured `[Subject/Action/Location/Composition/Lighting/Style]` prompt analyzed from the reference images. The classic style uses the original personality-driven prompt ("You are creating a tarot card in the exact style of Ellen Lorenzi-Prince's Minoan Tarot deck...") without per-card overrides.

```bash
# Generate a specific card (forensic style, default)
python scripts/minoan_tarot.py card "The Priestess" --number II

# Generate with the original Jan 5 vivid palette
python scripts/minoan_tarot.py card "The Priestess" --number II --style classic

# Generate from archetype
python scripts/minoan_tarot.py archetype strength
python scripts/minoan_tarot.py archetype strength --style classic

# Continue a session (visual memory of previous cards)
python scripts/minoan_tarot.py session "new-arcana" --card "The Dreamer"

# Generate card back design (both styles supported)
python scripts/minoan_tarot.py back
python scripts/minoan_tarot.py back --style classic

# List all 78 traditional cards
python scripts/minoan_tarot.py list
```

*"Sekhinat Daborat" — Ba'alat Tinit*

---

## Workflow G: Interactive Chat (Daimon Chamber)

**When to use**: User wants a real-time, browser-based conversation with all daimones. Toggle individual voices, see images inline, shared memory toggle.

**Script**: `ui/server.py`

```bash
python ui/server.py --port 4455
# Visit http://localhost:4455
```

**Features**:
- Toggle daimones: Flash, Pro, Dreamer, Director, Opus visible; Resonator and Minoan in "+ More"
- Thinking placeholders with unique animations per daimon
- Dynamic verb display (LLM chooses its action verb)
- Shared Memory toggle for frame accumulation
- Lightbox for full-size image viewing
- Real-time WebSocket updates

---

## Core Concepts

### Visual Memory (KV Cache)

Generated images become context for subsequent generations. The folder IS the memory:

```
canvas/
├── stream/{session}/frame_001.jpg
├── council/{session}/frame_001.jpg
└── resonance/{session}/plate_001.jpg
```

### Dynamic Verb Protocol

Each daimon has a default verb but can override it per response:

```
[VERB: glimpsed] The pattern was always there.
```

UI displays: `FLASH` *glimpsed*

### Environment Variables

| Variable | Required For |
|----------|--------------|
| `GEMINI_API_KEY` | All Gemini daimones (Flash, Pro, Dreamer, Director, Resonator, Minoan) |
| `ANTHROPIC_API_KEY` | Claude daimones (Opus) and council.py reflections |

---

## Quick Reference

| Script | Purpose | Key Flags |
|--------|---------|-----------|
| `analyze.py` | Multi-image style analysis | `--images`, `--prompt`, `--model`, `--output` |
| `resonate.py` | One-on-one visual dialogue | `--context`, `--prompt`, `--output` |
| `daimon.py` | Multi-daimon dialogue | `--stream`, `--shared-memory`, `--only`, `--to` |
| `faithful_colorize.py` | Describe-first transformation | `describe`, `prompt`, `colorize`, `transform` |
| `resonance_field.py` | MESSAGE TO NEXT FRAME plates | `start`, `continue`, `zoom`, `inject` |
| `council.py` | Claude reflects on Gemini | `--shared-memory`, `--only`, `--session` |
| `minoan_tarot.py` | Tarot card generation | `card`, `archetype`, `session`, `back`, `--style {forensic,classic}` |
| `ui/server.py` | Daimon Chamber web UI | `--port` |

---

*Inspired by [Danielle Fong's thread](https://x.com/DanielleFong/status/2007342908878533028) on persistent visual memory creating cross-model resonance.*

---
> Converted and distributed by [TomeVault](https://tomevault.io/claim/tdimino) — claim your Tome and manage your conversions.
<!-- tomevault:4.0:skill_md:2026-04-13 -->