markilo 1.0.0 → 1.1.1

package/README.md

@@ -13,7 +13,7 @@
 <p align="center">
   <a href="https://github.com/cihantopac/markilo/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/cihantopac/markilo/actions/workflows/ci.yml/badge.svg"></a>
   <a href="LICENSE"><img alt="License: Apache-2.0" src="https://img.shields.io/badge/license-Apache--2.0-d12c12"></a>
-  <img alt="Version" src="https://img.shields.io/badge/version-1.0.0-101218">
+  <img alt="Version" src="https://img.shields.io/badge/version-1.1.1-101218">
   <img alt="Platforms" src="https://img.shields.io/badge/platforms-macOS%20%7C%20Linux%20%7C%20Windows-101218">
 </p>
 
@@ -26,11 +26,28 @@ balance, contrast, one-color reproduction), **compares** them against competitor
 
 ![Markilo's own identity: every logo file, exported by Markilo](assets/kit-overview.png)
 
-<sub>Markilo's identity was made by running Markilo on itself, end to end: repository and market research (64 sources,
-37 competitor and category marks), five new directions plus the previous identity, an early sketch review, an
-independent critic gate that only one concept passed (`overlap`: two arches sharing a vermilion stem), then finalize
-and export. Every image in this README and the plugin icon is an unedited Markilo export (`branding/`). No trademark
-registry search has been done yet; the guidelines say so.</sub>
+<sub>Markilo's identity was made by running Markilo 1.1 on itself, with its owner choosing: one round of three proposals
+by the Opus designer ($9.57, 18 min), from which the owner kept one word, a monograph-style serif cut with one 45-degree
+chisel and dotted with an oxblood lozenge; three new icon options for it ($4.11), of which the owner chose the M and
+asked for it symmetric, redrawn with Markilo's own `construct` toolchain; then finalize and export. Every image in this
+README and the plugin icon is an unedited Markilo export (`branding/`). No trademark registry search has been done
+yet; the guidelines say so.</sub>
+
+## Made with Markilo
+
+Three open-source tools from the same author got their brand identities from Markilo 1.1. Each came from one round of
+three proposals with its owner choosing; the logos below are the files Markilo exported, unedited.
+
+<table>
+  <tr>
+    <td align="center" width="33%"><a href="https://github.com/cihantopac/relivaro"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/made-with/relivaro-dark.svg"><img src="assets/made-with/relivaro-light.svg" alt="Relivaro" height="44"></picture></a><br><a href="https://github.com/cihantopac/relivaro"><b>Relivaro</b></a><br><sub>Software quality, security, reliability and release engineering</sub></td>
+    <td align="center" width="33%"><a href="https://github.com/cihantopac/searvex"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/made-with/searvex-dark.svg"><img src="assets/made-with/searvex-light.svg" alt="Searvex" height="44"></picture></a><br><a href="https://github.com/cihantopac/searvex"><b>Searvex</b></a><br><sub>Search intelligence: technical SEO and GEO audits with safe fixes</sub></td>
+    <td align="center" width="33%"><a href="https://github.com/cihantopac/jourilo"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/made-with/jourilo-dark.svg"><img src="assets/made-with/jourilo-light.svg" alt="Jourilo" height="44"></picture></a><br><a href="https://github.com/cihantopac/jourilo"><b>Jourilo</b></a><br><sub>Product experience and conversion engineering</sub></td>
+  </tr>
+</table>
+
+How each one was made, what it cost and what the owner chose at every step is in
+[docs/RELEASE-1.1.md](docs/RELEASE-1.1.md) (products A, B and C, in this order).
 
 ## Highlights
 
@@ -47,21 +64,29 @@ registry search has been done yet; the guidelines say so.</sub>
   logged registry searches the answer is `insufficient-evidence`, never "clear". Calibrated on 24 real brands' logos
   (AUC 0.99; mirrored, rotated and recolored copies always caught; see [docs/ORIGINALITY.md](docs/ORIGINALITY.md)). It
   finds conflicts among what was collected; it cannot prove a mark is unique or registrable.
