fimo 0.0.0 → 0.2.1-experimental.1781864090656

package/assets/agent-templates/post-deploy-check/scripts/check-logs.ts

@@ -0,0 +1,39 @@
+/**
+ * Tool: check-logs
+ *
+ * Query the project's production log stream for the last N minutes and
+ * count errors. Used by the post-deploy-check summary line.
+ *
+ * Inputs (argv):
+ *   1. Minutes to look back (default 5)
+ *
+ * Outputs (stdout JSON): { errors: number; first?: { ts: string; message: string } }
+ */
+
+async function main(): Promise<void> {
+  const minutes = Number(process.argv[2] ?? '5');
+  const projectId = process.env.FIMO_PROJECT_ID ?? '';
+  const env = process.env.FIMO_ENV ?? 'main';
+  const base = process.env.FIMO_API_URL ?? 'http://localhost:3000';
+
+  const since = new Date(Date.now() - minutes * 60_000).toISOString();
+  const url = `${base}/api/management/projects/${projectId}/envs/${encodeURIComponent(env)}/logs?since=${encodeURIComponent(since)}&level=error`;
+
+  try {
+    const res = await fetch(url, { credentials: 'include' });
+    if (!res.ok) {
+      process.stdout.write(JSON.stringify({ errors: 0, note: `log endpoint returned ${res.status}` }));
+      return;
+    }
+    const payload = (await res.json()) as { data?: { entries?: Array<{ ts: string; message: string }> } };
+    const entries = payload.data?.entries ?? [];
+    process.stdout.write(JSON.stringify({ errors: entries.length, first: entries[0] }));
+  } catch (err) {
+    process.stdout.write(JSON.stringify({ errors: 0, note: `log fetch failed: ${(err as Error).message}` }));
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/agent-templates/post-deploy-check/scripts/probe-routes.ts

@@ -0,0 +1,53 @@
+/**
+ * Tool: probe-routes
+ *
+ * Fetch a list of critical routes and assert that each one responds
+ * with a 2xx. Optionally checks that a known selector is present.
+ *
+ * Inputs (argv): JSON array of `{ url, selector? }`
+ * Outputs (stdout JSON): { ok: number; failed: { url: string; status: number; reason: string }[] }
+ */
+
+interface Probe {
+  url: string;
+  selector?: string;
+}
+
+interface Result {
+  ok: number;
+  failed: { url: string; status: number; reason: string }[];
+}
+
+async function probe(p: Probe): Promise<{ url: string; status: number; reason: string } | null> {
+  const res = await fetch(p.url, { redirect: 'manual' });
+  if (res.status < 200 || res.status >= 300) {
+    return { url: p.url, status: res.status, reason: `non-2xx status ${res.status}` };
+  }
+  if (p.selector) {
+    const body = await res.text();
+    if (!body.includes(p.selector)) {
+      return { url: p.url, status: res.status, reason: `expected selector "${p.selector}" not found` };
+    }
+  }
+  return null;
+}
+
+async function main(): Promise<void> {
+  const raw = process.argv[2] ?? '[]';
+  const probes = JSON.parse(raw) as Probe[];
+  const result: Result = { ok: 0, failed: [] };
+  for (const p of probes) {
+    const failure = await probe(p);
+    if (failure) {
+      result.failed.push(failure);
+    } else {
+      result.ok += 1;
+    }
+  }
+  process.stdout.write(JSON.stringify(result));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/agent-templates/seo-audit/GOAL.md

@@ -0,0 +1,39 @@
+# SEO audit
+
+Audit the project's pages for SEO health and write a markdown report.
+
+## Inputs
+
+- The project's published routes (via `scripts/list-routes.ts`)
+- Each page's HTML + response headers (via `scripts/fetch-page.ts`)
+- The current analytics data (read-only, via `fimo:analytics:read`)
+
+## What to check (per page)
+
+1. **Title tag** — present, 30–60 chars, unique across routes
+2. **Meta description** — present, 50–160 chars, unique
+3. **Open Graph** — `og:title`, `og:description`, `og:image`, `og:url`
+4. **Schema.org** — at minimum `WebPage`; `Article` on blog posts;
+   `BreadcrumbList` on nested routes
+5. **Headings** — exactly one `h1`; `h2`/`h3` nest correctly
+6. **Canonical URL** — `<link rel="canonical">` present and self-referential
+7. **Robots / X-Robots-Tag** — not `noindex` on routes that should be indexed
+8. **Sitemap** — every route is present in `/sitemap.xml`
+
+## What to produce
+
+Write `reports/seo-audit-<YYYY-MM-DD>.md` with:
+
+- An executive summary (score / 100, top 3 issues)
+- A per-page table with status chips (✅ / ⚠️ / ❌)
+- A "fix recipes" appendix linking each failure to the smallest change
+  that would resolve it
+- A diff-friendly machine-readable footer (`<!-- agent-summary: ... -->`)
+  so subsequent runs can show the trend
+
+## What NOT to do
+
+- Don't modify any project files. This audit is read-only.
+- Don't fetch external URLs other than the project's own domain.
+- Don't include traffic / conversion data in the report — it lives
+  elsewhere in the Fimo dashboard.

package/assets/agent-templates/seo-audit/capabilities.yaml

@@ -0,0 +1,5 @@
+# Read-only audit — no writes to project files or CMS.
+- files:read
+- cms:read
+- net:fetch
+- fimo:analytics:read

package/assets/agent-templates/seo-audit/config.yaml

@@ -0,0 +1,13 @@
+version: 1
+description: "Audit the project's pages for SEO health and write a markdown report."
+# Read from main env. Switch to prod when running the audit against the
+# live site (M13 keeps data_sources here so M16's sandbox adapter can
+# bind the right Fimo API base URL).
+data_sources:
+  - main
+
+# Manual-only in v1. Add a schedule trigger when you're ready to run
+# this nightly — make sure fimo.config.json has
+# `agents.notifications.email_recipients` set before activating.
+triggers:
+  - type: manual

package/assets/agent-templates/seo-audit/references/report-template.md

@@ -0,0 +1,28 @@
+# Report template
+
+The agent renders `reports/seo-audit-<YYYY-MM-DD>.md` using the shape:
+
+```markdown
+# SEO audit · 2026-05-26
+
+**Overall score:** 78 / 100
+
+## Per-page summary
+
+| Path     | Score | Status |
+| -------- | ----- | ------ |
+| `/`      | 95    | OK     |
+| `/about` | 70    | WARN   |
+
+## Findings
+
+### `/about`
+
+- ⚠️ **title-length** — Title length 22 chars — recommend 30–60
+- ❌ **h1-present** — No <h1> on the page
+
+<!-- agent-summary: { "score": 78, "pages": 12 } -->
+```
+
+The `<!-- agent-summary -->` comment is parsed by subsequent runs to
+plot a trend; keep its shape stable.

package/assets/agent-templates/seo-audit/references/scoring-methodology.md

@@ -0,0 +1,30 @@
+# Scoring methodology
+
+A page starts at 100 points and loses:
+
+- **-15** per `fail` finding (missing title, missing `<h1>`, `noindex` on a public page, etc.)
+- **-5** per `warn` finding (length out of range, missing OG tag, no canonical, etc.)
+
+The overall project score is the arithmetic mean of per-page scores.
+
+## Severity guide
+
+| Rule             | Severity  | Why                                                                  |
+| ---------------- | --------- | -------------------------------------------------------------------- |
+| title-present    | fail      | Without a title, search snippets fall back to the URL — costly       |
+| title-length     | warn      | Outside 30–60 chars, Google truncates or pads — still ranks          |
+| description-\*   | warn/fail | Less impact on rank but huge impact on CTR                           |
+| og-{title,image} | warn      | Affects social shares only; no SEO rank impact                       |
+| h1-present       | fail      | Page has no semantic root — both screen-readers and search hurt      |
+| h1-single        | warn      | Multiple h1s — accessibility lint, not a ranking penalty             |
+| canonical        | warn      | Self-referential canonical is best practice; rarely required         |
+| robots-noindex   | fail      | Page explicitly excluded from index — review and remove if a mistake |
+| schema-org       | warn      | Missing rich-result eligibility — won't hurt rank but loses CTR      |
+
+## How the agent should act on findings
+
+Don't write to project files in v1. Instead, the report's "fix recipes"
+appendix should link to the file the agent suspects is responsible (e.g.
+"fix this in `src/routes/[slug].tsx`'s `meta` export"). A follow-up
+agent — the one that resolves recipes into actual PRs — is the
+appropriate writer.

package/assets/agent-templates/seo-audit/scripts/analyze-html.ts

@@ -0,0 +1,82 @@
+/**
+ * Tool: analyze-html
+ *
+ * Extract SEO signals from HTML — title, meta description, OG tags,
+ * schema.org JSON-LD, heading structure, canonical, robots directive.
+ * Returns a structured shape `score.ts` consumes.
+ *
+ * Inputs (stdin): HTML body
+ * Outputs (stdout JSON): SEOSignals
+ */
+
+interface SEOSignals {
+  title: string | null;
+  description: string | null;
+  canonical: string | null;
+  robots: string | null;
+  openGraph: Record<string, string>;
+  schemaOrg: unknown[];
+  headings: { h1: string[]; h2: string[]; h3: string[] };
+}
+
+function getMatch(html: string, regex: RegExp): string | null {
+  const m = html.match(regex);
+  return m && m[1] ? m[1].trim() : null;
+}
+
+function getAllMatches(html: string, regex: RegExp): string[] {
+  const out: string[] = [];
+  for (const m of html.matchAll(regex)) {
+    if (m[1]) {
+      out.push(m[1].trim());
+    }
+  }
+  return out;
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function main(): Promise<void> {
+  const html = await readStdin();
+
+  const openGraph: Record<string, string> = {};
+  for (const m of html.matchAll(/<meta\s+property=["']og:([^"']+)["']\s+content=["']([^"']*)["']/gi)) {
+    openGraph[m[1]!] = m[2] ?? '';
+  }
+
+  const schemaOrg: unknown[] = [];
+  for (const m of html.matchAll(/<script\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)) {
+    try {
+      schemaOrg.push(JSON.parse(m[1]!.trim()));
+    } catch {
+      // skip invalid JSON-LD blocks
+    }
+  }
+
+  const signals: SEOSignals = {
+    title: getMatch(html, /<title>([\s\S]*?)<\/title>/i),
+    description: getMatch(html, /<meta\s+name=["']description["']\s+content=["']([^"']*)["']/i),
+    canonical: getMatch(html, /<link\s+rel=["']canonical["']\s+href=["']([^"']*)["']/i),
+    robots: getMatch(html, /<meta\s+name=["']robots["']\s+content=["']([^"']*)["']/i),
+    openGraph,
+    schemaOrg,
+    headings: {
+      h1: getAllMatches(html, /<h1[^>]*>([\s\S]*?)<\/h1>/gi).map((s) => s.replace(/<[^>]+>/g, '').trim()),
+      h2: getAllMatches(html, /<h2[^>]*>([\s\S]*?)<\/h2>/gi).map((s) => s.replace(/<[^>]+>/g, '').trim()),
+      h3: getAllMatches(html, /<h3[^>]*>([\s\S]*?)<\/h3>/gi).map((s) => s.replace(/<[^>]+>/g, '').trim()),
+    },
+  };
+
+  process.stdout.write(JSON.stringify(signals, null, 2));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/agent-templates/seo-audit/scripts/fetch-page.ts

@@ -0,0 +1,39 @@
+/**
+ * Tool: fetch-page
+ *
+ * Fetch HTML + headers for a given URL. Used by the audit to walk every
+ * route returned by `list-routes` and feed the bytes to `analyze-html`.
+ *
+ * Inputs (argv):
+ *   1. The URL to fetch (must be the project's own domain)
+ *
+ * Outputs (stdout JSON):
+ *   {
+ *     "url": "...",
+ *     "status": 200,
+ *     "headers": { "content-type": "text/html; charset=utf-8", ... },
+ *     "body": "<!doctype html>..."
+ *   }
+ */
+
+async function main(): Promise<void> {
+  const url = process.argv[2];
+  if (!url) {
+    console.error('Usage: fetch-page <url>');
+    process.exit(1);
+  }
+
+  const res = await fetch(url, { redirect: 'manual' });
+  const headers: Record<string, string> = {};
+  res.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+
+  const body = await res.text();
+  process.stdout.write(JSON.stringify({ url, status: res.status, headers, body }, null, 2));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/agent-templates/seo-audit/scripts/list-routes.ts

@@ -0,0 +1,46 @@
+/**
+ * Tool: list-routes
+ *
+ * Enumerate every public route in the project via the Fimo management
+ * API. Returns paths the audit walks one-by-one through `fetch-page`.
+ *
+ * Inputs (env):
+ *   - FIMO_PROJECT_ID — provided by the runtime (M16 sandbox adapter)
+ *   - FIMO_ENV        — provided by the runtime
+ *   - FIMO_API_URL    — provided by the runtime
+ *
+ * Outputs (stdout JSON):
+ *   { "routes": [{ "path": "/", "label": "Home" }, ...] }
+ */
+
+interface Route {
+  path: string;
+  label: string;
+}
+
+async function main(): Promise<void> {
+  const projectId = process.env.FIMO_PROJECT_ID;
+  const env = process.env.FIMO_ENV ?? 'main';
+  const base = process.env.FIMO_API_URL ?? 'http://localhost:3000';
+
+  if (!projectId) {
+    console.error('FIMO_PROJECT_ID is required');
+    process.exit(1);
+  }
+
+  const url = `${base}/api/management/projects/${projectId}/envs/${encodeURIComponent(env)}/routes`;
+  const res = await fetch(url, { credentials: 'include' });
+  if (!res.ok) {
+    console.error(`Failed to list routes: ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+
+  const payload = (await res.json()) as { data?: { routes?: Record<string, Route> } };
+  const routes = Object.values(payload.data?.routes ?? {});
+  process.stdout.write(JSON.stringify({ routes }, null, 2));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/agent-templates/seo-audit/scripts/report.ts

@@ -0,0 +1,82 @@
+/**
+ * Tool: report
+ *
+ * Render a markdown report from the per-page audit results.
+ *
+ * Inputs (stdin JSON): { score: number, pages: PageReport[] }
+ * Outputs (stdout): markdown
+ */
+
+interface Finding {
+  rule: string;
+  severity: 'ok' | 'warn' | 'fail';
+  message: string;
+}
+
+interface PageReport {
+  path: string;
+  score: number;
+  findings: Finding[];
+}
+
+function statusChip(score: number): string {
+  if (score >= 80) {
+    return 'OK';
+  }
+  if (score >= 60) {
+    return 'WARN';
+  }
+  return 'FAIL';
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function main(): Promise<void> {
+  const text = await readStdin();
+  const data = JSON.parse(text) as { score: number; pages: PageReport[] };
+
+  const date = new Date().toISOString().slice(0, 10);
+  const lines: string[] = [];
+  lines.push(`# SEO audit · ${date}`);
+  lines.push('');
+  lines.push(`**Overall score:** ${data.score} / 100`);
+  lines.push('');
+  lines.push('## Per-page summary');
+  lines.push('');
+  lines.push('| Path | Score | Status |');
+  lines.push('|------|-------|--------|');
+  for (const page of data.pages) {
+    lines.push(`| \`${page.path}\` | ${page.score} | ${statusChip(page.score)} |`);
+  }
+  lines.push('');
+  lines.push('## Findings');
+  lines.push('');
+  for (const page of data.pages) {
+    const failures = page.findings.filter((f) => f.severity !== 'ok');
+    if (failures.length === 0) {
+      continue;
+    }
+    lines.push(`### \`${page.path}\``);
+    lines.push('');
+    for (const finding of failures) {
+      const sev = finding.severity === 'fail' ? '❌' : '⚠️';
+      lines.push(`- ${sev} **${finding.rule}** — ${finding.message}`);
+    }
+    lines.push('');
+  }
+  lines.push('');
+  lines.push(`<!-- agent-summary: { "score": ${data.score}, "pages": ${data.pages.length} } -->`);
+
+  process.stdout.write(lines.join('\n'));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/agent-templates/seo-audit/scripts/score.ts

@@ -0,0 +1,131 @@
+/**
+ * Tool: score
+ *
+ * Apply the SEO scoring methodology (see references/scoring-methodology.md)
+ * to a list of `(path, SEOSignals)` tuples and produce a per-page report.
+ *
+ * Inputs (stdin JSON): { signals: Record<path, SEOSignals> }
+ * Outputs (stdout JSON): { score: 0..100, pages: PageReport[] }
+ */
+
+interface SEOSignals {
+  title: string | null;
+  description: string | null;
+  canonical: string | null;
+  robots: string | null;
+  openGraph: Record<string, string>;
+  schemaOrg: unknown[];
+  headings: { h1: string[]; h2: string[]; h3: string[] };
+}
+
+interface Finding {
+  rule: string;
+  severity: 'ok' | 'warn' | 'fail';
+  message: string;
+}
+
+interface PageReport {
+  path: string;
+  score: number;
+  findings: Finding[];
+}
+
+function audit(signals: SEOSignals): Finding[] {
+  const out: Finding[] = [];
+
+  // Title
+  if (!signals.title) {
+    out.push({ rule: 'title-present', severity: 'fail', message: 'Missing <title>' });
+  } else if (signals.title.length < 30 || signals.title.length > 60) {
+    out.push({
+      rule: 'title-length',
+      severity: 'warn',
+      message: `Title length ${signals.title.length} chars — recommend 30–60`,
+    });
+  } else {
+    out.push({ rule: 'title', severity: 'ok', message: 'Title looks good' });
+  }
+
+  // Description
+  if (!signals.description) {
+    out.push({ rule: 'description-present', severity: 'fail', message: 'Missing meta description' });
+  } else if (signals.description.length < 50 || signals.description.length > 160) {
+    out.push({
+      rule: 'description-length',
+      severity: 'warn',
+      message: `Description length ${signals.description.length} chars — recommend 50–160`,
+    });
+  }
+
+  // OG tags
+  for (const key of ['title', 'description', 'image', 'url']) {
+    if (!signals.openGraph[key]) {
+      out.push({ rule: `og-${key}`, severity: 'warn', message: `Missing og:${key}` });
+    }
+  }
+
+  // Headings
+  if (signals.headings.h1.length === 0) {
+    out.push({ rule: 'h1-present', severity: 'fail', message: 'No <h1> on the page' });
+  } else if (signals.headings.h1.length > 1) {
+    out.push({ rule: 'h1-single', severity: 'warn', message: `Multiple <h1> tags (${signals.headings.h1.length})` });
+  }
+
+  // Canonical
+  if (!signals.canonical) {
+    out.push({ rule: 'canonical', severity: 'warn', message: 'Missing canonical link' });
+  }
+
+  // Robots
+  if (signals.robots && /noindex/i.test(signals.robots)) {
+    out.push({ rule: 'robots-noindex', severity: 'fail', message: 'Page is marked noindex' });
+  }
+
+  // Schema.org
+  if (signals.schemaOrg.length === 0) {
+    out.push({ rule: 'schema-org', severity: 'warn', message: 'No JSON-LD schema.org block' });
+  }
+
+  return out;
+}
+
+function scoreOf(findings: Finding[]): number {
+  // Each fail = -15, each warn = -5. Floor at 0.
+  let pts = 100;
+  for (const f of findings) {
+    if (f.severity === 'fail') {
+      pts -= 15;
+    } else if (f.severity === 'warn') {
+      pts -= 5;
+    }
+  }
+  return Math.max(0, pts);
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function main(): Promise<void> {
+  const text = await readStdin();
+  const payload = JSON.parse(text) as { signals: Record<string, SEOSignals> };
+
+  const pages: PageReport[] = [];
+  for (const [path, signals] of Object.entries(payload.signals)) {
+    const findings = audit(signals);
+    pages.push({ path, score: scoreOf(findings), findings });
+  }
+
+  const overall = pages.length === 0 ? 0 : Math.round(pages.reduce((a, p) => a + p.score, 0) / pages.length);
+
+  process.stdout.write(JSON.stringify({ score: overall, pages }, null, 2));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/agents-starter/AGENTS.md

@@ -0,0 +1,54 @@
+# Fimo project rules
+
+This is a Fimo project. Fimo is a content + media + forms + analytics platform for React websites with a CMS dashboard.
+
+## Working with this project
+
+When generating or modifying code in this Fimo project, your AI tool's `fimo` skill should load these references up front (they define the load-bearing primitives):
+
+- `content.md` — schemas + entries
+- `forms.md` — forms
+- `assets.md` — media + AI image generation
+- `translations.md` — `t()` and i18n
+- `ui.md` — `fimo/ui` components + JSX conventions
+
+The `fimo` skill describes how to build inside this project; the `fimo-cli` skill covers the `fimo` CLI itself (create, account, agent setup).
+
+**If your AI tool doesn't seem to know about Fimo, install the skills:**
+
+```bash
+fimo skills install
+# or, without a global fimo install, copy skills out of the npx cache:
+npx fimo@latest skills install --mode=copy
+```
+
+To add another AI tool to this project (e.g., a teammate joins on Cursor or Windsurf) — global skill + project skill + rule file in one shot:
+
+```bash
+fimo skills install --agents=cursor   # explicit
+fimo skills install                   # interactive: pick agents to add
+```
+
+If you later edit this `AGENTS.md` and want the per-agent variants (`CLAUDE.md`, `.cursor/rules/fimo.mdc`, `.windsurfrules`, `GEMINI.md`) regenerated from it, delete the stale variant file and run `fimo rules sync`. Sync is purely additive — it never overwrites existing files, so project-specific edits are preserved unless you remove the file first.
+
+## Critical project rules
+
+- **Deploy at meaningful milestones, not after every edit.** `fimo deploy` commits everything, pushes to `main`, and round-trips the sandbox — it's a finishing step, not a save step. For initial site generation, run it once at the end when the site is complete. For follow-up work, batch related edits and deploy when the user-visible unit of work is done.
+- **Run `fimo deploy --publish` only when the user signals "ship it"** — first-time site completion or an explicit "publish" / "go live" request. Plain `fimo deploy` (preview) is the right default; `--publish` is the visible, externally-facing step.
+- Do not add a second deploy tool (Vercel, Netlify, etc.).
+- **Never edit `.fimo.settings.json`.** It is the link between this folder and the remote project — it is written once by `fimo create`.
+- The scaffolded homepage is disposable starter content. On the first real generation, replace its copy, layout, and visual style instead of extending the Fimo-branded design. Keep only the technical shell and required legal pages unless the user explicitly asks to preserve the starter.
+- **Secrets live in the Fimo dashboard**, not in `.env` committed to git.
+- **Read before writing backend code.** Check the `fimo` skill's `references/<topic>.md` before calling the tenant API; the shape may have changed.
+- **Always pass flags to `fimo` commands when scripting** — `fimo deploy -m "<msg>"`, `fimo create <dir> --org <id> --no-install --agents=<list>`, `fimo switch --org <id>`, `fimo delete -y`. Bare interactive forms hang in non-TTY shells.
+
+## Design system (optional)
+
+If a `design.md` file exists at the project root, treat it as the source of truth for all visual decisions:
+
+- Use only the colors, fonts, spacing, and radius tokens defined there.
+- Do not invent new values or fall back to framework defaults (Tailwind defaults, shadcn defaults, etc.).
+- Match component states (hover, focus, active, disabled) to the patterns specified.
+- Follow the typographic scale and weight assignments verbatim.
+
+If `design.md` is absent, fall back to the `frontend-design` skill's guidance.

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

@@ -0,0 +1,19 @@
+{
+  "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:*)"
+    ]
+  }
+}