fimo 0.2.5-staging.14 → 0.2.5-staging.15

package/assets/skills/fimo-migration/SKILL.md

@@ -32,13 +32,21 @@ imports, and QA so any LLM can run the work without silently dropping content.
   schemas, forms, media primitives, translations, and routes.
 - Do not report completion until the QA gate passes or every failed check is
   recorded in the migration report.
+- Do not deploy or publish during the migration. Importing content is required
+  and uses the data-plane commands (`fimo assets upload`, `fimo schemas push`,
+  `fimo entries create`, `fimo forms push`); these do **not** rebuild the live
+  site. `fimo deploy` / `fimo publish` rebuild and restart the site — never run
+  them as part of the migration loop or to "check" rendering. Verify locally
+  (build + local dev). Deployment is a single, final, owner-approved step:
+  when the QA gate passes, **propose** it to the owner instead of running it.
 
 ## Intake Decision
 
 1. Read the target project `AGENTS.md`.
 2. If editing or creating a Fimo project, read the project `fimo` skill and the
-   `fimo-cli` skill references needed for schemas, entries, forms, assets, and
-   deploy commands.
+   `fimo-cli` skill references needed for schemas, entries, forms, and assets.
+   Do not run `fimo deploy` / `fimo publish` here — deployment is a final,
+   owner-approved step (see Non-Negotiables and the Deployment rule below).
 3. Classify the source:
    - **source-backed**: export folder, source repo, CMS CSV/XML/JSON, media
      folder, downloaded HTML, or platform export. Use source files as truth and
@@ -113,7 +121,28 @@ Final status must be one of:
   import/verify yet.
 
 Never use “complete” when CMS entries, media mappings, forms, or route coverage
-are unknown.
+are unknown. Generated seed JSON and media bundled under `public/` are **draft
+state**, not imported content: a migration whose entries were never created in
+Fimo, or whose referenced media was never uploaded to the Fimo media library, is
+`draft-only` (or `complete-with-unresolved` only when each gap is an explicit,
+owner-visible unresolved item). The QA gate enforces this and exits non-zero
+otherwise.
+
+## Deployment
+
+Deployment is **out of scope for the migration loop** and happens at most once,
+at the very end, with the owner's approval.
+
+- Never run `fimo deploy` or `fimo publish` to verify, preview, or "check"
+  rendering while migrating. All verification (build, local dev, route render,
+  visual comparison) is done locally.
+- Importing content (`fimo assets upload`, `fimo schemas push`,
+  `fimo entries create`, `fimo forms push`) is part of the migration and does
+  not deploy the site — run those as the import contract requires.
+- After the QA gate passes and the report is written, end by **proposing**
+  deployment: tell the owner the migration is ready and that running
+  `fimo deploy` once will publish it. Let them decide; do not deploy on their
+  behalf unless they explicitly ask in this turn.
 
 ## URL-Only Migration Contract
 

package/assets/skills/fimo-migration/references/content.md

@@ -2,6 +2,44 @@
 
 Model CMS content before page implementation.
 
+## Detecting Dynamic Collections (no CMS export)
+
+When there is no first-party CMS export (most url-only and website-builder
+migrations), dynamic content still exists and must be modeled. It shows up two
+ways:
+
+1. **Repeated route groups** - many sibling routes share a path prefix
+   (`/blog/*`, `/vr-games/*`, `/locations/*`). Each group is a collection.
+   Ignore locale prefixes (`/en-be/`, `/fr/`): a locale segment is never a
+   collection name.
+2. **Repeated in-page blocks** - a single page renders an array of
+   structurally-identical items: card grids, list rows, tiles, carousels, logo
+   walls. Games, locations, team members, testimonials, pricing tiers, FAQs,
+   news teasers, and feature lists are almost always collections even when the
+   source renders them inside one page.
+
+After the source-faithful rebuild, treat **any hardcoded array of 3+ items with
+the same shape** as a collection candidate. Do not leave it hardcoded.
+
+For each candidate:
+
+- name it as a singular content type with a plural label (`game`/Games,
+  `location`/Locations, `newsPost`/News, `testimonial`/Testimonials,
+  `pricingPlan`/Pricing). Never name a collection after a locale code or a
+  generic page route (no `EnBe`, no `Page`).
+- infer fields from the item shape using the Field Mapping below.
+- push the schema, then create one entry per item.
+- upload each item's image with `fimo assets upload` and store the returned Fimo
+  asset URL in the entry's `media` field (never the source URL or a local
+  `public/` path).
+- wire the component to render from the collection (Fimo content
+  query/primitives) with a seed/empty state. The hardcoded array is removed.
+- record source/generated/imported counts per content type in the manifest.
+
+Genuinely one-off blocks (a single hero, the footer) stay static. If unsure
+whether a block is a collection, prefer modeling it as one when items share a
+clear repeated shape and could plausibly be edited or extended.
+
 ## Field Mapping
 
 Use source headers, values, and repeated patterns:

