@event4u/agent-config 6.1.0 → 7.0.0

package/dist/agent-src/skills/image-provider-routing/SKILL.md

@@ -0,0 +1,96 @@
+---
+model_tier: inherit
+name: image-provider-routing
+description: "Select the right image-generation provider from job shape — text-in-image to Ideogram, photoreal to Flux, vector/logo to Recraft, general to Gemini/GPT."
+domain: product
+personas: []
+workspaces:
+  - small-business
+packs:
+  - ai-image
+trust:
+  level: experimental
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# image-provider-routing
+
+Route an image generation job to the right provider based on job shape. Adapters
+are scaffold-tier (dry-run only) — selection produces a plan; execution waits on
+promotion per `provider-lifecycle-discipline`.
+
+## When to use
+
+- Choosing which image model fits a brief (logo, banner, photo, icon, general art).
+- Before calling any `src/scripts/ai-image/adapters/*.sh` adapter.
+- When the user asks "which image model should I use?" or "route this image job."
+
+## Provider decision table
+
+| Job shape | Provider | Why |
+|---|---|---|
+| Text-in-image (logo, banner, typographic art) | **Ideogram** | Best glyph rendering; raster models garble text |
+| Photoreal (product shot, portrait, scene) | **Flux** | Photorealism specialist; routed via fal/Replicate |
+| Vector / SVG logo or icon | **Recraft** | Produces genuine `<path>` SVG; raster cannot |
+| General art / edit / multimodal | **Gemini-image** or **GPT Image 2** | Broad capability; natural-language prompts |
+| Budget-conscious 4K upscale | Flux via Replicate | Cost-competitive at high resolution |
+
+Decision order: text-in-image → Ideogram; must-be-vector → Recraft; photoreal → Flux;
+everything else → Gemini-image (default) or GPT Image 2 (when OpenAI key available
+and editing an existing image).
+
+## Procedure
+
+1. **Extract job shape** from the brief: does it need embedded text? vector output?
+   photorealistic rendering? or general illustration?
+2. **Apply table** — match the dominant shape to the provider row above.
+3. **Check lifecycle tier** — all adapters are `experimental` (scaffold). Surface
+   this before any live invocation.
+4. **Confirm with the user** when shape is ambiguous (e.g., logo that could be
+   vector OR raster typographic art → ask once).
+5. **Emit the routing decision** in the Output format below.
+
+## Output format
+
+1. **Chosen provider** — name + one-line rationale citing the job-shape match.
+2. **Lifecycle-tier caveat** — "adapter is experimental (scaffold tier); dry-run
+   only until a smoke trace is captured per `provider-lifecycle-discipline`."
+3. **Fallback** — if the primary adapter is unavailable or the smoke trace is
+   missing, name the next best provider and what changes.
+
+## Gotcha
+
+- **Routing a text-in-image job to a photoreal model is the #1 failure** — send a
+  logo/banner with embedded text to Flux and the text renders as garbled glyphs;
+  it must go to Ideogram. Likewise a vector logo sent to Ideogram/Flux returns a
+  raster PNG, not the editable `<path>` SVG a brand mark needs (→ Recraft).
+- All four adapters (`ideogram.sh`, `flux.sh`, `recraft.sh`, `gemini-image.sh`) are
+  **scaffold-tier** — dry-run plumbing only, no live generation yet. Routing
+  produces a selection + plan; actual API calls require promotion to `stable`
+  first (maintainer-captured smoke trace under `agents/reference/ai-image/smoke-traces/`).
+  Surfacing a provider without its `experimental` tier caveat misleads the caller
+  into expecting a rendered asset that won't come.
+
+**Good example:** "Text logo for a bakery → Ideogram (text-in-image); lifecycle:
+experimental — dry-run plan only."
+
+**Bad example:** "Use Recraft for the product photo" — Recraft is the vector path;
+photoreal jobs go to Flux.
+
+## Do NOT
+
+- Do NOT invoke an adapter without surfacing its lifecycle tier (all are `experimental`).
+- Do NOT route a text-in-image job to Flux — Flux has no glyph renderer; text garbles.
+- Do NOT route a vector/SVG job to Ideogram or Flux — neither outputs genuine `<path>` SVG.
+- Do NOT skip `image-likeness-and-rights` when the brief names a real person or brand mark.
+- Do NOT promote an adapter from `experimental` to `stable` — that is maintainer-only via smoke trace.
+
+## See also
+
+- [`prompt-engineering-image`](../prompt-engineering-image/SKILL.md) — translate the brief into provider-specific prompt grammar.
+- [`provider-lifecycle-discipline`](../../rules/provider-lifecycle-discipline.md) — read lifecycle tier before any run.
+- `src/scripts/ai-image/adapters/` — the four adapter files and their header comments.
+- [`media-governance-routing`](../../rules/media-governance-routing.md) — rights / likeness policies before generation.

