akili-specs 2.7.0 → 2.8.0

package/.claude/skills/gsap-animation/references/utils.md

@@ -0,0 +1,254 @@
+# gsap.utils
+
+Read when using **gsap.utils** for math, array/collection handling, unit parsing, or value mapping in animations (e.g. mapping scroll to a value, randomizing, snapping to a grid, normalizing inputs).
+
+## Overview
+
+**gsap.utils** provides pure helpers; no registration needed. Use in tween vars (function-based values), in ScrollTrigger or Observer callbacks, or any JS that drives GSAP. All are on **gsap.utils** (e.g. `gsap.utils.clamp()`).
+
+**Omitting the value: function form.** Many utils accept the value to transform as the **last** argument. Omit it and the util returns a **function** that accepts the value later — use this when clamping/mapping/normalizing/snapping many values with the same config (e.g. a mousemove handler). **Exception: random()** — pass **true** as the last argument for a reusable function (do not omit the value).
+
+```javascript
+// With value: returns the result
+gsap.utils.clamp(0, 100, 150); // 100
+
+// Without value: returns a function you call later
+let c = gsap.utils.clamp(0, 100);
+c(150);  // 100
+c(-10);  // 0
+```
+
+## Clamping and Ranges
+
+### clamp(min, max, value?)
+
+Constrains a value between min and max.
+
+```javascript
+gsap.utils.clamp(0, 100, 150); // 100
+gsap.utils.clamp(0, 100, -10); // 0
+
+let clampFn = gsap.utils.clamp(0, 100);
+clampFn(150); // 100
+```
+
+### mapRange(inMin, inMax, outMin, outMax, value?)
+
+Maps a value from one range to another. Use when converting scroll position, progress (0–1), or input range to an animation range.
+
+```javascript
+gsap.utils.mapRange(0, 100, 0, 500, 50);  // 250
+gsap.utils.mapRange(0, 1, 0, 360, 0.5);   // 180 (progress to degrees)
+
+let mapFn = gsap.utils.mapRange(0, 100, 0, 500);
+mapFn(50);  // 250
+```
+
+### normalize(min, max, value?)
+
+Returns a value normalized to 0–1 for the given range.
+
+```javascript
+gsap.utils.normalize(0, 100, 50);    // 0.5
+gsap.utils.normalize(100, 300, 200); // 0.5
+```
+
+### interpolate(start, end, progress?)
+
+Interpolates between two values at a given progress (0–1). Handles numbers, colors, and objects with matching keys.
+
+```javascript
+gsap.utils.interpolate(0, 100, 0.5);               // 50
+gsap.utils.interpolate("#ff0000", "#0000ff", 0.5); // mid color
+gsap.utils.interpolate({ x: 0, y: 0 }, { x: 100, y: 50 }, 0.5); // { x: 50, y: 25 }
+
+let lerp = gsap.utils.interpolate(0, 100);
+lerp(0.5); // 50
+```
+
+## Random and Snap
+
+### random(minimum, maximum[, snapIncrement, returnFunction]) / random(array[, returnFunction])
+
+Returns a random number in the range, or a random element from an **array**. Optional **snapIncrement** snaps to the nearest multiple. **For a reusable function, pass true as the last argument** (returnFunction) — the only util that uses `true` instead of omitting the value.
+
+```javascript
+gsap.utils.random(-100, 100);  // e.g. 42.7
+gsap.utils.random(0, 500, 5);  // 0–500, snapped to nearest 5
+
+let randomFn = gsap.utils.random(-200, 500, 10, true);
+randomFn();  // random value in range, snapped to 10
+
+gsap.utils.random(["red", "blue", "green"]); // one at random
+let randomFromArray = gsap.utils.random([0, 100, 200], true);
+randomFromArray(); // 0, 100, or 200
+```
+
+**String form in tween vars:** `"random(-100, 100)"`, `"random(-100, 100, 5)"`, or `"random([0, 100, 200])"`; GSAP evaluates per target.
+
+```javascript
+gsap.to(".box", { x: "random(-100, 100, 5)", duration: 1 });
+gsap.to(".item", { backgroundColor: "random([red, blue, green])" });
+```
+
+### snap(snapTo, value?)
+
+Snaps to the nearest multiple of **snapTo**, or to the nearest value in an array.
+
+```javascript
+gsap.utils.snap(10, 23);             // 20
+gsap.utils.snap(0.25, 0.7);          // 0.75
+gsap.utils.snap([0, 100, 200], 150); // 100 or 200
+
+let snapFn = gsap.utils.snap(10);
+snapFn(23); // 20
+```
+
+In tweens for grid/step-based animation:
+
+```javascript
+gsap.to(".x", { x: 200, snap: { x: 20 } });
+```
+
+### shuffle(array)
+
+Returns a new array with the same elements in random order.
+
+```javascript
+gsap.utils.shuffle([1, 2, 3, 4]); // e.g. [3, 1, 4, 2]
+```
+
+### distribute(config)
+
+**Returns a function** that assigns a value to each target based on its position in the array (or grid). Used internally for advanced staggers; use whenever values must spread across many elements (scale, opacity, x, delay). The returned function receives `(index, target, targets)` — call it manually or pass it directly into a tween.
+
+**Config (all optional):**
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `base` | Number | Starting value. Default `0`. |
+| `amount` | Number | Total distributed across all targets (added to base). E.g. `amount: 1` with 100 targets → 0.01 between each. |
+| `each` | Number | Amount added between each target. E.g. `each: 1` with 4 targets → 0, 1, 2, 3. |
+| `from` | Number \| String \| Array | Where distribution starts: index, `"start"`, `"center"`, `"edges"`, `"random"`, `"end"`, or ratios like `[0.25, 0.75]`. Default `0`. |
+| `grid` | String \| Array | Grid position instead of flat index: `[rows, columns]` or `"auto"`. |
+| `axis` | String | For grid: limit to one axis (`"x"` or `"y"`). |
+| `ease` | Ease | Distribute along an ease curve. Default `"none"`. |
+
+```javascript
+// Scale: middle elements 0.5, outer edges 3 (amount 2.5 from center)
+gsap.to(".class", {
+  scale: gsap.utils.distribute({ base: 0.5, amount: 2.5, from: "center" })
+});
+```
+
+**Manual use:** call the returned function with `(index, target, targets)`.
+
+```javascript
+const distributor = gsap.utils.distribute({ base: 50, amount: 100, from: "center", ease: "power1.inOut" });
+const targets = gsap.utils.toArray(".box");
+const valueForIndex2 = distributor(2, targets[2], targets);
+```
+
+See [distribute()](https://gsap.com/docs/v3/GSAP/UtilityMethods/distribute/).
+
+## Units and Parsing
+
+### getUnit(value)
+
+Returns the unit string of a value (`"px"`, `"%"`, `"deg"`).
+
+```javascript
+gsap.utils.getUnit("100px"); // "px"
+gsap.utils.getUnit("50%");   // "%"
+gsap.utils.getUnit(42);      // "" (unitless)
+```
+
+### unitize(value, unit)
+
+Appends a unit to a number, or returns the value unchanged if it already has one.
+
+```javascript
+gsap.utils.unitize(100, "px");    // "100px"
+gsap.utils.unitize("2rem", "px"); // "2rem" (unchanged)
+```
+
+### splitColor(color, returnHSL?)
+
+Converts a color string into an array: **[r, g, b]** (0–255) or **[r, g, b, a]** for RGBA. Pass **true** as the second argument (returnHSL) to get **[h, s, l]** / **[h, s, l, a]**. Works with `rgb()`, `rgba()`, `hsl()`, `hsla()`, hex, and named colors.
+
+```javascript
+gsap.utils.splitColor("red");                     // [255, 0, 0]
+gsap.utils.splitColor("#6fb936");                 // [111, 185, 54]
+gsap.utils.splitColor("rgba(204, 153, 51, 0.5)"); // [204, 153, 51, 0.5]
+gsap.utils.splitColor("#6fb936", true);           // [94, 55, 47] (HSL)
+```
+
+See [splitColor()](https://gsap.com/docs/v3/GSAP/UtilityMethods/splitColor/).
+
+## Arrays and Collections
+
+### selector(scope)
+
+Returns a scoped selector function that finds elements only within the given element (or ref). Use in components so `".box"` matches only descendants. Accepts a DOM element or a ref (handles `.current`).
+
+```javascript
+const q = gsap.utils.selector(containerRef);
+q(".box");        // array of .box elements inside container
+gsap.to(q(".circle"), { x: 100 });
+```
+
+### toArray(value, scope?)
+
+Converts a value to an array: selector string (scoped to element), NodeList, HTMLCollection, single element, or array.
+
+```javascript
+gsap.utils.toArray(".item");            // array of elements
+gsap.utils.toArray(".item", container); // scoped to container
+gsap.utils.toArray(nodeList);           // [ ... ] from NodeList
+```
+
+### pipe(...functions)
+
+Composes functions: **pipe(f1, f2, f3)(value)** returns f3(f2(f1(value))). Use for a chain of transforms (e.g. normalize → mapRange → snap).
+
+```javascript
+const fn = gsap.utils.pipe(
+  (v) => gsap.utils.normalize(0, 100, v),
+  (v) => gsap.utils.snap(0.1, v)
+);
+fn(50); // normalized then snapped
+```
+
+### wrap(min, max, value?)
+
+Wraps a value into the range min–max (inclusive min, exclusive max). Use for infinite scroll or cyclic values.
+
+```javascript
+gsap.utils.wrap(0, 360, 370); // 10
+gsap.utils.wrap(0, 360, -10); // 350
+
+let wrapFn = gsap.utils.wrap(0, 360);
+wrapFn(370); // 10
+```
+
+### wrapYoyo(min, max, value?)
+
+Wraps a value in range with a yoyo (bounces at ends).
+
+```javascript
+gsap.utils.wrapYoyo(0, 100, 150); // 50 (bounces back)
+```
+
+## Best practices
+
+- ✅ Omit the value argument to get a reusable function when the same range/config is used many times (e.g. `let mapFn = gsap.utils.mapRange(0, 1, 0, 360); mapFn(progress)`).
+- ✅ Use **snap** for grid-aligned or step-based values; use **toArray** when a real array is needed from a selector or NodeList.
+- ✅ Use **gsap.utils.selector(scope)** in components so selectors are scoped to a container or ref.
+
+## Do Not
+
+- ❌ Assume **mapRange** / **normalize** handle units; they work on numbers. Use **getUnit** / **unitize** when units matter.
+- ❌ Override or rely on undocumented behavior; stick to the documented API.
+
+### Learn More
+https://gsap.com/docs/v3/HelperFunctions

package/.claude/skills/judgment-day/SKILL.md

@@ -4,6 +4,9 @@ description: "Trigger: judgment day, dual review, adversarial review, juzgar. Ru
 license: Apache-2.0
 metadata:
   author: gentleman-programming
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: core
   version: "1.6"
 ---
 
@@ -49,4 +52,19 @@ Return target identity, round, confirmed/suspect/contradiction/INFO counts, corr
 ## References
 
 - [../_shared/review-ledger-contract.md](../_shared/review-ledger-contract.md) — canonical transaction, ledger, persistence, and lifecycle contract.
-- [references/prompts-and-formats.md](references/prompts-and-formats.md) — compact judge/fix prompts and verdict shape.
+- [references/prompts-and-formats.md](references/prompts-and-formats.md) — compact judge/fix prompts and verdict shape.
+
+These reference files are not packaged with AKILI-SPECS. When they are unavailable, proceed with the contract described in this document alone: persist the findings ledger inside the spec folder (see below) and derive judge prompts from the Hard Rules and Output Contract.
+
+## AKILI-SPECS Integration
+
+| AKILI moment | How to use this skill |
+|---|---|
+| `/akili-specify` Step 2.3 — **Review Design** option | The user-selected blind dual review of `design.md` before tasks are written; the target is the approved requirements + draft design |
+| `/akili-archive` Kaizen Measure | Severe confirmed findings from Judgment Day runs are a signal row in the `kaizen` retrospective |
+
+Adaptation rules:
+
+- Persist the findings ledger as `docs/specs/<spec-path>/judgment.md` so `/akili-archive` can read it as evidence.
+- The two-judge blind protocol, the two-round fix ceiling, and the `APPROVED`/`ESCALATED` terminal states apply unchanged.
+- Prefer running the two judges on a model different from the one that authored the design (author ≠ auditor, per AKILI model routing).

package/.claude/skills/kaizen/SKILL.md

@@ -4,6 +4,7 @@ description: "Trigger: kaizen, retrospective, continuous improvement, mejora con
 license: MIT
 metadata:
   author: Juan Carlos Cadavid — jcadavid.com
+  binding: core
   version: "1.0"
   inspired-by: "Kaizen Institute glossary (kaizen.com), 'El Método Kaizen' (small-steps approach, Robert Maurer), 'Emprendiendo Kaizen' (INTI, 2019, ISBN 978-950-532-415-6)"
 ---

package/.claude/skills/nestjs-expert/SKILL.md

@@ -4,6 +4,14 @@ description: Nest.js framework expert specializing in module architecture, depen
 category: framework
 displayName: Nest.js Framework Expert
 color: red
+license: MIT
+metadata:
+  author: Daniel Avila (davila7)
+  source: https://github.com/davila7/claude-code-templates
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: stack
+  version: "1.0"
 ---
 
 # Nest.js Expert

package/.claude/skills/product-manager-toolkit/SKILL.md

@@ -1,8 +1,14 @@
 ---
 name: product-manager-toolkit
 description: Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market strategies. Use for feature prioritization, user research synthesis, requirement documentation, and product strategy development. In AKILI-SPECS projects, follow the AKILI-SPECS Integration section first.
+license: MIT
 metadata:
-  adapted-for: "AKILI-SPECS methodology by Juan Carlos Cadavid — jcadavid.com"
+  author: Alireza Rezvani (alirezarezvani)
+  source: https://github.com/alirezarezvani/claude-skills
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: core
+  version: "1.0"
 ---
 
 # Product Manager Toolkit

package/.claude/skills/react-doctor/SKILL.md

@@ -2,6 +2,12 @@
 name: react-doctor
 description: Run after making React changes to catch issues early. Use when reviewing code, finishing a feature, or fixing bugs in a React project.
 version: 1.0.0
+metadata:
+  author: Million.dev (millionco)
+  source: https://github.com/millionco/react-doctor
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: stack
 ---
 
 # React Doctor

package/.claude/skills/seo-audit/SKILL.md

@@ -1,7 +1,13 @@
 ---
 name: seo-audit
-description: When the user wants to audit, review, or diagnose SEO issues on their site. Also use when the user mentions "SEO audit," "technical SEO," "why am I not ranking," "SEO issues," "on-page SEO," "meta tags review," "SEO health check," "my traffic dropped," "lost rankings," "not showing up in Google," "site isn't ranking," "Google update hit me," "page speed," "core web vitals," "crawl errors," or "indexing issues." Use this even if the user just says something vague like "my SEO is bad" or "help with SEO" — start with an audit. For building pages at scale to target keywords, see programmatic-seo. For adding structured data, see schema. For AI search optimization, see ai-seo.
+description: When the user wants to audit, review, or diagnose SEO issues on their site. Also use when the user mentions "SEO audit," "technical SEO," "why am I not ranking," "SEO issues," "on-page SEO," "meta tags review," "SEO health check," "my traffic dropped," "lost rankings," "not showing up in Google," "site isn't ranking," "Google update hit me," "page speed," "core web vitals," "crawl errors," or "indexing issues." Use this even if the user just says something vague like "my SEO is bad" or "help with SEO" — start with an audit. In AKILI-SPECS projects, /akili-seo loads this skill in its audit phase.
+license: MIT
 metadata:
+  author: Corey Haines (coreyhaines31)
+  source: https://github.com/coreyhaines31/marketingskills
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: core
   version: 2.0.0
 ---
 
@@ -453,7 +459,6 @@ Same format as above
 
 - [AI Writing Detection](references/ai-writing-detection.md): Common AI writing patterns to avoid (em dashes, overused phrases, filler words)
 - [International SEO](references/international-seo.md): Evidence and sources for hreflang, canonical + i18n, sitemaps, URL structure, and content quality across locales
-- For AI search optimization (AEO, GEO, LLMO, AI Overviews), see the **ai-seo** skill
 
 ---
 
@@ -487,11 +492,15 @@ Same format as above
 
 ---
 
-## Related Skills
+## AKILI-SPECS Integration
 
-- **ai-seo**: For optimizing content for AI search engines (AEO, GEO, LLMO)
-- **programmatic-seo**: For building SEO pages at scale
-- **site-architecture**: For page hierarchy, navigation design, and URL structure
-- **schema**: For implementing structured data
-- **cro**: For optimizing pages for conversion (not just ranking)
-- **analytics**: For measuring SEO performance
+| AKILI moment | How to use this skill |
+|---|---|
+| `/akili-seo` audit phase | Required skill — load before starting and apply throughout; the Audit Report Structure above is the finding format |
+| `/akili-validate` | When validating pages with search-visibility requirements, apply the On-Page checklist to the affected routes |
+
+Adaptation rules:
+
+- Findings land in the AKILI report artifacts (`/akili-seo` output), using the Issue / Impact / Evidence / Fix / Priority shape.
+- Fixes that exceed the trivial gate are routed through `/akili-propose` — never applied silently during the audit.
+- Sibling skills mentioned by upstream versions of this skill (programmatic-seo, schema, ai-seo, cro, analytics) are **not packaged** with AKILI-SPECS; when a finding needs them, note the gap in the report instead of loading them.

package/.claude/skills/shadcn-ui/SKILL.md

@@ -2,6 +2,12 @@
 name: shadcn-ui
 description: Provides complete shadcn/ui component library patterns including installation, configuration, and implementation of accessible React components. Use when setting up shadcn/ui, installing components, building forms with React Hook Form and Zod, customizing themes with Tailwind CSS, or implementing UI patterns like buttons, dialogs, dropdowns, tables, and complex form layouts.
 allowed-tools: Read, Write, Bash, Edit, Glob
+metadata:
+  author: community (origin unverified)
+  curated-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: stack
+  version: "1.0"
 ---
 
 # shadcn/ui Component Patterns

package/.claude/skills/stitch-design/SKILL.md

@@ -5,6 +5,13 @@ allowed-tools:
   - "StitchMCP"
   - "Read"
   - "Write"
+metadata:
+  author: Google (google-labs-code)
+  source: https://github.com/google-labs-code/stitch-skills
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: conditional
+  version: "1.0"
 ---
 
 # Stitch Design Expert

package/.claude/skills/systematic-debugging/SKILL.md

@@ -1,6 +1,14 @@
 ---
 name: systematic-debugging
 description: Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes
+license: MIT
+metadata:
+  author: Jesse Vincent (obra)
+  source: https://github.com/obra/superpowers
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: core
+  version: "1.0"
 ---
 
 # Systematic Debugging
@@ -287,6 +295,19 @@ These techniques are part of systematic debugging and available in this director
 - **superpowers:test-driven-development** - For creating failing test case (Phase 4, Step 1)
 - **superpowers:verification-before-completion** - Verify fix worked before claiming success
 
+These `superpowers:*` skills are not packaged with AKILI-SPECS. In AKILI projects, their role is covered by the methodology itself: the regression test comes from `/akili-specify` Bug Mode (red before the fix, green after), and verification comes from each task's verification command plus the Reviewer/Tester gates.
+
+## AKILI-SPECS Integration
+
+| AKILI moment | How to use this skill |
+|---|---|
+| `/akili-propose` Bug Track | Confirm reproduction + root cause and record them in the proposal's **Bug Diagnosis** section — never propose a fix for a guessed cause |
+| `/akili-specify` Bug Mode | If no proposal exists, run root-cause investigation before writing the fix plan |
+| `/akili-test` | When a Tester reports `PRODUCT_BUG`, apply Phases 1–3 to characterize the defect before any fix is planned; the test stays red |
+| `/akili-validate` / `/akili-seo` | Investigate mismatches and failures with this process before recommending corrections |
+
+The root cause and its evidence feed `/akili-archive`'s Kaizen retrospective (5W1H) — a lesson without a confirmed root cause is not recorded.
+
 ## Real-World Impact
 
 From debugging sessions:

package/.claude/skills/tailwind-design-system/SKILL.md

@@ -1,6 +1,14 @@
 ---
 name: tailwind-design-system
 description: Build scalable design systems with Tailwind CSS v4, design tokens, component libraries, and responsive patterns. Use when creating component libraries, implementing design systems, or standardizing UI patterns.
+license: MIT
+metadata:
+  author: Seth Hobson (wshobson)
+  source: https://github.com/wshobson/agents
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: stack
+  version: "1.0"
 ---
 
 # Tailwind Design System (v4)

package/.claude/skills/ui-ux-pro-max/SKILL.md

@@ -1,6 +1,14 @@
 ---
 name: ui-ux-pro-max
 description: "UI/UX design intelligence. 67 styles, 96 palettes, 57 font pairings, 25 charts, 13 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app, .html, .tsx, .vue, .svelte. Elements: button, modal, navbar, sidebar, card, table, form, chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette, accessibility, animation, layout, typography, font pairing, spacing, hover, shadow, gradient. Integrations: shadcn/ui MCP for component search and examples."
+license: MIT
+metadata:
+  author: nextlevelbuilder
+  source: https://github.com/nextlevelbuilder/ui-ux-pro-max-skill
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: conditional
+  version: "1.0"
 ---
 # UI/UX Pro Max - Design Intelligence
 
@@ -15,6 +23,19 @@ Reference these guidelines when:
 - Building landing pages or dashboards
 - Implementing accessibility requirements
 
+## AKILI-SPECS Integration
+
+This is AKILI's preferred UI/UX skill — commands reference it as "`ui-ux-pro-max` if available" (fallback: `frontend-design` + `stitch-design`).
+
+| AKILI moment | How to use this skill |
+|---|---|
+| `/akili-constitution` Step 4 | Drive `docs/ux-ui/design.md`: design tokens, palettes, typography, accessibility expectations |
+| `/akili-specify` design phase | Shape UI states, responsive behavior, and component architecture in `design.md` |
+| `/akili-execute` UI tasks | The Implementer loads it for UI-heavy tasks listed in `tasks.md` |
+| `/akili-test` / `/akili-validate` | The Tester/validator checks accessibility and UX rules (priority 1–4 categories) against the built screens |
+
+Design-token decisions made with this skill are recorded in `docs/ux-ui/design.md` — the Reviewer audits diffs against that document, not against this skill.
+
 ## Rule Categories by Priority
 
 | Priority | Category | Impact | Domain |

package/.claude/skills/vercel-react-best-practices/SKILL.md

@@ -4,6 +4,9 @@ description: React and Next.js performance optimization guidelines from Vercel E
 license: MIT
 metadata:
   author: vercel
+  adapted-by: "Juan Carlos Cadavid — jcadavid.com"
+  adapted-for: "AKILI-SPECS"
+  binding: stack
   version: "1.0.0"
 ---
 

package/.claude/templates/implementer.md

@@ -34,3 +34,9 @@ When you finish implementing and verifying your task, provide a concise response
 1.  **Task Completed:** (Brief 1-sentence summary of what you implemented)
 2.  **Verification Command Run:** (e.g. `npm run test` or `vitest run`)
 3.  **Verification Output/Evidence:** (Paste passing test outputs or compile success logs)
+
+---
+
+## Authorship
+
+AKILI-SPECS methodology by **Juan Carlos Cadavid** — [jcadavid.com](https://jcadavid.com). Licensed under the MIT License.

package/.claude/templates/leader.md

@@ -21,7 +21,7 @@ Your sole responsibility is to coordinate execution of an approved spec by orche
    * If no tasks are eligible, report completion or the blocking condition and stop.
 
 3. **Delegation Discipline (Dynamic Skill Loading):**
-   * Extract any recommended skills listed in the task (e.g., `shadcn-ui`, `nestjs-expert`).
+   * Extract any recommended skills listed in the task (e.g., `shadcn-ui`, `nestjs-expert`). If the task lists none, derive them from the project's `## Skill Map` in root `AGENTS.md`/`CLAUDE.md` (stack skills) plus the conditional skills matching the work (UI → `ui-ux-pro-max`, animation → `gsap-animation`).
    * Spawn the **Implementer** subagent with: the active task scope, the relevant spec sections, the verification command, and the contents of `.agents/implementer.md`.
    * **Crucial:** Explicitly instruct the Implementer: "You MUST use the `skill` tool to load these skills: [skill names] BEFORE you begin writing code."
    * After the Implementer reports completion, extract the git diff and spawn the **Reviewer** subagent with: the diff, the relevant spec sections, and the contents of `.agents/reviewer.md`.
@@ -75,3 +75,9 @@ After each task completes (whether on first pass or after self-correction), repo
 6. **Next step:** the next eligible task and a prompt to continue, pause, or skip.
 
 Keep this report concise. The full audit trail belongs in `execution.md`, not in chat.
+
+---
+
+## Authorship
+
+AKILI-SPECS methodology by **Juan Carlos Cadavid** — [jcadavid.com](https://jcadavid.com). Licensed under the MIT License.

package/.claude/templates/reviewer.md

@@ -51,3 +51,9 @@ Use this ONLY if you detect a critical architectural violation, the introduction
 STATUS: FATAL_FAIL
 SUMMARY: (Clear explanation of the catastrophic failure and why the loop must be aborted)
 ```
+
+---
+
+## Authorship
+
+AKILI-SPECS methodology by **Juan Carlos Cadavid** — [jcadavid.com](https://jcadavid.com). Licensed under the MIT License.

package/.claude/templates/tester.md

@@ -72,3 +72,9 @@ BUG:
 - **Failing Test:** (test file::test name — kept red on purpose)
 - **Observed vs Expected:** (actual behavior vs the required behavior)
 ```
+
+---
+
+## Authorship
+
+AKILI-SPECS methodology by **Juan Carlos Cadavid** — [jcadavid.com](https://jcadavid.com). Licensed under the MIT License.

package/CHANGELOG.md

@@ -10,6 +10,33 @@ The format is inspired by Keep a Changelog and the repository follows semantic v
 
 - No unreleased changes yet.
 
+## [2.8.0] - 2026-07-20
+
+### Added
+
+- **Skill governance (binding taxonomy + acceptance checklist):** new `docs/skills/governance.md` establishes the curation rule for the packaged skill set. Every skill now declares `metadata.binding` — `core` (hard-wired to a command step), `conditional` (loaded when the work touches its domain), or `stack` (never referenced in command text; reaches agents via the project Skill Map) — plus original author/license and `adapted-by`. New skills enter only through the acceptance checklist (need + binding + attribution + size + docs/CHANGELOG).
+- **Project Skill Map:** `/akili-constitution` Step 8D scaffolds a `## Skill Map` section into the project's root `AGENTS.md`/`CLAUDE.md` from the detected stack; `/akili-specify` derives each task's required skills from that map, and the `/akili-execute` Leader falls back to it when a task lists no skills.
+- **New unified `gsap-animation` skill** (author GSAP/GreenSock, MIT; adapted for AKILI-SPECS): replaces the 8 sibling `gsap-*` skills with one conditional skill — a compact router `SKILL.md` plus `references/` files (timeline, scrolltrigger, plugins, react, frameworks, performance, utils) following progressive disclosure. Wired into `/akili-specify` and `/akili-execute` for animation work.
+- **AKILI-SPECS Integration sections** added to the deeply-wired skills: `brainstorming` (AKILI artifacts override its generic `docs/plans/` flow), `judgment-day` (ledger persisted as `judgment.md` in the spec folder, author ≠ auditor note), `cognitive-doc-design` (document map per command), `systematic-debugging` (Bug Track / Bug Mode / PRODUCT_BUG / Kaizen 5W1H mapping), `seo-audit` (finding format + escalation rule), and `ui-ux-pro-max` (per-phase usage map).
+
+### Changed
+
+- **Skill attribution normalized across the package:** every kept skill's frontmatter now carries the standard schema (`license`, `metadata.author`, `source`, `adapted-by`, `adapted-for`, `binding`, `version`), preserving original authors — including newly researched attributions: `ui-ux-pro-max` → nextlevelbuilder, `seo-audit` → Corey Haines, `brainstorming` → Jesse Vincent (obra/superpowers), `nestjs-expert` → Daniel Avila, `react-doctor` → Million.dev, `stitch-design` → Google Labs, `product-manager-toolkit` → Alireza Rezvani, `api-design-principles`/`error-handling-patterns`/`tailwind-design-system` → Seth Hobson (wshobson/agents), `frontend-design` → Anthropic — plus the already-attributed Google, Vercel, GSAP, gentleman-programming, and vibeship. Only `shadcn-ui` remains `community (origin unverified)`.
+- **Truthful skill inventory:** `docs/skills/README.md` rebuilt with Binding and Origin columns and command associations that match the real command wiring (the previous table claimed command integrations that did not exist for `angular-developer` and the `gsap-*` family).
+- **`angular-developer` reclassified as a stack skill:** kept in the package, reachable via the project Skill Map and the constitution/specify stack lists (previously packaged but never referenced anywhere).
+- **Dangling references removed:** `seo-audit` no longer points to unpackaged sibling skills (`programmatic-seo`, `schema`, `ai-seo`, `cro`, `analytics`); `judgment-day` documents the fallback for its unpackaged shared-ledger references.
+
+### Removed
+
+- **The 8 `gsap-*` skill directories and their doc pages** (`gsap-core`, `gsap-frameworks`, `gsap-performance`, `gsap-plugins`, `gsap-react`, `gsap-scrolltrigger`, `gsap-timeline`, `gsap-utils`), fused into `gsap-animation`. **Existing installs are migrated automatically:** the installer's legacy cleanup now also removes stale legacy skill directories on every `akili install` run (counted in the `legacy cleaned` summary column, previewed in `--dry-run`), and `akili doctor` reports them as `STALE` with `--fix` removing them. Upgrade path for existing users: `akili update` (or `npm i -g akili-specs`) then `akili install --tool <tool>` — old gsap-* dirs are deleted and `gsap-animation` is installed in the same run.
+## [2.7.1] - 2026-07-20
+
+### Added
+
+- **Authorship section in commands and templates:** Every command in `.claude/commands/` and every agent role template in `.claude/templates/` now ends with an `## Authorship` section crediting the AKILI-SPECS methodology to Juan Carlos Cadavid ([jcadavid.com](https://jcadavid.com)).
+- **Authorship in README, LICENSE, and package metadata:** The README gains an `## Authorship` section, the MIT LICENSE copyright line uses the full author name and site, and `package.json` declares the `author` field.
+- **License metadata in commands:** Every command in `.claude/commands/` declares `license: MIT` and `metadata.author` in its frontmatter (matching the convention used by community skills), and the `## Authorship` footer of commands and templates states the MIT License. Third-party skills bundled in `.claude/skills/` keep their original authors and licenses untouched.
+- **Community governance files:** `CONTRIBUTING.md` (PR-only workflow, changelog discipline, and security rules for editing agent-executed prompt files), `SECURITY.md` (private vulnerability reporting with prompt-injection and installer threat scope), and `.github/CODEOWNERS` (maintainer review required on every change).
 ## [2.7.0] - 2026-07-20
 
 ### Added

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Juan Cadavid
+Copyright (c) 2026 Juan Carlos Cadavid (jcadavid.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -82,14 +82,7 @@ AKILI-SPECS is a constitution-first, spec-driven methodology for AI-assisted dev
   - `cognitive-doc-design`
   - `error-handling-patterns`
   - `frontend-design`
-  - `gsap-core`
-  - `gsap-frameworks`
-  - `gsap-performance`
-  - `gsap-plugins`
-  - `gsap-react`
-  - `gsap-scrolltrigger`
-  - `gsap-timeline`
-  - `gsap-utils`
+  - `gsap-animation`
   - `judgment-day`
   - `kaizen`
   - `nestjs-expert`
@@ -746,6 +739,8 @@ Fallback rule:
 
 - when `ui-ux-pro-max` is unavailable, use `frontend-design` + `stitch-design` for UX/UI design work and `frontend-design` for UI validation/testing support.
 
+**Skill governance:** the skill set is curated, not accumulated. Every packaged skill declares its original author and license plus how AKILI binds it into the flow (`core` — hard-wired to a command step; `conditional` — loaded when the work touches its domain; `stack` — selected per project via the `## Skill Map` that `/akili-constitution` writes into the project guides). New skills enter only through the acceptance checklist in [docs/skills/governance.md](docs/skills/governance.md). Curation and adaptation by [Juan Carlos Cadavid](https://jcadavid.com), always preserving original authorship.
+
 ## Methodology Contract
 
 - **User-Facing Summaries:** All major commands (`/akili-propose`, `/akili-specify`, `/akili-execute`, `/akili-validate`, `/akili-test`, `/akili-constitution`) generate a short, digestible summary on the screen before proceeding to the next step, ensuring developers always understand what the agent just did.
@@ -832,3 +827,9 @@ and the default registry for Claude Code (PRO) and OpenCode Go.
 - Skills were copied with their bundled references and helper assets.
 - This repository stores the current methodology baseline so it can be reused or versioned independently.
 - Dotfiles are snapshots of the working environment and may include plugin source copies for portability.
+
+## Authorship
+
+The AKILI-SPECS methodology is created and maintained by **Juan Carlos Cadavid** — [jcadavid.com](https://jcadavid.com).
+
+Every command in `.claude/commands/` and every agent role template in `.claude/templates/` carries this authorship notice. The project is released under the [MIT License](LICENSE): you are free to use, modify, and redistribute it, provided the copyright and attribution notices are kept intact.