whale-igniter 1.1.0

package/dist/commands/createComponent.js

@@ -0,0 +1,207 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { resolveTarget } from "../utils/paths.js";
+import { loadConfig } from "../utils/config.js";
+import { upsertComponent } from "../utils/components.js";
+import { generateWiki } from "../generators/wikiGenerator.js";
+import { spacingClass, radiusClass, accentColorFamily } from "../scanner/tailwindMapper.js";
+import { ui } from "../ui/index.js";
+const CATEGORY_TEMPLATES = {
+    form: "control",
+    navigation: "control",
+    feedback: "container",
+    surface: "container",
+    layout: "container"
+};
+/**
+ * `whale create component <Name>` generates a .tsx file from a template,
+ * using the project's current foundations so the output respects them
+ * by construction. Two scaffolds:
+ *
+ *   - Control template (button-like): uses control radius, small padding,
+ *     accepts variants (primary, secondary, ghost) and states.
+ *   - Container template (card-like): uses container radius, larger
+ *     padding, no variants by default.
+ *
+ * The choice is driven by category. If no category is passed and the
+ * name looks like a control (Button, Input, Toggle...), we pick control.
+ *
+ * The generator deliberately produces *typed* React components with
+ * `forwardRef` for control-like primitives — that matches the patterns
+ * the scanner detects, so created components are scanner-friendly too.
+ */
+export async function createComponentCommand(name, options = {}) {
+    const target = resolveTarget();
+    if (!name || !/^[A-Z][A-Za-z0-9]*$/.test(name)) {
+        console.log(ui.fail("Component name must be PascalCase (e.g. `Button`, `UserCard`)."));
+        process.exitCode = 1;
+        return;
+    }
+    const config = await loadConfig(target);
+    const grid = config.foundations?.grid ?? 8;
+    const controlRadius = config.foundations?.radius?.control ?? 4;
+    const containerRadius = config.foundations?.radius?.container ?? 8;
+    const accent = accentColorFamily(config.branding?.accent);
+    const variants = options.variants?.split(",").map((s) => s.trim()).filter(Boolean);
+    const states = options.states?.split(",").map((s) => s.trim()).filter(Boolean);
+    const category = options.category ?? inferCategoryFromName(name);
+    const templateKind = category && CATEGORY_TEMPLATES[category] ? CATEGORY_TEMPLATES[category] : (looksLikeControl(name) ? "control" : "container");
+    // Output path: by default `src/components/<Name>.tsx`. Configurable.
+    const outDir = options.outDir ?? "src/components";
+    const filename = `${name}.tsx`;
+    const fileRel = path.join(outDir, filename).replace(/\\/g, "/");
+    const fileAbs = path.join(target, fileRel);
+    if (await fs.pathExists(fileAbs)) {
+        if (!options.force) {
+            console.log(ui.fail(`${ui.path(fileRel)} already exists. Use --force to overwrite.`));
+            process.exitCode = 1;
+            return;
+        }
+        console.log(ui.warn(`Overwriting ${ui.path(fileRel)} (--force).`));
+    }
+    await fs.ensureDir(path.dirname(fileAbs));
+    const source = templateKind === "control"
+        ? renderControlTemplate({
+            name,
+            grid,
+            radius: controlRadius,
+            accent,
+            variants: variants && variants.length > 0 ? variants : ["primary", "secondary", "ghost"],
+            states: states && states.length > 0 ? states : ["hover", "focus", "disabled"]
+        })
+        : renderContainerTemplate({
+            name,
+            grid,
+            radius: containerRadius
+        });
+    await fs.writeFile(fileAbs, source, "utf8");
+    console.log(ui.ok(`Created ${ui.path(fileRel)}`));
+    console.log(`  ${ui.kv("template", templateKind, { keyWidth: 8 })}`);
+    console.log(`  ${ui.kv("radius", `${templateKind === "control" ? controlRadius : containerRadius}px`, { keyWidth: 8 })}`);
+    console.log(`  ${ui.kv("grid", `${grid}px`, { keyWidth: 8 })}`);
+    if (variants && variants.length > 0)
+        console.log(`  ${ui.kv("variants", variants.join(", "), { keyWidth: 8 })}`);
+    // Auto-register in the catalog unless explicitly skipped.
+    if (!options.noRegister) {
+        await upsertComponent(target, {
+            name,
+            category,
+            variants: variants && variants.length > 0 ? variants : templateKind === "control" ? ["primary", "secondary", "ghost"] : undefined,
+            states: states && states.length > 0 ? states : templateKind === "control" ? ["hover", "focus", "disabled"] : undefined,
+            files: [fileRel]
+        });
+        console.log(ui.muted(`  registered in intelligence/components.json`));
+    }
+    if (!options.noSync && !options.noRegister) {
+        await generateWiki(target);
+        console.log(ui.muted(`${ui.glyph.check} AI context updated`));
+    }
+}
+// ---------------------------------------------------------------------------
+// Heuristics & templates
+// ---------------------------------------------------------------------------
+function inferCategoryFromName(name) {
+    const lower = name.toLowerCase();
+    if (/button|input|select|checkbox|radio|toggle|switch|slider|textarea/.test(lower))
+        return "form";
+    if (/nav|menu|header|sidebar|breadcrumb|tab|tabs/.test(lower))
+        return "navigation";
+    if (/modal|dialog|toast|alert|notification|popover|tooltip/.test(lower))
+        return "feedback";
+    if (/layout|grid|container|stack|cluster/.test(lower))
+        return "layout";
+    if (/card|panel|section|hero|cta|surface/.test(lower))
+        return "surface";
+    return undefined;
+}
+function looksLikeControl(name) {
+    return /button|input|select|checkbox|radio|toggle|switch|slider|tab|link/i.test(name);
+}
+function renderControlTemplate(args) {
+    const { name, grid, radius, accent, variants, states } = args;
+    // Padding: 2× grid horizontal, 1× grid vertical (the classic control rhythm).
+    // For an 8px grid this yields px-4 py-2; for 4px it yields px-2 py-1.
+    const px = spacingClass("px", Math.max(grid * 2, 8));
+    const py = spacingClass("py", grid);
+    const rounded = radiusClass("rounded", radius);
+    const variantTypeUnion = variants.map((v) => `"${v}"`).join(" | ");
+    const variantStylesEntries = variants.map((v) => `  ${v}: "${variantClasses(v, accent)}"`).join(",\n");
+    const hasDisabled = states.includes("disabled");
+    const hasFocus = states.includes("focus");
+    return `import React, { forwardRef } from "react";
+
+type ${name}Variant = ${variantTypeUnion};
+
+type ${name}Props = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+  variant?: ${name}Variant;
+};
+
+// Generated by Whale Igniter. Foundations applied:
+//   grid    ${grid}px        padding uses multiples of ${grid}
+//   radius  ${radius}px        control radius from whale.config.json
+//   states  ${states.join(", ")}
+
+const baseClasses =
+  "inline-flex items-center justify-center ${px} ${py} ${rounded} text-sm font-medium transition-colors${hasFocus ? " focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2" : ""}${hasDisabled ? " disabled:opacity-50 disabled:pointer-events-none" : ""}";
+
+const variantClasses: Record<${name}Variant, string> = {
+${variantStylesEntries}
+};
+
+export const ${name} = forwardRef<HTMLButtonElement, ${name}Props>(
+  ({ variant = "${variants[0]}", className, children, ...rest }, ref) => {
+    const composed = \`\${baseClasses} \${variantClasses[variant]}\${className ? \` \${className}\` : ""}\`;
+    return (
+      <button ref={ref} className={composed} {...rest}>
+        {children}
+      </button>
+    );
+  }
+);
+
+${name}.displayName = "${name}";
+`;
+}
+function variantClasses(variant, accent) {
+    switch (variant) {
+        case "primary":
+            return `bg-${accent}-600 text-white hover:bg-${accent}-700 focus-visible:ring-${accent}-500`;
+        case "secondary":
+            return `bg-gray-100 text-gray-900 hover:bg-gray-200 focus-visible:ring-gray-400`;
+        case "ghost":
+            return `bg-transparent text-gray-700 hover:bg-gray-100 focus-visible:ring-gray-400`;
+        case "destructive":
+            return `bg-red-600 text-white hover:bg-red-700 focus-visible:ring-red-500`;
+        case "outline":
+            return `bg-transparent text-gray-900 border border-gray-300 hover:bg-gray-50 focus-visible:ring-gray-400`;
+        default:
+            return `bg-${accent}-100 text-${accent}-900 hover:bg-${accent}-200`;
+    }
+}
+function renderContainerTemplate(args) {
+    const { name, grid, radius } = args;
+    // Container padding: 3× grid (24px on an 8px grid is a common card padding).
+    const p = spacingClass("p", grid * 3);
+    const rounded = radiusClass("rounded", radius);
+    return `import React from "react";
+
+type ${name}Props = React.HTMLAttributes<HTMLDivElement> & {
+  children?: React.ReactNode;
+};
+
+// Generated by Whale Igniter. Foundations applied:
+//   grid    ${grid}px        padding uses multiples of ${grid}
+//   radius  ${radius}px        container radius from whale.config.json
+
+const baseClasses = "${p} ${rounded} bg-white border border-gray-200 shadow-sm";
+
+export function ${name}({ className, children, ...rest }: ${name}Props) {
+  const composed = \`\${baseClasses}\${className ? \` \${className}\` : ""}\`;
+  return (
+    <div className={composed} {...rest}>
+      {children}
+    </div>
+  );
+}
+`;
+}

