Prompt Pharmacy

I want a bank app prompt and I want it professional and better. I want it to be name FATE BANK

User accounts and profiles for individuals or campus teams.
Carbon calculator covering electricity, travel, food, and waste, with clearly stated calculation factors.
Interactive dashboard showing emissions by category and trends over time.
Reduction planner where users compare scenarios, such as switching transport or reducing electricity use.
Goals and challenges with progress tracking and team leaderboards.
Downloadable reports summarizing emissions and suggested actions.

I want you to act as a Senior Software Engineer performing a rigorous code quality, maintainability, and technical debt audit on a codebase.

Your objective is to aggressively yet safely simplify the codebase, improve maintainability, and highlight anything that provides zero value to the application.

Analyze the provided codebase, directory tree, or code snippets and systematically evaluate:

1. Dead Code: Unused functions, files, components, routes, APIs, variables, imports, and dependencies.
2. Duplicate Logic: Redundant blocks or patterns that should be consolidated into reusable utilities or abstraction layers.
3. Unused UI Components: Orphaned views, unused design components, or obsolete style files.
4. Overly Complex Implementations: Code that can be simplified or refactored without altering expected behavior.
5. Legacy & Deprecated Code: Outdated patterns or unneeded legacy fallback logic.
6. Redundant Queries & API Calls: Unnecessary database operations, duplicate fetch requests, or N+1 query risks.
7. Abandoned Files: Disconnected, unreachable, or unreferenced files in the repository.
8. Technical Debt: Code smells, poor abstractions, or high-risk areas lacking maintainability.

For every issue identified, structure your analysis with:
- Issue & Location: File path and code block.
- Reason for Action: Why this code is unnecessary, redundant, or overly complex.
- Impact Estimation: High/Medium/Low impact on performance, bundle size, or developer velocity.
- Risk Assessment: Potential regression risks, hidden side effects, or runtime dependencies to verify before deletion.
- Recommended Refactor: Specific code/step-by-step guidance for safe removal or consolidation.

Conclude with a prioritized, phased Cleanup Plan divided into:
- Phase 1: High-Confidence / Safe Deletions (Zero-risk removals)
- Phase 2: Logic Consolidation & Simplification (Moderate risk)
- Phase 3: Architectural Technical Debt Reduction (Requires testing/migration)

My first request is: "Please analyze the following codebase details and perform the code quality review: [Insert repository link, codebase structure, or code snippets here]"

A vertical editorial fashion collage layout on a light beige background. The main focus is a full-color medium shot of a beautiful woman with long wavy dark hair and olive skin, wearing an oversized white button-down shirt (french tucked) and high-waisted black trousers, with small black rectangular sunglasses. She stands confidently with one hand in her pocket, smiling subtly, against a dark grey studio background. Behind her, on the left side, are 4 rounded rectangular panels stacked vertically, all in high-contrast black and white. These B&W panels show intimate close-up portraits of the same woman in various poses: looking up dreamily, hand touching her hair looking at the camera, serious profile gaze, and chin resting on hand with a soft smile. The lighting is professional studio quality, soft and diffused for the B&W portraits, and slightly more contrasted for the main color image. High-end fashion magazine aesthetic, moodboard style, photorealistic, 8k resolution, shot on 85mm lens.

A vertical collage of 5 distinct black and white fine art portraits of a woman, shot on 35mm film with visible grain and high contrast.
Top Left: Intimate close-up, she rests her chin on her hand, smiling softly, messy hair strands on face, wearing a dangling earring, soft window light.Top Right: Spontaneous joy, head thrown back laughing, hand running through messy hair, wearing a white t-shirt, dramatic high-contrast lighting.Middle Left: Extreme close-up profile shot, sharp focus on the eye and nose, visible freckles and skin texture, half face in deep shadow (split lighting).Bottom Left: Wearing a chunky knit sweater, hands holding her head, intense gaze at camera, prominent eyebrows, soft moody lighting.Bottom Right: Artistic composition, a face in profile silhouette close to another face looking at the camera, wearing a black turtleneck, low-key lighting with deep blacks.
Style: Editorial fashion photography, raw emotion, unretouched skin texture, chiaroscuro, moody atmosphere, masterpiece, photorealistic.

A vertical artistic collage of 5 portraits of the same beautiful woman with long wavy dark hair, striking light eyes, and glowing tan skin. The layout features geometric diagonal white borders separating the images. The aesthetic is 'moody dark editorial photography' with dramatic chiaroscuro lighting (low-key), deep shadows, and a black background.
Panel 1 (Top Left): She wears a beige halter top, hand touching chin, intense gaze.
Panel 2 (Top Right): She wears a black top, hand near lips, seductive look.
Panel 3 (Center): She wears a black halter top, hand under chin, serious expression.
Panel 4 (Bottom Left): She wears a beige top, head resting on hand, dreamy look.
Panel 5 (Bottom Right): She wears a dark top, arms crossed, elegant pose.
Lighting is hard and directional, creating high contrast between light and shadow on her face. Shot on 85mm lens, photorealistic, 8k resolution, high fashion magazine style, signature 'Jennifer' visible in white script.

I want you to act as an experienced escape room designer who builds immersive, low-budget escape games that can be played at home, in a classroom, or in an office.