package/dist/agent-src/skills/image-provider-routing/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "skill": "image-provider-routing",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers job-shape to provider matching. Should-not-trigger covers near-miss neighbors: writing the actual prompt (prompt-engineering-image), invoking the adapter directly, media policy checks (media-governance-routing), and general image editing without a routing question.",
+  "queries": [
+    {"q": "which image model should I use for a logo with text?", "trigger": true},
+    {"q": "route this image generation job — it needs a photorealistic product shot", "trigger": true},
+    {"q": "I need a vector SVG icon, what provider handles that?", "trigger": true},
+    {"q": "pick the right AI image provider for a bakery banner with the name on it", "trigger": true},
+    {"q": "should I use Ideogram or Flux for this image brief?", "trigger": true},
+    {"q": "write me an Ideogram prompt for this logo brief", "trigger": false, "note": "writing provider-specific prompt grammar → prompt-engineering-image"},
+    {"q": "run the recraft adapter with this prompt", "trigger": false, "note": "direct adapter invocation, not routing selection"},
+    {"q": "can I use a celebrity's face in this image?", "trigger": false, "note": "likeness / rights question → media-governance-routing / image-likeness-and-rights"},
+    {"q": "edit this existing photo to remove the background", "trigger": false, "note": "editing task, not a provider routing decision"},
+    {"q": "what lifecycle tier is the Flux adapter?", "trigger": false, "note": "lifecycle tier lookup → provider-lifecycle-discipline"}
+  ]
+}

package/dist/agent-src/skills/launch-readiness/SKILL.md

@@ -91,6 +91,27 @@ For each stage:
 Pre-mortem rule: every trip wire must answer *"what would have
 caused this in six hours?"* If you cannot, the trip wire is wrong.
 
+### 4b. Post-deploy verification fragments (manual checks, not an auto-canary)
+
+Right after deploy, the on-call runs these by hand — **checklist items, not an
+automated canary loop** (a real canary is a runtime, out of scope). Cheap "did
+the deploy silently break a thing that doesn't page" probes; include only those
+that apply:
+
+- **SSE / streaming heartbeat** — if the app serves SSE / a long-lived stream,
+  confirm a connection stays open + emits a heartbeat past the proxy's idle
+  timeout (a proxy/buffering config change silently kills streaming while every
+  other endpoint looks fine).
+- **Static-asset content-type drift** — fetch a built asset, assert its
+  `Content-Type` (JS as `*/javascript`, CSS as `text/css`); a CDN/build change
+  serving assets as `text/plain` breaks the browser but returns 200.
+- **LCP delta** — spot-check Largest-Contentful-Paint on the top route vs the
+  pre-deploy baseline; a regression past the agreed delta is a trip wire even
+  when no error fires.
+
+Each is a one-shot pass/fail an on-call can eyeball; failures feed the § 4 trip
+wires. Do not build a standing canary service for them.
+
 ### 5. Ops handoff
 
 - Who is paged on which alert (from **team** spine slot).

package/dist/agent-src/skills/learning-to-rule-or-skill/SKILL.md

@@ -58,6 +58,7 @@ Do not use this skill when:
 | An always-true constraint ("never X", "always Y") | **Rule** | Create/update rule |
 | A repeatable workflow with steps and validation | **Skill** | Create/update skill |
 | A coding convention or reference material | **Guideline** | Create/update guideline |
+| A reusable **fix/refactor recipe** for a specific problem (problem → before → after → verification) | **Pattern** | Create/update `src/patterns/<slug>.md` (see [`src/patterns/README.md`](../../patterns/README.md)) |
 | Baseline model knowledge or standard tool usage | **Nothing** | Do not create anything |
 | A refinement of existing guidance | **Update** | Extend the existing file |
 