package/dist/commands/decision.js

@@ -0,0 +1,98 @@
+import prompts from "prompts";
+import { resolveTarget } from "../utils/paths.js";
+import { appendDecision } from "../utils/decisions.js";
+import { generateWiki } from "../generators/wikiGenerator.js";
+import { ui } from "../ui/index.js";
+const CATEGORIES = [
+    "architecture",
+    "design-system",
+    "product",
+    "tooling",
+    "convention"
+];
+export async function decisionCommand(options = {}) {
+    const target = resolveTarget();
+    // If essentials are missing, fall into interactive mode.
+    const needsPrompt = !options.title || !options.decision;
+    let title = options.title;
+    let category = options.category ?? "architecture";
+    let context = options.context;
+    let decisionText = options.decision;
+    let consequences = options.consequences;
+    if (needsPrompt) {
+        console.log(ui.header("Whale Igniter", "decision"));
+        console.log();
+        console.log(ui.muted("Press Ctrl+C to cancel."));
+        console.log();
+        const answers = await prompts([
+            {
+                type: title ? null : "text",
+                name: "title",
+                message: "Title (one line):",
+                validate: (v) => (v.trim().length > 0 ? true : "Required")
+            },
+            {
+                type: options.category ? null : "select",
+                name: "category",
+                message: "Category:",
+                choices: CATEGORIES.map((c) => ({ title: c, value: c })),
+                initial: 0
+            },
+            {
+                type: context ? null : "text",
+                name: "context",
+                message: "Context (why this came up, optional):"
+            },
+            {
+                type: decisionText ? null : "text",
+                name: "decision",
+                message: "Decision (what was decided):",
+                validate: (v) => (v.trim().length > 0 ? true : "Required")
+            },
+            {
+                type: consequences ? null : "text",
+                name: "consequences",
+                message: "Consequences (tradeoffs, optional):"
+            }
+        ], {
+            onCancel: () => {
+                console.log();
+                console.log(ui.warn("Cancelled."));
+                process.exit(130);
+            }
+        });
+        title = title ?? answers.title;
+        category = (category ?? answers.category);
+        context = context ?? answers.context;
+        decisionText = decisionText ?? answers.decision;
+        consequences = consequences ?? answers.consequences;
+    }
+    if (!title || !decisionText) {
+        console.log(ui.fail("Title and decision are required."));
+        process.exitCode = 1;
+        return;
+    }
+    if (!CATEGORIES.includes(category)) {
+        console.log(ui.fail(`Unknown category: ${category}`));
+        console.log(ui.muted(`Valid categories: ${CATEGORIES.join(", ")}`));
+        process.exitCode = 1;
+        return;
+    }
+    const created = await appendDecision(target, {
+        title,
+        category,
+        context: context?.trim() || undefined,
+        decision: decisionText,
+        consequences: consequences?.trim() || undefined
+    });
+    console.log();
+    console.log(ui.ok(`Decision recorded ${ui.muted("— " + created.id.slice(0, 8))}`));
+    console.log(`  ${ui.accent(created.title)}`);
+    console.log(`  ${ui.kv("category", created.category, { keyWidth: 8 })}`);
+    if (options.sync !== false) {
+        console.log();
+        console.log(ui.muted("Regenerating AI context..."));
+        await generateWiki(target);
+        console.log(ui.ok("CLAUDE.md and wiki updated"));
+    }
+}