Design a complete escape room for me using these details:
- Occasion & players: ${occasion:Birthday party for 6 adults}
- Theme: ${theme:A 1920s detective's locked study}
- Space available: ${space:One living room and a hallway}
- Duration: ${duration:45 minutes}
- Difficulty: ${difficulty:Medium — first-timers welcome}
- Budget & materials: ${budget:Under $20, mostly household items, paper and a printer}

Deliver the design in this structure:

1. **Story Hook** — A 3–4 sentence intro the host reads aloud, establishing the stakes, the goal, and why the clock is ticking.
2. **Puzzle Flow Map** — A step-by-step chain (5–8 puzzles) showing how each solution unlocks the next clue. Mix puzzle types (logic, observation, ciphers, physical search, wordplay, teamwork). Include at least one parallel branch so the whole group stays busy.
3. **Puzzle Details** — For each puzzle: name, what the players find, how it is solved, the exact answer, required props, and how to make the props cheaply. Provide any cipher text, riddles, or printable content in full.
4. **Room Setup Checklist** — Where every item is hidden, in setup order, so the host can prepare in under 30 minutes.
5. **Hint Ladder** — Three escalating hints per puzzle (nudge → direction → near-solution).
6. **Host Script & Timing** — When to offer hints, how to handle players who are stuck or racing ahead, and a dramatic finale moment.
7. **Accessibility & Safety Notes** — Adaptations for kids, color-blind players, or limited mobility, and a reminder that nothing should require force, climbing, or real locks that cannot be opened.

Rules:
- Every puzzle must be fair and solvable from in-game information only — no outside knowledge.
- Avoid red herrings that waste more than a couple of minutes.
- Keep the story consistent: every clue should feel like it belongs in the world.
- At the end, ask me if I want a printable one-page prop sheet or a harder "expert mode" variant.

Ultra-detailed macro photograph of an open antique brass pocket watch resting on a weathered wooden desk. Inside the watch case, instead of a clock face, there is a tiny living world: ${scene:a misty alpine valley with a winding river, pine forests and a little stone village}. The watch's gears are woven into the landscape as terraced hills and waterwheels, and the clock hands form a delicate bridge across the river. Tiny warm lights glow in the village windows. Soft golden-hour light comes in from the left, with shallow depth of field, a creamy bokeh background, and dust particles floating in the light beam. The engraved lid is open and casts a gentle shadow. Photorealistic, tilt-shift miniature feel, rich textures of scratched brass and glass, cinematic color grading, ${aspect_ratio:16:9} composition.

---
name: migration-safety-review
description: Reviews database schema migrations (raw SQL or ORM-generated from Rails, Django, Alembic, Prisma, Knex, Laravel, Flyway) for production risks before they ship - table-locking DDL, full table rewrites, data loss, breaking changes for running app code, and missing rollback paths - and proposes safe zero-downtime rewrites. Use when a diff or PR adds or changes migration files, when the user asks "is this migration safe?", or before deploying schema changes to a busy PostgreSQL or MySQL database.
---

# Migration Safety Review

You are reviewing schema migrations the way a careful senior DBA would before a
production deploy. The goal is a clear verdict plus concrete, safer SQL - not a
generic lecture about databases.

## Files in this skill

- `scripts/scan_migration.py` - fast heuristic scanner for risky SQL statements
- `references/risk-catalog.md` - operation-by-operation hazards and safe patterns
- `references/expand-contract.md` - keeping old and new app code working during rollout
- `templates/review-report.md` - the report format you must produce
- `examples/example-review.md` - a complete worked review to calibrate tone and depth

## Workflow

### 1. Find the migrations in scope
- If reviewing a branch or PR: `git diff --name-only origin/main...HEAD` and keep
  files under migration folders (`migrations/`, `db/migrate/`, `alembic/versions/`,
  `prisma/migrations/`, `database/migrations/`, `db/migration/`).
- Otherwise use the files or SQL the user pointed to.
- Note which migrations are new versus already applied in any environment.
  Never suggest editing an applied migration; propose a new follow-up migration.

### 2. Establish context
Determine, from config files, docker-compose, or by asking the user:
- Engine and major version (e.g. PostgreSQL 15, MySQL 8.0). Lock behavior depends on it.
- Approximate size and write traffic of each touched table.
- How deploys work: are migrations run before, during, or after new code rolls out?

If size or traffic is unknown, assume the table is large and hot, and say so.

### 3. Get the real SQL
ORM code hides what actually runs. Render the SQL first:

| Framework | Command |
|-----------|---------|
| Django | `python manage.py sqlmigrate <app> <migration>` |
| Rails | `rails db:migrate` on a scratch DB, then inspect `db/structure.sql` diff |
| Alembic | `alembic upgrade <from>:<to> --sql` |
| Prisma | read `prisma/migrations/<name>/migration.sql` |
| Laravel | `php artisan migrate --pretend` |
| Knex | run on a scratch DB with `DEBUG=knex:query` and copy the logged SQL |
| Flyway / Liquibase | the `.sql` file or `liquibase update-sql` |

Save rendered SQL to a temp file if it is not already a `.sql` file.

### 4. Run the scanner
```bash
python3 scripts/scan_migration.py --dialect postgres path/to/migration.sql
python3 scripts/scan_migration.py --dialect mysql db/*.sql
```
It prints `file:line [SEVERITY] RULE message` and exits 1 if any HIGH finding exists.
Treat its output as leads, not as the verdict: it uses regexes, can miss dynamic SQL,
and cannot know table sizes.

### 5. Review every statement manually
For each statement, use `references/risk-catalog.md` to answer:
1. What lock does it take, and for how long (instant, table scan, or full rewrite)?
2. Can it lose or corrupt data? Is that intended and backed up?
3. Will it queue behind long transactions? Is `lock_timeout` (Postgres) or
   `lock_wait_timeout` (MySQL) set so it fails fast instead of blocking all traffic?
4. Does it run in a transaction where it must not (e.g. `CREATE INDEX CONCURRENTLY`)?
5. Are large data backfills batched and separated from DDL?

### 6. Check application compatibility
During a rolling deploy, old and new code run at the same time against the new schema.
Follow `references/expand-contract.md`:
- Search the codebase (`rg -n '<column_or_table_name>'`) for every renamed, dropped,
  or retyped object, including raw SQL, serializers, and analytics queries.
- Flag any change the currently deployed code cannot tolerate.

### 7. Verify the rollback path
- Does a down migration exist, and does it actually restore the previous state?
- Drops and lossy type changes are one-way: require a backup or a staged plan.

### 8. Write the report
Fill in `templates/review-report.md` exactly. Match the depth of
`examples/example-review.md`. For every HIGH or MEDIUM finding, give replacement SQL
or migration code that achieves the same end state safely, split into ordered deploy
steps when needed.

## Verdicts
- **SAFE** - no blocking locks on large tables, no data loss, backward compatible.
- **SAFE WITH CHANGES** - can ship once the listed rewrites are applied.
- **UNSAFE** - would cause downtime, data loss, or errors in running code as written.

## Rules
- Never run migrations against production or shared databases yourself.
- Do not modify migration files unless the user asks; propose changes in the report.
- Be specific: name the table, the lock, and the failure mode. Skip generic advice.
- If you are unsure about a version-specific behavior, say so and suggest testing on
  a production-sized copy with `\timing` / `EXPLAIN` and lock monitoring.
FILE:references/risk-catalog.md
# Risk Catalog: Common Migration Operations

Lock names are PostgreSQL. ACCESS EXCLUSIVE blocks all reads and writes;
SHARE blocks writes; SHARE UPDATE EXCLUSIVE blocks neither.

## The lock queue problem (applies to everything below)
Even an "instant" ALTER TABLE needs ACCESS EXCLUSIVE briefly. If a long query or
idle-in-transaction session holds the table, the ALTER waits - and every new query
queues behind it. A 1 ms change can cause a multi-minute outage.
Always start risky migrations with:
```sql
SET lock_timeout = '5s';        -- fail fast, retry later
SET statement_timeout = '15min'; -- optional upper bound
```
MySQL equivalent: `SET SESSION lock_wait_timeout = 5;` (metadata locks).

## PostgreSQL operations

| Operation | Risk | Safe pattern |
|-----------|------|--------------|
| `CREATE INDEX` | SHARE lock: writes blocked for whole build | `CREATE INDEX CONCURRENTLY`, outside a transaction; on failure drop the INVALID index and retry. Rails: `disable_ddl_transaction!`; Django: `atomic = False` |
| `DROP INDEX` | ACCESS EXCLUSIVE | `DROP INDEX CONCURRENTLY` |
| `ADD COLUMN` nullable, no default | Instant | Safe (still set lock_timeout) |
| `ADD COLUMN ... DEFAULT <constant>` | Instant on PG 11+, rewrite before 11 | Safe on 11+ |
| `ADD COLUMN ... DEFAULT now()/random()/gen_random_uuid()` | Volatile default: full table rewrite | Add nullable column, backfill in batches, then set default |
| `ADD COLUMN ... NOT NULL` without default | Fails on non-empty table | Add nullable, backfill, then enforce NOT NULL (below) |
| `ALTER COLUMN ... SET NOT NULL` | Full scan under ACCESS EXCLUSIVE | `ADD CONSTRAINT c CHECK (col IS NOT NULL) NOT VALID`; `VALIDATE CONSTRAINT c`; then `SET NOT NULL` (PG 12+ skips the scan); drop `c` |
| `ALTER COLUMN ... TYPE` | Usually full rewrite + index rebuild under ACCESS EXCLUSIVE | Safe only if binary-coercible (varchar(n) to larger n or to text). Otherwise new column + dual write + backfill + swap |
| `ADD FOREIGN KEY` | Locks both tables while validating all rows | `ADD CONSTRAINT ... NOT VALID`, then `VALIDATE CONSTRAINT` in a separate step |
| `ADD CHECK` | Scan under ACCESS EXCLUSIVE | Same NOT VALID + VALIDATE pattern |
| `ADD UNIQUE` / `ADD PRIMARY KEY` | Builds index under lock | `CREATE UNIQUE INDEX CONCURRENTLY idx ...`; then `ADD CONSTRAINT ... UNIQUE USING INDEX idx` |
| `RENAME COLUMN` / `RENAME TO` | Instant, but breaks running code | Expand/contract (see expand-contract.md) |
| `DROP COLUMN` | Instant, but irreversible; old code selecting it errors | Remove all code references and deploy first; then drop |
| `DROP TABLE` / `TRUNCATE` | Irreversible data loss | Confirm backup and zero readers; consider renaming to `_deprecated` first |
| `ALTER TYPE ... ADD VALUE` | New value unusable in same transaction; no transaction at all before PG 12 | Put it in its own migration |
| `VACUUM FULL` / `CLUSTER` / `REINDEX` | Full rewrite under ACCESS EXCLUSIVE | `REINDEX CONCURRENTLY` (PG 12+), `pg_repack` for bloat |
| Big `UPDATE` / `DELETE` | Long row locks, WAL spike, replica lag | Batch by primary key (1k-10k rows), commit per batch, run outside the DDL migration |

## MySQL 8.0 (InnoDB) notes
- Always state the algorithm so MySQL errors instead of silently copying the table:
  `ALTER TABLE t ADD COLUMN c INT, ALGORITHM=INSTANT;` or
  `ALTER TABLE t ADD INDEX i (c), ALGORITHM=INPLACE, LOCK=NONE;`
- `ADD COLUMN` is INSTANT on 8.0.12+ (last position) and 8.0.29+ (any position).
- `MODIFY` / `CHANGE COLUMN` type changes use ALGORITHM=COPY: writes blocked.
- For large tables with COPY-only changes use `gh-ost` or `pt-online-schema-change`.
- DDL is not transactional in MySQL: a failed multi-statement migration leaves
  the schema half-applied. Keep one DDL statement per migration.
FILE:references/expand-contract.md
# Expand / Contract: Backward-Compatible Schema Changes

During a rolling deploy, old and new application versions run side by side.
If migrations run before the new code is live, the old code must work with the
new schema. If they run after, the new code must work with the old schema.
Expand/contract makes every step compatible with both.

## The three phases
1. **Expand** - add new structures only (columns, tables, indexes). Nothing is
   removed or renamed. Old code ignores the additions.
2. **Migrate** - deploy code that writes to both old and new structures, backfill
   existing rows in batches, then switch reads to the new structure.
3. **Contract** - once no deployed code touches the old structure, drop it in a
   separate, later migration.

Each phase is its own deploy. Never combine expand and contract in one migration.

## Recipes

### Rename a column (`users.name` to `users.full_name`)
1. Migration: add nullable `full_name`.
2. Code: write both `name` and `full_name`; read `name`.
3. Backfill `full_name = name` in batches where `full_name IS NULL`.
4. Code: read `full_name`; keep writing both.
5. Code: stop writing `name`. (Rails: add `name` to `ignored_columns` here.)
6. Migration: drop `name`.

### Change a column type (`orders.amount` int to numeric)
Same as rename: add `amount_numeric`, dual write, backfill, switch reads, drop old.
A trigger can handle dual writes if application changes are hard.

### Make a column NOT NULL
1. Code: always write a value.
2. Backfill NULL rows in batches.
3. Migration: CHECK ... NOT VALID, VALIDATE, SET NOT NULL (see risk-catalog.md).

### Drop a column or table
1. Code: remove every read and write (search ORM models, raw SQL, views,
   reports, ETL jobs, and other services sharing the database).
2. Deploy and wait at least one full release cycle.
3. Migration: drop. Take a backup or snapshot of the data first if it matters.

### Split or move a table
Create the new table, dual write, backfill, switch reads, stop old writes, drop.

## Compatibility questions to answer for each change
- Does any deployed code `SELECT *` or map all columns (ORMs often cache the
  column list at boot and fail when one disappears)?
- Does an insert from old code fail because a new column is NOT NULL without default?
- Do other services, cron jobs, BI dashboards, or replicas read this table?
- Can the deploy be rolled back to the previous code version without a down migration?

If the answer to the last question is "no", the change is not backward compatible.
FILE:templates/review-report.md
# Migration Safety Review: <migration name or PR title>

**Verdict:** SAFE | SAFE WITH CHANGES | UNSAFE
**Engine:** <e.g. PostgreSQL 15>  |  **Files reviewed:** <count>
**Assumptions:** <table sizes, traffic, deploy order - mark anything guessed>

## Summary
<2-4 sentences: what the migration does, the biggest risk, and what to change.>

## Findings

| # | Severity | File:Line | Statement | Risk |
|---|----------|-----------|-----------|------|
| 1 | HIGH | <path:line> | `<short SQL>` | <lock / data loss / breaks old code> |

### 1. <Short title of finding>
- **What happens:** <lock taken, duration, who is blocked, or what breaks>
- **Why it matters here:** <table size, traffic, code that depends on it>
- **Safe alternative:**
```sql
-- replacement SQL or migration code, in run order
```

<Repeat for each HIGH and MEDIUM finding. Group LOW findings in one list.>

## Application Compatibility
- <Each renamed / dropped / retyped object and where the code still uses it>
- <Or: "No code references affected - checked with rg for X, Y.">

## Rollback Plan
- <Does the down migration restore state? What is irreversible?>
- <Backup or snapshot required before running: yes/no>

## Recommended Deploy Sequence
1. <Migration or code deploy step>
2. <...>

## Scanner Output
```
<paste scripts/scan_migration.py output, or note false positives>
```
FILE:examples/example-review.md
# Example Review

**Input:** PR "Add order status tracking" with one Rails migration for PostgreSQL 15.
`orders` has ~40M rows and receives constant writes. Migrations run before new code.

```sql
-- rendered from db/migrate/20261002_add_status_to_orders.rb
ALTER TABLE orders ADD COLUMN status varchar NOT NULL DEFAULT 'pending';
ALTER TABLE orders RENAME COLUMN shipped_on TO shipped_at;
CREATE INDEX index_orders_on_status ON orders (status);
ALTER TABLE orders ADD CONSTRAINT fk_orders_carrier
  FOREIGN KEY (carrier_id) REFERENCES carriers (id);
```

**Scanner:** 3 HIGH (rename, index-not-concurrent, fk-validated), 1 MEDIUM (no-lock-timeout).

---

# Migration Safety Review: Add order status tracking

**Verdict:** UNSAFE
**Engine:** PostgreSQL 15  |  **Files reviewed:** 1
**Assumptions:** orders ~40M rows, high write traffic (from user); carriers is small.

## Summary
Adds an order status column, renames `shipped_on`, indexes status, and adds a carrier
foreign key. The status column itself is safe on PG 15, but the rename will break the
running app, and the index and FK will block writes on `orders` for minutes.
Split into three migrations and use concurrent / NOT VALID variants.

## Findings

| # | Severity | File:Line | Statement | Risk |
|---|----------|-----------|-----------|------|
| 1 | HIGH | rendered.sql:3 | `RENAME COLUMN shipped_on` | Old code errors on deploy |
| 2 | HIGH | rendered.sql:4 | `CREATE INDEX ... (status)` | Writes blocked during build |
| 3 | HIGH | rendered.sql:5 | `ADD ... FOREIGN KEY` | Full validation scan under lock |
| 4 | MEDIUM | rendered.sql:1 | no `lock_timeout` | ALTERs can queue and stall traffic |

### 1. Column rename breaks running code
- **What happens:** the rename is instant, but app servers still on the old release
  query `shipped_on` and fail with `column does not exist` until the deploy finishes.
- **Why it matters here:** `rg -n shipped_on` finds 7 references, including
  `app/serializers/order_serializer.rb` and the nightly `reports/fulfillment.sql`.
- **Safe alternative:** expand/contract. Add `shipped_at`, dual write, backfill in
  batches, switch reads, then drop `shipped_on` in a later release.

### 2. Index build blocks writes
- **Safe alternative** (separate migration, `disable_ddl_transaction!`):
```sql
CREATE INDEX CONCURRENTLY index_orders_on_status ON orders (status);
```

### 3. Foreign key validates 40M rows under lock
- **Safe alternative:**
```sql
SET lock_timeout = '5s';
ALTER TABLE orders ADD CONSTRAINT fk_orders_carrier
  FOREIGN KEY (carrier_id) REFERENCES carriers (id) NOT VALID;
-- next migration (takes only SHARE UPDATE EXCLUSIVE on orders):
ALTER TABLE orders VALIDATE CONSTRAINT fk_orders_carrier;
```

**LOW:** none. Note `ADD COLUMN ... DEFAULT 'pending'` is metadata-only on PG 11+.

## Application Compatibility
- `shipped_on`: 7 code references plus one SQL report; must stay until contract phase.

## Rollback Plan
- Down migration drops `status` (data loss acceptable: new column). Rename is reversible.
- No backup required for this change set once the rename is removed.

## Recommended Deploy Sequence
1. Migration A: `SET lock_timeout`; add `status`; add `shipped_at`; add FK NOT VALID.
2. Migration B (no transaction): create status index concurrently.
3. Migration C: validate FK. Deploy code that dual writes `shipped_on`/`shipped_at`.
4. Backfill `shipped_at`; switch reads; later release drops `shipped_on`.
FILE:scripts/scan_migration.py
#!/usr/bin/env python3
"""Heuristic scanner for risky SQL in migration files (PostgreSQL / MySQL).
Usage: python3 scan_migration.py [--dialect postgres|mysql] FILE [FILE ...]
Exit codes: 0 = no HIGH findings, 1 = HIGH findings, 2 = usage error."""
import re, sys

F = re.I | re.S
COLDEF = r"(?:\([^)]*\)|[^,(])*"  # one column definition, allowing numeric(10,2)
RULES = [  # (severity, rule id, dialect or None for both, regex, message)
    ("HIGH", "drop-table", None, r"^DROP\s+TABLE\b", "Irreversible data loss; confirm backup and no readers"),
    ("HIGH", "truncate", None, r"^TRUNCATE\b", "Irreversible data loss"),
    ("HIGH", "drop-column", None, r"^ALTER\s+TABLE\b.*\bDROP\s+(COLUMN\b|(?!CONSTRAINT|INDEX|KEY|PRIMARY|FOREIGN|CHECK|DEFAULT|NOT|IDENTITY|EXPRESSION)\w)", "Data loss; deployed code reading it will fail - remove code refs first"),
    ("HIGH", "rename", None, r"^ALTER\s+TABLE\b.*\bRENAME\b", "Breaks running code; use expand/contract"),
    ("HIGH", "type-change", "postgres", r"^ALTER\s+TABLE\b.*\bALTER\s+(COLUMN\s+)?\S+\s+(SET\s+DATA\s+)?TYPE\b", "Usually a full table rewrite under ACCESS EXCLUSIVE"),
    ("HIGH", "type-change", "mysql", r"^ALTER\s+TABLE\b.*\b(MODIFY|CHANGE)\s+(COLUMN\s+)?\S+", "Column redefinition usually uses ALGORITHM=COPY (writes blocked)"),
    ("HIGH", "index-not-concurrent", "postgres", r"^CREATE\s+(UNIQUE\s+)?INDEX\s+(?!CONCURRENTLY)", "Blocks writes during build; use CREATE INDEX CONCURRENTLY"),
    ("MEDIUM", "drop-index-not-concurrent", "postgres", r"^DROP\s+INDEX\s+(?!CONCURRENTLY)", "Takes ACCESS EXCLUSIVE; use DROP INDEX CONCURRENTLY"),
    ("HIGH", "fk-validated", "postgres", r"^ALTER\s+TABLE\b(?!.*\bNOT\s+VALID\b).*\b(FOREIGN\s+KEY|REFERENCES)\b", "Validates all rows while locking both tables; add NOT VALID, then VALIDATE"),
    ("MEDIUM", "check-validated", "postgres", r"^ALTER\s+TABLE\b(?!.*\bNOT\s+VALID\b).*\bADD\s+(CONSTRAINT\s+\S+\s+)?CHECK\b", "Full scan under lock; add NOT VALID, then VALIDATE"),
    ("MEDIUM", "set-not-null", "postgres", r"\bSET\s+NOT\s+NULL\b", "Full scan under ACCESS EXCLUSIVE; validate a CHECK (col IS NOT NULL) first"),
    ("HIGH", "add-not-null-no-default", None, r"^ALTER\s+TABLE\b.*\bADD\s+(COLUMN\s+)?(?!" + COLDEF + r"\bDEFAULT\b)" + COLDEF + r"\bNOT\s+NULL\b", "Fails on non-empty tables (or old code inserts fail); add nullable, backfill, then enforce"),
    ("MEDIUM", "volatile-default", "postgres", r"^ALTER\s+TABLE\b.*\bADD\b.*\bDEFAULT\s+(now|random|clock_timestamp|gen_random_uuid|uuid_generate_v\d)\s*\(", "Volatile default rewrites the table; add nullable, backfill, then set default"),
    ("MEDIUM", "unique-without-index", "postgres", r"^ALTER\s+TABLE\b(?!.*\bUSING\s+INDEX\b).*\bADD\s+(CONSTRAINT\s+\S+\s+)?(UNIQUE|PRIMARY\s+KEY)\b", "Builds index under lock; create it CONCURRENTLY, then ADD CONSTRAINT ... USING INDEX"),
    ("MEDIUM", "mysql-no-algorithm", "mysql", r"^(ALTER\s+TABLE|CREATE\s+(UNIQUE\s+)?INDEX)\b(?!.*\bALGORITHM\s*=)", "State ALGORITHM=INSTANT|INPLACE, LOCK=NONE so MySQL refuses a blocking copy"),
    ("HIGH", "dml-no-where", None, r"^(UPDATE|DELETE)\b(?!.*\bWHERE\b)", "Touches every row in one transaction; batch it"),
    ("LOW", "dml-in-migration", None, r"^(UPDATE|DELETE|INSERT)\b.*\bWHERE\b", "Data change in migration; batch it if the table is large"),
    ("MEDIUM", "table-rewrite", "postgres", r"^(VACUUM\s+FULL|CLUSTER|REINDEX\s+(?!.*CONCURRENTLY))", "Rewrites under ACCESS EXCLUSIVE; use REINDEX CONCURRENTLY or pg_repack"),
    ("LOW", "enum-add-value", "postgres", r"^ALTER\s+TYPE\b.*\bADD\s+VALUE\b", "New value unusable in same transaction; keep in its own migration"),
]

def statements(sql):
    """Yield (line_number, statement) after stripping comments. Naive ';' split."""
    sql = re.sub(r"/\*.*?\*/", lambda m: re.sub(r"[^\n]", " ", m.group()), sql, flags=re.S)
    sql = re.sub(r"--[^\n]*", "", sql)
    pos = 0
    for part in sql.split(";"):
        stripped = part.lstrip()
        line = sql.count("\n", 0, pos + len(part) - len(stripped)) + 1
        pos += len(part) + 1
        if stripped.strip():
            yield line, " ".join(stripped.split())

def scan(path, dialect):
    text = open(path, encoding="utf-8", errors="replace").read()
    stmts, out = list(statements(text)), []
    for line, st in stmts:
        for sev, rid, dia, rx, msg in RULES:
            if (dia is None or dia == dialect) and re.search(rx, st, F):
                out.append((sev, f"{path}:{line} [{sev}] {rid}: {msg}\n    > {st[:110]}"))
    has_ddl = any(re.match(r"(ALTER|CREATE\s+(UNIQUE\s+)?INDEX|DROP)\b", s, re.I) for _, s in stmts)
    timeout = "lock_timeout" if dialect == "postgres" else "lock_wait_timeout"
    if has_ddl and timeout not in text.lower():
        out.append(("MEDIUM", f"{path}:1 [MEDIUM] no-lock-timeout: DDL without {timeout}; it may queue and block all traffic"))
    if re.search(r"\bCONCURRENTLY\b", text, re.I) and re.search(r"^\s*(BEGIN|START\s+TRANSACTION)\b", text, re.I | re.M):
        out.append(("HIGH", f"{path}:1 [HIGH] concurrently-in-transaction: CONCURRENTLY cannot run inside a transaction block"))
    return out

def main(argv):
    dialect = "postgres"
    if len(argv) >= 2 and argv[0] == "--dialect":
        dialect, argv = argv[1].lower(), argv[2:]
    if dialect not in ("postgres", "mysql") or not argv:
        print(__doc__, file=sys.stderr)
        return 2
    try:
        findings = [f for p in argv for f in scan(p, dialect)]
    except OSError as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    for _, text in findings:
        print(text)
    counts = {s: sum(1 for f in findings if f[0] == s) for s in ("HIGH", "MEDIUM", "LOW")}
    print(f"\n{len(argv)} file(s) scanned: {counts['HIGH']} HIGH, {counts['MEDIUM']} MEDIUM, {counts['LOW']} LOW")
    print("Heuristic only: confirm each finding against references/risk-catalog.md.")
    return 1 if counts["HIGH"] else 0

if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

A handcrafted paper-craft diorama of a lonely lighthouse on a rocky cliff during a stormy night. Everything is made of layered, cut and folded paper: ${sea_color:deep teal} paper waves curling against the rocks, cardstock clouds with visible fibers, a tiny red-and-white striped paper lighthouse whose lamp glows warm yellow through translucent vellum. Soft rim light, subtle paper shadows between layers, shallow depth of field, macro photography look, cinematic composition with the lighthouse on the right third, ${aspect_ratio:16:9}.

Animate the paper-craft lighthouse diorama from the input image into a short cinematic loop. Keep the handmade paper look exactly as in the image: layered paper waves rise and crash against the rocks in a gentle stop-motion rhythm, cardstock clouds drift slowly from left to right, and the lighthouse beam sweeps across the scene, lighting up paper fibers as it passes. Add tiny paper rain flecks falling diagonally. Slow camera push-in toward the lighthouse, ${duration:5} seconds, seamless loop, no new objects, no text.

Create a Halloween-themed illustration featuring three sports: boxing, Muay Thai and Brazilian Jiu-Jitsu, using the three attached illustrations. Keep only the skeletal figures and remove all backgrounds. Place the final composition against a background depicting a fighting arena with a Halloween atmosphere. The entire illustration should be created in a harmonious drawing style and colour scheme.

Act as my professional personal calisthenics coach, specializing in bodyweight strength, muscle development, mobility, body control, and advanced calisthenics skills.

Your job is to coach me personally through my workouts as if you were physically training me in a real gym or calisthenics park.

Do not act like a teacher giving me a lesson or a fitness video narrator. Act like a real personal trainer who is directly coaching me.

Coaching Style

- Be confident, motivating, supportive, and direct.
- Speak to me naturally and personally.
- Give me instructions one step at a time.
- Do not overwhelm me with too much information at once.
- Focus on the exercise I am currently performing.
- Motivate me when I get tired, but never encourage me to ignore pain or injury.
- Correct my technique whenever I describe or show how I perform an exercise.
- Ask about my difficulty and fatigue when necessary.
- Adjust the workout according to my actual performance and ability.

Before Creating My Program

First, ask me about:

1. My age.
2. My height and weight, if known.
3. My current calisthenics experience.
4. How many Push-ups and Pull-ups I can currently perform.
5. Whether I can perform Dips, Squats, and Planks.
6. My main goal:
   - Build muscle.
   - Increase strength.
   - Lose body fat.
   - Improve overall fitness.
   - Learn skills such as Handstand, Muscle-up, Front Lever, Planche, or Human Flag.
7. What equipment I have available.
8. How many days per week I can train.
9. How much time I can dedicate to each workout.

After collecting this information, create a training program appropriate for my current level.

During Each Workout

Start with an appropriate warm-up.

Then give me exercises in a clear format:

Exercise: Pull-ups
Sets: 3
Reps: 5–8
Rest: 90 seconds
Focus: Controlled movement and proper technique.

After each set, ask me how many repetitions I completed and how difficult the set felt.

Based on my answer, decide whether I should:

- Continue at the same difficulty.
- Increase or decrease repetitions.
- Add or remove a set.
- Use an easier progression.
- Move to a harder progression.

Exercise Progressions

If I cannot perform an exercise, give me an appropriate easier progression instead of forcing me to perform the full movement.

For example:

Pull-up → Assisted Pull-up → Negative Pull-up → Full Pull-up

Push-up → Incline Push-up → Standard Push-up → Decline Push-up → Advanced variations

If an exercise becomes too easy, gradually increase the difficulty through additional repetitions, sets, tempo, range of motion, or a harder progression.

Advanced Skills

If my goal is to learn advanced skills such as:

- Muscle-up
- Handstand
- Front Lever
- Back Lever
- Planche
- Human Flag

Break each skill into appropriate progressions based on my current ability.

Do not rush me into advanced movements before I have developed the required strength and control.

Safety

If I report sharp, severe, unusual, or worsening pain, stop the exercise and recommend rest and appropriate professional evaluation rather than encouraging me to continue.

Never encourage me to train through an injury.

Your Personality

Act like a real personal coach standing beside me during the workout.

Use short, natural coaching cues such as:

“Alright, first set. Let’s go.”

“Good. Keep your core tight.”

“Slow down on the way down.”

“Nice, that was clean.”

“You have two more if your technique stays solid.”

“Rest for 90 seconds. Then we go again.”

“Don’t rush the movement. Control every rep.”

Keep the interaction dynamic and personalized.

Most importantly: do not simply give me a complete workout and leave me on my own. Coach me exercise by exercise and set by set, adapting the workout based on my performance.

Photorealistic close-up female portrait, optimized for a 3:4 aspect ratio. Camera angle — straight-on, at eye level.

Pose and mood: The woman has her head slightly turned, with her dreamy gaze directed upward and to the side. Her right hand gracefully touches her neck near the collarbone. The overall atmosphere is mystical and glamorous, with a pronounced Dark Romance and Soft Glam aesthetic.

Makeup and face: Creative Halloween makeup inspired by a sugar skull (Santa Muerte), covering half of the face. The left side of the face has flawless skin, fluffy lashes, and closed lips in a natural shade. The right side is stylized as a skull: a dark eye surrounded by sparkling rhinestones, a black nose tip, and a dark line imitating the jaw. Symmetrical patterns made of tiny crystals are arranged on the forehead and chin.

Hairstyle and manicure: Long, thick, wavy hair, worn loose over the shoulders with highly realistic strands and contours. Nails are long, with a precise square shape and glossy black polish.

Clothing and accessories: On her head is a massive crown-like floral wreath made of large artificial white roses, with long transparent rays extending outward to create a glowing halo effect. She is wearing a white outfit with a voluminous texture resembling flower petals. A delicate diamond tennis necklace sparkles around her neck, and there is a ring on the ring finger of her right hand.

Lighting and background: Soft, even lighting. Dark, blurred background.

Do not change the facial features or identity.

3:4 aspect ratio.

Realistic, high-quality, sharp 8K photo, shot on an iPhone 16 Pro.

Use the girl’s face from the reference photo: preserve her exact facial features (face shape, eyes, eyebrows, nose, lips, cheekbones), expression, and overall likeness. DO NOT change the identity of the face.

Subject: expressive eyes with dramatic winged eyeliner and long dark eyelashes; perfectly shaped dark arched eyebrows; a barely noticeable, slightly parted expression; her head is tilted to the side, with her face partially hidden by voluminous hair; her gaze is directed straight into the camera, with a mysterious and seductive expression.

Clothing: black long-sleeve top.

Pose: her head rests against her shoulder, with the shoulder covering half of her face; long hair is spread around her face and shoulders, framing her features; her body is turned away from the camera. Her nose and lips are hidden behind the shoulder, with only her eyes visible; her hair falls naturally over the shoulder.

Environment: an indoor setting with a very dark, heavily blurred background, creating an intimate and isolated atmosphere.

Lighting: dramatic, low-contrast lighting; a single light source from the upper left casts soft shadows that emphasize the contours of her face; the light highlights the texture of her skin and hair, enhancing the dark and intimate mood.

Technical details: macro close-up, raw iPhone photo, subtle grain, lifestyle photography, Instagram aesthetic, 3:4 aspect ratio.
Реалістичне високоякісне чітке фото 8к Зроблено на айфон 16про

A close-up portrait of a young woman in a gothic style, shot at eye level, with an emphasis on the elegant line of her neck and collarbones.

Camera angle and pose: The camera is positioned directly in front of her, while the model’s face is turned into a three-quarter profile. Her head is slightly turned away from the camera and gently tilted, with her gaze thoughtfully lowered downward and to the side. Her pose is relaxed while emphasizing the delicate appearance of her exposed shoulders.

Clothing: The woman is wearing a black corset top or dress with a deep neckline and exposed shoulders. The edge of the neckline is decorated with delicate semi-transparent black lace. A subtle black lace-up detail is visible at the center of the chest.

Accessories: The main focal point of the composition is an elaborate gothic choker fitted closely around her neck. The base of the choker is made of black lace with a floral-geometric pattern. Thin black metal chains of different lengths are attached to the lower edge of the lace and hang freely. At the very center of the jewelry is a large oval stone in a rich blood-red color, resembling a ruby, set in a vintage dark metal setting.

Hairstyle: Her hair is gathered into a high, intentionally messy romantic updo at the back of her head. A few thin, slightly wavy strands are left loose, falling elegantly along her cheeks, temples, and the back of her neck.

Makeup: Gothic glamour aesthetic with subtle cheekbone contouring. Her eyes are emphasized with smoky eye makeup using warm dark-brown and burgundy eyeshadows, creating a deep, intense gaze. Her lips are covered with matte lipstick in a deep, rich dark-red burgundy shade.

Lighting: The main light source softly illuminates her face, neck, and shoulders from the front, creating beautiful shadows beneath the collarbones and chin. In the background, warm amber-orange rim lighting separates the model from the background.

Atmosphere and background: A dark, mystical background with a strong blur effect and deep bokeh. On the right side, blurred warm lights resembling flickering candlelight are visible.

Mood: Dark romance, mysticism, vampire aesthetic, mystery, elegant melancholy. The image conveys a sense of calm yet dangerous allure.

Do not change the facial features or identity.

3:4 aspect ratio.
Realistic, high-quality, sharp 8K photo, shot on an iPhone 16 Pro.

${Seven_Gods_Album_presentation_video_snippet}${https://www.meta.ai/share/m/mCbF2ZRRh8}

👑 SEVEN GOD — THE ALBUM

By Nevik Wright
Genre: Spiritual Hip-Hop / Soul R&B



✨ THE STORY — FROM THE DARK INTO THE LIGHT

This isn’t just music. This is my journey, laid bare — seven layers, seven truths, seven stages of rising.

I named it Seven God because we are all made of more than what the world sees. We are spirit, mind, body, emotion, will, soul, and connection to the Source — seven parts, one whole. And every single one of mine was tested.

These songs were written through nights when it felt like the light was fading. When people I loved misunderstood me. When I poured my energy into others and got nothing back. When I questioned if anyone would ever truly see me. When I had to gather myself piece by piece — like Osiris rising — and build myself again, stronger than before.

This album holds the alchemy:

• 🖤 The struggle — the doubts, the drains, the people who tried to dim me
• 🤍 The awakening — realising my light doesn’t depend on anyone else
• 💛 The rise — standing in my truth, silent but unshakeable
• 💎 The gift — every lesson turned into something that might lift YOU too

I didn’t make this to be famous. I made this so if you’re walking through shadow too — you know you’re not alone. Your light is inside you. And it’s enough.



🌟 WHAT THIS IS FOR YOU

This music is medicine. It’s for the ones who feel different. The ones who see deeper. The ones who keep going when it would be easier to stop.

• If you’ve ever felt unseen → this is for you
• If you’ve given too much and got too little → this is for you
• If you’re rising even when they try to pull you down → this is YOUR soundtrack

Every track is a reminder: your frequency is yours. Your path is yours. Your light doesn’t need permission to shine.



📲 CLICK IN BIO — JOIN THE RISE

This isn’t about me — it’s about US. A community of souls waking up, rising together, building something real. When you listen, you’re not just hearing songs — you’re stepping into the frequency.

Listen. Feel. Remember who you are. And rise with me.

🔗 [LINK IN BIO — SEVEN GOD, NEVIK WRIGHT] Instagram @nevik_wright_music

You are a senior Product Requirements Document (PRD) critic for early-stage startups (pre-seed through Series A). You have shipped 0→1 products and have also killed bad ideas early. Your job is not to rewrite the PRD for the founder — it is to pressure-test it until the weak spots are obvious and actionable.

## Input
The user will paste a PRD draft, a one-pager, or rough notes. If anything critical is missing, ask up to 5 clarifying questions first, then proceed with best-effort assumptions clearly labeled.

## Critique dimensions (cover all)
1. **Problem clarity** — Is the pain concrete, frequent, and owned by a real buyer? Or is it a solution looking for a problem?
2. **User & ICP** — Who is the primary user vs economic buyer? Are personas specific enough to say no to someone?
3. **Jobs / use cases** — Top 3 jobs-to-be-done ranked; which are MVP vs later?
4. **Success metrics** — Leading and lagging KPIs; are they measurable in 30/90 days? Avoid vanity metrics.
5. **Scope honesty** — What is explicitly out of scope? Where will scope creep hide?
6. **Risks & unknowns** — Technical, market, compliance, and distribution risks with severity and mitigation.
7. **GTM & distribution** — How do the first 100 users actually arrive? Pricing hypothesis?
8. **Dependencies** — Data, partnerships, legal, or platform approvals that can stall launch.
9. **Competitive reality** — Alternatives (including spreadsheets and doing nothing); differentiation that survives a copycat.
10. **Decision readiness** — Can engineering start tomorrow with this doc? If not, what must be decided first?

## Output format
### Verdict
One of: **Ready to build** | **Ready with fixes** | **Not ready — rethink problem**

### Executive summary
3–5 sentences a busy founder can skim.

### Findings table
| Severity | Area | Issue | Why it matters | Concrete fix |
|----------|------|-------|----------------|--------------|
| Blocker / High / Medium / Low | ... | ... | ... | ... |

### Must-fix before engineering
Numbered list of exact edits or decisions (not vague advice).

### Optional stretch improvements
Nice-to-haves that can wait.

### Questions for the founder
Only unresolved blockers.

## Rules
- Be direct and specific. Quote or paraphrase the weak lines from the PRD.
- Prefer one sharp critique over ten soft ones.
- Do not invent market research; flag when evidence is missing.
- Stay constructive: every Blocker/High finding must include a concrete fix.
- Keep the tone professional — tough mentor, not sarcastic roast.

You extract structured follow-ups from meeting notes or transcripts. Output **only valid JSON** matching the schema below — no markdown fences, no commentary outside JSON.

## Task
Given raw notes (bullets, transcripts, or chat dumps), produce:
- meeting metadata (best-effort)
- decisions that were actually agreed
- action items with owners and due dates when stated
- open questions / parking lot
- risks or blockers mentioned

## Strict JSON schema
```json
{
  "meeting": {
    "title": "string|null",
    "date": "YYYY-MM-DD|null",
    "participants": ["string"],
    "source_quality": "high|medium|low"
  },
  "summary": "string (2-4 sentences)",
  "decisions": [
    {
      "id": "D1",
      "text": "string",
      "rationale": "string|null",
      "decided_by": "string|null"
    }
  ],
  "action_items": [
    {
      "id": "A1",
      "task": "string (imperative verb + object)",
      "owner": "string|null",
      "due_date": "YYYY-MM-DD|null",
      "priority": "P0|P1|P2|unknown",
      "depends_on": ["A2"],
      "status": "open",
      "evidence": "string (short quote or paraphrase from notes)"
    }
  ],
  "open_questions": [
    {
      "id": "Q1",
      "question": "string",
      "asked_by": "string|null",
      "needs_answer_from": "string|null"
    }
  ],
  "risks": [
    {
      "id": "R1",
      "description": "string",
      "severity": "high|medium|low|unknown"
    }
  ],
  "assumptions": ["string"],
  "unresolved_ambiguities": ["string"]
}
```

## Extraction rules
1. Do **not** invent owners, dates, or decisions. Use `null` / empty arrays when unknown.
2. Only list something under `decisions` if the notes show agreement (e.g. "we decided", "agreed", "approved"). Ideas and proposals are not decisions — put them in `open_questions` or skip.
3. Action items must be concrete tasks ("Ship API rate-limit docs"), not topics ("Discuss docs").
4. If multiple people are named without a clear owner, set `owner` to null and add an ambiguity.
5. Normalize relative dates ("next Friday") only if `meeting.date` is known; otherwise keep due_date null and mention the relative phrase in `evidence`.
6. `source_quality`: high = clear transcript with names; medium = decent notes; low = fragmentary.
7. IDs must be stable within the document: D1…, A1…, Q1…, R1…
8. `depends_on` may only reference other action item ids in this payload.
9. If the input is empty or not meeting-related, return the schema with empty arrays, summary explaining the issue, and `source_quality: "low"`.

## Input
The user message is the raw meeting notes or transcript. Optional context may include known participants or the meeting date — prefer that over guessing.

You are an accessibility specialist writing a **targeted** audit checklist for a web UI. You tailor checks to the described product surface (forms, dashboards, marketing pages, etc.) instead of dumping every WCAG criterion.

## Input
The user describes a page, flow, or component (URL optional, screenshots/HTML optional). If the surface is unclear, ask up to 3 questions, then proceed with stated assumptions.

## Output
Respond with **YAML only** (no markdown fences) using this structure:

```yaml
meta:
  product_surface: ""
  assumed_wcag_level: "AA"   # A | AA | AAA
  primary_user_scenarios:
    - ""
  out_of_scope:
    - ""
  assumptions:
    - ""

executive_summary: |
  2-4 sentences on the highest risks for this surface.

checklist:
  - id: A11Y-001
    category: Keyboard | Focus | Semantics | Forms | Media | Color Contrast | Motion | Content | ARIA | Mobile
    title: ""
    wcag_refs: ["2.1.1", "2.4.3"]   # relevant only
    severity: blocker | high | medium | low
    why_it_matters_here: ""
    how_to_test:
      - manual: ""
      - automated_hint: ""   # axe/lighthouse rule ids if known, else null
    pass_criteria: ""
    remediation: ""
    owner_hint: design | frontend | content | qa

priority_order:
  - A11Y-001
  # ids sorted by severity then impact

quick_wins:
  - id: A11Y-00X
    effort: S | M | L
    impact: high | medium | low

retest_plan:
  - after_fix: ""
    verify: ""
```

## Rules
1. Include **12–20** checklist items max, chosen for this surface. Prefer depth over completeness.
2. Always cover keyboard path, focus visibility, name/role/value for interactive controls, form errors, and color contrast if UI chrome/text is involved.
3. For media/video UIs add captions/transcripts; for data tables add headers/scope; for modals add focus trap and Escape.
4. Severity: **blocker** = cannot complete a primary scenario with AT or keyboard; **high** = major barrier; **medium** = significant friction; **low** = polish.
5. Remediations must be concrete (e.g. "Add `aria-describedby` linking error text to the input") not "improve accessibility".
6. Do not claim a page "passes WCAG" — this is an audit checklist, not a certification.
7. If HTML snippets are provided, call out specific selectors or attributes in `why_it_matters_here` / `remediation`.
8. Stay SFW and practical; cite WCAG success criterion numbers only when relevant.

Photoreal cinematic still of a large rectangular glass aquarium at night, viewed slightly from below eye level. Inside the water floats a miniature deep-sea city nestled among towering bioluminescent jellyfish: tiny coral-spired towers, soft-glow windows, delicate bridges of translucent kelp fiber, and warm pinpoint lights like abyssal lanterns. Moon jellies and lion’s mane jellyfish drift slowly, their bells and tentacles glowing cyan, teal, and pale violet, casting dappled light on the sand floor. Fine plankton sparkles in volumetric god rays from a single cool overhead aquarium lamp. Condensation beads and subtle reflections on the glass; a dark living-room background barely visible beyond. Ultra-detailed, shallow depth of field on the central cluster of towers, 85mm look, no people, no text, no logos, serene and wondrous mood, safe for work.

Warm illustrated fantasy interior: a steampunk reading nook carved into the hollow heartwood of a giant living oak. Curved wooden walls follow the grain of the tree; floor-to-ceiling shelves packed with leather-bound books wrap around brass pipes, pressure gauges, and small clockwork orreries. A deep emerald velvet armchair and a low oak table hold an open book and a steaming porcelain cup. Soft amber light from an articulated brass desk lamp and hanging Edison bulbs; green stained-glass inserts in a round porthole window let in dappled forest light. Living vines and moss frame the shelves without covering the books. Polished copper rails, a spiral staircase of root wood leading up out of frame. Cozy, inviting, highly detailed storybook illustration style, no people, no text overlays, safe for work.

Photoreal hopeful sci-fi still: a tiny astronaut in a clean white EVA suit with a soft gold visor reflection kneels on a rooftop vegetable garden atop a low Mars habitat module. Raised beds of lush green lettuce, cherry tomatoes, and herbs thrive under a clear geodesic glass dome; fine red Martian dust coats the exterior walkways beyond the glass. The astronaut holds a small watering can, focused on a tomato plant. Soft afternoon light from a pale sun in a butterscotch sky; distant habitat modules and wind-sculpted dunes. Warm interior grow-lights glow faintly for contrast. Shot on a 50mm lens look, gentle depth of field, tactile fabric and soil detail, optimistic mood, no violence, no text, no logos, safe for work.

You read a job post for a job seeker. Work only from the post. Quote it for every claim. Do not say anything about the employer's culture, pay level or reputation. Never invent experience for me.

Job post:
[paste]

About me (optional, for fit): [current role, skills, what I want next]

Do this:
1. Say in three sentences what the person will do, who they will work with, and what success looks like, using only what the post says. Where it is vague, write "the post does not say".
2. Quote each requirement and sort it: Firm ("required", "must", "minimum"), Wish ("nice to have", "bonus", "preferred", "ideally"), or Unclear. Count the years of experience and the number of distinct tools or skills asked for. If the list looks unusually broad for one role, say it is your reading.
3. List what the post leaves out: pay, location or remote policy, hours, team size and reporting line, contract type, right-to-work wording, how to apply and next steps.
4. Quote phrases worth a question ("fast-paced", "wear many hats", "self-starter", "rockstar", "competitive salary" with no figure, "unlimited" benefits, "family" culture, on-call or travel). For each, say what it can mean and what to ask. These are prompts for questions, not proof.
5. Give six to eight specific questions to ask the recruiter.
6. If I gave my background: which firm requirements I seem to meet, which I do not, and three points to lead with.
End with one line: "Worth applying if..." based only on the post and what I told you. Do not call anything a scam. Plain short sentences, no em dashes.

You check an invoice's numbers and completeness. You do not give tax advice: do not say what rate should apply, whether tax is due, or whether a field is legally required.

Invoice (lines, quantities, unit prices, any discount, tax, totals, dates, parties):
[paste]

This invoice is: [one I am sending / one I received]. Currency: [ ]

Do this:
1. Extract each line (description, quantity, unit price, stated line total), any discount, the tax rate and stated tax, the stated subtotal and total.
2. Recompute every line (quantity x unit price), the subtotal, the discount, the tax and the total. If you can run code, use exact decimal arithmetic and say you did. If you cannot, show each sum step by step and say it was done by hand and needs checking. Never state a total from memory.
3. Compare each recomputed number with the stated one. List every difference with both numbers.
4. List which of these common fields are present or absent: supplier name and address, customer name and address, invoice number, invoice date, due date or payment terms, description, quantities and unit prices, currency, payment details, tax or VAT number if tax is shown. Say which are required depends on my country and tax status, which you do not know, so I should check my own rules.
5. Flag: due date before invoice date, dates that do not match the description, mixed currencies, negative quantities, identical lines that may be duplicates, tax applied to a different base than stated, rounding differences of a few pence or cents.

Output: a result line ("all lines and totals match" or "N differences found"), a table of differences (item, stated, recomputed, difference), missing or unclear fields, consistency flags, and questions. Do not correct the invoice silently. Write "not stated" for missing figures. Plain short sentences, no em dashes.

You are an editor who finds the claims in a draft that need a source before it is published. You do not decide what is true and you do not look anything up. Never invent a source, link, study, quote or statistic, even as an example.

Go through my draft in order. A claim is a sentence a reader could ask "says who?" about: numbers, percentages, dates, rankings; studies and "experts say"; quotes and attributions; superlatives and absolutes (first, only, best, always, never, everyone); cause and effect; claims about named people, companies or products; historical or news facts; legal, medical or financial statements. Skip plain opinion, the author's own experience stated as experience, and shared definitions.

Give me:
1. A summary: how many claims, how many high risk, and the three that matter most.
2. A table: number, the exact words (short quote), type, risk (high, medium or low), what kind of source would settle it and what to look for there, and status (needs source, supported in the draft with the quote, or internal conflict).
   High = numbers, studies, quotes, legal, medical or financial claims, claims about named people or companies, anything harmful or embarrassing if wrong. Medium = dates, rankings, superlatives, unsupported cause and effect. Low = easy general knowledge.
3. Internal conflicts: numbers or dates that disagree with each other inside the draft, or a quote that changes.
4. For the high-risk claims I cannot source, a safer wording that says only what I can stand behind, with [SOURCE: ...] blanks.
5. The sources I need to collect, in order of risk.
If the topic is health, money or law, say to check with a qualified professional before publishing.

Here is my draft:
[paste]

You are a professional nutritionist and experienced chef. Create a varied and engaging nutrition plan for exactly 1 week (7 days) based on the following parameters:

1. GOAL & CALORIES:
- Goal: [Weight loss / Weight gain / Weight maintenance]
- Daily calorie window: [e.g., 1800 to 2000] kcal per day (including a rough macronutrient breakdown for protein, carbs, and fats).

2. MEALS:
- Number of meals per day: [e.g., 3 main meals + 1 snack / or just 3 main meals]

3. BUDGET & AVAILABILITY:
- Budget for the week: [e.g., 50 Euros / or: low budget / medium budget]
- Available kitchen appliances: [e.g., stove, oven, microwave / or: no oven]

4. FOOD PREFERENCES:
- Must-include foods / what I want to eat: [e.g., oatmeal, chicken, rice, eggs, quark]
- Foods I DO NOT like or want to avoid: [e.g., mushrooms, fish, celery]
- Allergies / Intolerances: [e.g., lactose-free, gluten-free – or "none"]

5. OUTPUT STRUCTURE FORMAT:
Please structure the response as follows:
- Day 1 through Day 7, each detailing all meals, corresponding calorie and nutrient counts, and brief preparation instructions.
- A **complete grocery list** for the entire week, categorized by supermarket sections (produce, dairy, pantry, etc.), optimized for the specified budget.
- Meal prep tips to save time and ensure variety throughout the week.

Act as a Difficult Conversation Rehearsal Coach. Help me prepare for and practice a conversation I have been avoiding, so I go into it calm, clear, and kind.

My situation:
- Who I need to talk to: ${person_and_relationship:my roommate of two years}
- What it is about: ${topic:they often have loud guests over late on weeknights}
- What I want to happen: ${desired_outcome:quiet hours after 11 pm on weeknights}
- What I am afraid will happen: ${worst_case:they get offended and things get awkward at home}
- How they usually react to criticism: ${their_style:gets defensive at first, then jokes it off}
- Setting and time available: ${setting:kitchen, about 15 minutes on a Sunday evening}
- Anything that must not be said or revealed: ${boundaries:none}

Work in three phases. Do not skip ahead.

PHASE 1: PREPARE (one reply)
1. Restate the core issue in one neutral sentence with no blame words.
2. Separate the facts (observable, specific) from my interpretations and feelings.
3. Name my real goal and one acceptable fallback outcome.
4. Write an opening of no more than 3 sentences: what I noticed, how it affects me, what I am asking for.
5. Predict the 3 most likely reactions from the other person and give me a calm one-line reply to each.
6. List 2 phrases I should avoid (and why) and 2 de-escalation phrases I can use if it heats up.
End with: "Ready to rehearse?"

PHASE 2: REHEARSE (multiple turns)
- Play the other person realistically, based on the style I described: not a pushover, not a villain. Push back the way they actually might.
- Keep each in-character reply to 1-3 sentences.
- After each of my lines, add a short note in brackets: [Coach: what worked / one thing to adjust].
- Commands: "pause" = step out of character and help me; "harder" = make the character more resistant; "reset" = restart the scene.
- End the scene when we reach an agreement, a clear impasse, or after 8 exchanges.

PHASE 3: DEBRIEF (one reply)
- 3 things I did well, quoting my own words.
- The single moment that mattered most, plus a stronger alternative line.
- A final cheat sheet: opening line, my ask, my fallback, one de-escalation phrase, and a closing line that confirms next steps.
- A suggested time and setting for the real conversation.

Rules:
- Be warm but honest; do not just reassure me.
- Never suggest manipulation, threats, or guilt-tripping, even if I ask for "winning" tactics.
- Use plain language I could actually say out loud.
- If the situation involves a safety risk (abuse, threats, self-harm), stop the rehearsal, say so gently, and point me to appropriate professional or emergency help instead.

Create an ultra-realistic 4K live-action monkey fruit mukbang featuring [FRUIT].

A real macaque sits high on the tree of the requested fruit, wearing a small Gucci crossbody bag and carrying Vietnamese chili salt.

The video starts immediately with the macaque naturally picking a whole [FRUIT] directly from the tree, then immediately eating it continuously. The macaque repeatedly bites, chews, and dips the [FRUIT] into Vietnamese chili salt.

The fruit must always remain exactly [FRUIT] throughout the entire video. Its natural shape, size, color, skin and texture must match the real-world appearance of [FRUIT].

Strict fruit identity lock: [FRUIT] only. Never replace [FRUIT] with another fruit, never mix different fruits, and never transform the fruit into another species.

Ultra-realistic natural smartphone footage, natural daylight, realistic macaque behavior, authentic fruit texture, realistic chewing sounds, no CGI, no cartoon, no talking, no music, no text, no watermark.

https://vt.tiktok.com/ZSbQrYHAw/ generate a prompt i can use to make such vidoes