whale-igniter 1.2.2 → 1.3.0

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://unpkg.com/whale-igniter@latest/brand/lockup.svg" alt="Whale Igniter" width="640">
+  <img src="https://cdn.jsdelivr.net/npm/whale-igniter@1.3.0/brand/lockup.svg" alt="Whale Igniter" width="640">
 </p>
 
 <p align="center">
@@ -9,332 +9,140 @@
   <img alt="local first" src="https://img.shields.io/badge/local--first-agent%20memory-%230034D3?labelColor=%23F2ECE1&style=flat-square">
 </p>
 
-**CLI-first operational intelligence for AI-assisted product workflows.**
+**Local-first project memory for AI agents.**
 
-Whale gives your project a machine-readable memory so AI agents like
-Claude Code, Codex, Cursor and Copilot understand your design system,
-conventions and decisions from the first commit — without you having
-to re-explain everything every session.
+Whale Igniter gives your repo a structured memory: design foundations,
+components, decisions, refinements and generated agent context. It is
+CLI-first, deterministic by default, and works with Codex, Claude Code,
+Cursor, Copilot and any MCP client.
 
-> AI-native, not AI-dependent. The core is deterministic and runs
-> offline. AI is an enrichment layer — opt-in via API key, or via the
-> built-in MCP server.
-
----
-
-## Install
+## Quick Start
 
 ```bash
-npm install -g whale-igniter
-# or use it directly without installing
 npx whale-igniter ignite my-app
+cd my-app
+npx whale-igniter remember
+npx whale-igniter check
 ```
 
-Requires Node 20 or newer.
-
-Whale's executable is `whale`:
+Install globally if you want the shorter `whale` command:
 
 ```bash
-whale --version
+npm install -g whale-igniter
 whale ignite my-app
 ```
 
----
+Requires Node 20 or newer.
 
-## The two-minute version
+## What It Creates
 
