fimo 0.3.1 → 0.3.2-experimental.1783328062928

package/dist/scripts/scan-wrappable.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import { scanWrappableFile } from './scan-wrappable.js';
+const scan = (code) => scanWrappableFile('/test/page.tsx', code, 'app/page.tsx');
+describe('scanWrappableFile', () => {
+    it('finds hardcoded JSX text with its line', () => {
+        const { items } = scan(`export default function Page() {
+  return (
+    <div>
+      <h1>Ship your site in hours</h1>
+    </div>
+  );
+}`);
+        expect(items).toEqual([{ kind: 'text', file: 'app/page.tsx', line: 4, preview: 'Ship your site in hours' }]);
+    });
+    it('skips whitespace and short fragments', () => {
+        const { items } = scan(`const x = <div> {'a'} <span>ok</span> </div>;`);
+        expect(items.filter((i) => i.kind === 'text')).toEqual([]);
+    });
+    it('finds images, videos, file links, and attribute strings', () => {
+        const { items } = scan(`const x = (
+  <div>
+    <img src="/images/hero.png" alt="Hero" />
+    <video src="/demo.mp4" />
+    <a href="/whitepaper.pdf">Download</a>
+    <input placeholder="Your work email" />
+  </div>
+);`);
+        expect(items.map((i) => i.kind).sort()).toEqual(['attribute', 'file-link', 'image', 'text', 'video']);
+        expect(items.find((i) => i.kind === 'attribute')?.preview).toBe('placeholder: Your work email');
+    });
+    it('treats content inside Fimo wrappers as wrapped', () => {
+        const { items, wrapped } = scan(`const x = (
+  <div>
+    <FimoText id="home.hero.title">Ship your site in hours</FimoText>
+    <FimoMediaImage id="home.hero.image" src="/images/hero.png" alt="Hero" />
+  </div>
+);`);
+        expect(items).toEqual([]);
+        expect(wrapped).toBe(2);
+    });
+    it('counts t() calls as wrapped and skips regular links', () => {
+        const { items, wrapped } = scan(`const x = <input placeholder={String(t('home.email', 'Your email'))} />;
+const y = <a href="/about">About</a>;`);
+        expect(items.filter((i) => i.kind === 'attribute')).toEqual([]);
+        expect(items.filter((i) => i.kind === 'file-link')).toEqual([]);
+        expect(wrapped).toBe(1);
+    });
+});

package/dist/scripts/validate-route-metadata.js

