@neikyun/ciel 6.10.1 → 6.11.1

package/assets/skills/workflow/memoire/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: memoire
+description: Persists project knowledge in Ciel via cued-recall memory (etape 15 MEMOIRE). Captures interventions and decisions into .ciel/memory/{episodes,concepts,guards}/ with index.json mapping cues (paths, symbols, intents) to memories. Replayed automatically when matching cues fire. Replaces the legacy free-recall .ciel/learnings.md blob.
+---
+
+# Persist Project Knowledge — Cued-Recall Memory (Ciel v6.5+)
+
+## What this covers
+
+How to save and retrieve project knowledge using **cued recall**: memories tagged with mechanical cues (file paths, symbols, intents) that fire automatically when those cues appear in the next task's context. The model never has to "remember to search" — the system surfaces relevant memory by mechanical match.
+
+See `docs/adrs/0001-cued-recall-memory.md` for the full design rationale.
+
+## Core principle
+
+**Cued recall over free recall.** Don't ask the model "is there relevant memory?" — surface memory automatically when the context cue (file, symbol, intent) matches.
+
+## Three persistence targets
+
+### 1. Episodes — `.ciel/memory/episodes/<YYYY-MM-DD>-<slug>.md`
+
+Dated events: human corrections, incidents, decisions discovered during a task.
+
+Frontmatter:
+```yaml
+---
+id: mem_012
+title: Admin routes use admin-guard wrapper
+languages: [typescript]
+path_patterns:
+  - src/admin/**
+  - src/pages/admin/**
+symbols: [AdminGuard, useAdminGuard]
+intents: [new-route, admin]
+captured_at: 2026-05-08T14:32:00Z
+captured_from: user-intervention  # or: incident, decision, bootstrap
+trigger_count: 0
+last_triggered: null
+stale_after_days: 90
+stale: false
+---
+
+# Admin routes use admin-guard wrapper
+
+**Context:** when adding a route under `/admin/*`, do not use the standard
+auth middleware. Use the project's `admin-guard` wrapper, which adds
+audit logging and role-based checks.
+
+**Why:** captured 2026-05-08 after the third incident where standard
+middleware allowed read access without role check.
+
+**How to apply:** import from `src/lib/auth/admin-guard.ts`. Wrap the
+route handler. See `src/admin/users/page.tsx` for canonical usage.
+```
+
+Capture when:
+- User corrects the model ("non, on utilise X ici")
+- An incident is documented (build broke, prod paged, test flaked for non-obvious reason)
+- A non-obvious decision is made (chose lib A over B because constraint C)
+
+### 2. Concepts — `.ciel/memory/concepts/<topic>.md`
+
+Stable conventions promoted from episodes that triggered ≥ N times. Same frontmatter, but with `captured_from: consolidation` and `promoted_from: [mem_012, mem_018]`.
+
+Promotion rule (handled by `memoire-consolidator` skill):
+- Episode triggered ≥ 5 times in last 60 days → candidate for promotion
+- ≥ 2 episodes share ≥ 80% of tags + similar lesson → candidate for merge
+
+### 3. Guards — `.ciel/memory/guards/<scope>.md`
+
+Vigilance rules with narrow trigger scope and high-severity warnings. Same frontmatter, but with `severity: critical`. Used for:
+- Foot-guns (commands that destroy prod)
+- Forbidden patterns (editing a deployed migration)
+- Mandatory checks before specific actions
+
+## Index — `.ciel/memory/index.json`
+
+The cue → memory mapping. Always loaded by `session-start.sh` at SessionStart.
+
+```json
+{
+  "version": 2,
+  "memories": {
+    "mem_012": { "title": "...", "file": "...", "languages": [...], "..." : "..." }
+  },
+  "by_path": { "src/admin/**": ["mem_012"] },
+  "by_symbol": { "AdminGuard": ["mem_012"] },
+  "by_intent": { "new-route": ["mem_012"] },
+  "by_language": { "typescript": ["mem_012"] }
+}
+```
+
+The index is rebuilt from frontmatter scans by `memoire-consolidator` whenever a memory is added/updated.
+
+## Capture flow
+
+1. User submits prompt
+2. `user-prompt-submit.sh` hook scans for intervention patterns: "tu as oublié", "non en fait", "attention que", "rappelle-toi", "n'oublie pas", "wait", "stop", "non on fait plutôt", "ici on fait plutôt"
+3. If matched → emits a context message: "INTERVENTION DETECTED — propose capture"
+4. Model surfaces an `AskUserQuestion`: "Capture this correction as memory? [Title / Tags suggested / Skip]"
+5. User confirms or skips
+6. On confirm → write `.ciel/memory/episodes/<date>-<slug>.md`, update `index.json`
+
+**Never auto-silent.** The user is the filter against cargo-cult capture.
+
+## Recall flow
+
+1. SessionStart or new task begins
+2. `session-start.sh` hook reads:
+   - The user's prompt (extract keywords → intent cues)
+   - `.ciel/map.json` (current focus modules → path cues)
+   - Recently tracked files (`.ciel/tracked-files.json`) → path + symbol cues
+3. Queries `index.json`: cues ∩ memories → candidate set
+4. Scores by: `recency × trigger_count × tag-overlap`
+5. Selects top-K under depth budget (Trivial 1K / Standard 3K / Critical 5K tokens)
+6. Injects one-line previews:
+   ```
+   [mem_012, fired 7×] Admin routes use admin-guard wrapper
+   [mem_007, fired 3×] Migration files are checksum-locked
+   ```
+7. Model can `Read` full content if relevant (cued exploration, not blanket dump)
+
+## Bootstrap from existing docs
+
+On first run, the slash command `/ciel-memory-bootstrap` ingests:
+
+| Source | Format expected |
+|---|---|
+| `.ciel/learnings.md` | Legacy Ciel format with `[date] MISTAKE/RULE` entries |
+| `.claude/lessons.md` or `lessons.md` | Same as above |
+| `ciel-overlay.md` | "Key Lessons" section |
+| `.claude/rules/*.md` | Each file = one rule |
+| `AGENTS.md` | Rules sections |
+
+Each ingested item becomes an episode with `captured_from: bootstrap`. Tags are inferred from content (file paths mentioned, symbols mentioned, language detected from imports).
+
+If no source is found, the system reports it and waits for organic capture via interventions.
+
+## Decay
+
+- `last_triggered` is updated by `session-start.sh` whenever a memory is matched and injected
+- After `stale_after_days` (default 90) without trigger → `stale: true`
+- Stale memories excluded from auto-injection but kept on disk
+- Skill `memoire-consolidator` periodically suggests purge or refresh
+
+## Token budget (hard caps)
+
+| Depth | Cap |
+|---|---|
+| Trivial | 1K tokens injected |
+| Standard | 3K tokens injected |
+| Critical | 5K tokens injected |
+
+If candidate set exceeds cap, drop lowest-scoring entries first. Index itself is small (~50 tokens per entry); the cap concerns content previews and any auto-loaded full content.
+
+## Common rationalizations
+
+| Rationalization | Reality |
+|---|---|
+| "I'll remember this next session" | You won't. Even if you do, the next agent session won't. Capture or it's gone. |
+| "The user corrected me, but it was obvious" | The fact that you missed it makes it non-obvious. Capture. |
+| "All this is in CLAUDE.md already" | CLAUDE.md is loaded once and diluted by lost-in-the-middle (Liu 2023). Cued memory bypasses that. |
+| "Capturing slows the user down" | One confirmation now vs. the same intervention next month. The math favors capture. |
+
+## What to persist vs what to skip
+
+PERSIST (becomes a memory):
+- User corrections that aren't obvious from reading the code
+- Incidents (what broke, root cause, fix that worked)
+- Architecture decisions with their motivation
+- Foot-guns (commands/patterns to avoid in this project)
+- Wrappers / conventions that override library defaults
+
+SKIP (don't pollute the corpus):
+- The code itself (it's in git)
+- Routine task completion ("I added a button")
+- Anything trivially derivable by reading the file
+- Personal style preferences (those go in `ciel-overlay.md`)
+
+## How to verify (etape MEMOIRE)
+
+- [ ] Did this session contain a user intervention/correction? If yes, was it captured?
+- [ ] Did this session document a new pattern, foot-gun, or convention? If yes, episode created?
+- [ ] Was the index.json updated by the capture flow?
+- [ ] Are tags reasonable (paths actually exist, symbols are real)?
+- [ ] If the same correction came up next month, would the cued recall fire? (Mental dry-run.)
+
+## Migration from legacy `.ciel/learnings.md`
+
+The legacy single-blob `learnings.md` is kept for backward compatibility but **deprecated**. New writes should go to `.ciel/memory/episodes/` via the capture flow. Run `/ciel-memory-bootstrap` to migrate existing entries — it parses the dated entries and converts each into an episode with inferred tags.
+
+## Related
+
+- `docs/adrs/0001-cued-recall-memory.md` — full design rationale and binding principles
+- `skills/workflow/memoire-consolidator` — periodic maintenance: promote, merge, decay
+- `commands/ciel-memory-bootstrap.md` — first-run scan + ingestion
+- `hooks/user-prompt-submit.sh` — detects intervention patterns and proposes capture
+- `hooks/session-start.sh` — injects matching memories at session start

package/assets/skills/workflow/memoire-consolidator/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: memoire-consolidator
+description: Periodic maintenance of .ciel/memory/ — promotes high-frequency episodes to concepts, merges duplicates, marks stale entries, rebuilds index.json. Run manually or via /ciel-improve. Keeps the cued-recall corpus from accumulating noise as projects age.
+---
+
+# Consolidate Cued-Recall Memory
+
+## What this covers
+
+The corpus under `.ciel/memory/` grows over time. Without maintenance it accumulates duplicates, stale entries, and episodes that should have been promoted to stable concepts long ago. This skill is the maintenance pass.
+
+See `skills/workflow/memoire/SKILL.md` for the capture/recall flow and `docs/adrs/0001-cued-recall-memory.md` for the full design.
+
+## When to run
+
+- Manually via `/ciel-improve` or direct invocation
+- When `index.json` shows ≥ 50 episodes
+- Quarterly on long-lived projects
+- After any large bootstrap import (existing tribal docs ingested at once)
+
+## Five operations
+
+### 1. Promote frequent episodes → concepts
+
+Criterion: episode with `trigger_count ≥ 5` AND `last_triggered` within 60 days.
+
+Action: copy episode content to `.ciel/memory/concepts/<slug>.md`, set `captured_from: consolidation` and `promoted_from: [original_id]`. Mark original episode `superseded_by: <new_id>` and exclude from active index.
+
+Why: concepts are stable conventions. Frequent triggers prove the rule has crystallized.
+
+### 2. Merge similar episodes
+
+Criterion: two or more episodes share ≥ 80% of tags AND describe the same lesson (semantic similarity, judged by reading content).
+
+Action: create a new concept that subsumes them, mark all originals `merged_into: <concept_id>`.
+
+Why: bootstrap or rapid capture often produces near-duplicates ("admin routes use admin-guard" + "always wrap admin in admin-guard"). Merging reduces noise without losing the signal.
+
+### 3. Mark stale entries
+
+Criterion: `last_triggered` is older than `stale_after_days` (default 90) OR null + `captured_at` older than 90 days.
+
+Action: set `stale: true` in frontmatter and in `index.json`. Stale entries are excluded from auto-injection but remain on disk.
+
+Why: untriggered memories may be obsolete (the file no longer exists, the convention changed). Auto-injecting them produces false positives.
+
+### 4. Detect dead anchors
+
+Criterion: a memory's `path_patterns` no longer match any file in the repo (deleted module, renamed convention).
+
+Action: flag for human review in `.ciel/memory/review-queue.md`. Don't auto-delete — the user should decide whether the memory is obsolete or needs updated paths.
+
+### 5. Rebuild `index.json`
+
+Always done last. Scans all `*.md` under `.ciel/memory/{episodes,concepts,guards}/`, parses frontmatter, regenerates the cue indices (`by_path`, `by_symbol`, `by_intent`, `by_language`).
+
+This guarantees the index never drifts from source-of-truth (the markdown files).
+
+## Output report
+
+After running, emit a summary:
+
+```
+[memoire-consolidator] 2026-05-08
+Promoted: 3 episodes → concepts
+Merged:   2 episode pairs → 2 concepts
+Stale:    7 entries flagged
+Dead:     1 anchor needs review (see .ciel/memory/review-queue.md)
+Index:    rebuilt — 42 active memories, 9 stale, 51 total
+```
+
+## Anti-patterns to avoid
+
+| Anti-pattern | Reason |
+|---|---|
+| Auto-deleting stale entries | User may want to revive; deletion is irreversible. Always flag, never delete. |
+| Promoting on first trigger | One trigger isn't crystallization. Wait for repetition. |
+| Merging without reading content | Tags may overlap by accident (two different `auth/**` rules). Read before merge. |
+| Skipping index rebuild | Drift between index and markdown is worse than missing data — silent corruption. |
+
+## Design principles inherited from ADR-0001
+
+- Markdown is source of truth; index is derived
+- User is the filter for irreversible actions (deletion, merge with conflict)
+- Decay over accumulation: stale flag is automatic, but action on it is human
+
+## Related skills
+
+- `memoire` — capture/recall flow (writes the inputs this skill consumes)
+- `meta-critiquer` — post-task reflection that may trigger consolidation if many captures occurred
+- `learnings-capture` — older format, superseded by cued-recall memoire

package/assets/skills/workflow/meta-critiquer/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: meta-critiquer
+description: How to reflect on completed work — 10-item post-task reflection checklist for Ciel v5. Covers depth match, failure mode detection, user corrections, stale branches, uncovered issues, context health, dead code, map update, parking lot, and boy-scout rule. Closes the feedback loop between execution and improvement.
+---
+
+# Post-Task Reflection — 10-Item Checklist (Ciel v5)
+
+## What this covers
+
+How to reflect on completed work and capture learnings. In Ciel v5, this is the last pipeline step (etape 16: META). Always run after every task, even trivial ones.
+
+## Core principle
+
+**Always reflect, even after trivial tasks.** 30 seconds is cheap; missed reflections compound. In v5, the reflection covers not just the code but the project map, parking lot, and boy-scout rule.
+
+## The 10 checks (v5)
+
+### 1. Depth match?
+
+Was the task processed at the right depth?
+- Over-processed trivial = waste
+- Under-processed critical = risk
+- Wrong depth -> flag for future classifier refinement
+
+### 2. New failure mode?
+
+Did something go wrong that current gates didn't catch?
+- Yes -> add a new gate immediately
+- Capture the pattern for future reference (in .ciel/learnings.md)
+
+### 3. User correction?
+
+Did the user correct you during the task?
+- Yes -> persist to .ciel/learnings.md
+- Don't just note it -- save it so it doesn't happen again
+
+### 4. Stale branches?
+
+```bash
+git branch -r | wc -l
+```
+Excessive remote branches (> 30) -> consider cleanup of merged branches.
+
+### 5. Uncovered issues?
+
+Any recently closed issues with 0 comments? -> missing evidence comment -> add it now.
+
+### 6. Context health?
+
+After Critical task or 3+ agent dispatches: consider context compression or new session. Stacking Critical tasks in one context window degrades output quality.
+
+### 7. Dead code sweep
+
+Run language-specific linter:
+- **Python**: `ruff check --select F401,F811,F841 . && vulture . --min-confidence 80`
+- **TypeScript**: `npx knip` or manual grep for unused exports
+- **Kotlin**: Detekt `UnusedPrivateMember` + `UnusedImport`
+- **Go**: `go vet ./...`
+- **Rust**: `cargo clippy -- -W unused`
+
+### 8. Map update (v5)
+
+Has the project map (.ciel/map.json) been updated with new modules, key files, or patterns discovered during this task?
+- If exploration happened -> update map
+- If new ADR was written -> reference it in map
+
+### 9. Parking lot (v5)
+
+Were any tangential discoveries made during the task?
+- Yes -> note in .ciel/parking.md
+- Don't act on them now -- just note them
+
+### 10. Boy-scout rule (v5)
+
+Did you leave the code better than you found it?
+- Minor improvements count: better naming, removed dead code, added missing test, improved error message
+- If you only modified what was required and nothing else -> acceptable but note it
+
+## Output format
+
+```
+## REFLECTION
+
+1. Depth match: <match | over/under-processed>
+2. New failure mode: <none | detected>
+3. User correction: <none | captured in .ciel/learnings.md>
+4. Stale branches: <N branches | cleanup recommended>
+5. Uncovered issues: <none | #N needs closure>
+6. Context health: <N% | compact recommended>
+7. Dead code: <0 findings | N fixed>
+8. Map update: <up-to-date | needs update>
+9. Parking: <none | N notes added>
+10. Boy-scout: <improved | status quo>
+
+### ACTION ITEMS
+- <list or "none">
+```
+
+## How to verify
+
+- [ ] All 10 checks completed?
+- [ ] >= 1 action item generated?
+- [ ] User corrections captured (if any)?
+- [ ] Stale branches flagged (if any)?
+- [ ] Map checked for updates?
+- [ ] Parking lot entries noted?
+
+## Key rules
+
+- **Always non-blocking**: reflection never blocks the commit/push
+- **Persist, don't just report**: items 2 and 3 must trigger learnings capture
+- **Map update (item 8) is mandatory after exploration**: without it, the next session starts with a stale map

package/assets/skills/workflow/modern-patterns-checker/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: modern-patterns-checker
+description: Scans proposed or existing code for obsolete patterns that LLMs tend to reproduce from stale training data — React class components instead of hooks, sync-when-async-is-standard, callback hell, Python 2 idioms, old Go error handling, jQuery in React codebases, CommonJS in ESM projects. Flags each anti-pattern with the 2026 canonical replacement and a link to the migration note. Referenced by ThoughtWorks Technology Radar April 2026.
+allowed-tools: Read, Grep, Glob, Bash
+---
+
+# modern-patterns-checker — Don't ship 2019-era code in 2026
+
+LLMs over-weight patterns that dominated their training set years ago. Without a guardrail, React class components, callback-based async, and sync-APIs-in-async-codebases keep leaking into new PRs. ThoughtWorks 2026 calls this "cognitive debt from AI autocompletion."
+
+---
+
+## Inputs (infer before asking — see orchestrator's Autonomy protocol)
+
+```
+CODE_UNDER_REVIEW: [file paths OR diff hunk]
+TARGET_STACK: [language + framework + version — resolved from package manifests]
+```
+
+### Auto-inference sources (exhaust BEFORE asking the user)
+
+- **CODE_UNDER_REVIEW** → `git diff main...HEAD` for the branch under review; fall back to `git diff HEAD~1` for the latest commit; or the user-named file(s).
+- **TARGET_STACK** → read `package.json` / `pyproject.toml` / `go.mod` / `Cargo.toml`; derive framework from dependencies (`react`, `vue`, `svelte`, `fastapi`, `django`, etc.). Read `tsconfig.json` / `pyproject.toml` for strictness settings. Cross-check with `ciel-overlay.md`.
+
+Never ask the user for either. Both are deterministically inferable.
+
+---
+
+## Anti-pattern catalogue (2026)
+
+### TypeScript / JavaScript
+
+| Anti-pattern | Canonical 2026 replacement |
+|---|---|
+| `class Foo extends React.Component` | Functional component + hooks |
+| `componentDidMount / componentDidUpdate` | `useEffect` (or Server Component for data fetching) |
+| `.then().catch()` chains > 2 links | `async/await` with `try/catch` |
+| `require()` in a project with `"type":"module"` | `import` (ESM) |
+| `var` | `const` / `let` |
+| `null`-checks everywhere | Discriminated unions + `?.` / `??` |
+| `any` as escape hatch | `unknown` + narrowing, or proper type |
+| `lodash.get` / `lodash.set` | Optional chaining `?.` + `??` |
+| `fetch().then(r => r.json()).then(...)` | `await fetch()` + `await r.json()` |
+| `moment.js` | `Temporal` API (Node 22+) or `date-fns` |
+| Redux for local UI state | `useState` / `useReducer` / Zustand |
+| PropTypes | TypeScript types |
+
+### Python
+
+| Anti-pattern | Canonical 2026 replacement |
+|---|---|
+| `print` as debug | `logging` with structured fields |
+| `%`-format or `.format()` | f-strings |
+| `dict.has_key(k)` | `k in dict` |
+| Nested `if` guards | Early-return pattern |
+| Bare `except:` | `except SpecificError:` |
+| `os.path.join` | `pathlib.Path` |
+| Sync `requests` in async codebase | `httpx.AsyncClient` / `aiohttp` |
+| `dataclass` without `slots=True` | `@dataclass(slots=True)` (3.10+) |
+| `typing.List`, `typing.Dict` | Built-in `list`, `dict` (3.9+ PEP 585) |
+| `from typing import Optional` | `X \| None` (3.10+ PEP 604) |
+
+### Go
+
+| Anti-pattern | Canonical 2026 replacement |
+|---|---|
+| `if err != nil { return err }` without wrapping | `fmt.Errorf("context: %w", err)` |
+| Bare `err == sql.ErrNoRows` | `errors.Is(err, sql.ErrNoRows)` |
+| Passing request context implicitly | Explicit `ctx context.Context` first arg |
+| `interface{}` | `any` (Go 1.18+), or typed interface |
+| `sync.Mutex` wrapping a slice | `sync.Map` or channel |
+
+### SQL
+
+| Anti-pattern | Canonical 2026 replacement |
+|---|---|
+| String concatenation for queries | Parameterized queries / prepared statements |
+| `SELECT *` in production queries | Explicit column list |
+| `N+1` loop queries | JOIN or batched `IN (...)` |
+| Missing indexes on FK | Index on every foreign key |
+
+### React (post-19)
+
+| Anti-pattern | Canonical 2026 replacement |
+|---|---|
+| `useEffect` for data fetching | Server Components, `use()`, or TanStack Query |
+| `useState` for derived values | `useMemo` or compute inline |
+| Prop-drilling > 3 levels | Context, composition, or state library |
+| Manual form state | `react-hook-form` or native `<form>` actions |
+
+---
+
+## Detection method
+
+1. **Regex pass** (fast) — grep for obvious markers: `extends Component`, `componentDidMount`, `require(`, `var `, `any`, `.then(.*).then(`, etc.
+2. **AST pass** (accurate, optional) — if `tsc` / `ruff` / `go vet` configured in the repo, run with strict rules.
+3. **Context pass** — read `tsconfig.json`, `pyproject.toml`, `go.mod` to confirm the stack is modern enough to allow the replacement. Don't suggest `Temporal` if Node is pinned to 18.
+
+---
+
+## Report format
+
+```
+## MODERN-PATTERNS VERDICT
+
+### Findings
+[BLOCK]  components/Profile.tsx:24 — class component
+         Replacement: functional + hooks
+         Migration: react.dev/reference/react/Component#alternatives
+
+[WARN]   lib/api.ts:55-70 — .then() chain (3 links)
+         Replacement: async/await
+         Rationale: readability + stack traces
+
+[INFO]   tests/user.test.ts:8 — `any` as escape hatch
+         Replacement: `unknown` + narrowing, or proper User type
+         Rationale: loses type safety in test-critical code
+
+### Stack-compatibility confirmed
+- Node: 22.3 ✓ allows Temporal
+- TS: 5.5 ✓ allows `satisfies` operator
+- React: 19.0.2 ✓ allows Server Components
+
+### Summary
+BLOCK: 1  (must fix)
+WARN:  1  (strongly advised)
+INFO:  1  (opportunistic)
+```
+
+---
+
+## Guardrails
+
+- **Verify stack before recommending** — suggesting `Temporal` on Node 18 wastes a review cycle.
+- **Don't aggregate-rewrite legacy** — flag, don't refactor wholesale. A single migration is a PR, not a silent edit.
+- **Repo-level opt-outs respected** — if `.eslintrc` deliberately allows `var` or a deprecated pattern (grandfather clause for a legacy module), note and skip.
+- **Citation required** — every suggestion links to the official migration doc or the MDN/React/Python guide. No link → drop the suggestion.
+- **BLOCK only for compile-breaking or security-sensitive** — class components don't BLOCK a working PR; a missing parameterized query DOES.
+- **Stop at 10 findings per file** — above 10, return "file needs a dedicated modernization task" rather than a linter dump.
+
+---
+
+## How to verify
+
+- [ ] Anti-pattern catalogue checked for each language in stack?
+- [ ] Each finding has 2026 canonical replacement?
+- [ ] Stack compatibility confirmed?
+- [ ] VERDICT issued (CLEAN / FINDINGS)?
+- [ ] Migration notes provided for each finding?
+
+## When triggered
+
+- CODEBASE step after `explorer` reads the target files
+- `@ciel-explorer` dispatched for PR review
+- Before accepting LLM-generated code in a legacy codebase (high drift risk)
+- After `@ciel-researcher` validates an API — this skill confirms the call site uses modern idioms
+
+---
+
+## References
+
+- ThoughtWorks Technology Radar April 2026 — "curated shared instructions" volume
+- React 19 migration guide — react.dev/blog/2024/04/25/react-19
+- PEP 585 / PEP 604 — Python builtin-generics + union syntax
+- Go 1.18 — `any` alias, generics
+- MDN Async/Await — developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous

package/assets/skills/workflow/pattern-fitness-check/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: pattern-fitness-check
+description: For every existing code pattern being considered for reuse, applies a 3-question fitness check (same problem? same constraints? same volume?) before copying. Flags HUBs (high fan-in files), duplication candidates, and prior AI-generated patterns that contradict official docs. Invoked during the CODEBASE step of every Ciel task.
+allowed-tools: Read, Grep, Glob, Bash
+---
+
+# pattern-fitness-check — Don't copy patterns blindly
+
+Part of CRÉER step 5 (CODEBASE). Pattern-matching without fitness checking is the single most common LLM coding failure (per Ciel's Guards table).
+
+---
+
+## 3-question fitness check
+
+For EACH pattern considered for reuse, answer all 3:
+
+1. **Same problem?** — What problem did this pattern solve originally? (git blame the commit)
+   - If the pattern was written for use case A and you're facing use case B → NOT the same problem.
+
+2. **Same constraints?** — Volume, transport, sync/async, batch/single, cardinality
+   - Pagination pattern written for 1k items might fail at 100M items.
+   - Sync validation pattern might not fit async flow.
+   - REST pagination pattern doesn't fit WebSocket message stream.
+
+3. **Same data shape?** — Is the input/output structure identical?
+   - Different field names → adapter needed
+   - Different nullable fields → null-safety differs
+   - Different ordering guarantees → might break downstream
+
+→ **All yes** → APPLY. **Any no** → ADAPT or DO NOT USE.
+
+---
+
+## Additional checks
+
+### Prior AI-generated patterns
+
+Treat existing code written during a prior AI session as a **suggestion, not law**. If it contradicts current official docs → likely an inherited anti-pattern. Flag and do not follow.
+
+Signal: code with unusual structure, comments like `// AI-suggested` or `// TODO: verify this approach`.
+
+### Duplication check
+
+If 2+ copies of the pattern you're about to write ALREADY EXIST → extract a shared helper FIRST, then use it.
+
+```bash
+# Find similar patterns
+grep -rn "fun <functionName>" --include='*.kt' src/
+```
+
+### Mini repo-map (3 greps)
+
+For impacted files, build a minimal map:
+
+1. **Signatures** — `grep -n "^fun \|^class \|^interface \|^object " <file>`
+2. **Dependents** — `grep -rln "import .*<filename>" src/`
+3. **Hub check** — if step 2 returns 5+ files → **HUB WARNING**: changes ripple widely, proceed with caution
+
+---
+
+## Output format
+
+```
+## PATTERN FITNESS
+
+### Patterns considered
+- APPLY: <pattern at file:line> — same problem ✓ same constraints ✓ same shape ✓
+- ADAPT: <pattern at file:line> — <what differs> → <how to adapt>
+- DO NOT USE: <pattern at file:line> — <reason>
+
+### Mini repo-map
+- Impacted files: <list>
+- Key signatures: <func/class at file:line>
+- Dependents (1 hop): <list>
+- Hub check: <NO — safe | YES — N files, changes ripple>
+
+### Duplication check
+- [None / Found N copies at file:line — extract helper first]
+
+### Prior AI patterns
+- [None / Flagged: <file:line> contradicts <doc URL> — do not follow]
+```
+
+---
+
+## Guardrails
+
+- **Git blame mandatory** for "same problem?" — don't rely on current code reading. Read the commit message where the pattern was introduced.
+- **Numeric constraints**: quantify "volume" — "1k items" vs "1M items" matters. Don't say "big" or "small".
+- **HUB threshold**: 5+ importers is the default; adjust per project size. A core util imported by 50+ files is extremely high-ripple — needs cross-team coordination.
+- **Don't over-adapt**: if adaptation grows to > 50 lines different from the original, just write new code. Adapting is not saving effort.
+
+---
+
+## How to verify
+
+- [ ] 3-question fitness check applied (same problem? same constraints? same volume)?
+- [ ] Prior AI-generated patterns flagged?
+- [ ] Duplication check performed (≥ 2 copies)?
+- [ ] Mini repo-map generated (impacted files, key signatures, dependents)?
+- [ ] Hub check performed (high fan-in files)?
+
+## When triggered
+
+- Standard/Critical tasks, during CODEBASE step
+- Trivial tasks, if the fix is "use an existing pattern" (quickly — 1 pattern, 1 fitness check)
+- When user says "we already have code for this" or "reuse X"
+- When `explorer` agent identifies a candidate pattern