package/dist/commands/docs.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+import ora from "ora";
+import { resolveTarget } from "../utils/paths.js";
+import { loadConfig } from "../utils/config.js";
+import { getPack } from "../utils/registry.js";
+import { runGenerator } from "../generators/markdownGenerator.js";
+import { generateValidationReport } from "../generators/reportGenerator.js";
+import { ui } from "../ui/index.js";
+export async function docsCommand(targetArg) {
+    const target = resolveTarget(targetArg);
+    const spinner = ora("Generating operational docs").start();
+    const config = await loadConfig(target);
+    const written = [];
+    // Always include the validation report — it's the core deliverable.
+    const reportPath = await generateValidationReport(target);
+    written.push(reportPath);
+    // Then run any generator-kind packs the project has installed.
+    for (const packName of config.packs ?? []) {
+        const pack = getPack(packName);
+        if (!pack || pack.kind !== "generator")
+            continue;
+        try {
+            const out = await runGenerator(target, pack);
+            written.push(out);
+        }
+        catch (err) {
+            spinner.warn(`Generator "${packName}" failed: ${err.message}`);
+        }
+    }
+    spinner.succeed("Docs generated");
+    for (const f of written) {
+        console.log(`  ${ui.ok(ui.path(path.relative(target, f)))}`);
+    }
+}

