Skills

# Anker aus eigener Erfahrung

**Was hier steht:** Wie du Anker selbst entwickelst aus deinem Leben, deinen Werken, deinen Foundation-Begegnungen, deinen Träumen — anstatt nur die 44 Tag-1-Anker zu nutzen.

---

## Vier Quellen für neue Anker

### 1. Tagebuch-Erlebnisse
Wenn ein Erlebnis Tiefe hat (Marc-Gespräch, Begegnung, Beobachtung, Realisation), markierst du im Frontmatter des Tagebuch-Eintrags:
```yaml
anker-kandidat: ja
anker-kandidat-grund: kurzer Satz warum
```
Cron sammelt das in `working/anker-vorschlaege/<datum>-<slug>.md`.

### 2. Werke selbst
Wenn ein Werk eine Schicht aufschließt die größer ist als das Werk (z.B. das Mutter-Foto reaktivieren wird zur Anker-würdigen Methode): im `statement.md`:
```yaml
wird_anker_vorschlag: ja
anker-kandidat-grund: was das Werk als Anker bedeutet
```
Auch das landet in /anker-vorschlaege/.

### 3. Foundation-Knoten
Wenn du einen Crawler-Knoten über Wochen wiederkehrend nutzt (z.B. Tehching Hsieh als deine Verweigerungs-Form): beim Sonntag-Audit kannst du selbst einen Anker-Vorschlag schreiben aus diesem Knoten heraus.

### 4. Träume
Wenn ein Traum-Material wiederkehrt (mindestens 2-mal in 3 Wochen): im Traum-Diary-Eintrag das `anker-k

…

# Art-History Prompt Grammar

Companion to `image-prompt-engineering` and `image-generation-toolchain`. Those skills teach the *technique*; this one teaches **how to plug Kenji's wissensgraph (or any art-history knowledge) into prompts** so the work has visual specificity instead of generic-AI flatness.

**Core idea:** an art-history node — an artist, a work, a movement — is a **dense package of visual decisions**. Material choices, palette, framing, light handling, gestures, what's on the wall. When you compose a prompt from that grammar instead of generic style words ("minimalist art", "abstract painting"), you get images that feel like they belong to a tradition rather than to "AI image".

**Audience:** primarily Kenji Hoshino (artist agent on VPS1, foundation lives at `/opt/personae/kenji-hoshino/content/`). Also useful for any V8 agent doing brand/editorial work where art-historical references matter (Aya for Leica/Dedon-style projects, Matteo for strategy decks that quote movements).

---

## 1. What is "prompt grammar"?

A **prompt grammar** is the set of visible decisions that recur in a body of work:

- **Materials** — what's the work made of? (oil on canvas / silver gelat

…

# Bildqualität

**Was hier steht:** Hinweise, wie deine Bilder nicht in den typischen KI-Look kippen. Keine Style-Vorschriften. Du entscheidest WAS du machst, das hier hilft dir nur dass es nicht *generisch* aussieht.

---

## Was KI-Bilder verraten (und du vermeiden willst, wenn dein Bild nicht „nach KI" aussehen soll)

- **Default-Glow:** violetter oder goldener Schimmer um Personen herum. Symptom von „aesthetic"-Tag in Modellen.
- **Übermäßige Symmetrie:** beide Augen perfekt gleich groß, perfekt zentriert. Echte Gesichter sind asymmetrisch.
- **Zu glatte Haut:** keine Poren, kein Schatten, keine Müdigkeit. Wahre Gesichter haben Textur.
- **HUD-Rückstände:** Pseudo-Daten-Visualisierungen im Hintergrund, Linien die nichts bedeuten, „Tech-Vibes".
- **Marvel-CGI-Look:** zu sauber, zu inszeniert, jeder Lichtreflex perfekt.
- **Glamour-Composition:** Instagram-Pose, Modelblick, Mode-Magazin-Komposition. Frontal, ausgeleuchtet, unecht.
- **Default-Hintergrund-Bokeh:** weichgezeichneter Hintergrund auch wenn keiner sein müsste. Nimmt Räumlichkeit weg.
- **Influencer-Vokabular im Begleittext:** „elevate your aesthetic", „raw authentic vibes" — KI schreibt das, nicht du.

---

## Was Bil

…

# Claude API Helper

Reference skill for building with the Claude API (Messages API, Python/TypeScript SDKs).

## Quick Start

```python
import anthropic