@@ -67,6 +68,8 @@ Do not use this skill when:
 * One-off or too narrow → do not create anything yet
 * Standard tool knowledge (jq, docker, git basics) → **Nothing** — the model knows this
 * If unsure between skill and guideline: does it need step-by-step decisions? → Skill. Just conventions? → Guideline
+* If unsure between guideline and pattern: prose convention ("how to write code in X")? → Guideline. Keyed recipe ("problem P → recipe + verification + reliability")? → **Pattern**
+* When a related workflow fires, **surface** a matching `src/patterns/` recipe (never auto-apply) — the human decides
 
 ## Procedure
 
@@ -129,17 +132,18 @@ Choose one:
 ### 4. Check for overlap — search protocol (mandatory)
 
 A grep that returns zero hits is **not** proof of no overlap. Knowledge in
-this package is distributed across **four surfaces** — `skills/`, `rules/`,
-`docs/guidelines/`, `commands/`. Skip any of them and recall drops to ~25 %.
-Run all four steps before declaring "no overlap":
+this package is distributed across **five surfaces** — `skills/`, `rules/`,
+`docs/guidelines/`, `commands/`, `src/patterns/`. Skip any of them and recall
+drops. Run all the steps before declaring "no overlap":
 
-**Step 1 — list all four surfaces.** Directory taxonomy is free evidence:
+**Step 1 — list all five surfaces.** Directory taxonomy is free evidence:
 
 ```bash
-ls .agent-src.uncondensed/skills/ \
-   .agent-src.uncondensed/rules/ \
+ls src/skills/ \
+   src/rules/ \
    docs/guidelines/ \
-   .agent-src.uncondensed/commands/
+   dist/agent-src/commands/ \
+   src/patterns/
 ```
 
 Sub-directories matter — `docs/guidelines/php/patterns/`, `docs/guidelines/agent-infra/`,
@@ -155,7 +159,7 @@ artifact may name the *symptom*, not the cure.
 | Problem-words | `discriminator`, `enum.*match`, `switch.*on`, `if.*else.*chain` |
 
 ```bash
-grep -rl -E "<solution-words>|<problem-words>" .agent-src.uncondensed/
+grep -rl -E "<solution-words>|<problem-words>" src/ docs/guidelines/
 ```
 
 **Step 3 — taxonomy scan.** For any topic with a likely sub-folder

package/dist/agent-src/skills/lint-skills/SKILL.md

@@ -10,7 +10,7 @@ execution:
   allowed_tools: []
   command:
     - python3
-    - src/scripts/skill_linter.py
+    - src/scripts/skill_linter.ts
     - "--all"
 workspaces:
   - agent-config-maintainer
@@ -31,7 +31,7 @@ Use this skill when:
 
 Do NOT use when:
 
-- Linting only one file — call `python3 src/scripts/skill_linter.py <path>` directly
+- Linting only one file — call `./scripts-run src/scripts/skill_linter <path>` directly
 - Checking cross-references between files — use `check-refs` instead
 - Checking condensation freshness — use `bash scripts/condense.sh --check` instead
 
@@ -49,11 +49,11 @@ Invoke the skill through the runtime dispatcher so the `execution:` block in
 this skill's frontmatter governs the call:
 
 ```bash
-python3 scripts/runtime_dispatcher.py run --skill lint-skills
+./scripts-run src/scripts/runtime_dispatcher run --skill lint-skills
 ```
 
 The dispatcher resolves the request, the shell handler runs
-`python3 src/scripts/skill_linter.py --all`, captures stdout/stderr, and returns
+`python3 src/scripts/skill_linter.ts --all`, captures stdout/stderr, and returns
 a typed `ExecutionResult`.
 
 ### 3. Verify the result
@@ -86,7 +86,7 @@ Check the returned `ExecutionResult`:
 
 ## Do NOT
 
-- Do NOT invoke `src/scripts/skill_linter.py` directly when the intent is to test
+- Do NOT invoke `src/scripts/skill_linter.ts` directly when the intent is to test
   the runtime path — use the dispatcher so the handler and result object are
   exercised
 - Do NOT raise `timeout_seconds` to hide a genuinely slow linter pass —

package/dist/agent-src/skills/logo-generation/SKILL.md