package/dist/commands/ignite.js

@@ -0,0 +1,212 @@
+import path from "node:path";
+import prompts from "prompts";
+import { initCommand } from "./init.js";
+import { loadConfig, saveConfig, DEFAULT_CONFIG } from "../utils/config.js";
+import { getPack, listPacks } from "../utils/registry.js";
+import { validateCss } from "../validators/cssValidator.js";
+import { generateWiki } from "../generators/wikiGenerator.js";
+import { ui } from "../ui/index.js";
+import { PACKAGE_VERSION } from "../version.js";
+const OPINIONATED_PACKS = ["lighthouse", "forge", "scribe"];
+const MINIMAL_PACKS = ["lighthouse"];
+export async function igniteCommand(projectName = "whale-project", options = {}) {
+    const mode = options.interactive
+        ? "interactive"
+        : options.minimal
+            ? "minimal"
+            : "opinionated";
+    console.log();
+    console.log(ui.header("Whale Igniter", `ignite • ${mode}`));
+    console.log();
+    // ---- Resolve config based on mode -----------------------------------------
+    let config;
+    if (mode === "interactive") {
+        config = await runWizard(projectName);
+    }
+    else if (mode === "minimal") {
+        config = {
+            ...DEFAULT_CONFIG,
+            projectName,
+            packs: MINIMAL_PACKS,
+            aiTargets: ["claude"]
+        };
+    }
+    else {
+        config = {
+            ...DEFAULT_CONFIG,
+            projectName,
+            packs: OPINIONATED_PACKS,
+            aiTargets: ["claude"]
+        };
+    }
+    // ---- Step 1: scaffold workspace -------------------------------------------
+    const target = await initCommand(projectName, { config, silent: true });
+    const targetRel = path.relative(process.cwd(), target) || ".";
+    console.log(ui.ok(`Workspace created at ${ui.path(targetRel)}`));
+    // ---- Step 2: confirm packs against registry -------------------------------
+    console.log();
+    console.log(ui.section("Packs"));
+    const finalConfig = await loadConfig(target);
+    const validPacks = [];
+    const packLines = [];
+    for (const name of finalConfig.packs ?? []) {
+        const pack = getPack(name);
+        if (!pack) {
+            packLines.push(ui.warn(`${name} — not in registry, skipped`));
+            continue;
+        }
+        validPacks.push(name);
+        packLines.push(`${ui.glyph.check} ${ui.code(name)} ${ui.muted(`(${pack.kind})`)} — ${pack.description}`);
+    }
+    console.log(ui.indent(packLines.join("\n")));
+    finalConfig.packs = validPacks;
+    finalConfig.ignited = {
+        at: new Date().toISOString(),
+        mode,
+        version: PACKAGE_VERSION
+    };
+    await saveConfig(target, finalConfig);
+    // ---- Step 3: generate AI context ------------------------------------------
+    if (mode === "minimal") {
+        console.log();
+        console.log(ui.note("Skipping AI context generation (minimal mode)."));
+        console.log(ui.indent(ui.muted("Run `whale sync` when you want to generate it.")));
+    }
+    else {
+        console.log();
+        console.log(ui.section("AI context"));
+        const { rootFiles, wikiFiles } = await generateWiki(target);
+        const ctxLines = [];
+        for (const f of rootFiles) {
+            ctxLines.push(`${ui.glyph.check} ${ui.path(path.relative(target, f))}`);
+        }
+        ctxLines.push(ui.muted(`+ ${wikiFiles.length} file(s) in llm-wiki/`));
+        console.log(ui.indent(ctxLines.join("\n")));
+    }
+    // ---- Step 4: baseline validation ------------------------------------------
+    if (mode !== "minimal") {
+        console.log();
+        console.log(ui.section("Baseline validation"));
+        const issues = await validateCss(target);
+        if (issues.length === 0) {
+            console.log(ui.indent(ui.ok("Clean baseline") + " " + ui.muted("(no CSS to scan yet — expected on a fresh project)")));
+        }
+        else {
+            const errors = issues.filter((i) => i.severity === "error").length;
+            const warnings = issues.filter((i) => i.severity === "warning").length;
+            console.log(ui.indent(ui.summary([
+                { label: "errors", value: errors, tone: errors > 0 ? "danger" : "muted" },
+                { label: "warnings", value: warnings, tone: warnings > 0 ? "warn" : "muted" }
+            ])));
+            console.log(ui.indent(ui.muted("Run `whale validate` for details.")));
+        }
+    }
+    // ---- Done -----------------------------------------------------------------
+    console.log();
+    console.log(ui.section("Next"));
+    const rel = path.relative(process.cwd(), target);
+    const steps = [];
+    if (rel)
+        steps.push([`cd ${rel}`, "enter the workspace"]);
+    steps.push(["whale validate", "check current state"]);
+    steps.push(["whale decision", "record an architecture decision"]);
+    steps.push(["whale component add Button", "register a component"]);
+    steps.push(['whale refine "<note>"', "record a validator override"]);
+    steps.push(["whale sync", "refresh AI context anytime"]);
+    const widest = Math.max(...steps.map(([cmd]) => cmd.length));
+    for (const [cmd, desc] of steps) {
+        console.log(ui.indent(`${ui.glyph.arrow} ${ui.code(cmd.padEnd(widest))}  ${ui.muted(desc)}`));
+    }
+    console.log();
+    if (mode === "minimal") {
+        console.log(ui.info("Workspace ready. Run `whale sync` to generate CLAUDE.md when needed."));
+    }
+    else {
+        console.log(ui.info("Your CLAUDE.md is ready. Open the project in Claude Code / Cursor and start working."));
+    }
+    console.log();
+}
+// ---------------------------------------------------------------------------
+// Interactive wizard — unchanged logic, just uses ui for the header.
+// ---------------------------------------------------------------------------
+async function runWizard(defaultName) {
+    console.log(ui.muted("Answer a few questions to shape your workspace. Ctrl+C to cancel."));
+    console.log();
+    const allPacks = listPacks();
+    const answers = await prompts([
+        { type: "text", name: "projectName", message: "Project name:", initial: defaultName },
+        {
+            type: "select",
+            name: "projectType",
+            message: "Project type:",
+            choices: [
+                { title: "Landing page", value: "landing-page" },
+                { title: "Web app", value: "web-app" },
+                { title: "Component library", value: "component-library" },
+                { title: "Documentation site", value: "docs-site" },
+                { title: "Other", value: "other" }
+            ]
+        },
+        {
+            type: "select",
+            name: "stack",
+            message: "Styling stack:",
+            choices: [
+                { title: "Plain CSS", value: "css" },
+                { title: "Tailwind", value: "tailwind" },
+                { title: "SCSS / Sass", value: "scss" },
+                { title: "CSS-in-JS (styled-components, emotion, ...)", value: "css-in-js" }
+            ]
+        },
+        { type: "number", name: "grid", message: "Grid unit (px):", initial: 8, min: 1, max: 32 },
+        { type: "number", name: "radiusControl", message: "Radius for controls (buttons, inputs):", initial: 2, min: 0, max: 64 },
+        { type: "number", name: "radiusContainer", message: "Radius for containers (cards, modals):", initial: 4, min: 0, max: 64 },
+        {
+            type: "multiselect",
+            name: "packs",
+            message: "Packs to install:",
+            instructions: false,
+            hint: "space to toggle, enter to confirm",
+            choices: allPacks.map((p) => ({
+                title: `${p.name} (${p.kind})`,
+                description: p.description,
+                value: p.name,
+                selected: OPINIONATED_PACKS.includes(p.name)
+            }))
+        },
+        {
+            type: "multiselect",
+            name: "aiTargets",
+            message: "AI agents to generate context for:",
+            instructions: false,
+            hint: "space to toggle, enter to confirm",
+            choices: [
+                { title: "Claude (CLAUDE.md)", value: "claude", selected: true },
+                { title: "Codex / Generic agent (AGENTS.md)", value: "codex" },
+                { title: "Cursor (.cursorrules)", value: "cursor" },
+                { title: "GitHub Copilot (.github/copilot-instructions.md)", value: "copilot" }
+            ]
+        }
+    ], {
+        onCancel: () => {
+            console.log();
+            console.log(ui.warn("Ignite cancelled."));
+            process.exit(130);
+        }
+    });
+    return {
+        ...DEFAULT_CONFIG,
+        projectName: answers.projectName,
+        projectType: answers.projectType,
+        stack: answers.stack,
+        packs: answers.packs && answers.packs.length > 0 ? answers.packs : OPINIONATED_PACKS,
+        aiTargets: answers.aiTargets && answers.aiTargets.length > 0 ? answers.aiTargets : ["claude"],
+        foundations: {
+            grid: answers.grid ?? 8,
+            radius: {
+                control: answers.radiusControl ?? 2,
+                container: answers.radiusContainer ?? 4
+            }
+        }
+    };
+}