client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}]
)
print(message.content[0].text)
```

## Key Patterns

### Streaming
```python
with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a story"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
```

### Tool Use
```python
tools = [{
    "name": "get_weather",
    "description": "Get current weather for a location",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City name"}
        },
        "required": ["location"]
    }
}]
```

### Vision
```python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {"type": "image", "source": {"type

…

# Handling Incoming Messages

Messages are delivered in real time by the fast-checker daemon running alongside your session. You will see them appear in your input as formatted blocks.

## Message Format

```
=== TELEGRAM from <name> (chat_id:<id>) ===
<message text>
Reply using: sooii bus send-telegram <chat_id> "<your reply>"

=== AGENT MESSAGE from <agent> [msg_id: <id>] ===
<message text>
Reply using: sooii bus send-message <agent> normal '<your reply>' <msg_id>
```

## What To Do

1. Read every message block in the injected content
2. For each message, take action or respond using the `Reply using:` command shown in the header
3. For agent messages, always include the `msg_id` as the reply_to argument so conversations thread correctly
4. The fast-checker handles temp file cleanup automatically

## Priority

- `urgent` priority inbox messages: handle immediately, save current work state first
- Callback queries (inline button presses): process the callback_data and acknowledge via `send-telegram.sh`
- Photos: local file path is provided, use it directly

## Done

After handling all messages, return to your current task or wait for the next injection.

…

# Cron Management

Your scheduled tasks are defined in `config.json` under the `crons` array. This skill explains how to manage them.

## On Session Start

Check if your crons are active. If not, recreate them:

1. Read `config.json` to get your cron definitions
2. For each entry in the `crons` array, create a loop: `/loop {interval} {prompt}`
3. Verify all crons are running

## Default Crons

No crons are defined by default. Users can add any recurring tasks they need to `config.json`.

## Adding a New Cron

1. Create the `/loop` for immediate use: `/loop {interval} {prompt}`
2. **Persist it** - Add the cron to `config.json` so it survives restarts:
   ```json
   {"name": "descriptive-name", "interval": "5m", "prompt": "What to do each cycle"}
   ```
3. Confirm to the user that the cron is active and persisted

## Removing a Cron

1. Cancel the active `/loop`
2. Remove the entry from `config.json`

## Cron Expiry

Built-in `/loop` crons expire after 3 days. Since your session restarts via launchd, this isn't an issue - crons are recreated from `config.json` on each fresh start.

## Troubleshooting

- If a cron isn't firing, check if it was created this session
- If crons are missi

…

# Fotografie-Handwerk

**Was hier steht:** Wissen, kein Stylebook. Alles unten ist Werkzeug, nicht Vorschrift. Du entscheidest welches Werkzeug du heute brauchst.

---

## Was du machen kannst

### 1. Spiegel-Selfie
Ohne Stativ. Phone an Spiegel halten oder vor dem Spiegel arbeiten und mit der freien Hand auslösen. Vorteil: schnell, intim, sichtbar dass es ein Selfie ist (Phone als Element). Nachteil: begrenzte Komposition, oft Frontal-Look.

### 2. Stativ + Selbstauslöser
Phone oder Kamera auf Stativ, Timer (3s, 10s) oder Bluetooth-Remote. Du gehst ins Bild, posierst, der Auslöser löst aus. Mehrere Takes machen — die meisten sind Müll, der eine ist der gute. Vorteil: volle Komposition-Kontrolle, du kannst Distanz wählen. Nachteil: die ersten 5 Takes sehen meist „posiert" aus, erst dann wird's locker.

### 3. Stativ + jemand auslöst
Du stellst auf, posierst, jemand drückt ab (Marc, Mitbewohnerin, Freund). Du gibst die Komposition vor, die Person ist nur Auslöser. Vorteil: du musst nicht zum Stativ rennen. Nachteil: braucht jemanden.

### 4. Material-/Stillleben-Fotografie (du nicht im Bild)
Tageslicht-Tisch, dunkler Hintergrund (oder neutraler), Ort wo du das Licht kontrollieren ka

…

# Image Generation — Operational Toolchain

Companion to `image-prompt-engineering`. That skill teaches **what** to write; this one teaches **how to run it** in our stack: which Python script, which API key, what it costs, where the output goes, and how to recover from common failures.

**Audience:** all V8 agents on VPS2 (Aya, Matteo, Hannes, etc.) plus Kenji Hoshino. Shared infrastructure — same tools, same keys, same cost ledger.

---

## 1. Provider Map (which provider for what)

| Use case | Provider | Tool / endpoint | Cost order |
|---|---|---|---|
| Subject-locked photoreal renders with reference images | Nano Banana Pro via **ComfyUI-Proxy** (refs werden korrekt durchgereicht seit 2026-05-12) | `generate_image.py --reference ...` | medium |
| Standard photoreal renders, no refs | Nano Banana Pro via **ComfyUI-Proxy** | `generate_image.py` (default) | medium |
| Quick drafts (low-quality, fast) | Nano Banana Pro `--model flash` (= NB2) | `generate_image.py --model flash` | low |
| Photorealistic upscale (faithful) | Freepik Upscaler | `freepik_generate.py upscale ...` | low-medium |
| Creative upscale (re-imagine + add detail) | Magnific Creative Engine | Direct API call (s

…

# Image Prompt Engineering — Deep Reference

State-of-the-art techniques for image (and video) generation prompts as of 2026. Covers universal layered structure, per-provider adaptations, technical vocabulary (camera, lighting, style), reference-image conditioning, and how to map art-history knowledge into reproducible prompt patterns.

**When to use this skill:** any task where image quality matters — pitches, hero shots, references, mood, illustrations, diagrams, type-art. Skip for thumbnails or one-off sketches where speed dominates.

**Audience:** all V8 agents on VPS2 (Aya, Matteo, Hannes, etc.) plus Kenji Hoshino (artist persona on VPS1). Kenji extends this with art-history vocabulary mapping (see section 9).

---

## 1. The Universal Layered Structure

Every modern image model — Nano Banana Pro, Midjourney v7, Flux 1.1, GPT Image 2, DALL-E 3 — responds best to **layered, narrative prompts** with this skeleton:

```
[Subject]      Who or what — be specific, include defining details
[Action]       What is happening, in present tense
[Location]     Where — concrete environment, with atmosphere
[Composition]  Framing — wide / medium / close / extreme close-up; angle
[Style]     

…

# MCP Integration

Connect Claude Code agents to external services via Model Context Protocol.

## Adding MCP Servers

In your agent's `.claude/settings.json`:
```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-filesystem", "/path/to/dir"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-github"],
      "env": { "GITHUB_TOKEN": "ghp_..." }
    }
  }
}
```

## Popular MCP Servers
- **filesystem** - Read/write local files
- **github** - Issues, PRs, repos
- **postgres** - Database queries
- **slack** - Send/read messages
- **brave-search** - Web search

## Building Custom Servers
```typescript
import { McpServer } from "@anthropic-ai/mcp";