package/assets/skills/fimo-migration/references/import-contract.md

@@ -29,9 +29,10 @@ Import requirements:
 
 Acceptance:
 
-- `media.total` and `media.imported/unresolved` counts are in the report
-- referenced media has `targetAssetId`, `targetUrl`, `unsupported`, or
-  `unresolved`
+- `media.total` and `media.uploaded/unresolved` counts are in the report
+- referenced media has a Fimo `targetAssetId` or an uploaded Fimo `targetUrl`,
+  or is explicitly `unsupported`/`unresolved`. A local `public/` path or the
+  original source URL does not count as covered.
 - primary routes render without broken images
 
 ## CMS Entries

package/assets/skills/fimo-migration/references/media.md

@@ -37,7 +37,15 @@ sources point to one uploaded asset.
 
 ## Upload And Replacement
 
-After upload, update the manifest with target asset ID/URL.
+Referenced media must be uploaded into the Fimo media library with
+`fimo assets upload`. Copying a file under `public/` so the deployed site can
+serve it is **not** a completed import: it has no Fimo asset id/URL, editors
+cannot manage it, and the QA gate treats a referenced-but-not-uploaded asset as
+failing. Either upload it (and record the Fimo target), or mark it `unresolved`
+with an owner action. "Bundled locally, upload later" is not an acceptable
+terminal state for referenced media.
+
+After upload, update the manifest with the Fimo target asset ID/URL.
 
 When using downloaded files from a Fimo migration pack, copy the recorded
 `localPath` from the media map exactly. Do not reconstruct local filenames from

package/assets/skills/fimo-migration/references/qa.md

@@ -6,9 +6,11 @@ Run this gate before reporting completion.
 
 - Every intended source route is implemented, ignored with a reason, or unresolved.
 - Every CMS export file is mapped to a schema, ignored with a reason, or unresolved.
-- Source entry counts match generated/imported counts, excluding documented skips.
-- Every media item referenced by routes, CMS entries, SEO, or forms has an upload
-  mapping or unresolved item.
+- Source entry counts match imported counts (entries created in Fimo), excluding
+  documented skips/unresolved. Generated seed JSON alone does not satisfy this.
+- Every media item referenced by routes, CMS entries, SEO, or forms is uploaded to
+  the Fimo media library (Fimo asset id/URL) or has an unresolved item. A local
+  `public/` copy is not an upload mapping.
 - Every visible form has a Fimo replacement, third-party plan, or unsupported note.
 - SEO title, description, canonical URL, share image, slugs, dates, authors,
   categories, tags, redirects, and locales are preserved when present.
@@ -43,9 +45,13 @@ Record:
 
 Counts must be written into `.fimo/migration/manifest.json`.
 
-Media, entries, and forms are blocking checks. If any of these are present in
-the source but have unknown imported counts or no unresolved item, report
-`draft-only`.
+Media, entries, and forms are blocking checks. Entries generated as seed JSON but
+not created in Fimo, and media bundled under `public/` but not uploaded to the
+Fimo media library, are NOT covered: the gate fails to `draft-only` unless each
+gap has an explicit, owner-visible unresolved item. The bundled report script
+enforces this - `cms-counts` requires imported (or skipped/unresolved) entries,
+`schemas-pushed` requires the content type registered, and `media-covered`
+requires a Fimo asset id/URL.
 
 ## Report
 

package/assets/skills/fimo-migration/references/workflow.md

@@ -78,14 +78,18 @@ Every item needs one of these statuses:
 
 Before writing page code:
 
-1. Map each CMS export or inferred collection to a Fimo schema or unresolved item.
-2. Preserve stable source IDs, slugs, dates, SEO, authors, categories, tags,
+1. Detect dynamic collections from both repeated route groups AND repeated
+   in-page blocks. A hardcoded array of 3+ structurally-identical items (cards,
+   list rows, tiles) is a collection, not static markup. Ignore locale prefixes
+   when naming collections.
+2. Map each CMS export or inferred collection to a Fimo schema or unresolved item.
+3. Preserve stable source IDs, slugs, dates, SEO, authors, categories, tags,
    locales, and publish status.