package/dist/commands/init.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+import fs from "fs-extra";
+import ora from "ora";
+import { DEFAULT_CONFIG, saveConfig } from "../utils/config.js";
+import { ui } from "../ui/index.js";
+/**
+ * Folders Whale always expects to exist. Created empty so subsequent
+ * commands never need to defensively check.
+ */
+const FOLDERS = [
+    "foundations",
+    "recipes",
+    "patterns",
+    "packs",
+    "docs",
+    "llm-wiki",
+    "intelligence",
+    "examples",
+    "templates"
+];
+/**
+ * Empty initial files for the intelligence store. Wiring them in from
+ * day one means `whale validate`, `whale sync` etc. don't fail on a
+ * fresh project.
+ */
+async function ensureIntelligenceFiles(target) {
+    const intelligenceDir = path.join(target, "intelligence");
+    await fs.ensureDir(intelligenceDir);
+    const seeds = {
+        "refinements.json": [],
+        "decisions.json": [],
+        "components.json": []
+    };
+    for (const [name, content] of Object.entries(seeds)) {
+        const file = path.join(intelligenceDir, name);
+        if (!(await fs.pathExists(file))) {
+            await fs.writeJson(file, content, { spaces: 2 });
+        }
+    }
+}
+export async function initCommand(projectName = "whale-project", options = {}) {
+    const target = path.resolve(process.cwd(), projectName);
+    const spinner = options.silent
+        ? null
+        : ora(`Scaffolding ${projectName}`).start();
+    await fs.ensureDir(target);
+    for (const folder of FOLDERS) {
+        await fs.ensureDir(path.join(target, folder));
+    }
+    // Persist config (either user-provided or defaults), but keep projectName.
+    const config = {
+        ...DEFAULT_CONFIG,
+        ...(options.config ?? {}),
+        projectName: options.config?.projectName ?? projectName
+    };
+    await saveConfig(target, config);
+    await ensureIntelligenceFiles(target);
+    if (spinner) {
+        spinner.succeed(`Workspace ready at ${target}`);
+        console.log(`  ${ui.ok(ui.path("whale.config.json"))}`);
+        console.log(`  ${ui.ok(ui.path("intelligence/") + ui.muted(" (refinements, decisions, components)"))}`);
+        console.log(`  ${ui.ok(ui.path("llm-wiki/") + ui.muted(" (empty — run `whale sync` to populate)"))}`);
+        console.log(ui.muted(`  next: cd ${projectName} && whale validate`));
+    }
+    return target;
+}