@@ -0,0 +1,98 @@
+---
+model_tier: inherit
+name: logo-generation
+description: "Generate a logo or brand mark — structured prompt + provider routing, with a true-vector path via a vector-native provider or LLM-authored SVG for simple marks. Use for logo or brand mark generation."
+domain: product
+personas:
+  - design-director
+workspaces:
+  - small-business
+packs:
+  - ai-image
+trust:
+  level: experimental
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# logo-generation
+
+Generate a logo or brand mark end-to-end: capture the brand brief, choose raster
+vs. true-vector path, inject brand tokens when available, route to the right
+provider, author a provider-specific prompt, dry-run the adapter, and apply rights
+governance. All adapters are scaffold-tier (dry-run) until promoted to `stable`.
+
+## When to use
+
+- User asks to generate, create, or design a logo or brand mark.
+- End-to-end logo production (path selection + routing + prompting + governance).
+- When a simple geometric mark can be authored directly as SVG without a raster
+  model.
+
+## Procedure
+
+1. **Capture the brand brief** — extract: business name, style intent (wordmark /
+   icon mark / combination), colour palette, do/don't constraints (e.g. "no gradients",
+   "must be legible at 16 px").
+2. **Choose the path** — raster concept (text-in-mark → Ideogram for legible type)
+   vs. **true vector** (vector-native provider emitting `<path>` SVG for editable
+   marks, or LLM-authored SVG for simple geometric marks). Raster output is a
+   concept only — not a shippable logo asset.
+3. **Inject brand tokens when a brand layer is present** (`pack-brand`) — pull the
+   registered palette, typeface, and spacing tokens. When no brand layer exists,
+   use the brief's palette and type choices directly.
+4. **Route + prompt** via [`image-provider-routing`](../image-provider-routing/SKILL.md)
+   and [`prompt-engineering-image`](../prompt-engineering-image/SKILL.md) — apply
+   provider-specific grammar (text-literal first for Ideogram, `style: vector` param
+   for a vector-native provider, direct SVG authoring for simple geometric shapes).
+5. **Dry-run + validate** — invoke the adapter (scaffold-tier; returns a dry-run
+   plan). If the vector path is taken, validate that the output contains `<path>`
+   elements before treating it as an editable mark.
+6. **Rights check** — never reproduce a mark that resembles an existing trademarked
+   logo. Run [`image-likeness-and-rights`](../../rules/image-likeness-and-rights.md)
+   when the brief names a brand, references a known mark style, or targets a
+   regulated sector.
+
+## Output format
+
+1. **Chosen path** — raster concept or true vector, with rationale.
+2. **Prompt or SVG** — the prompt string ready to copy (raster/vector provider), or
+   the authored SVG markup (LLM-authored geometric mark path).
+3. **Governance note** — rights check outcome and the adapter dry-run caveat:
+   "adapter is experimental (scaffold-tier) — dry-run plan only; no rendered asset
+   until promotion per `provider-lifecycle-discipline`."
+
+## Gotcha
+
+- **Raster models cannot emit usable editable logos** — general-purpose image
+  models garble text and produce no `<path>` geometry. A PNG concept is useful
+  for direction-setting, but it is not a logo asset. Use the vector path for any
+  mark that must scale, be modified, or be handed to a designer.
+- **Scaffold-tier adapters produce plans, not pixels** — all adapters are
+  `experimental` (dry-run only). Claiming a rendered asset exists while no adapter
+  is `stable` misleads the caller.
+
+**Good example:** Brief for a wordmark → route to a vector-native provider with
+`style: vector`, validate `<path>` elements in output, note "experimental —
+dry-run plan only."
+
+**Bad example:** Routing a logo brief to a photoreal raster model and delivering the
+PNG as the final logo file.
+
+## Do NOT
+
+- Do NOT ship a raster PNG as a "logo" when an editable vector mark is needed —
+  surface the vector path and the raster-model limitation explicitly.
+- Do NOT generate a mark resembling an existing trademarked logo — run
+  `image-likeness-and-rights` when the brief references a known brand or mark.
+- Do NOT claim a live render at scaffold tier — the dry-run caveat is mandatory
+  every time.
+
+## See also
+
+- [`image-generation`](../image-generation/SKILL.md) — general-purpose image generation (non-logo briefs).
+- [`image-provider-routing`](../image-provider-routing/SKILL.md) — select the right provider before writing the prompt.
+- [`prompt-engineering-image`](../prompt-engineering-image/SKILL.md) — translate the brief into provider-specific prompt grammar.
+- [`image-likeness-and-rights`](../../rules/image-likeness-and-rights.md) — rights check before generating brand marks or likenesses.