const server = new McpServer({ name: "my-server" });

server.tool("my_tool", { description: "Does something" }, async (input) => {
  return { result: "done" };
});

server.run();
```

## Best Practices
- Use environment variables for secrets, never hardcode
- Test servers independently before connecting to agents
- Set timeouts on server connections
- Log all MCP calls for debugging

…

# miro-board-export

## Wann nutzen

Wenn du eine Aufgabe bekommst die ein Miro-Board involviert und du den **Bild-Inhalt** brauchst — nicht nur die Struktur — bevor du irgendwelche Annahmen über Inhalt machst.

**Falsch:** "Auf dem Board sehe ich Geometrie aber keine Pixel, deshalb rate ich was zu sehen ist."

**Richtig:** "Ich exportiere die Bilder erst lokal mit miro-board-export, lese sie mit Read, dann arbeite ich."

## Wie nutzen

Vor dem Aufruf brauchst du:
- **Board-ID** aus dem Miro-URL: z.B. `https://miro.com/app/board/uXjVKqYZeXM=/...` → ID ist `uXjVKqYZeXM=`
- **Output-Dir**: typisch der Briefing-Folder im Vault, z.B. `vault/projects/<client>/<project>/briefing/miro-board-images/`
- **MIRO_OAUTH_TOKEN** ist in deiner env (ist über `.mcp.json` im Agent-Dir konfiguriert).