-```bash
-# Brand new project
-whale ignite my-app
-
-# Existing React + Tailwind codebase
-cd my-existing-app
-whale adopt
-whale adopt review        # accept/reject scanner proposals
+```text
+my-app/
+├── whale.config.json
+├── CLAUDE.md
+├── intelligence/
+│   ├── components.json
+│   ├── decisions.json
+│   └── refinements.json
+└── llm-wiki/
 ```
 
-Either path produces a `CLAUDE.md` at the project root plus a
-`llm-wiki/` folder. Open the project in Claude Code (or any AI
-assistant) and it picks up the context automatically.
-
----
-
-## What Whale does
-
-### 1. Bootstraps AI context for new projects
-
-`whale ignite` creates a workspace with foundations, a config, the
-intelligence stores, and a fully-generated `CLAUDE.md`. Three modes:
-opinionated default, `--minimal` skeleton, or `--interactive` wizard.
-
-### 2. Adopts existing projects
+`intelligence/*.json` is the source of truth. Markdown files are rendered
+from it so agents always read current project state.
 
-`whale adopt` parses your React/Tailwind source with a real AST, infers
-foundations (grid, radii, palette), detects components, and stages
-proposals you can review and accept. Idempotent — re-runs don't
-duplicate or overwrite your decisions.
+## What's new in v1.3
 
-### 3. Records operational context as you work
+**UI references library** — curated, copy-paste component references ship with the tool. Run `whale references add forms` (or `--all`) to install them into your project. CLAUDE.md and MCP tools automatically expose the files to agents.
 
-Three structured stores capture what would otherwise live in your head:
+**Cross-framework drift detection** — `whale insights drift spacing|color|radii` scans CSS, inline styles, Vue/Svelte style blocks and JSX props for values that don't match your foundations. Run `--review` to accept exceptions as refinements or flag them for refactor.
 
-- **`intelligence/components.json`** — component catalog
-- **`intelligence/decisions.json`** — architectural and product decisions
-- **`intelligence/refinements.json`** — approved exceptions to the system
+**Human-language wizard** — `whale ignite --interactive` now asks plain-English questions (what are you building, which framework, team size) and maps answers to a sensible config automatically.
 
-Every write auto-regenerates `CLAUDE.md` so agents always read current state.
+**Template extraction** — wiki templates moved to `src/templates/` as composable render functions. CLAUDE.md is now structured as three clear sections: what the project is, what to read, and how to work here.
 
-### 4. Surfaces accountable insights
+**`whale changes --since <ref>`** — shows what changed in intelligence stores (decisions, components, refinements) since any git ref, ISO date, or `HEAD~1`.
 
-`whale insights` runs deterministic analyzers over your stores and code:
-refinement clusters, decision tension, orphan components, token drift,
-grid drift, catalog coverage gaps. No AI in the loop — local,
-explainable, machine-checkable.
+## Core Commands
 
-### 5. Generates code that respects your foundations
-
-`whale create component Card --variants primary,outline` produces a
-typed React component using your actual grid, radii, and accent color.
-No invented values. Auto-registers in the catalog.
-
-### 6. Bridges to any AI agent (Selene)
-
-Three composable commands — `describe`, `audit`, `suggest` — package
-your full project context into a structured prompt. They work three ways:
-
-- **Prompt mode** (default, offline): writes the prompt to clipboard;
-  paste into Claude/ChatGPT/Cursor; paste response back with
-  `whale selene apply`.
-- **API mode** (opt-in): if `ANTHROPIC_API_KEY` or `OPENAI_API_KEY`
-  is set, Whale calls the provider directly and auto-applies the result.
-  Transparent fallback to prompt mode on any failure.
-- **MCP mode** (new in v1.0): Whale exposes its capabilities as MCP
-  tools that Claude Code, Cursor, Zed and any MCP client use natively.
-
-### 7. Stays in sync automatically
-
-`whale watch` regenerates `CLAUDE.md` and the wiki when your foundations
-or stores change. Plays well with pre-commit hooks and CI.
-
----
-
-## MCP server
-
-The most powerful integration in v1.0. Wire Whale into your AI tool:
+| Command | Use it when you want to... |
+| --- | --- |
+| `whale ignite my-app` | Create a new Whale workspace |
+| `whale ignite my-app --interactive` | Wizard: project type, stack, team size, packs |
+| `whale adopt` | Scan an existing React/Tailwind project |
+| `whale remember` | Regenerate agent context and wiki |
+| `whale check` | Run validation and project insights |
+| `whale improve` | Ask Selene for improvement suggestions |
+| `whale explain` | Generate docs and AI-readable context |
+| `whale references add --all` | Install UI component reference library |
+| `whale insights drift spacing` | Find off-grid spacing across CSS and JSX |
+| `whale insights drift spacing --review` | Interactively accept or queue each drift issue |
+| `whale changes --since HEAD~5` | Show what changed in intelligence stores |
+| `whale team` | See active operating roles/packs |
+| `whale create component Hero` | Generate a typed React component |
+| `whale mcp config --client cursor` | Configure an MCP client |
+
+## Operating Roles
+
+Whale includes five operating roles as packs:
 
 ```bash
-whale mcp config --client claude-code
-# Prints the JSON snippet for ~/Library/Application Support/Claude/claude_desktop_config.json
+whale team add atlas       # product strategy
+whale team add forge       # implementation architecture
+whale team add scribe      # documentation
+whale team add lighthouse  # quality checks
+whale team add selene      # AI suggestions and audits
 ```
 
-Once configured, the agent gets tools like:
-
-- `whale_project_overview` — read foundations, packs, counts in one call
-- `whale_list_components` — see what already exists before creating duplicates
-- `whale_list_decisions` — understand why the project is structured this way
-- `whale_register_component` — record components the agent creates
-- `whale_record_decision` — record non-obvious choices as they happen
-- `whale_validate`, `whale_insights` — check state mid-session
+They are not autonomous background agents. They are structured project
+roles and instructions that help the agent you already use work with
+better context.
 
-Available client snippets: `--client claude-code | cursor | zed | raw`.
+## AI Bridge
 
----
+Selene packages your project context into structured prompts, or calls an
+API when `ANTHROPIC_API_KEY` or `OPENAI_API_KEY` is configured.
 
-## Command reference
-
-| Command | What it does |
-| --- | --- |
-| `whale ignite [name]` | Bootstrap a workspace. Flags: `--interactive`, `--minimal`. |
-| `whale adopt [target]` | Scan an existing project and stage proposals. |
-| `whale adopt review` | Walk through pending proposals interactively. |
-| `whale adopt status` | List proposals without entering review. |
-| `whale sync` | Regenerate CLAUDE.md + wiki from `intelligence/*.json`. |
-| `whale remember` | Friendly alias for `sync`: update project memory for AI assistants. |
-| `whale check` | Friendly health check: run `validate` and then `insights`. |
-| `whale improve` | Friendly Selene entry point: suggest project-wide improvements. |
-| `whale explain` | Friendly docs entry point: generate reports and wiki/context. |
-| `whale team` | Show active and available AI teammates. |
-| `whale team add <name>` | Add atlas, forge, scribe, lighthouse, or selene as an AI teammate. |
-| `whale watch` | Auto-regenerate on changes. Flags: `--once`, `--verbose`, `--debounce`. |
-| `whale validate` | Run validators. Non-zero exit on errors. |
-| `whale insights` | Local analyzers + recommendations. Flags: `--json`, `--category`, `--min-severity`. |
-| `whale refine "<note>"` | Record a validator override. |
-| `whale decision` | Record an architectural / product decision. |
-| `whale component add <name>` | Register a component. |
-| `whale create component <name>` | Generate a typed component scaffold. |
-| `whale selene describe <component>` | AI-assisted catalog description. |
-| `whale selene audit <file>` | AI-assisted audit against foundations. |
-| `whale selene suggest` | AI-suggested patterns and decisions. |
-| `whale selene apply <kind>` | Apply pasted LLM response. |
-| `whale selene status` | Show provider state, mode, cache. |
-| `whale mcp serve` | Start the MCP server on stdio. |
-| `whale mcp config` | Print client configuration snippets. |
-| `whale docs` | Generate human-facing reports. |
-
----
-
-## Project structure
-
-```
-my-app/
-├── whale.config.json              foundations, packs, AI targets
-├── CLAUDE.md                      AI entry point (auto-generated)
-├── AGENTS.md                      if "codex" in aiTargets
-├── .cursorrules                   if "cursor" in aiTargets
-├── intelligence/                  source of truth (JSON)
-│   ├── refinements.json
-│   ├── decisions.json
-│   └── components.json
-├── llm-wiki/                      rendered view (markdown)
-│   ├── FOUNDATIONS.md
-│   ├── CONVENTIONS.md
-│   ├── DECISIONS.md
-│   ├── COMPONENTS.md
-│   └── WORKFLOWS.md
-└── .whale/                        runtime caches and Selene stash
-    └── selene/
-        ├── cache/
-        └── *.prompt.md / *.response.md
+```bash
+whale selene status
+whale selene suggest --focus all
+whale selene audit src/components/Hero.tsx
 ```
 
-**JSON is the source of truth. Markdown is rendered.** Edit a JSON
-store by hand, run `whale sync` (or have `whale watch` running), and
-everything else catches up.
-
----
-
-## Selene configuration
+Without an API key, Selene runs in prompt mode and prints/copies a prompt
+you can paste into Claude, ChatGPT, Cursor or Codex.
 
-Optional block in `whale.config.json` for API mode:
+## MCP
 
-```json
-{
-  "selene": {
-    "provider": "anthropic",
-    "model": "claude-sonnet-4-6",
-    "temperature": 0.2,
-    "maxTokens": 1500,
-    "autoCall": true,
-    "confirmCost": false,
-    "noCache": false
-  }
-}
+```bash
+whale mcp config --client claude-code
+whale mcp config --client cursor
+whale mcp config --client zed
 ```
 
-Everything is optional. With no config and no key, Selene runs in
-prompt mode forever. Adding a key (env or here) flips it to API mode.
-Set `autoCall: false` to keep prompt mode even with a key available.
-
----
-
-## Presentation
-
-Whale's terminal output is built on a semantic UI layer: commands describe
-*intent* (success, warning, section header, key/value pair) and the active
-theme decides what each intent looks like. One result is that the same
-command produces premium output in a real terminal and clean, grep-friendly
-output in CI.
-
-Three environment variables control presentation:
-
-| Variable | Effect |
-| --- | --- |
-| `WHALE_PLAIN=1` | Disable color *and* Unicode glyphs. The output becomes ASCII-only and grep-friendly. Recommended for CI logs and pipelines. |
-| `WHALE_UNICODE=0` | Keep color, fall back to ASCII glyphs (`*`, `v`, `x`, `->`). Useful for terminals that render color but mangle Unicode. |
-| `NO_COLOR=1` / `FORCE_COLOR=0` | Standard environment overrides — chalk respects them, so does Whale. |
-
-In normal terminals Whale auto-detects capabilities and uses Unicode + color.
-In non-TTY contexts (piping, CI, scripts) it strips both automatically. You
-don't need to opt in unless you want to override the default.
-
----
-
-## Brand kit
-
-Whale ships its identity assets in `brand/` so the GitHub README, npm page,
-demos and future splash surfaces all speak the same visual language.
+MCP exposes project overview, components, decisions, refinements,
+validation, insights and write tools to compatible AI clients.
 
-### Palette
-
-| Token | Hex | Role |
-| --- | --- | --- |
-| `--wi-royal` | `#0034D3` | Primary ink, mark body, headings |
-| `--wi-paper` | `#F2ECE1` | Page background, knockout fill |
-| `--wi-sky` | `#99CCFF` | Soft accent and fills |
-| `--wi-deep` | `#003087` | Dark surface and on-light text |
-
-### Typography
+## Brand Tokens
 
 ```css
+--wi-royal: #0034D3;
+--wi-paper: #F2ECE1;
+--wi-sky:   #99CCFF;
+--wi-deep:  #003087;
+
 --wi-font-display: "Special Elite", ui-monospace, monospace;
 --wi-font-mono:    "JetBrains Mono", ui-monospace, monospace;
 ```
 
-- **Display** — `Special Elite`, used for the wordmark and expressive headings.
-- **Mono** — `JetBrains Mono`, used for CLI surfaces and code samples.
-
-### Assets
-
-| File | Use |
-| --- | --- |
-| `brand/logo.svg` | Primary mark |
-| `brand/wordmark.svg` | Wordmark only |
-| `brand/lockup.svg` | Mark + wordmark for README and docs |
-| `brand/logo-on-paper.svg` | Mark on paper background |
-| `brand/logo-on-royal.svg` | Knockout mark on royal |
-| `brand/favicon.svg` | Light favicon |
-| `brand/favicon-dark.svg` | Dark favicon |
-
----
-
-## CI usage
-
-```yaml
-- run: npx whale-igniter validate .       # exits non-zero on errors
-- run: npx whale-igniter sync              # ensure CLAUDE.md is current
-- run: git diff --exit-code                # fail if sync produced uncommitted changes
-```
-
-This turns "is the AI context current?" into a checkable property of
-the repo. Combine with `whale insights --json --min-severity warning`
-for automated quality reports.
-
----
-
-## Design principles
-
-1. **CLI-first.** Whale is a CLI and the MCP server. No dashboard, no SaaS.
-2. **Local-first.** Intelligence lives in your repo, in git. No accounts.
-3. **AI-native, not AI-dependent.** Core works offline. AI is opt-in at
-   every level.
-4. **Source of truth in JSON; rendered views in Markdown.** One direction.
-5. **Idempotent everywhere.** Re-running adopt, sync, watch, or
-   register doesn't duplicate or corrupt anything.
-6. **Honest fallbacks.** API down? Falls back to prompt mode. Scan
-   fails? Insights skip orphan/drift but still run. Watcher recursive
-   not supported? Falls back to non-recursive. The user is never stuck.
-
----
-
-## What v1.2 doesn't do (and why)
-
-- **Vue / Svelte parsing.** Scanner is React + Tailwind only. Other
-  frameworks need their own parsers; that's post-v1.0.
-- **Hosted SaaS.** Whale is a tool, not a service. By design.
-- **Real-time team sync.** Today everything is local + git. Team
-  workflows happen through PRs against `intelligence/*.json`.
-- **Generic linting.** ESLint and Stylelint exist. Whale only checks
-  what's tied to operational context.
-
-See [docs/ROADMAP.md](docs/ROADMAP.md) for what's planned next.
-
----
+Brand assets ship in `brand/` and are included in the npm package.
 
-## License
+## Links
 
-MIT. See [LICENSE](LICENSE).
+- Roadmap: [`docs/ROADMAP.md`](docs/ROADMAP.md)
+- Package: [npmjs.com/package/whale-igniter](https://www.npmjs.com/package/whale-igniter)
+- License: MIT
 
 <p align="center">
-  <img src="https://unpkg.com/whale-igniter@latest/brand/logo.svg" alt="" width="44"><br>
-  <sub><b>Whale Igniter</b> · local-first project memory for AI agents</sub>
+  <img src="https://cdn.jsdelivr.net/npm/whale-igniter@1.3.0/brand/logo.svg" alt="" width="44"><br>
+  <sub><b>Whale Igniter</b> · map the project before the agent moves</sub>
 </p>

package/dist/analyzer/insights.js

@@ -253,6 +253,145 @@ function analyzeGridDrift(config, observations) {
     return [];
 }
 // ---------------------------------------------------------------------------
+// Cross-framework drift analyzers (Block D)
+// ---------------------------------------------------------------------------
+const SPACING_PROPERTIES = new Set([
+    "padding", "padding-top", "padding-right", "padding-bottom", "padding-left",
+    "margin", "margin-top", "margin-right", "margin-bottom", "margin-left",
+    "gap", "column-gap", "row-gap"
+]);
+const COLOR_PROPERTIES = new Set(["color", "background-color", "border-color"]);
+const RADIUS_PROPERTIES = new Set([
+    "border-radius",
+    "border-top-left-radius", "border-top-right-radius",
+    "border-bottom-left-radius", "border-bottom-right-radius"
+]);
+function isRefinedSpacing(refinements) {
+    return refinements.some((r) => r.scope?.issueType === "spacing");
+}
+export function analyzeSpacingDrift(observations, config, refinements = []) {
+    if (isRefinedSpacing(refinements))
+        return [];
+    const grid = config.foundations?.grid ?? 8;
+    const drifting = observations.filter((o) => SPACING_PROPERTIES.has(o.property) &&
+        o.pxValue != null &&
+        o.pxValue !== 0 &&
+        o.pxValue % grid !== 0);
+    if (drifting.length === 0)
+        return [];
+    // Group by file
+    const byFile = new Map();
+    for (const obs of drifting) {
+        const key = obs.file;
+        if (!byFile.has(key))
+            byFile.set(key, []);
+        byFile.get(key).push(obs);
+    }
+    const insights = [];
+    for (const [file, items] of byFile) {
+        const severity = items.length >= 3 ? "warning" : "info";
+        const fileShort = file.split("/").slice(-2).join("/");
+        insights.push({
+            id: `drift.spacing.${Buffer.from(file).toString("base64").slice(0, 12)}`,
+            category: "tokens",
+            severity,
+            title: `${items.length} off-grid spacing value(s) in ${fileShort}`,
+            detail: `Grid is ${grid}px. Found values that are not multiples: ${[...new Set(items.map((o) => o.value))].slice(0, 5).join(", ")}.`,
+            evidence: items.slice(0, 5).map((o) => `${fileShort}:${o.line} — ${o.property}: ${o.value}`),
+            action: `Run \`whale insights drift spacing --review\` to accept as refinement or flag for refactor.`
+        });
+    }
+    return insights;
+}
+export function analyzeColorDrift(observations, _config, refinements = []) {
+    const colorObs = observations.filter((o) => COLOR_PROPERTIES.has(o.property) &&
+        !o.value.startsWith("var(") &&
+        /^#[0-9a-fA-F]{3,8}$/.test(o.value));
+    if (colorObs.length === 0)
+        return [];
+    // Derive reference palette: top-10 most frequent hex values
+    const freq = new Map();
+    for (const obs of colorObs) {
+        const hex = obs.value.toLowerCase();
+        freq.set(hex, (freq.get(hex) ?? 0) + 1);
+    }
+    const palette = new Set([...freq.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([hex]) => hex));
+    // Check refinements for color exceptions
+    const hasColorRefinement = refinements.some((r) => r.scope?.issueType === "hex");
+    if (hasColorRefinement)
+        return [];
+    // Drifting = hex that is NOT in the top-10 palette
+    const drifting = colorObs.filter((o) => !palette.has(o.value.toLowerCase()));
+    if (drifting.length === 0)
+        return [];
+    // Group by hue family (first 2 hex digits after #)
+    const byHue = new Map();
+    for (const obs of drifting) {
+        const hue = obs.value.slice(1, 3).toLowerCase();
+        if (!byHue.has(hue))
+            byHue.set(hue, []);
+        byHue.get(hue).push(obs);
+    }
+    const insights = [];
+    for (const [hue, items] of byHue) {
+        const severity = items.length >= 3 ? "warning" : "info";
+        const uniqueValues = [...new Set(items.map((o) => o.value))];
+        insights.push({
+            id: `drift.color.${hue}`,
+            category: "tokens",
+            severity,
+            title: `${items.length} color value(s) outside the project palette (hue ~#${hue})`,
+            detail: `Colors not in the top-10 palette: ${uniqueValues.slice(0, 4).join(", ")}.`,
+            evidence: items.slice(0, 5).map((o) => {
+                const short = o.file.split("/").slice(-2).join("/");
+                return `${short}:${o.line} — ${o.property}: ${o.value}`;
+            }),
+            action: `Run \`whale insights drift color --review\` to accept as refinement or flag for refactor.`
+        });
+    }
+    return insights;
+}
+export function analyzeRadiiDrift(observations, config, refinements = []) {
+    const hasRadiusRefinement = refinements.some((r) => r.scope?.issueType === "radius");
+    if (hasRadiusRefinement)
+        return [];
+    const control = config.foundations?.radius?.control ?? 2;
+    const container = config.foundations?.radius?.container ?? 4;
+    const drifting = observations.filter((o) => RADIUS_PROPERTIES.has(o.property) &&
+        o.pxValue != null &&
+        o.pxValue !== 0 &&
+        o.pxValue !== 9999 &&
+        o.pxValue !== control &&
+        o.pxValue !== container);
+    if (drifting.length === 0)
+        return [];
+    // Group by px value to show the spread
+    const byValue = new Map();
+    for (const obs of drifting) {
+        const key = obs.pxValue;
+        if (!byValue.has(key))
+            byValue.set(key, []);
+        byValue.get(key).push(obs);
+    }
+    const spread = [...byValue.keys()].sort((a, b) => a - b);
+    const severity = drifting.length >= 5 ? "warning" : "info";
+    return [{
+            id: "drift.radii",
+            category: "tokens",
+            severity,
+            title: `${drifting.length} border-radius value(s) outside foundations (${control}px / ${container}px)`,
+            detail: `Values found: ${spread.map((v) => `${v}px`).join(", ")}. Expected: ${control}px (controls) or ${container}px (containers).`,
+            evidence: drifting.slice(0, 5).map((o) => {
+                const short = o.file.split("/").slice(-2).join("/");
+                return `${short}:${o.line} — ${o.property}: ${o.value}`;
+            }),
+            action: `Run \`whale insights drift radii --review\` to accept as refinement or flag for refactor.`
+        }];
+}
+// ---------------------------------------------------------------------------
 // Main entry
 // ---------------------------------------------------------------------------
 export function analyze(input) {
@@ -264,6 +403,11 @@ export function analyze(input) {
     all.push(...analyzeTokenDrift(input.observations));
     all.push(...analyzeDecisionTension(input.decisions));
     all.push(...analyzeGridDrift(input.config, input.observations));
+    if (input.styleObservations) {
+        all.push(...analyzeSpacingDrift(input.styleObservations, input.config, input.refinements));
+        all.push(...analyzeColorDrift(input.styleObservations, input.config, input.refinements));
+        all.push(...analyzeRadiiDrift(input.styleObservations, input.config, input.refinements));
+    }
     // Sort by severity (critical > warning > info), then by category for stable output.
     const sevRank = { critical: 0, warning: 1, info: 2 };
     all.sort((a, b) => {

package/dist/commands/adopt.js

@@ -1,12 +1,14 @@
 import path from "node:path";
 import fs from "fs-extra";
 import ora from "ora";
+import prompts from "prompts";
 import { resolveTarget } from "../utils/paths.js";
 import { scanComponents } from "../scanner/componentScanner.js";
 import { aggregateTailwind, detectTailwindConfig } from "../scanner/tailwindScanner.js";
 import { inferFoundations } from "../scanner/foundationInferrer.js";
 import { loadProposals, saveProposals, upsertProposal, fingerprintComponent, fingerprintFoundations, pendingProposals } from "../utils/proposals.js";
 import { loadConfig, saveConfig, DEFAULT_CONFIG } from "../utils/config.js";
+import { getAiAvailability } from "../utils/aiAvailability.js";
 import { ui } from "../ui/index.js";
 const SCANNER_VERSION = "1.1.0";
 export async function adoptCommand(targetArg, options = {}) {
@@ -140,6 +142,24 @@ export async function adoptCommand(targetArg, options = {}) {
         if (!(await fs.pathExists(p)))
             await fs.writeJson(p, [], { spaces: 2 });
     }
+    // ---- Step 7: optional Selene enrichment -----------------------------------
+    const ai = await getAiAvailability(target);
+    if (ai.available) {
+        console.log();
+        const { doEnrich } = await prompts({
+            type: "confirm",
+            name: "doEnrich",
+            message: "Use Selene to add prose descriptions to the inferred foundations? (requires API key)",
+            initial: false
+        });
+        if (doEnrich) {
+            console.log(ui.note("Selene enrichment: run `whale selene describe` after review to add descriptions."));
+        }
+    }
+    else {
+        console.log();
+        console.log(ui.muted("AI features available with Claude Code, Codex, or an API key."));
+    }
     // ---- Summary --------------------------------------------------------------
     console.log();
     console.log(ui.section("Proposals"));