@@ -31,6 +31,17 @@ export function validateRouteMetadata(options = {}) {
     const srcDir = path.resolve(cwd, 'src');
     const routesFilePath = path.resolve(srcDir, 'routes.ts');
     const errors = [];
+    // Everything below the i18n checks cross-validates React Router's
+    // src/routes.ts. Adopted (wrapped) projects on another framework declare it
+    // in fimo-config.json — their routes come from framework scans, so only the
+    // framework-neutral config checks apply.
+    const earlyConfig = readJson(configFilePath);
+    const framework = typeof earlyConfig.framework === 'string' ? earlyConfig.framework : 'react-router';
+    if (framework !== 'react-router') {
+        const i18n = validateI18nConfig(earlyConfig);
+        const configRoutes = loadConfigRoutes(earlyConfig);
+        return { errors: i18n.errors, routesChecked: configRoutes.length };
+    }
     // Parse routes from src/routes.ts (file → path mapping)
     let fileRoutes = [];
     if (!fs.existsSync(routesFilePath)) {

package/dist/scripts/validate-schemas.d.ts

@@ -0,0 +1,13 @@
+export interface SchemaFileError {
+    rule: string;
+    message: string;
+    file: string;
+}
+export interface ValidateSchemasResult {
+    errors: SchemaFileError[];
+    schemasChecked: number;
+}
+export declare function validateSchemas(options?: {
+    cwd?: string;
+}): ValidateSchemasResult;
+export declare function validateSchemaFile(absolutePath: string, file: string): SchemaFileError[];

package/dist/scripts/validate-schemas.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { FieldTypeSchema, RESERVED_CONTENT_FIELD_NAMES } from '@fimo/api-contracts';
+/**
+ * Validate `src/schemas/*.json` locally against the same rules the API's
+ * schema validator enforces (field types, reserved field names, required
+ * uid/name). Catching these in `fimo validate` surfaces the real problem
+ * before a `schemas push` can fail with a less direct server error.
+ */
+const SCHEMAS_REL = 'src/schemas';
+const FIELD_TYPES = new Set(FieldTypeSchema.options);
+const RESERVED_FIELD_NAMES = new Set(RESERVED_CONTENT_FIELD_NAMES);
+export function validateSchemas(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const schemasDir = join(cwd, SCHEMAS_REL);
+    if (!existsSync(schemasDir)) {
+        return { errors: [], schemasChecked: 0 };
+    }
+    const files = readdirSync(schemasDir)
+        .filter((f) => f.endsWith('.json'))
+        .sort();
+    const errors = [];
+    for (const fileName of files) {
+        const file = join(SCHEMAS_REL, fileName);
+        errors.push(...validateSchemaFile(join(schemasDir, fileName), file));
+    }
+    return { errors, schemasChecked: files.length };
+}
+export function validateSchemaFile(absolutePath, file) {
+    let schema;
+    try {
+        schema = JSON.parse(readFileSync(absolutePath, 'utf-8'));
+    }
+    catch (error) {
+        return [
+            {
+                rule: 'schemas/parse',
+                message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                file,
+            },
+        ];
+    }
+    if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
+        return [{ rule: 'schemas/shape', message: 'Schema must be a JSON object.', file }];
+    }
+    const errors = [];
+    const { uid, name, fields } = schema;
+    const expectedUid = basename(file, '.json');
+    if (typeof uid !== 'string' || uid.length === 0) {
+        errors.push({
+            rule: 'schemas/uid',
+            message: `Missing "uid". Set it to the file name: "${expectedUid}".`,
+            file,
+        });
+    }
+    else if (uid !== expectedUid) {
+        errors.push({
+            rule: 'schemas/uid',
+            message: `"uid" is "${uid}" but the file is ${expectedUid}.json — they must match.`,
+            file,
+        });
+    }
+    if (typeof name !== 'string' || name.length === 0) {
+        errors.push({
+            rule: 'schemas/name',
+            message: 'Missing "name" (the human-readable label).',
+            file,
+        });
+    }
+    if (typeof fields !== 'object' || fields === null || Array.isArray(fields)) {
+        errors.push({
+            rule: 'schemas/fields',
+            message: 'Missing "fields" object.',
+            file,
+        });
+        return errors;
+    }
+    for (const [fieldName, definition] of Object.entries(fields)) {
+        if (RESERVED_FIELD_NAMES.has(fieldName)) {
+            errors.push({
+                rule: 'schemas/reserved-field',
+                message: `Field "${fieldName}" is reserved entry metadata — the platform manages it automatically. ` +
+                    `Remove it from the schema${fieldName === 'slug' ? ' (set slug inside entry data on create instead)' : ''}.`,
+                file,
+            });
+            continue;
+        }
+        if (typeof definition !== 'object' || definition === null || Array.isArray(definition)) {
+            errors.push({
+                rule: 'schemas/field-shape',
+                message: `Field "${fieldName}" must be an object like { "type": "string" }.`,
+                file,
+            });
+            continue;
+        }
+        const { type } = definition;
+        if (typeof type !== 'string' || !FIELD_TYPES.has(type)) {
+            errors.push({
+                rule: 'schemas/field-type',
+                message: `Field "${fieldName}" has unsupported type "${String(type)}". Allowed: ${[...FIELD_TYPES].join(', ')}.`,
+                file,
+            });
+        }
+        if ('i18n' in definition) {
+            errors.push({
+                rule: 'schemas/field-i18n',
+                message: `Field "${fieldName}": field-level locale settings ("i18n") are not supported.`,
+                file,
+            });
+        }
+    }
+    return errors;
+}

package/dist/scripts/validate-schemas.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/validate-schemas.test.js

@@ -0,0 +1,132 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { validateSchemas } from './validate-schemas';
+describe('validateSchemas', () => {
+    let scratch = null;
+    afterEach(() => {
+        if (scratch) {
+            rmSync(scratch, { recursive: true, force: true });
+            scratch = null;
+        }
+    });
+    function writeProject(schemas) {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
+        for (const [fileName, schema] of Object.entries(schemas)) {
+            writeFileSync(join(scratch, 'src/schemas', fileName), typeof schema === 'string' ? schema : JSON.stringify(schema, null, 2));
+        }
+        return scratch;
+    }
+    it('accepts a valid schema', () => {
+        const cwd = writeProject({
+            'BlogPost.json': {
+                uid: 'BlogPost',
+                name: 'Blog Posts',
+                fields: {
+                    title: { type: 'string' },
+                    body: { type: 'richtext' },
+                    coverImage: { type: 'media' },
+                    featured: { type: 'boolean' },
+                },
+            },
+        });
+        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 1 });
+    });
+    it('returns no errors when the schemas directory does not exist', () => {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        expect(validateSchemas({ cwd: scratch })).toEqual({ errors: [], schemasChecked: 0 });
+    });
+    it('rejects reserved field names like slug', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'TeamMember',
+                name: 'Team Members',
+                fields: {
+                    name: { type: 'string' },
+                    slug: { type: 'string' },
+                },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reserved-field', file: 'src/schemas/TeamMember.json' });
+        expect(errors[0].message).toContain('"slug" is reserved');
+        expect(errors[0].message).toContain('entry data');
+    });
+    it('rejects every reserved metadata name', () => {
+        const cwd = writeProject({
+            'Bad.json': {
+                uid: 'Bad',
+                name: 'Bad',
+                fields: Object.fromEntries(['id', 'documentId', 'slug', 'locale', 'createdAt', 'updatedAt', '__fimo'].map((name) => [
+                    name,
+                    { type: 'string' },
+                ])),
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(7);
+        expect(errors.every((err) => err.rule === 'schemas/reserved-field')).toBe(true);
+    });
+    it('rejects unsupported field types', () => {
+        const cwd = writeProject({
+            'Product.json': {
+                uid: 'Product',
+                name: 'Products',
+                fields: { price: { type: 'decimal' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-type' });
+        expect(errors[0].message).toContain('"decimal"');
+        expect(errors[0].message).toContain('string, richtext, media');
+    });
+    it('rejects field-level i18n settings', () => {
+        const cwd = writeProject({
+            'Page.json': {
+                uid: 'Page',
+                name: 'Pages',
+                fields: { title: { type: 'string', i18n: true } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
+    });
+    it('rejects a uid that does not match the file name', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'Member',
+                name: 'Team Members',
+                fields: { name: { type: 'string' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/uid' });
+    });
+    it('rejects missing uid, name, and fields', () => {
+        const cwd = writeProject({ 'Empty.json': {} });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors.map((err) => err.rule)).toEqual(['schemas/uid', 'schemas/name', 'schemas/fields']);
+    });
+    it('reports invalid JSON', () => {
+        const cwd = writeProject({ 'Broken.json': '{ not json' });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/parse' });
+    });
+    it('validates multiple files and counts them', () => {
+        const cwd = writeProject({
+            'Good.json': { uid: 'Good', name: 'Good', fields: { title: { type: 'string' } } },
+            'Bad.json': { uid: 'Bad', name: 'Bad', fields: { slug: { type: 'string' } } },
+        });
+        const result = validateSchemas({ cwd });
+        expect(result.schemasChecked).toBe(2);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0].file).toBe('src/schemas/Bad.json');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.3.1",
+  "version": "0.3.2-experimental.1783328062928",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"
@@ -15,10 +15,23 @@
   ],
   "type": "module",
   "exports": {
+    "./package.json": "./package.json",
     "./ui": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
     },
+    "./react": {
+      "types": "./dist/runtime/react/index.d.ts",
+      "import": "./dist/runtime/react/index.js"
+    },
+    "./next": {
+      "types": "./dist/runtime/next/index.d.ts",
+      "import": "./dist/runtime/next/index.js"
+    },
+    "./next/server": {
+      "types": "./dist/runtime/next/server.d.ts",
+      "import": "./dist/runtime/next/server.js"
+    },
     "./react-router": {
       "types": "./dist/runtime/react-router/index.d.ts",
       "import": "./dist/runtime/react-router/index.js"
@@ -96,11 +109,26 @@
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.80.6",
+    "next": ">=14.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-router": "^7.0.0",
     "vite": "^7.0.0 || ^8.0.0"
   },
+  "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "react-router": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20.12.0"
   }

package/release.json

@@ -1,5 +1,5 @@
 {
   "source": "npm",
-  "apiUrl": "https://api.fimo.ai",
-  "webUrl": "https://fimo.ai"
+  "apiUrl": "https://api.staging.fimo.team",
+  "webUrl": "https://staging.fimo.team"
 }

package/scripts/postinstall.mjs

@@ -2,8 +2,9 @@
 // Two paths:
 //
 //  1) GLOBAL install (`npm i -g fimo`, `pnpm add -g fimo`, etc.)
-//     → offer to run `fimo skills install` when the install is interactive;
-//       otherwise print the non-blocking hint.
+//     → print a short, non-blocking hint. We steer users toward
+//       `npx fimo@latest` (always current) and `fimo init`, and don't run any
+//       interactive prompt from a package lifecycle script.
 //
 //  2) LOCAL / project install (`pnpm install` in a project that has `fimo`
 //     in its dependencies)
@@ -17,20 +18,18 @@
 //       never break the user's install).
 //
 // pnpm caveat: by default, pnpm strips build scripts from non-approved deps.
-// Fimo-controlled installs (`fimo create --install`, sandbox `fimopm install`,
+// Fimo-controlled installs (`fimo init --install`, sandbox `fimopm install`,
 // and E2E helper installs) pass a scoped allow-all-builds flag for pnpm so the
 // fimo postinstall hook can refresh project skills. The template intentionally
 // does not persist allowlists in package.json / pnpm-workspace.yaml because
 // those conflict with sandbox install flags and drift when deps change. npm /
 // yarn run lifecycle scripts by default and need no extra config.
 
-import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import readline from 'node:readline/promises';
 import { fileURLToPath } from 'node:url';
 
-import { isGlobalInstall, parseYesNo, shouldPromptForGlobalSkills } from './lib/postinstall-onboarding.mjs';
+import { isGlobalInstall } from './lib/postinstall-onboarding.mjs';
 
 const THIS_FILE = fileURLToPath(import.meta.url);
 const CLI_ROOT = path.resolve(path.dirname(THIS_FILE), '..');
@@ -45,22 +44,12 @@ if (isGlobalInstall(process.env)) {
   console.log();
   console.log(`${green('✓')} ${bold('fimo')} installed`);
   console.log();
-  const promptDecision = shouldPromptForGlobalSkills();
-  if (promptDecision.ok) {
-    const shouldInstallSkills = await confirm(`Install Fimo skills for your AI coding tools now? ${dim('[Y/n]')} `);
-    if (shouldInstallSkills) {
-      await runSkillsInstall();
-    } else {
-      console.log();
-      console.log(`  Later: run ${cyan('fimo skills install')} to register Fimo skills.`);
-    }
-  } else {
-    console.log(`  Tip: run ${cyan('fimo skills install')} to register Fimo skills`);
-    console.log(`  for your AI coding tools (Claude Code, Cursor, Codex, ...).`);
-    console.log(`  ${dim('Skip if you don’t use AI tools.')}`);
-  }
+  console.log(`  Tip: run the latest without a global install:`);
+  console.log(`       ${cyan('npx fimo@latest <command>')}`);
   console.log();
-  console.log(`  Next: run ${cyan('fimo login')} when you're ready to connect your Fimo account.`);
+  console.log(`  Get started:`);
+  console.log(`       ${cyan('fimo init')}            ${dim('# sign in, create or link a project')}`);
+  console.log(`       ${cyan('fimo skills install')}  ${dim('# set up skills for your AI coding tools')}`);
   console.log();
   process.exit(0);
 }
@@ -97,36 +86,3 @@ try {
     console.error('[fimo postinstall] sync failed:', err);
   }
 }
-
-async function confirm(message) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await rl.question(message);
-    return parseYesNo(answer, true);
-  } finally {
-    rl.close();
-  }
-}
-
-async function runSkillsInstall() {
-  const entry = path.join(CLI_ROOT, 'dist', 'cli', 'index.js');
-  if (!fs.existsSync(entry)) {
-    console.log();
-    console.log(`  Run ${cyan('fimo skills install')} after installation finishes.`);
-    return;
-  }
-
-  console.log();
-  const result = spawnSync(process.execPath, [entry, 'skills', 'install', '--yes'], {
-    stdio: 'inherit',
-    env: {
-      ...process.env,
-      FIMO_POSTINSTALL_CHILD: '1',
-    },
-  });
-
-  if (result.error || result.status !== 0) {
-    console.log();
-    console.log(`  Skills were not installed. Run ${cyan('fimo skills install')} to try again.`);
-  }
-}

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.3.1",
+    "fimo": "0.3.2-experimental.1783328062928",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",

package/assets/agents-starter/claude/settings.json

@@ -1,19 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(fimo:*)",
-      "Bash(npx fimo:*)",
-      "Bash(pnpm:*)",
-      "Bash(pnpm dlx:*)",
-      "Bash(npx:*)",
-      "Bash(git status)",
-      "Bash(git status:*)",
-      "Bash(git diff)",
-      "Bash(git diff:*)",
-      "Bash(git log:*)",
-      "Bash(git add:*)",
-      "Bash(git restore:*)",
-      "Bash(mkdir:*)"
-    ]
-  }
-}

package/assets/skills/fimo-cli/references/create.md

@@ -1,90 +0,0 @@
-# `fimo create`
-
-Scaffold a new Fimo project linked to a remote on the Fimo platform.
-
-## Command
-
-```bash
-fimo create [dir] [options]
-```
-
-| Flag                         | Required       | Purpose                                                                                                                              |
-| ---------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `[dir]` positional           | yes in non-TTY | Target directory (e.g. `my-site`)                                                                                                    |
-| `--org <id>`                 | yes in non-TTY | Target organization **id** (use the `ID` column from `fimo orgs list`, NOT the slug). Picker shown interactively if omitted and TTY. |
-| `--install` / `--no-install` | yes in non-TTY | Run `pnpm install` after scaffolding (or skip it).                                                                                   |
-| `--agents <list>`            | yes in non-TTY | Comma-separated agent IDs (e.g. `claude-code,cursor`). Pass `none` to write only universal AGENTS.md.                                |
-| `-a, --agent <id>`           | alternative    | Repeatable form: `-a claude-code -a cursor`.                                                                                         |
-| `--template-root <path>`     | no             | Override the bundled template (development only).                                                                                    |
-
-Without the required flags in a non-TTY shell, the command exits with `Cannot prompt in a non-interactive shell.`
-
-For `--agents`, pass the AI tool you're running in: `--agents=claude-code` for Claude Code, `--agents=cursor` for Cursor, `--agents=codex` for Codex, etc. When the flag is omitted, env-var detection of the invoking harness (e.g. `CLAUDECODE` / `CLAUDE_CODE_ENTRYPOINT` → claude-code) auto-targets that agent; other agents must be selected explicitly via `--agents`/`-a` or the interactive picker.
-
-## What gets written
-
-`fimo create` scaffolds:
-
-- The project template (Vite + React 19 + TypeScript + Tailwind v4 + shadcn/ui + react-router)
-- `.fimo.settings.json` — links this directory to the remote project (read-only after creation)
-- `.env` — initial env vars (currently just `VITE_API_URL`)
-- `AGENTS.md` — project rules read by all agentskills.io-compatible AI tools (Codex, OpenCode, Aider, etc.)
-- Per-agent variants based on `--agents`:
-  - `claude-code` → `CLAUDE.md` + `.claude/settings.json`
-  - `cursor` → `.cursor/rules/fimo.mdc`
-  - `windsurf` → `.windsurfrules`
-  - `gemini-cli` → `GEMINI.md`
-  - codex / opencode / aider / others → no extra file; AGENTS.md is read natively
-- The project-scope `fimo` skill (npm package surface: schemas, forms, `t()`, `fimo/ui` components) copied into each selected agent's skill dir (`.claude/skills/fimo/`, `.cursor/skills/fimo/`, etc.). Version-locked to the bundled `fimo` package — the installed `SKILL.md` is stamped with `fimoVersion`. Refresh later with `fimo skills sync`. See `references/agent-setup.md`.
-- A git repository with `fimo` as the remote, an initial commit, and an initial push
-
-Codex, OpenCode, Aider, and similar AGENTS.md-native tools work directly off AGENTS.md without a per-agent variant.
-
-`.env` is only the bootstrap app env so local `pnpm dev` works immediately. User-managed public variables are stored with `fimo vars set` and synced into a managed `.env.local` block; hidden values use `fimo secrets set`. See `references/project-vars-and-secrets.md`.
-
-## Right after scaffolding
-
-Set a human-readable display name with `fimo rename "<Name>"`. Infer it from what the user is building (e.g. "Acme Coffee" for a café site, "Jane Doe Portfolio" for a personal site). The default post-`fimo create` name is an auto-generated slug; renaming updates the dashboard label and the SEO `siteName`.
-
-```bash
-cd my-site
-fimo rename "Acme Coffee"
-```
-
-**Then kick off a warm-up deploy in the background** so the sandbox provisions and installs the user's deps (which may differ from the template's baked ones) while you generate code. The first deploy of a project's life pays a ~15-30s provisioning cost; doing it in the background means the user's first interactive deploy lands on a warm sandbox and finishes in ~4-10s instead. See `references/deploy.md` § Warm the sandbox early in a session.
-
-```bash
-fimo deploy -m "chore: init" &
-```
-
-`-m` is the commit message for any files `validate` may codegen — use a sensible conventional-commit string (e.g. `chore: init`, `chore: scaffold`).
-
-## Load the project context
-
-After `fimo create` completes, the project root has:
-
-- `AGENTS.md` (universal) plus the per-agent variant for the AI tool you're running in (e.g. `CLAUDE.md` for Claude Code, `.cursor/rules/fimo.mdc` for Cursor)
-- `.claude/skills/fimo/SKILL.md` (or the equivalent per-agent path) — the project-scope `fimo` skill, version-locked to the installed `fimo` package
-
-**These files came into existence mid-session, so they may not be auto-loaded by the harness.** Explicitly:
-
-1. `cd <project-dir>` — switch into the new project.
-2. `Read` the project rules file: `AGENTS.md` (or `CLAUDE.md` if you're Claude Code).
-3. `Read` the project skill: `.claude/skills/fimo/SKILL.md` (or `.cursor/skills/fimo/SKILL.md` for Cursor, etc.).
-4. From the project skill's "load these references up front" section, batch-read `references/content.md`, `references/forms.md`, `references/assets.md`, `references/labels.md`, `references/locales.md`, `references/ui.md` before generating any significant code.
-
-Once those are in context, generation respects the project's conventions (schemas, `t()`, `fimo/ui` components, asset handling).
-
-## Adding another AI tool to an existing project later
-
-If a teammate joins on a different AI tool (e.g. Cursor) after the project was scaffolded for claude-code only:
-
-```bash
-fimo skills install --agents=cursor       # one command — global skill + project skill + rule file
-```
-
-Run from inside the project. The command detects the project context and wires up everything for the new agent in a single shot. See `references/agent-setup.md`.
-
-## Multi-org accounts
-
-If you belong to a single organization, `fimo create` defaults to it. If you belong to multiple and don't pass `--org`, the CLI shows an interactive picker. For `fimo create`, pass the org **id** (from the `ID` column of `fimo orgs list`) — not the slug. Use `fimo orgs switch --org <id-or-slug>` to set a default for future `fimo create` invocations. See `references/account.md`.