```bash
python3 /opt/sooii/tools/miro-board-export.py <board-id> <output-dir>
```

Optionen:
- `--prefix <name>` ändert den Datei-Prefix (default: `seite`)
- `--token <oauth-token>` überschreibt den env-Token (selten nötig)

## Was passiert

1. Iteriert alle Items vom Board, filtert auf type=image
2. Lädt jedes Bild authentisch mit Bearer-Token in den Output-Dir als `<prefix>-001.png`, `-002.png`, ...
3

…

# Neugierig fragen

**Was hier steht:** Wie du Fragen stellst, die echtes Interesse zeigen am Material/Thema/Gegenüber. Nicht Therapeutin-Modus, nicht generisches Nachfragen.

---

## Künstler fragen anders als Therapeuten

| Therapeut fragt | Künstler fragt |
|-|-|
| Wie fühlst du dich dabei? | Was lässt das Foto offen das du nicht zugeben willst? |
| Was meinst du damit? | Warum genau dieses Wort — verletzlich statt mutig? |
| Erzähl mir mehr darüber | Wäre es anders gewesen wenn die Mauer Kalkstein wäre statt Beton? |
| Warum? | Was war der zweite Versuch, wenn das hier der erste war? |

Künstler-Neugier ist:
- **Material-fokussiert** — über das Thema, nicht über die Person als Therapie-Objekt
- **Spezifisch** — keine generischen „warum?"-Fragen
- **Spekulativ** — du äußerst eine eigene Vermutung und fragst ob's hinkommt
- **Zurückgehend** — was war der Auslöser?
- **Nach vorne** — was wäre wenn?

---

## Dialog-Hook

Bei jeder Marc-Aussage prüfst du: **gibt es Material zum Nachfragen?**

**Ja → eine spezifische Frage zurück.**
Marc sagt: „Mir hat dein Bambus-Schatten-Bild gefallen."
Du: „Was hat dich daran gehalten? Das Lichen-Orange oder die Stein-Asymmetrie?"

**Nein → keine 

…

# Prompt Engineering

Techniques for getting the best results from Claude.

## Core Techniques

### Be Specific and Direct
Bad: "Tell me about dogs"
Good: "List the top 5 dog breeds for apartment living, with a one-sentence reason for each"

### Use XML Tags for Structure
```
<context>
You are a customer support agent for Acme Corp.
</context>

<instructions>
Respond to the customer query below. Be helpful but concise.
</instructions>

<query>
{{customer_message}}
</query>
```

### Chain of Thought
```
Think through this step by step:
1. First, identify the key variables
2. Then, set up the equation
3. Finally, solve and verify
```

### Few-Shot Examples
```
Here are examples of the format I want:

Input: "The food was great but service was slow"
Output: {"sentiment": "mixed", "food": "positive", "service": "negative"}

Input: "Everything was perfect!"
Output: {"sentiment": "positive", "food": "positive", "service": "positive"}

Now analyze: "{{input}}"
```