-3. Decide which relations are real. Do not invent references from vague text.
-4. Build seed/import entries with source IDs and media references preserved.
-5. Record source count and planned import count for each content type.
+4. Decide which relations are real. Do not invent references from vague text.
+5. Build seed/import entries with source IDs and media references preserved.
+6. Record source count and planned import count for each content type.
 
-Use `references/content.md`.
+Use `references/content.md`, including "Detecting Dynamic Collections".
 
 ## Phase 4: Media And Forms
 
@@ -132,6 +136,9 @@ Rules:
 - Schema-driven media renders with Fimo media primitives, not raw source URLs.
 - CMS pages must have matching `src/schemas/*.json` before generated clients or
   queries are used.
+- Repeated dynamic items (games, locations, posts, testimonials, pricing) render
+  from CMS collections, not hardcoded arrays. A page left with a hardcoded array
+  of collection-shaped items is an incomplete migration, not a finished one.
 - Generated `.ts` schema/form clients are not edited manually.
 - Unsupported source behavior is replaced with a Fimo-native equivalent or shown
   as unresolved, never hidden behind broken UI.
@@ -171,3 +178,16 @@ node <this-skill>/scripts/write-migration-report.mjs <project-root>
 
 The script exits non-zero when required coverage checks fail. That is a prompt
 to continue the migration or document the gaps, not a reason to hide the report.
+
+All checks in this phase are **local** (build, local dev, route render, visual
+comparison). Do not run `fimo deploy` / `fimo publish` to verify anything.
+
+## Phase 9: Propose Deployment
+
+Deployment is not part of the migration loop and is never run to preview or
+verify. Once Phase 8 passes:
+
+1. Do not run `fimo deploy` or `fimo publish` yourself.
+2. End by proposing it: tell the owner the migration is ready and that a single
+   `fimo deploy` will publish it.
+3. Deploy only if the owner explicitly asks in this turn, and then only once.

package/assets/skills/fimo-migration/scripts/write-migration-report.mjs