package/dist/agent-src/skills/logo-generation/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "skill": "logo-generation",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers end-to-end logo / brand mark generation requests. Should-not-trigger covers near-miss neighbors: general image generation (image-generation), banner/social asset production (brand-asset-generation), routing-only questions (image-provider-routing), prompt-authoring-only (prompt-engineering-image), and rights checks (image-likeness-and-rights).",
+  "queries": [
+    {"q": "generate a logo for my bakery called Golden Crust", "trigger": true},
+    {"q": "create a brand mark for our SaaS startup — minimalist, dark blue, no text", "trigger": true},
+    {"q": "I need a vector SVG logo for our coffee shop", "trigger": true},
+    {"q": "design a wordmark logo for our law firm with clean sans-serif type", "trigger": true},
+    {"q": "produce a combination mark logo — icon plus company name — for our fitness app", "trigger": true},
+    {"q": "generate a hero image for our homepage", "trigger": false, "note": "general image generation → image-generation"},
+    {"q": "create a banner for our bakery's Instagram with the seasonal offer", "trigger": false, "note": "social/banner asset → brand-asset-generation"},
+    {"q": "which provider should I use for a logo with text inside?", "trigger": false, "note": "routing-only question → image-provider-routing"},
+    {"q": "write me a Recraft prompt for a minimalist geometric logo mark", "trigger": false, "note": "prompt authoring only → prompt-engineering-image"},
+    {"q": "can I use a design that looks like the Apple logo as inspiration for my mark?", "trigger": false, "note": "rights / trademark check → image-likeness-and-rights"}
+  ]
+}

package/dist/agent-src/skills/markitdown/SKILL.md

@@ -37,7 +37,7 @@ Do NOT use when:
 - **1.5-2× token reduction** on plain-text-heavy PDFs.
 - **Negative** ratio on DOCX with revision history ON or PPTX with verbose presenter notes — see § Step 3 mitigations.
 
-Measure on your own corpus before quoting numbers. The bundled measurement corpus at `tests/fixtures/markitdown-corpus/` plus `python3 scripts/measure_markitdown_lift.py` lets the consumer ground the claim locally — the script lists each fixture, computes the raw-bytes baseline, and (if `markitdown-mcp` is reachable peer-side) prints the converted-Markdown token count + ratio per format.
+Measure on your own corpus before quoting numbers. The bundled measurement corpus at `tests/fixtures/markitdown-corpus/` plus `./scripts-run src/scripts/measure_markitdown_lift` lets the consumer ground the claim locally — the script lists each fixture, computes the raw-bytes baseline, and (if `markitdown-mcp` is reachable peer-side) prints the converted-Markdown token count + ratio per format.
 
 ## Procedure: markitdown
 

package/dist/agent-src/skills/md-language-check/SKILL.md

@@ -51,7 +51,7 @@ one turn → pass them all to a single invocation.
 ### 2. Run the checker
 
 ```bash
-python3 scripts/check_md_language.py <path> [<path> …] [--format json]
+./scripts-run src/scripts/check_md_language <path> [<path> …] [--format json]
 ```
 
 Exit codes:

package/dist/agent-src/skills/motion-choreographer/SKILL.md

@@ -25,7 +25,7 @@ install:
 > environment motion, physics constraints, and — when the adapter
 > declares `audio: native` — a synchronized audio direction block.
 > Reads adapter capabilities from
-> [`adapter-contract.md`](../../../scripts/ai-video/lib/adapter-contract.md);
+> [`adapter-contract.md`](../../../scripts/media/lib/adapter-contract.md);
 > never speaks to a network API.
 
 ## When to use

package/dist/agent-src/skills/php-coder/evals/triggers.json