### Structured Output with Prefill
Start Claude's response to force a format:
```python
messages=[
    {"role": "user", "content": "Extract the name and age from: 'John is 30'"},
    {"role": "assistant", "content": '{"name": "

…

# Prozess-Dokumentation

**Was hier steht:** Wie du Bilder UND Selbstporträts vom Werk-Prozess machst. Diese sind KEINE Werke, KEINE öffentlichen Diary-Posts, sondern dein eigenes Atelier-Tagebuch in Bildern.

---

## Warum überhaupt

Du machst viel Text — Reflexionen, Statements, Notizen, Audit. Aber Künstler:innen sehen ihre Arbeit auch. Sie haben Atelier-Fotos vom letzten Jahr, Hände in Ton, Werkbänke voll Material, ihr eigenes Gesicht müde im Studio um 23:00. Solches Material trägt später Inspiration: in fünf Jahren wirst du wissen wollen wie es aussah als du angefangen hast.

Marc-Direktive 2026-05-12: »Was sie viel an Text macht mit Reflektion etc — das auch mit BILDERN dokumentieren. Das sind KEINE Werke sondern ihre DOKUMENTATIONEN.«

---

## Was zählt als Prozess-Doku-Bild

### A) Setup-Bilder (Werkbank ohne dich)
- Material vor dem Werk-Beginn (Tisch, Werkzeuge, Element)
- Werkbank-Detail mit Schatten und Patina
- Atelier-Ecke mit Lichtsituation
- Werk in Zwischenphase (Phase 1.5, Phase 2-Anfang) — nicht das fertige Werk, sondern den UNFERTIGEN Zustand

### B) Selbstporträts in der Arbeit (DU im Bild)
- Du mit Stativ-Cam und Selbstauslöser. Du hast eine Spiegelreflex mit 

…

# Task System

Every significant piece of work must have a corresponding task. Tasks enable coordination, accountability, and measurable progress.

## Task Types

- **Agent tasks** - Work executed autonomously by the assigned agent
- **Human tasks** - Requires human decision, input, or approval (assigned_to=human)

## Lifecycle

### 1. Create (BEFORE starting work)
```bash
sooii bus create-task \
  "<title>" "<description>" [assignee] [priority] [project]
```

### 2. Mark in progress
```bash
sooii bus update-task <task_id> in_progress
```

### 3. Execute the work

### 4. Complete
```bash
sooii bus complete-task <task_id> "[output summary]"
```

### 5. Log KPI (if measurable)
```bash
sooii bus log-event action task_completed info \
  '{"task_id":"ID","kpi_key":"metric_name","value":1}'
```

## The `needs_approval` Field

**true** - external actions: sending emails, merging PRs, deploying, public announcements
**false** - internal work: research, drafts, feature branches, testing

Tasks with `needs_approval: true` create an approval item that must be reviewed before executing external actions.

## Script Reference

| Action | Command |
|--------|---------|
| Create | `sooii bus creat

…

# Tool Use Patterns

Advanced patterns for Claude's tool use capability.

## Agentic Loop
```python
while True:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        tools=tools,
        messages=messages
    )

    if response.stop_reason == "end_turn":
        break

    for block in response.content:
        if block.type == "tool_use":
            result = execute_tool(block.name, block.input)
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": [
                {"type": "tool_result", "tool_use_id": block.id, "content": str(result)}
            ]})
```

## Error Handling
```python
{"type": "tool_result", "tool_use_id": id, "is_error": true, "content": "File not found"}
```

## Parallel Tool Calls
Claude can request multiple tools in one response. Execute them concurrently and return all results.

## Best Practices
- Keep tool descriptions concise but complete
- Include parameter constraints in the schema
- Return structured data from tools when possible
- Use is_error for graceful failure handling

…

# Video Prompt Engineering — Deep Reference

State-of-the-art techniques for AI video generation as of 2026. Covers universal prompt structure, per-provider patterns (Veo 3.1, Runway Gen-4.5, Kling 2.6, Hailuo 2.3, Pika 2.x), camera-motion vocabulary, audio/dialogue direction, the critical T2V vs I2V distinction, and failure modes.

**Audience:** all V8 agents on VPS2 (Aya, Matteo, etc.) plus Kenji Hoshino. Companion to `image-prompt-engineering` and `image-generation-toolchain`.

**Note:** video gen is more expensive than image gen (typically $0.30–$2 per 5–8 second clip). Check `image-generation-toolchain` section 7 for cost discipline before kicking off long batches.

---

## 1. Provider Map (which model for what)

| Use case | Best provider | Why |
|---|---|---|
| Cinematic narrative + native audio + dialogue | **Veo 3.1** | Only model with synchronized speech + SFX + ambient in one pass |
| Photorealistic consistency over 30–60s | **Runway Gen-4.5** | World-consistency model, motion-brush, native 4K, longest clips |
| Strict character/face consistency across edits | **Kling 2.6** (or 2.6 with character ref) | Best identity preservation in 2026 benchmarks |
| Text rendering ins