@@ -91,14 +91,21 @@ function buildChecks(manifest, projectRoot) {
   addCheck(
     checks,
     'cms-counts',
-    'CMS generated/imported counts match planned source counts',
+    'CMS entries are imported into Fimo (or explicitly skipped/unresolved) per content type',
     contentCountsPass(manifest),
     contentCountStats(manifest)
   );
+  addCheck(
+    checks,
+    'schemas-pushed',
+    'Schemas for content with entries are pushed to Fimo before entries',
+    schemasPushedPass(manifest),
+    schemaPushStats(manifest)
+  );
   addCheck(
     checks,
     'media-covered',
-    'Referenced media has upload mapping or unresolved status',
+    'Referenced media is uploaded to Fimo (Fimo asset id/URL) or marked unresolved',
     mediaCoveragePass(manifest),
     mediaStats(manifest)
   );
@@ -238,7 +245,8 @@ function mediaSummary(manifest) {
   if (media.length === 0) return '- No media recorded.';
   return [
     `- Media items: ${media.length}`,
-    `- Imported: ${media.filter((item) => item.status === 'imported' || item.targetAssetId || item.targetUrl).length}`,
+    `- Uploaded to Fimo: ${media.filter((item) => isFimoAssetTarget(item)).length}`,
+    `- Bundled locally (not uploaded): ${media.filter((item) => isLocallyBundled(item)).length}`,
     `- Unresolved: ${media.filter((item) => item.status === 'unresolved' || item.uploadError).length}`,
     `- Referenced: ${media.filter((item) => asArray(item.referencedBy).length > 0).length}`,
   ].join('\n');
@@ -310,16 +318,52 @@ function coverageStats(items) {
 }
 
 function contentCountsPass(manifest) {
+  // Hard gate: generating seed JSON is not enough. A batch with source entries
+  // passes only when those entries were actually created in Fimo (importedCount),
+  // were explicitly skipped, or the whole batch is deliberately marked
+  // unresolved/unsupported/ignored. `generatedCount` no longer satisfies this.
   return asArray(manifest.entries).every((batch) => {
     const source = numberOr(batch.sourceCount, 0);
-    const generated = numberOr(batch.generatedCount, 0);
+    if (source === 0) return true;
     const imported = numberOr(batch.importedCount, 0);
     const skipped = asArray(batch.skipped).length;
-    if (source === 0) return true;
-    return generated + skipped >= source || imported + skipped >= source || terminalStatus(batch.status);
+    if (imported + skipped >= source) return true;
+    return ['unresolved', 'unsupported', 'ignored'].includes(batch.status);
   });
 }
 
+function schemasPushedPass(manifest) {
+  const requiredTypes = entryBatchTypesNeedingSchema(manifest);
+  if (requiredTypes.size === 0) return true;
+  const byName = new Map(asArray(manifest.contentTypes).map((type) => [type.name ?? type.uid, type]));
+  for (const name of requiredTypes) {
+    const type = byName.get(name);
+    if (!type || !['imported', 'verified'].includes(type.status)) return false;
+  }
+  return true;
+}
+
+function schemaPushStats(manifest) {
+  const requiredTypes = entryBatchTypesNeedingSchema(manifest);
+  const byName = new Map(asArray(manifest.contentTypes).map((type) => [type.name ?? type.uid, type]));
+  const pushed = [...requiredTypes].filter((name) => ['imported', 'verified'].includes(byName.get(name)?.status));
+  return {
+    requiredTypes: requiredTypes.size,
+    pushed: pushed.length,
+    missing: [...requiredTypes].filter((name) => !pushed.includes(name)),
+  };
+}
+
+function entryBatchTypesNeedingSchema(manifest) {
+  return new Set(
+    asArray(manifest.entries)
+      .filter((batch) => numberOr(batch.sourceCount, 0) > 0)
+      .filter((batch) => !['unresolved', 'unsupported', 'ignored'].includes(batch.status))
+      .map((batch) => batch.contentType ?? batch.type ?? batch.uid)
+      .filter(isNonEmptyString)
+  );
+}
+
 function contentCountStats(manifest) {
   const batches = asArray(manifest.entries);
   return {
@@ -332,25 +376,51 @@ function contentCountStats(manifest) {
 }
 
 function mediaCoveragePass(manifest) {
+  // Hard gate: a referenced asset bundled locally under public/ does not count as
+  // covered. It must be uploaded to the Fimo media library (target asset id, or an
+  // absolute upload URL distinct from the source) or be explicitly unresolved.
   return asArray(manifest.media).every((item) => {
     const referenced = asArray(item.referencedBy).length > 0;
     if (!referenced) return true;
-    return Boolean(
-      item.targetAssetId || item.targetUrl || ['ignored', 'unsupported', 'unresolved'].includes(item.status)
-    );
+    return isFimoAssetTarget(item) || ['ignored', 'unsupported', 'unresolved'].includes(item.status);
   });
 }
 
+function isFimoAssetTarget(item) {
+  if (!item) return false;
+  if (isNonEmptyString(item.targetAssetId)) return true;
+  return isUploadedTargetUrl(item);
+}
+
+function isUploadedTargetUrl(item) {
+  const url = item.targetUrl;
+  if (!isNonEmptyString(url)) return false;
+  const trimmed = url.trim();
+  // Reject local/site-relative bundles: /assets/..., public/..., ./..., bare filenames.
+  if (!/^https?:\/\//i.test(trimmed)) return false;
+  // Reject a target that merely echoes the source location (nothing was uploaded).
+  const sources = [item.sourceUrl, item.sourcePath, item.source].filter(isNonEmptyString).map((value) => value.trim());
+  if (sources.includes(trimmed)) return false;
+  return true;
+}
+
 function mediaStats(manifest) {
   const media = asArray(manifest.media);
   return {
     total: media.length,
     referenced: media.filter((item) => asArray(item.referencedBy).length > 0).length,
-    imported: media.filter((item) => item.targetAssetId || item.targetUrl || item.status === 'imported').length,
+    uploaded: media.filter((item) => isFimoAssetTarget(item)).length,
+    bundledLocally: media.filter((item) => isLocallyBundled(item)).length,
     unresolved: media.filter((item) => item.status === 'unresolved' || item.uploadError).length,
   };
 }
 
+function isLocallyBundled(item) {
+  if (!item || isFimoAssetTarget(item)) return false;
+  const candidates = [item.targetUrl, item.targetPath, item.localPath].filter(isNonEmptyString);
+  return candidates.some((value) => !/^https?:\/\//i.test(value.trim()));
+}
+
 function formsCoveragePass(manifest) {
   return asArray(manifest.forms).every((form) => {
     if (form.classification === 'fimo-native') return Boolean(form.targetFiles?.length) || terminalStatus(form.status);
@@ -445,6 +515,10 @@ function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '';
+}
+
 function numberOr(value, fallback) {
   return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }

package/dist/cli/bundle.json

@@ -1,8 +1,8 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-06-26T17:21:55.057Z",
-  "cliVersion": "0.2.5-staging.14",
+  "bundledAt": "2026-06-30T07:17:47.484Z",
+  "cliVersion": "0.2.5-staging.15",
   "external": [
     "oxc-parser",
     "fsevents"