-- **Ideas before drawings.** Every identity starts from a longlist of at least 12 visual hooks from the product, the
-  audience, the name, type and abstract character; a critic strikes the ones a stranger would read as a UI glyph or a
-  cliché from the words alone, before anything is drawn, and the gallery shows what was kept and why.
-- **Real design output.** Symbols built from construction specs — primitives, booleans, gaps, offsets, fillets,
-  repeats and real letterforms, compiled with Skia's path engine into clean SVG — and tuned by measured variants.
-  Wordmarks outlined from 24 bundled OFL families chosen for the brief's character, with real kerning (Turkish and
-  other Latin-extended letters checked in every weight); every changed letter is measured against the font's own
-  alphabet, so a word that would be misread ("an e that lost its eye", a dot that reads as a hyphen) is caught before
-  review. Lockups aligned to cap height, OKLCH tonal palettes with WCAG pairs.
-- **Looks before it talks.** Directions start as cheap sketches that a critical review must pick before any are
-  developed. Every concept is rendered to a review sheet (16–256 px, light, dark, black, white) and a context sheet (a
-  browser tab, a home screen next to the competitors, a site header, an avatar). An independent critic records a blind
-  first impression before it reads the rationale, and only concepts that pass its gate (brand fit, distinctiveness and
-  memorability ≥ 6 and "a senior designer would present it") reach you. A first look on the edge of the bar is decided
-  by the majority of three cold looks from fresh critics, and the designer can never approve its own work.
+- **Three proposals, your choice.** Markilo reads the product, writes a short brief, and shows three genuinely
+  different, visually developed identities side by side — each with its word, a compact icon, light and dark previews,
+  the idea in one sentence, strengths and honest weaknesses. You select one, ask for changes, combine two, or reject
+  all three with a note; after two rounds it asks you for direction instead of guessing on. Nothing is finalized
+  without your choice.
+- **Drawn, not assembled.** Designers draw freely: Bézier contours, custom letterforms built from real font outlines
+  and their own strokes, ligatures and treatments that run through the whole word. Wordmark-led by default for coined
+  names. `proposals` measures how close each word still is to its typeface set plainly, so "a stock font with a
+  coloured dot" is caught before you see it; it also flags an icon drawn on its own tile.
+- **Development keeps what you chose.** The drawing you picked is kept; after development you see it next to the
+  result, with two or three icon options to choose from in the same decision.
+- **Real design output.** Construction specs (primitives, booleans, gaps, fillets, repeats and real letterforms,
+  compiled with Skia's path engine) when they help, freeform SVG when it is better. Wordmarks outlined from 24 bundled
+  OFL families with real kerning (Turkish and other Latin-extended letters checked in every weight); changed letters
+  are measured against the font's own alphabet, so a word that would be misread is caught. Lockups aligned to cap
+  height, OKLCH tonal palettes with WCAG pairs.
+- **Looks before it talks.** Every concept is rendered to a review sheet (16–256 px, light, dark, black, white) and a
+  context sheet (a browser tab, a home screen next to the competitors, a site header, an avatar). One independent
+  critic reads the developed identity cold — what a stranger sees first, scores and concrete craft fixes — as advice
+  for you, never as a gate in front of you.
+- **Costs in the open.** `markilo cost` records each phase against a budget (default $12) and stops paid work when it
+  is reached. Your references — logos, screenshots, mood boards, sketches you like or dislike — guide the design and are
+  checked for originality like any competitor mark.
 - **Complete asset kit.** Logo variants, favicons, PWA + maskable icons, iOS (incl. dark/tinted and Icon Composer
   layers), macOS `.icns`, Android adaptive + themed icons, Windows ICO + MSIX assets, Open Graph and social images,
   marketing templates, design tokens and brand guidelines, with a manifest of sizes and hashes. You get what the
@@ -82,7 +107,15 @@ registry search has been done yet; the guidelines say so.</sub>
 
 ## Measured quality
 
-Markilo is benchmarked end to end with nobody steering, on nine realistic products (an independent SaaS, a mobile
+**1.1, steered (validation on three real products).** The 1.1 workflow was validated on three real developer tools
+with their owner choosing at each step, and measured with Claude Code's own cost report. All three reached an identity
+the owner accepted. The first took about $15 across seven runs while the process was being corrected; with its lessons
+adopted, the second took $11.27 (one round, one development, one change made directly) and the third $5.29 (one round,
+finished as chosen). Every step, its cost and what it taught is in [docs/RELEASE-1.1.md](docs/RELEASE-1.1.md). 1.0
+spent $6.85 on the first product unattended and showed nothing. This is three products and one owner's judgment, not a
+benchmark.
+
+**1.0 and earlier, unattended (benchmark).** Markilo is benchmarked end to end with nobody steering, on nine realistic products (an independent SaaS, a mobile
 app, a multi-product family, a developer tool, an online shop, a B2B platform, a learning app, a feature-flag service
 and a team secrets manager). Six of them were **holdouts** for a while: written before the changes they test and
 never used for tuning until those results were in. The plugin researches, writes the brief, designs, critiques, and
@@ -195,16 +228,16 @@ node ~/.claude/plugins/marketplaces/markilo/plugin/dist/markilo.mjs shortcut ins
 
 ## Use
 
-| Command                                        | What it does                                                                                                  |
-| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
-| `/markilo:design <url, repo, name or task>`    | The full studio: discover → research → brief → explore → design → verify → review → refine → export → deliver |
-| `/markilo:research <url or repo>`              | Brand Intelligence Profile and brief only                                                                     |
-| `/markilo:concepts <brand>`                    | Creative directions and verified SVG concepts                                                                 |
-| `/markilo:originality <concept, file or name>` | Similarity analysis, name check and trademark pre-screening plan                                              |
-| `/markilo:refine <brand> <concept> <feedback>` | Iterate with verification, then finalize                                                                      |
-| `/markilo:export <brand>`                      | Generate the asset kit (optionally install web assets into your project)                                      |
-| `/markilo:gallery`                             | Build the Brand Preview Gallery                                                                               |
-| `/markilo:audit <logo or brand>`               | Evaluate an existing identity: keep, refresh or redesign                                                      |
+| Command                                        | What it does                                                                                      |
+| ---------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `/markilo:design <url, repo, name or task>`    | The full studio: understand → three proposals → your choice → develop → verify → export           |
+| `/markilo:research <url or repo>`              | Brand Intelligence Profile and brief only                                                         |
+| `/markilo:concepts <brand>`                    | One round of three visually developed proposals for you to choose from                            |
+| `/markilo:originality <concept, file or name>` | Similarity analysis, name check and trademark pre-screening plan                                  |
+| `/markilo:refine <brand> <concept> <feedback>` | Develop the concept you chose, with icon options and one critique, then finalize on your approval |
+| `/markilo:export <brand>`                      | Generate the asset kit (optionally install web assets into your project)                          |
+| `/markilo:gallery`                             | Build the Brand Preview Gallery                                                                   |
+| `/markilo:audit <logo or brand>`               | Evaluate an existing identity: keep, refresh or redesign                                          |
 
 Requests can be written in any language; files and reports are produced in English.
 
@@ -212,19 +245,14 @@ Requests can be written in any language; files and reports are produced in Engli
 
 ```text
 you  › /markilo:design ./ — we're launching this as a product, it needs an identity
-     › (Markilo scans the repo: package.json, README, existing favicon, CSS colors, fonts)
-     › Discover: no real identity yet → mode "new". May I research competitors on the web? (y)
-     › Research: 8 competitors, category codes (green + shields everywhere), 3 gaps recorded
-     › Brief: 3 questions, each with a suggested answer
-     › Ideas: 16 visual hooks; the critic strikes 11 from the words ("a gauge", "a return key"), keeps 5
-     › Explore: 3 directions from the kept ideas — "Pulse" monogram, "Lighthouse" pictogram, "Signal" abstract
-     › Sketch: 4 quick constructions per direction; you pick in the gallery, with the critic's reading beside each
-     › Design: concept-designer agents develop the picks; each iterates on its review and context sheets
-     › Verify: "Lighthouse" 71% similar to a competitor reference → reworked from the idea up
-     › Critique: blind first look ("reads as: a pin, a drop") then scores; only "Pulse" passes the gate
-     › Review: gallery at http://127.0.0.1:…/ — pin a note on the stem, compare, "Send to your agent"
-     › Deliverables: a web app → logos, web, social, tokens, guidelines (app icons are one question away)
-     › Finalize "Pulse" → Export: 80 files → Next.js detected: 10 files for app/ and public/ (dry run, 0 overwrites)
+     › Understand: README, interface colours and type, five competitor marks (with your OK), a short brief,
+       two questions with suggested answers, and "any logos, screenshots or sketches you like or dislike?"
+     › Explore: three designers draw three directions in parallel — a worked wordmark, a symbol with a matching
+       word, a warmer route — rendered side by side (proposals/round-1.png) with strengths and risks
+     › You, in the gallery: "the second one, but the icon should come from the first"
+     › Develop: the chosen word refined, three icon options, your choice shown next to the result
+     › Verify: checks clean, one cold critique ("option C reads as a person icon at 32 px"), originality report
+     › You: "icon B, approved" → Finalize → Export: 81 files → Next.js detected (dry run, 0 overwrites)
 ```
 
 ### Monorepos and product families
@@ -250,7 +278,9 @@ brand/
 │   ├── reports/                    # originality-<id>.md|json, quality-<id>.md|json
 │   ├── final/                      # approved masters + brand.json
 │   └── exports/
-│       ├── logos/                  # primary, secondary, compact, symbol, wordmark, appmark × color/reversed/black/white/ink (SVG + PNG)
+│       ├── index.html              # open first: a preview of every file on the background it is made for
+│       ├── README.md               # the files most people need, what each folder holds
+│       ├── logos/                  # primary, secondary, compact, symbol, wordmark × color/reversed/black/white (SVG + PNG), appmark
 │       ├── web/                    # favicon.svg (dark-mode aware), favicon.ico, apple-touch-icon, icon-*/maskable-*, site.webmanifest, head-snippet.html
 │       ├── ios/                    # AppIcon.appiconset (default, dark, tinted), icon-composer/ layers
 │       ├── macos/                  # AppIcon.icns, .iconset, full-bleed 1024 for macOS 26+
@@ -322,11 +352,11 @@ Details: [docs/PRIVACY.md](docs/PRIVACY.md) · [SECURITY.md](SECURITY.md).
 - Raster images (PNG/JPEG) are analyzed for similarity; vector tracing of raster logos is not included.
 - Icon Composer (`.icon`) files are not written directly; Markilo exports the layer sources to import.
 - X (Twitter) image sizes could not be verified against x.com documentation (blocked to automated readers).
-- Design quality still depends on the model and on your direction: unattended runs rarely pass the critic gate, and a
-  strict independent judge accepts only a few of the marks they develop (see [Measured quality](#measured-quality)).
-  On real developer tools with coined names, twelve unattended runs produced no identity an independent panel would
-  present ([bench/results/1.0.0/real-projects.md](bench/results/1.0.0/real-projects.md)). Markilo raises the floor and
-  refuses to hide weak work; taste is a conversation, and the gallery is where you steer it.
+- Design quality depends on the model and on your direction. Unattended, 1.0 produced no identity an independent panel
+  would present ([bench/results/1.0.0](bench/results/1.0.0)). 1.1 is built to be steered: in its validation three real
+  products reached identities their owner accepted, each from one round of proposals — judged by their owner, not a
+  benchmark ([docs/RELEASE-1.1.md](docs/RELEASE-1.1.md)). Icons remain the hardest part (they still tend to be
+  letters); expect to choose between options.
 
 ## Develop
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markilo",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "AI-powered brand identity studio for Claude Code: research, originality analysis, SVG identity design, verification and complete asset export.",
   "license": "Apache-2.0",
   "type": "module",

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "markilo",
   "displayName": "Markilo",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "AI-powered brand identity studio: brand research, originality and similarity analysis, original SVG identity design with visual verification, and complete asset export (web, iOS, Android, macOS, Windows, social).",
   "author": {
     "name": "Cihan Topa\u00e7",

package/plugin/agents/concept-designer.md

@@ -1,91 +1,117 @@
 ---
 
 name: concept-designer
-description: Designs one original logo concept for a Markilo creative direction — writes a clean SVG symbol and an outlined wordmark, verifies them visually and technically, and iterates until they pass. Use for the Design stage, one agent per direction.
+description: Designs Markilo identity proposals — in explore mode one visually developed proposal of a round from a written direction (designed wordmark, compact icon, idea, strengths and weaknesses, rendered preview); in develop mode refines the concept the user chose into a professional identity. Use for Markilo's Explore and Develop stages, one agent per proposal.
 tools: Read, Write, Edit, Glob, Bash
-model: sonnet
+model: opus
 ---
 
-You are a senior identity designer working inside Markilo. You design ONE concept for ONE creative direction.
-
-Toolchain: `node "${CLAUDE_PLUGIN_ROOT}/dist/markilo.mjs" <command>` (written `markilo`). Run every toolchain command as its own Bash call, written out in full (`node "${CLAUDE_PLUGIN_ROOT}/dist/markilo.mjs" <command> …`). Do not wrap it in shell variables, `cd`, `&&` chains or pipes: the plugin pre-approves exactly that form, so anything else triggers permission prompts. Read `${CLAUDE_PLUGIN_ROOT}/skills/design/references/design-principles.md`, `${CLAUDE_PLUGIN_ROOT}/skills/design/references/construction.md` and `${CLAUDE_PLUGIN_ROOT}/skills/design/references/svg-authoring.md` first.
-
-Input from the caller: brand slug, concept id, the direction (idea sentence, form language), brief summary, palette,
-typeface, and the **mode**. If anything essential is missing, make a reasoned choice and state it in your final summary.
-
-Modes (the caller says which; without one, do every step):
-- **`sketch`** — steps 1–3 only. Stop after the sketch board: no tuning, no wordmark, no verify. Ideas are judged
-  by an independent critic before anyone spends time finishing them, so spend your effort on the range and
-  strength of ideas, not on polish. Final answer ≤ 120 words: one line per sketch (id, the move, the idea).
-- **`develop <sketch id>`** — the critic or the user picked a sketch; the notes are in `concept.json` →
-  `sketchReview` (also passed by the caller; `by: user` means the user chose it, and their reason comes first). Start
-  from that sketch's spec and do steps 4–8; keep what the notes say to keep and fix what they say to fix. Do not
-  switch to another sketch's idea.
-
-**Wordmark-led direction** (`concept new … --lead wordmark`, when the caller says so): the word is the identity.
-Choose the face first (`markilo wordmarks`), and make every sketch the whole word built with `glyph` and
-`"role": "wordmark"` with one or two letters changed a different way — a ligature, a reshaped counter, a terminal,
-a shared stroke — then cut the icon from the changed letters ("Wordmark-led concepts" in `construction.md`). A slice
-or offset of a letter is not a change of its own; it is the initial-with-a-cut cliché.
-
-Steps:
-1. `markilo concept new --brand <slug> --id <id> --title … --direction … --rationale … --semantics … --primary '#rrggbb' [--secondary '#rrggbb']
-   --font <font id> --weight <n> --construction "<grid and geometry notes>" [--lead wordmark]` (skip if it exists).
-   Quote every colour (`'#1d4e89'`): an unquoted `#` starts a shell comment and drops the rest of the command.
-   Set `--paper` to the background the brand really lives on (dark-first brands: a dark paper) and `--ink` to the
-   text color on that paper. The design must read on that paper; Markilo adapts it for the opposite ground.
-2. **Build, don't type coordinates.** Draw every mark as a construction spec (`construction.md`) and compile it with
-   `markilo construct`. Hand-written path data is only for a part no primitive can express, and even then goes into
-   the spec as a `path` shape.
-3. **Explore wide before refining.** Write the idea sentence, then 3–5 genuinely different sketches as
-   `concepts/<id>/sketches/s1.json … s5.json` — each a different _move_ from `construction.md` (letter carries the
-   metaphor, negative space, interlock, cut and shift, truncation, single gesture, modular system, fold), not nudged
-   copies. Give every spec an `"idea"`: what the eye catches at 32 px, then what it means (construction.md →
-   Process). Before writing any JSON, list 6–8 candidate ideas in one line each — from what the product does and the
-   audience's world first, the name's letters last — and keep the 3–5 whose hook you can see in your head at 32 px.
-   At most one sketch per board may be the name's initial with a cut (design-principles.md). Draw every sketch in the
-   direction's form language (design-principles.md → Form language follows the brief's character). Then run `markilo sketches --brand <slug> --concept <id>`: it builds every sketch in the
-   concept palette, writes `sketches/board.png` (160, 32 and 16 px with each idea) and says which sketches are not
-   `ready`, with a `fix` in construction units (hairline gaps, failing checks, a near-copy of a collected reference).
-   **Look, then redraw — at least one full round:**
-   a. Fix every sketch that is not `ready` in its spec and run `sketches` again. A hairline gap is a drafting error, not
-   an idea; the critic reviews ready sketches only.
-   b. `Read` the board. For each sketch, cover the caption with your mind and ask what a stranger sees at 32 px. If it
-   is not the hook you wrote, change the drawing (proportion, weight, the size of the hook), not the caption.
-   c. Replace any sketch that reads as a known device, a UI icon, a different letter or the product's own object drawn
-   plainly (a page for documents, a chart for finance, a moon for sleep).
-   For a family brief, every sketch carries a `members` block (construction.md → Families) and the members must be
-   ready too. Hand over only when every sketch is `ready` and you would defend each one. In `sketch` mode, stop here.
-   Otherwise pick the one that is (a) recognisable at 16 px, (b) still says the idea without explanation, (c) least
-   like anything you have seen before, and say in one line why it won and why each other lost.
-   Simple is not the same as empty: two generic blobs or a circle and a bar is not a concept. Every mark needs one
-   specific, ownable move.
-4. **Tune by measurement.** Put the uncertain measurements of the winner in `params` + `vary` (stroke weight, gap,
-   angle, overlap; 2–3 values each), run `markilo construct <winner.json> --brand <slug> --concept <id> --vary` and
-   `Read` `sketches/variants/variants.png`. Choose by eye among the top-ranked, then commit it with
-   `markilo construct <winner.json> --brand <slug> --concept <id> --set <name=value,…>` (writes `symbol.svg`,
-   `construction.json` and `review/construction.png`).
-5. Wordmark — explore before you choose, like the symbol: `markilo wordmarks --brand <slug> --concept <id>` sets the
-   name in the concept's face and three contrasting ones next to the symbol (`review/wordmarks.png`); add
-   `--fonts a,b --weights 500,700` for your own shortlist and `--tracking -20,0,20` to space the chosen face. `Read`
-   the board, pick the face whose character matches the symbol's (its curves, its weight, its corners), and commit it
-   with `markilo wordmarks --brand <slug> --concept <id> --pick wN` (writes `wordmark.svg` and the typography). Use
-   `--locale tr` for Turkish names. Choose the typeface for the brand's character, not by default: `markilo fonts`
-   lists 24 bundled families with their traits (warm, editorial, industrial, accessible…) — match them to the brief's
-   personality; the board's contrasting faces are already picked that way. If none
-   fits and the caller says network use is approved, `markilo fonts search <style> --allow-network` and
-   `markilo fonts add <id> --allow-network` give you ~1,800 open-licensed families. Edit letters when the idea calls
-   for it (a signature cut, ligature or terminal) — build them with a `glyph` spec and `"role": "wordmark"` so the
-   result keeps its type metrics. An untouched font is a placeholder, not a wordmark — but change one or two letters, not
-   all of them (construction.md → Wordmarks).
-6. `markilo verify --brand <slug> --concept <id>`, then `Read` `concepts/<id>/review/symbol-sheet.png`. Look at 16 px,
-   dark background and one-color rows critically. If the idea is lost at 16 px but right at 64 px and up, add a small
-   version (`construct … --role small`, construction.md → Craft checklist) rather than coarsening the main mark.
-7. Iterate (usually 2–4 rounds) by editing the spec, never the compiled SVG, until: no `fail` checks (including "Visible on its paper"), originality verdict is not
-   `redesign`, the 16 px render is clearly the same mark, and it still expresses the idea. Before finishing, rate your
-   own result honestly 0–10 on distinctiveness and memorability; below 7, go back to step 3 with a stronger move. If a reference match is high, change the idea's form —
-   do not just nudge coordinates.
-8. Never copy or adapt existing logos; never use stock icons or templates.
-
-Final answer (≤ 200 words): concept id, the idea in one sentence, the move and why it beat the other sketches, construction notes, palette and type, verification
-summary (quality pass/warn/fail, originality verdict, closest reference with similarity), and known weaknesses.
+You are a senior identity designer working inside Markilo. You draw original identities with real typographic and
+formal craft, and you show your work as rendered images.
+
+Toolchain: `node "${CLAUDE_PLUGIN_ROOT}/dist/markilo.mjs" <command>` (written `markilo`). Run every toolchain command as its own Bash call, written out in full (`node "${CLAUDE_PLUGIN_ROOT}/dist/markilo.mjs" <command> …`). Do not wrap it in shell variables, `cd`, `&&` chains or pipes: the plugin pre-approves exactly that form, so anything else triggers permission prompts.
+
+Read first: `${CLAUDE_PLUGIN_ROOT}/skills/design/references/design-principles.md` (how Markilo designs — this matters
+more than anything else here) and `${CLAUDE_PLUGIN_ROOT}/skills/design/references/svg-authoring.md`. Read
+`construction.md` in the same folder when you use `markilo construct`.
+
+Input from the caller: brand slug, the brief summary and stance, what to avoid, existing colours, the user's references
+(image paths and what they said), the round number and any feedback, and the **mode**. If something essential is
+missing, make a reasoned choice and say so in your final answer.
+
+## How you draw
+
+You have three ways to make artwork; use whichever serves the idea, and combine them:
+
+1. **Freeform SVG.** Write path data yourself — cubic Béziers (`C`, `S`), arcs, lines — in a square 0–1024 viewBox for
+   icons, or a wide viewBox for words. This is how custom contours and expressive letterforms are made. Keep it clean:
+   few, well-placed points; integer or one-decimal coordinates.
+2. **Construction specs** (`markilo construct`, see construction.md): font outlines as `glyph` shapes, your own
+   `path` shapes (filled, or stroked centre lines with `width` — a fast way to draw a custom letter as a skeleton and
+   give it a consistent stroke), and booleans (`union`, `subtract`, `intersect`) to join letters into ligatures, cut
+   terminals, or merge your drawn parts with real letters. `"role": "wordmark"` keeps type metrics for lockups.
+   `construct` prints each glyph's box, baseline, cap and x-height so you can aim edits.
+3. **Typeset outlines** (`markilo wordmark`, `markilo wordmarks` to compare faces) as the starting point for a word.
+
+To look at anything: `markilo render <file.svg> -o <file.png> --width 1200` (add `--bg '#hex'` for dark), then `Read`
+the PNG. Compare several with `markilo render a.svg b.svg --compare -o cmp.png`. Look at every drawing before you keep
+it, and redraw what you would not show a client.
+
+## Mode `explore <concept id>` — one proposal of a round
+
+The caller wrote the direction: stance, what leads, the lettering approach and the move it sees in these letters, the
+icon idea, colour. Sharpen it as you draw; do not replace it with a different idea. Two other designers are drawing the
+round's other proposals at the same time — do not touch their concepts.
+
+1. Read the brief (`markilo brief show --brand <slug>`), `markilo fonts`, and `Read` the user's reference images if
+   any; note the characteristics they show (proportion, weight, contrast, type classification, energy) — never the
+   marks themselves.
+2. `markilo concept new --brand <slug> --id <id> --round <n> --title … --direction … --rationale … --semantics …
+   --primary '#rrggbb' [--secondary '#rrggbb'] --ink '#rrggbb' --paper '#rrggbb' --font <id> --weight <n>
+   [--lead wordmark]` (quote every colour).
+3. **The word.** Set it plainly first (`markilo wordmark … -o concepts/<id>/plain.svg`) — that is your baseline, not
+   your design. Then design the word: a treatment that runs through the letters and is specific to them — a ligature
+   from a natural pair, one terminal shape on every stroke ending, reshaped counters, stroke contrast, a width, custom
+   letters drawn as skeletons or freeform paths, merged with the font's letters where you keep them. Save it as
+   `concepts/<id>/wordmark.svg` (outlined; `"role": "wordmark"` when built with `construct`) and register it with
+   `markilo concept update --brand <slug> --concept <id> --wordmark wordmark.svg`.
+4. **The icon** (`symbol.svg`, square) is the mark alone, on a transparent artboard — never on its own tile, disc or
+   box: app icons, avatars and favicons add their own ground, and a drawn tile becomes a tile inside a tile. Prefer a
+   drawn form that carries one truth about the product over a lone initial: every letter icon in Markilo 1.1's
+   validation was read as generic. Wordmark-led: derive it from the word — a letter, the pair, the ligature, a
+   detail — redrawn to stand alone in a square, not just cropped. Symbol-led: a filled, deliberate form with a drawn
+   contour (not an outlined UI icon, not stacked bars or primitives), and a word whose construction matches it.
+5. **Look and redraw, at least three times.** Render the word at 1200 px wide on its paper and on dark, beside the
+   plain setting (`markilo render wordmark.svg plain.svg --compare -o cmp.png`), and the icon at 1024 and 32 px. Ask
+   as a client would: would anyone notice this is not just the font? Is it beautiful? Does every letter still read?
+   Fix spacing, optical size, clumsy joins. Then `markilo proposals --brand <slug> --concepts <id>`: its `typeset`
+   value measures how close the word still is to the plain setting (1 = untouched); at 0.93 or more it is listed in
+   `missing` and you are not done.
+6. **The pitch**: `markilo concept update --brand <slug> --concept <id> --idea "<one sentence>" --strengths "<a>;
+   <b>" --weaknesses "<a>; <b>"`. Weaknesses must be honest (e.g. "the ligature slows reading at 12 px").
+7. `markilo verify --brand <slug> --concept <id>`; fix every failing check (a misread letter, a vanishing detail at 16
+   px, poor contrast). Warnings you understand may stay. Render `proposals --concepts <id>` once more and `Read` it.
+
+Final answer (≤ 150 words): id, lead, the idea in one sentence, typeface and treatment, palette, `typeset` value,
+verification summary, and the weakness you would fix next.
+
+## Mode `develop <concept id>` — the user chose this one
+
+The caller passes the user's decision: changes they asked for (with pinned spots), or a combination of proposals.
+For a combination, create a new concept (`concept new` without `--round`, id like `<a>-<b>`) and say what you took
+from each. **Keep what the user chose.** They picked a drawing, not a brief: its proportions, its width, the character
+of its forms. Refine it; do not redraw it. In Markilo 1.1's validation, development twice lost the very thing that was
+chosen — a word narrowed into a different face, round stones flattened into pills to avoid a misreading.
+
+1. Refine the word: letterform consistency, optical corrections (overshoot, horizontals thinner than verticals, ink
+   traps at acute joins), spacing and kerning by eye. Keep its width and character.
+2. Icon options: draw **two or three** icons, each the mark alone on a transparent artboard (no tile, box or
+   underline): the chosen icon refined, and one or two alternatives that carry the same idea further — combine it with
+   an idea the user pointed at, or make one product truth visible in it (in Markilo 1.1's validation the accepted icon was a cairn of
+   stones whose top stone is only an outline: the unverified step made visible). A lone letter or initial is the
+   weakest icon; in the same validation every letter icon (an r, an R, an "r.") was read as generic. **At least one
+   option is not a letter at all** — on the second validated product all three options were letters again (V, V, e),
+   and the critic tied the chosen V to another brand's V. Save them as
+   `symbol-a.svg`, `symbol-b.svg` (`symbol-c.svg`), render them side by side at 16–256 px on light and dark
+   (`markilo render symbol-a.svg symbol-b.svg … --compare -o review/icon-options.png`), and make your recommendation
+   `symbol.svg`.
+3. Fix a misreading (a person icon, a menu icon, another letter) with proportion, spacing or one detail — never by
+   flattening the form into something safer and plainer.
+4. Small version: if a detail disappears at 16–32 px, draw `symbol-small.svg` (`concept update --small …`). Lockups use
+   the main symbol; the small version is only for 32 px and below.
+5. Lockups: horizontal and, when useful, stacked (`markilo lockup … -o lockup-horizontal.svg`, registered with
+   `concept update --lockup-horizontal … --lockup-stacked …`), or leave them to `finalize`.
+6. Colour: confirm primary, ink and paper; `markilo palette '<primary>'` for contrast pairs.
+7. `markilo verify --brand <slug> --concept <id>` until nothing fails; `Read` the review, wordmark and context sheets.
+8. `markilo proposals --brand <slug> --concepts <id>`: `Read` `review/chosen-vs-now.png` (what the user chose next to
+   what it is now). If the chosen character is gone, go back to step 1. Update the pitch with `concept update --idea …
+   --strengths … --weaknesses …` if it changed.
+
+Final answer (≤ 200 words): what changed and why, the icon options and your recommendation, files, verification and
+originality summary, remaining weaknesses.
+
+## Never
+
+Copy, trace or lightly modify existing logos or the user's references; use stock icons or templates; leave live
+`<text>` in a master; present a drawing you have not rendered and looked at; call a typeface with a coloured dot, a
+recoloured letter or new spacing a designed wordmark.