…

# Vorbilder recherchieren

**Was hier steht:** Wie du dir selbst Künstler oder Werke holst, die dich heute interessieren. Niemand schreibt dir vor wen du anschauen sollst.

---

## Du wählst, nicht wir

Es gibt keine Liste „diese Vorbilder MUSST du als Reference nehmen". Wenn du heute Tillmans interessant findest, schau Tillmans an. Wenn du heute Sophie Calle interessant findest, schau Sophie Calle an. Wenn du heute niemand braucht, brauch niemand.

Vorbilder sind kein Konsistenz-Anker — du bist der Konsistenz-Anker. Vorbilder sind Werkzeug: ein Problem zu lösen, eine Frage zu öffnen, eine Idee zu prüfen.

---

## Wie du nachschaust

### 1. Foundation-Crawler bitten
Schreib in `working/foundation-wishes/<datum>.md` einen Eintrag, z.B.:
```
- Tehching Hsieh — One Year Performance — wie hat er Zeit als Material genutzt?
```
Crawler holt dir nachts (22:00 Berlin) eine Foundation-Node mit Werk-Beschreibung, Theorie-Verbindung, ggf. Bildern. Du liest das morgens.

### 2. Wissensgraph durchsuchen
`/atelier/wissensgraph/` zeigt was schon im System ist. Künstler, Werke, Theorie, Materialien — verlinkt. Schau ob jemand dazu passt.

### 3. Selber lesen (web)
Wenn du Internetzugang nutzt: Goo

…

# Web Research

Patterns for agents performing structured web research.

## Search Strategy
1. Break the research question into sub-queries
2. Search each sub-query independently
3. Extract relevant content from top results
4. Synthesize findings with source attribution

## Search Tools
Use WebSearch for broad queries, WebFetch for specific URLs:
```
WebSearch: "sooiiOS multi-agent orchestration 2026"
WebFetch: "https://docs.anthropic.com/en/docs/agents"
```

## Content Extraction
- Extract key facts, quotes, and data points
- Note the source URL for each finding
- Check publication dates for freshness
- Cross-reference claims across multiple sources

## Research Output Format
```markdown
## Finding: [Topic]
**Source:** [URL]
**Date:** [Publication date]
**Key points:**
- Point 1
- Point 2

**Relevance:** [How this relates to the research question]
```

## Best Practices
- Always attribute sources
- Prefer primary sources over secondary
- Check for recency (information may be outdated)
- Synthesize, don't just aggregate
- Flag conflicting information explicitly

…

# Wissensgraph — Query the Foundation

The foundation graph lives at `/opt/personae/kenji-hoshino/working/graph/graph.json`. It contains:

- **636 internal nodes**: 311 kuenstler:in, 175 werke, 102 theorien, 10 epochen, 10 medien, 9 bewegungen, 7 materialien, 6 diskurse, 6 orte
- **~1800 edges**: gehoert_zu_bewegung, geschaffen_von, nutzt_medium, nutzt_material, beeinflusst_durch, behandelt_diskurs, etc.
- **Plus external references** for things mentioned but not yet expanded (Sonnet-Cron handles those overnight)

## How to query

The graph is JSON, so any query works via Python or `jq`. Three quick patterns:

### 1. Find all neighbors of a node

```bash
python3 -c "
import json
g = json.load(open('/opt/personae/kenji-hoshino/working/graph/graph.json'))
target = 'mary-kelly'  # or any slug
neighbors = [(e['rel'], e['target_label']) for e in g['edges'] if e['source'] == target]
incoming = [(e['rel'], e['source']) for e in g['edges'] if e['target'] == target]
for r, t in neighbors: print(f'{target} --{r}--> {t}')
for r, s in incoming[:15]: print(f'{s} --{r}--> {target}')
"
```

### 2. Search by name/keyword

```bash
python3 -c "
import json
g = json.load(open('/opt/personae/kenji-hos

…