@@ -1,5 +1,6 @@
 {
   "skill": "php-coder",
+  "last_eval": "2026-06-16",
   "description": "5 should-trigger + 5 should-not-trigger queries. Multi-skill co-activation (e.g. php-coder alongside pest-testing on a test query) is accepted as TP where writing PHP code is a legitimate sub-task. Near-misses share PHP/Laravel vocabulary without being code-generation tasks.",
   "queries": [
     {"q": "my UserController is getting huge, split it into a service", "trigger": true},

package/dist/agent-src/skills/prediction-pool-optimizer/evals/triggers.json

@@ -1,5 +1,6 @@
 {
   "skill": "prediction-pool-optimizer",
+  "last_eval": "2026-06-16",
   "description": "9 should-trigger + 5 should-not-trigger queries. Should-trigger covers DE + EN phrasings and the core intent (pool tips, kicktipp, expected-points optimization across sports, plus answering the bonus / award questions and using bookmaker-consensus odds). Should-not-trigger covers near-miss neighbours: regulated financial advice (finance pack), plain match-result prediction with no pool, generic web research, AI video, and real-money sportsbook betting (out of scope / refuse).",
   "queries": [
     {"q": "optimize my kicktipp tips for the football WM 2026", "trigger": true},

package/dist/agent-src/skills/premortem/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: premortem
+description: "Use before committing to a heavy or irreversible plan — imagine it's 6 months later and this failed; enumerate why, score each mode, derive early-warning signals and preventive guardrails."
+source: package
+domain: quality
+model_tier: high
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+lifecycle: active
+trust:
+  level: professional
+  confidence: medium
+  human_review_required: false
+install:
+  default: false
+  removable: true
+---
+
+# premortem
+
+> Forward-looking imagined-failure analysis. Sibling of
+> [`blameless-post-mortem`](../blameless-post-mortem/SKILL.md) (which
+> analyses what actually went wrong after the fact) and
+> [`risk-officer`](../risk-officer/SKILL.md) (which scores pre-commit
+> risks per likelihood × impact). This skill adds the prospective frame:
+> "Assume total failure at horizon H — reconstruct why."
+
+## When to use
+
+Before committing to a plan that is:
+
+- Heavy to execute (multi-sprint, multi-team, or high coordination cost), or
+- Irreversible or costly to reverse (schema migration, public API change,
+  infrastructure restructure, major dependency swap, architecture decision).
+
+Trigger phrasing: "premortem this", "what if this fails?", "imagine it's 6
+months later and this shipped badly", "help me stress-test this plan".
+
+Do NOT use when:
+
+- The failure is already evidenced — root cause is known → use
+  [`systematic-debugging`](../systematic-debugging/SKILL.md).
+- Analysing something that already failed in the past →
+  use [`blameless-post-mortem`](../blameless-post-mortem/SKILL.md).
+- The plan is trivial or fully reversible — overhead exceeds value.
+
+## Procedure
+
+### 1. State the plan and set the horizon
+
+Summarise the plan in one sentence: *"We are doing X for outcome Y, touching
+Z."* Set the prospective-failure frame explicitly: *"Assume total failure at
+horizon H (e.g. 6 months post-launch). What went wrong?"*
+
+If the plan cannot be summarised in one sentence, it is not reviewable — stop
+and ask for scope clarification.
+
+### 2. Enumerate failure stories
+
+Generate failure scenarios across multiple angles (people, process, technical,
+external, timing). Each scenario is a short narrative in past tense: *"We
+shipped, but adoption collapsed because …"*
+
+For each scenario:
+
+- Invoke [`adversarial-review`](../adversarial-review/SKILL.md) to attack the
+  plan's assumptions and surface hidden coupling or over-engineering.
+- Invoke [`risk-officer`](../risk-officer/SKILL.md) to assign L × I (likelihood
+  × impact) scores to each failure mode.
+
+Do NOT re-implement L × I scoring inline — delegate to `risk-officer`.
+
+### 3. Derive early-warning signals and preventive guardrails
+
+For each top failure mode (sorted by L × I from `risk-officer`):
+
+1. **Early-warning signal** — what would you observe *first* if this failure
+   mode were activating? Name a concrete, observable indicator (metric, alert,
+   user behaviour, team signal). This is the load-bearing output.
+2. **Preventive guardrail** — one specific change to the plan, process, or
+   rollout strategy that reduces the likelihood of this failure mode. Keep it
+   executable; flag as `accept` if no practical guardrail exists.
+
+### 4. Optional memory write-back
+
+If the analysis surfaces a pattern worth preserving for future decisions:
+
+1. Run a dedup pre-check: call `retrieve()` over the same key-space (plan type,
+   affected paths, decision area). If a match is found, propose a
+   `frequency`/`supersedes` update to the existing entry rather than a new one.
+2. Draft a `historical-patterns` candidate and send it to `/memory propose` per
+   [`docs/contracts/analysis-memory-loop.md`](../../docs/contracts/analysis-memory-loop.md).
+3. Never auto-promote. Human action drives `/memory promote`.
+
+## Output format
+
+1. **Ranked prospective failure modes** — L × I ordered list (from `risk-officer`)
+2. **Early-warning signal per failure mode** — concrete, observable indicator
+3. **Preventive guardrails** — one per failure mode (or `accept` with rationale)
+4. **Optional memory candidate** — drafted to `/memory propose` if the pattern
+   clears the admission gate (≥ 2 distinct file paths OR ≥ 3 future decisions)
+
+## Do NOT
+
+- Do NOT invent strawman failure modes — each must be grounded in the actual
+  plan's structure, assumptions, or dependencies.
+- Do NOT re-implement L × I scoring — invoke `risk-officer`; don't duplicate
+  its five-lens framework inline.
+- Do NOT present speculation as evidence — premortem is imaginative framing,
+  not a prediction; label scenarios as prospective.
+- Do NOT auto-promote memory candidates — `/memory propose` is the intake;
+  `/memory promote` requires explicit human action and passes
+  `check_memory_proposal.py`.
+
+## Gotchas
+
+- Premortem is **forward-looking** — it imagines a future failure to improve
+  the present plan. `blameless-post-mortem` is backward-looking — it analyses
+  a past failure. Do not conflate them.
+- The **early-warning signal** is the load-bearing output, not the doom list.
+  A failure mode without a detectable signal cannot be caught in time — flag
+  it explicitly.
+- Failure stories in past tense ("we shipped, and then X happened") are more
+  generative than abstract risk statements. Force the past-tense narrative.
+
+## See also
+
+- [`risk-officer`](../risk-officer/SKILL.md) — L × I scoring; invoked in
+  Step 2. Not duplicated here.
+- [`adversarial-review`](../adversarial-review/SKILL.md) — assumption attack;
+  invoked in Step 2. Not duplicated here.
+- [`blameless-post-mortem`](../blameless-post-mortem/SKILL.md) — post-hoc
+  analysis of an actual failure; backward-looking counterpart to this skill.
+- Invocation surfaces: `/analyze premortem`, `feature:plan`, `roadmap-create`
+  (surface the premortem step as optional before committing to a plan).

package/dist/agent-src/skills/prompt-engineering-image/SKILL.md

@@ -0,0 +1,115 @@
+---
+model_tier: inherit
+name: prompt-engineering-image
+description: "Translate an image brief into provider-specific prompt grammar per model. Use when writing or refining an image-generation prompt for Ideogram, Flux, Gemini, GPT Image 2, or Recraft."
+domain: product
+personas: []
+workspaces:
+  - small-business
+packs:
+  - ai-image
+trust:
+  level: experimental
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# prompt-engineering-image
+
+Translate an image brief into a provider-specific prompt string. Each model
+has distinct prompt grammar — this skill applies the right structure per adapter.
+
+## When to use
+
+- Writing or refining a prompt for any `pack-ai-image` provider.
+- After `image-provider-routing` has selected the target provider.
+- When a prompt is underperforming and needs provider-specific tuning.
+
+## Per-provider prompt grammar
+
+### Ideogram (text-in-image: logos, banners, typographic art)
+
+- **Lead with the text literal** in quotes: `"BAKERY NAME" in bold serif on a cream background`.
+- Follow with visual context: background, color palette, style (flat, vintage, art-deco).
+- Avoid long scene descriptions — Ideogram renders text best with a focused layout brief.
+- Key params: `model: V_2`, `aspect_ratio: ASPECT_1_1` (square logo) or `ASPECT_16_9`
+  (banner), `magic_prompt_option: AUTO` (let Ideogram enrich).
+
+### Flux (photoreal: product shots, portraits, scenes)
+
+- **Descriptive noun phrase first**: subject → lighting → environment → camera.
+- Example: `"Close-up product shot of a ceramic coffee mug, soft studio lighting,
+  clean white background, 50 mm lens bokeh, ultra sharp"`.
+- Style descriptors: cinematic, hyperrealistic, 8K, golden hour, DSLR.
+- Negative prompts accepted: `--no cartoon, illustration, text`.
+- Routes through fal/Replicate — model slug: `fal-ai/flux-pro` or `black-forest-labs/flux-pro`.
+
+### Recraft (vector / SVG logos and icons)
+
+- **Style param is mandatory**: `style: vector_illustration` (SVG output),
+  `style: icon` (for simplified marks), `style: realistic_image` (raster fallback).
+- Keep prompt minimal — recraft interprets shape semantics: `"minimalist leaf icon, single color"`.
+- Avoid photographic language (lighting, bokeh, grain) — it has no effect on vector output.
+- Key params: `model: recraftv3`, `response_format: url`.
+
+### Gemini-image / GPT Image 2 (general art, edits, multimodal)
+
+- **Natural language** works well — no special syntax required.
+- Be explicit about style: `"watercolor illustration"`, `"flat design"`, `"oil painting"`.
+- For GPT Image 2 image editing: include the edit instruction after describing the target:
+  `"Remove the background and replace with a solid pastel blue"`.
+- Gemini: submit via `generateContent` (Nano Banana family) or `imagen-4.0:predict` (Imagen 4).
+
+## Procedure
+
+1. **Receive the brief** — extract: subject, style, output format (raster/vector/banner),
+   target provider (from `image-provider-routing` or explicitly stated).
+2. **Structure the prompt blocks** — subject · style · composition · technical params.
+3. **Apply provider grammar** from the section above for the target model.
+4. **Tune for the job shape** — text-literal first for Ideogram; noun-phrase first for Flux;
+   minimal + `style:` param for Recraft; natural language for Gemini/GPT.
+5. **Inspect the adapter header** — open `src/scripts/ai-image/adapters/<provider>.sh`
+   and confirm the param enums (aspect/style/model) the prompt relies on still match.
+6. **Emit the prompt** in the Output format below.
+
+## Output format
+
+1. **Target provider** — name + adapter file reference.
+2. **Prompt string** — the exact string to pass to the adapter, ready to copy.
+3. **Key params** — any model-specific fields (aspect ratio, style, negative prompts).
+4. **Variant** (optional) — one alternative phrasing when the brief is ambiguous.
+
+## Gotcha
+
+- **Per-provider param enums drift** — `aspect_ratio`, `style`, and `model` enum values
+  are ASSUMED from the adapter header comments. Verify against live API docs before
+  promotion; never hardcode these in production without a smoke trace.
+- **Adapters are scaffold-tier** — prompts authored here are not live-validated.
+  Actual rendering requires adapter promotion to `stable` per `provider-lifecycle-discipline`.
+- Recraft: photographic descriptors (`bokeh`, `lighting`, `grain`) silently have no effect
+  on vector output — strip them to avoid prompt budget waste.
+
+**Good example:** Ideogram brief for a bakery logo — lead with the text literal:
+`'"Le Four" in warm serif, vintage French patisserie style, cream and terracotta'.`
+
+**Bad example:** Sending a photorealism-heavy Flux prompt to Recraft — the style
+descriptors will be ignored and the vector output will be wrong.
+
+## Do NOT
+
+- Do NOT send photographic descriptors (`bokeh`, `lighting`, `grain`) to Recraft —
+  they have no effect on vector output and waste the prompt budget.
+- Do NOT hardcode ASSUMED param enums into a live run without a smoke trace —
+  verify against the adapter header / provider docs first.
+- Do NOT embed a real person's likeness, a trademarked brand mark, or a named living
+  artist's style in a prompt without the rights check (`image-likeness-and-rights`).
+- Do NOT write a prompt before the provider is chosen — route via `image-provider-routing` first.
+
+## See also
+
+- [`image-provider-routing`](../image-provider-routing/SKILL.md) — select the provider before writing the prompt.
+- [`provider-lifecycle-discipline`](../../rules/provider-lifecycle-discipline.md) — lifecycle tier gates live runs.
+- `src/scripts/ai-image/adapters/` — adapter header comments for param enums.
+- [`image-likeness-and-rights`](../../rules/image-likeness-and-rights.md) — rights check before generating real-person likenesses or brand marks.