create-ailk 0.7.0 → 0.8.0

package/dist/programmatic.js

@@ -25,13 +25,14 @@ import { deriveArchitecture } from "./derive-architecture.js";
 import { extractModuleBundle, installBundleTree, } from "./lib/extract-module-bundle.js";
 import { fetchTemplate } from "./lib/fetch-template.js";
 import { assertLicenseKeyShape, writeLicenseKeyFiles, } from "./lib/license-key-files.js";
-import { resolvePaidModules } from "./lib/module-license-gate.js";
+import { FREE_DESIGNS, assertDesignAllowed, deriveLevel, resolveModuleSet, resolvePaidModules, } from "./lib/module-license-gate.js";
 import { classifyModules } from "./lib/module-tier.js";
 import { normalizeModules } from "./module-architecture.js";
+import { RECOGNIZED_SHAPES, RESERVED_SHAPES, } from "./parse-args.js";
 import { SITE_CHROME_PATH, renderSiteChrome, resolveSiteChrome, } from "./site-chrome.js";
 import { GATEABLE_SURFACES, MODULE_SURFACES, NAV_CONFIG_PATH, excludedRoutePaths, renderNavConfig, resolveSurfaces, } from "./surfaces.js";
 import { syncRoutes } from "./sync-routes.js";
-import { BASE_LAYER_DIR, STARTER_DESIGNS, TemplateError, mergeRoster, resolveTemplate, resolveTemplateLineage, rosterDeclares, templateDelivery, } from "./template-manifest.js";
+import { BASE_LAYER_DIR, SHAPE_STARTERS, STARTER_DESIGNS, TEMPLATE_MANIFESTS, TemplateError, mergeRoster, resolveTemplate, resolveTemplateLineage, rosterDeclares, templateDelivery, templateTreeDir, } from "./template-manifest.js";
 import { validateTarget } from "./validate.js";
 const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const TEMPLATES_DIR = resolve(PKG_ROOT, "templates");
@@ -75,6 +76,37 @@ function countFiles(dir) {
     }
     return count;
 }
+/**
+ * The template a `shape` scaffolds (#6754 D5, extended #6757 D6 row 1): the
+ * one FREE-delivery manifest of that shape — a declared `--template` alias
+ * (`TEMPLATE_MANIFESTS`) or a bare-shape starter with no alias of its own
+ * (`SHAPE_STARTERS`), the union the candidate set draws from. Reads manifest
+ * fields only — no roster.
+ *
+ * @throws TemplateError on a reserved or unknown shape, a shape with no Free
+ *   starter yet (D6), or more than one (never picked silently).
+ */
+function resolveShapeTemplate(shape) {
+    if (!RECOGNIZED_SHAPES.includes(shape)) {
+        const known = RECOGNIZED_SHAPES.join(", ");
+        throw new TemplateError(RESERVED_SHAPES.includes(shape)
+            ? `shape "${shape}" is not available yet. Choose one of: ${known}.`
+            : `unknown shape "${shape}". Recognized: ${known}`);
+    }
+    const ofShape = [
+        ...Object.values(TEMPLATE_MANIFESTS),
+        ...Object.values(SHAPE_STARTERS),
+    ].filter((manifest) => manifest.shape === shape);
+    const free = ofShape.filter((manifest) => templateDelivery(manifest) === "free");
+    if (free.length === 0) {
+        const names = ofShape.map((manifest) => manifest.name).join(", ");
+        throw new TemplateError(`shape "${shape}" has no Free starter yet — its page list lands with #6743. Templates built on this shape: ${names || "none"}.`);
+    }
+    if (free.length > 1) {
+        throw new TemplateError(`shape "${shape}" has more than one Free starter: ${free.map((manifest) => manifest.name).join(", ")}`);
+    }
+    return free[0];
+}
 /**
  * Scaffold an AI Launch Kit starter project into targetDir (synchronous).
  *
@@ -118,7 +150,12 @@ export function scaffoldSync(opts) {
     if (opts.withCatalog === true)
         writeComponentCatalog(targetAbs);
     const filesCreated = countFiles(targetAbs);
-    return { targetDir: targetAbs, filesCreated, surfaces: enabledSurfaces };
+    return {
+        targetDir: targetAbs,
+        filesCreated,
+        surfaces: enabledSurfaces,
+        modules: normalizeModules(opts.modules ?? ["marketing"]),
+    };
 }
 /**
  * Scaffold an AI Launch Kit starter project into targetDir (async wrapper).
@@ -138,8 +175,14 @@ export function scaffoldSync(opts) {
  *      its fetched bundle or — when it requires only free modules — from the
  *      `site-templates/` tree this package ships.
  *
- * And, ahead of all five when `opts.template` is set (0): resolve the
- * template and union its `requires` with `opts.modules`, so every step above
+ * Between 2 and 3, `assertDesignAllowed` (#6760) refuses a design the caller
+ * CHOSE (`opts.design`) for a level below Pro, HERE, also before anything is
+ * written to disk. A template's own declared design is never gated (#6778
+ * option (c)): the template's `requires` already decide its level.
+ *
+ * And, ahead of all five when `opts.template` (or `opts.shape`, #6754 D5) is
+ * set (0): resolve the template and union its `requires` with `opts.modules`,
+ * so every step above
  * runs over the EFFECTIVE module set rather than the requested one.
  *
  * `scaffoldSync` itself stays licensing-oblivious on purpose: every existing
@@ -155,8 +198,17 @@ export async function scaffold(opts) {
     const licenseKey = opts.license ?? opts.licenseKey;
     // Resolved first, and by the registry rather than re-validated here: the
     // name already passed `parse-args.ts`, and `resolveTemplate` throws a
-    // `TemplateError` for a programmatic caller that skipped the parser.
-    const template = opts.template !== undefined ? resolveTemplate(opts.template) : undefined;
+    // `TemplateError` for a programmatic caller that skipped the parser. A
+    // `shape` resolves to its one Free starter and from there is the template
+    // path verbatim (#6754 D5); neither leaves the bare overlay untouched.
+    if (opts.template !== undefined && opts.shape !== undefined) {
+        throw new TemplateError("pass a template or a shape, not both");
+    }
+    const template = opts.template !== undefined
+        ? resolveTemplate(opts.template)
+        : opts.shape !== undefined
+            ? resolveShapeTemplate(opts.shape)
+            : undefined;
     // #6638 — the design this scaffold renders: the caller's override, else the
     // template's own. Unset for a scaffold naming neither.
     const design = opts.design ?? template?.design;
@@ -165,29 +217,108 @@ export async function scaffold(opts) {
     }
     // #5618 D2 — the `extends` chain is resolved in the client registry before
     // any fetch: an unknown parent or a cycle is refused here, with the target
-    // still non-existent, like the four refusals below.
-    if (template !== undefined)
-        resolveTemplateLineage(template.name);
+    // still non-existent, like the four refusals below. The registry is the
+    // union of TEMPLATE_MANIFESTS and SHAPE_STARTERS (#6757 D6 row 1): a
+    // `--shape` run's resolved template may be a bare-shape starter, whose name
+    // (the shape itself) `TEMPLATE_MANIFESTS` alone does not carry.
+    if (template !== undefined) {
+        resolveTemplateLineage(template.name, {
+            ...TEMPLATE_MANIFESTS,
+            ...SHAPE_STARTERS,
+        });
+    }
     // The effective module set: union(template.requires, parsed --modules),
     // normalized through `normalizeModules` — the single ordering authority
     // (parent record D7). Order-independence falls out rather than being
     // engineered: it returns `RECOGNIZED_MODULES.filter(...)`, declaration-
     // ordered and deduped, so the same SET in any argument order is the same
     // list.
-    const modules = normalizeModules([
-        ...(template?.requires ?? []),
-        ...(opts.modules ?? ["marketing"]),
-    ]);
-    const { paid } = classifyModules(modules);
-    const bundles = await resolvePaidModules({
-        paidModules: paid,
-        licenseKey,
-        ...(template !== undefined ? { templateName: template.name } : {}),
-        ...(opts.moduleRegistryUrl !== undefined
-            ? { registryUrl: opts.moduleRegistryUrl }
-            : {}),
-        ...(opts.fetchImpl !== undefined ? { fetchImpl: opts.fetchImpl } : {}),
-    });
+    let modules;
+    let bundles;
+    // The run's derived level (#6759), for `assertDesignAllowed` below.
+    // Undefined on the alias branch and on a `--modules`-keep run (D2/D4 in
+    // module-license-gate.ts — the level plays no part in composing either),
+    // so a non-`standard` design on either path derives it separately, below.
+    let level;
+    if (opts.template !== undefined) {
+        // Alias run — untouched (NFR-4): the union line and its
+        // resolvePaidModules({ …, templateName }) call stay exactly as they were.
+        modules = normalizeModules([
+            ...(template?.requires ?? []),
+            ...(opts.modules ?? ["marketing"]),
+        ]);
+        const { paid } = classifyModules(modules);
+        bundles = await resolvePaidModules({
+            paidModules: paid,
+            licenseKey,
+            ...(template !== undefined ? { templateName: template.name } : {}),
+            ...(opts.moduleRegistryUrl !== undefined
+                ? { registryUrl: opts.moduleRegistryUrl }
+                : {}),
+            ...(opts.fetchImpl !== undefined ? { fetchImpl: opts.fetchImpl } : {}),
+        });
+        // #6760 — `resolveModuleSet` never runs on this branch (NFR-4), so no
+        // level was derived above. Derive one — from the registry's per-module
+        // answers, never a key claim (D2) — only when the caller CHOSE a
+        // non-`standard` design alongside the template (`opts.design`). An
+        // alias's own declared design is never gated (#6778 option (c)), so a
+        // plain `--template minimalism-site` run makes no extra network call and
+        // is never refused on its design.
+        if (opts.design !== undefined && !FREE_DESIGNS.includes(opts.design)) {
+            ({ level } = await deriveLevel({
+                licenseKey,
+                ...(opts.moduleRegistryUrl !== undefined
+                    ? { registryUrl: opts.moduleRegistryUrl }
+                    : {}),
+                ...(opts.fetchImpl !== undefined ? { fetchImpl: opts.fetchImpl } : {}),
+            }));
+        }
+    }
+    else {
+        // Shape and bare runs — the key's level decides (#6759 D6), never a flag,
+        // a manifest or a key claim.
+        const chosen = await resolveModuleSet({
+            named: opts.modules,
+            licenseKey,
+            ...(opts.moduleRegistryUrl !== undefined
+                ? { registryUrl: opts.moduleRegistryUrl }
+                : {}),
+            ...(opts.fetchImpl !== undefined ? { fetchImpl: opts.fetchImpl } : {}),
+        });
+        bundles = chosen.bundles;
+        level = chosen.level;
+        modules =
+            template !== undefined
+                ? normalizeModules([...template.requires, ...chosen.modules])
+                : chosen.modules;
+        // A paid member of the shape's own starter `requires` not already
+        // fetched during the level probe (D6) — every buildable shape's starter
+        // requires only `marketing` today, so this is presently a no-op branch.
+        if (template !== undefined) {
+            const templatePaid = classifyModules(template.requires).paid;
+            const stillMissing = templatePaid.filter((m) => !bundles.has(m));
+            if (stillMissing.length > 0) {
+                const extra = await resolvePaidModules({
+                    paidModules: stillMissing,
+                    licenseKey,
+                    ...(opts.moduleRegistryUrl !== undefined
+                        ? { registryUrl: opts.moduleRegistryUrl }
+                        : {}),
+                    ...(opts.fetchImpl !== undefined
+                        ? { fetchImpl: opts.fetchImpl }
+                        : {}),
+                });
+                for (const [k, v] of extra)
+                    bundles.set(k, v);
+            }
+        }
+    }
+    // #6760 D4 — after the level is resolved, before any fetch or write below.
+    // Only the caller's chosen design is gated (#6778 option (c)); a template's
+    // own declared design is not. `level ?? "free"` fails closed: a
+    // `--modules`-keep run under-reports its level by design (NFR-2), so a
+    // chosen non-`standard` design on that path is refused rather than trusted.
+    assertDesignAllowed(opts.design, level ?? "free");
     // The template's OWN bundle, fetched here — before `scaffoldSync` — so the
     // fourth refusal (the template's bundle unpublished, parent record D17 /
     // spec 5481 § 3 DD5 row 4) throws with the target still non-existent, like
@@ -326,7 +457,7 @@ export async function scaffold(opts) {
                 ownership,
             })
             : (() => {
-                const sourceRoot = join(SITE_TEMPLATES_DIR, template.name);
+                const sourceRoot = join(SITE_TEMPLATES_DIR, templateTreeDir(template.name));
                 if (!existsSync(sourceRoot)) {
                     throw new Error(`template "${template.name}": ${sourceRoot} is missing — the published package must carry site-templates/ in its "files" list`);
                 }
@@ -351,6 +482,13 @@ export async function scaffold(opts) {
     if (opts.license !== undefined) {
         writeLicenseKeyFiles(result.targetDir, opts.license);
     }
+    // #6754 D4/D5 — the resolved starter, so the CLI names what it built.
+    if (template !== undefined && design !== undefined) {
+        return {
+            ...result,
+            starter: { template: template.name, shape: template.shape, design },
+        };
+    }
     return result;
 }
 /**

package/dist/site-roster.js

@@ -30,7 +30,7 @@ import { AddModuleRefusedError, readArchitectureHeader, } from "./add-module-cor
 import { diffTwoStrings } from "./lib/extract-module-bundle.js";
 import { MODULE_SLICES, normalizeModules, } from "./module-architecture.js";
 import { substituteMarkers } from "./substitute.js";
-import { BASE_LAYER_DIR, TEMPLATE_MANIFESTS, resolveTemplate, rosterDeclares, } from "./template-manifest.js";
+import { BASE_LAYER_DIR, SHAPE_STARTERS, TEMPLATE_MANIFESTS, resolveTemplate, rosterDeclares, templateTreeDir, } from "./template-manifest.js";
 /** The site-root file that is the roster of record (#6658 D7). */
 export const SITE_ROSTER_PATH = ".ailk-site-manifest.json";
 /**
@@ -168,10 +168,15 @@ export function readSiteRoster(targetDir) {
     if (path === undefined)
         return undefined;
     const file = parseRosterFile(readFileSync(join(targetDir, path), "utf8"), path);
-    const name = file.doc["template"];
+    const name = String(file.doc["template"]);
     let template;
     try {
-        template = resolveTemplate(String(name));
+        // #6757 D6 — a bare-shape starter's name (the shape itself) resolves
+        // through SHAPE_STARTERS first; `resolveTemplate` alone never sees one
+        // (NFR-3).
+        template = Object.prototype.hasOwnProperty.call(SHAPE_STARTERS, name)
+            ? SHAPE_STARTERS[name]
+            : resolveTemplate(name);
     }
     catch (err) {
         throw new AddModuleRefusedError(`${path} names no declared template (${err.message}), so the page roster is unknown`);
@@ -279,7 +284,7 @@ function expectedRow(ref, targetDir) {
 /** The bytes a scaffold installed at `path` from the template, base or overlay layer. */
 function installedSeed(opts, path) {
     const layers = [
-        join(opts.siteTemplatesDir, opts.roster.template.name),
+        join(opts.siteTemplatesDir, templateTreeDir(opts.roster.template.name)),
         join(opts.siteTemplatesDir, BASE_LAYER_DIR),
         opts.templatesDir,
     ];
@@ -308,7 +313,7 @@ export function planRosterAppend(opts) {
     const inSet = new Set(opts.modules);
     const refs = opts.references.filter((ref) => inSet.has(ref.module));
     const contributed = new Set(refs.map((ref) => ref.contribution.route));
-    const shipped = readShippedManifest(opts.siteTemplatesDir, roster.template.name);
+    const shipped = readShippedManifest(opts.siteTemplatesDir, templateTreeDir(roster.template.name));
     const templateRows = [];
     const moduleRows = new Map();
     const superseded = [];
@@ -393,7 +398,7 @@ function layerInstalledSeeds(template, modules, opts) {
     }
     // The template's own tree, as the generator's `ownedContent` reads it: an
     // `installMap` source lands at its mapped destination instead.
-    const ownRoot = join(opts.siteTemplatesDir, template.name);
+    const ownRoot = join(opts.siteTemplatesDir, templateTreeDir(template.name));
     const ownManifest = join(ownRoot, "ailk-template.json");
     const ownMap = existsSync(ownManifest)
         ? (JSON.parse(readFileSync(ownManifest, "utf8")).installMap ?? {})

package/dist/starter-grid.d.ts

@@ -0,0 +1,216 @@
+/**
+ * The starter grid's data (#6753): the shape rosters and the alias table
+ * every `--template` name resolves through. A starter is one shape rendered
+ * in one design with a module list (starter-template contract § The three
+ * axes); an alias names those coordinates plus how its own rows differ from
+ * the shape's standard roster.
+ *
+ * DATA ONLY, AND IMPORT-FREE AT RUNTIME. Every import below is `import type`,
+ * erased at emit. `template-names.ts` derives `RECOGNIZED_TEMPLATES` from
+ * `ALIASES` and `parse-args.ts` imports that at runtime, so a runtime import
+ * here could reach `lib/module-tier.ts` and re-open the `RECOGNIZED_MODULES`
+ * temporal-dead-zone cycle `template-names.ts`'s header records (spec 6753
+ * D1). The composition itself — shape roster, minus `drop`, plus `add` —
+ * lives in `template-manifest.ts`, whose `resolveTemplate` is the one reader
+ * that yields a template's roster. Nothing but those two files imports this one.
+ */
+import type { CategorySlug } from "@working-theory/schema/categories";
+import type { ModuleName } from "./parse-args.js";
+import type { TemplateLayout } from "./site-chrome.js";
+import type { StarterDesign, StarterShape, TemplateRosterRow } from "./template-manifest.js";
+/** The shapes a starter can be built from — every StarterShape but the reserved one. */
+export type BuildableShape = Exclude<StarterShape, "local-business-product">;
+/** How an alias's own rows differ from its shape's standard roster. */
+export interface AliasDifferences {
+    /** Shape-roster routes this alias does not carry. */
+    readonly drop?: readonly string[];
+    /** Rows this alias carries that its shape roster does not. */
+    readonly add?: readonly TemplateRosterRow[];
+    /** The retained shape route `add` is inserted before; absent → appended. */
+    readonly before?: string;
+    /**
+     * Further positioned groups (#6757 D7): each group's rows go before its
+     * own `before` route, applied group by group in array order, AFTER `add`
+     * is placed. The one alias that needs more than one anchor
+     * (`minimalism-site`, which interleaves rows at two separate points in the
+     * shape's row order) uses this; every other alias leaves it unset.
+     */
+    readonly insert?: readonly {
+        readonly before: string;
+        readonly rows: readonly TemplateRosterRow[];
+    }[];
+}
+/**
+ * One `--template` name: the grid coordinates it stands for.
+ *
+ * No `tier`, `level`, `price` or optional-module member, for the reason
+ * `TemplateManifest` carries none (parent § D4, D12): the level is derived
+ * from `modules`, never declared, and the type is what makes declaring one a
+ * compile error.
+ */
+export interface TemplateAlias {
+    readonly shape: BuildableShape;
+    readonly design: StarterDesign;
+    /** Becomes the manifest's `requires`. */
+    readonly modules: readonly ModuleName[];
+    readonly categories: readonly CategorySlug[];
+    readonly layout?: TemplateLayout;
+    readonly differences?: AliasDifferences;
+}
+/**
+ * Each buildable shape's standard roster (#6753 D3) — the rows an alias starts
+ * from before its `differences` apply.
+ *
+ * `organization-product` is today's base roster, the `/blog` teaser and the
+ * portfolio pair. `organization-service`, `local-business-service` (#6757)
+ * and `person-service` (#6758, roadmap § 6 Phase 2) are each their own rows,
+ * the `/blog` teaser and the portfolio pair.
+ */
+export declare const SHAPE_ROSTERS: Readonly<Record<BuildableShape, readonly TemplateRosterRow[]>>;
+/**
+ * The `--template` names and the grid coordinates each stands for (#6753) —
+ * the one table `TEMPLATE_MANIFESTS` and `RECOGNIZED_TEMPLATES` derive from,
+ * in the declaration order both keep. The plain name is the Pro one: it is
+ * the flagship and the demo (Sam, 2026-09-14, parent § D12).
+ *
+ * `workspace` appears in no module list. It is a Pro module, but an authed app
+ * surface contributing no PUBLIC page to a marketing site, and `modules` names
+ * what the roster uses (parent § D15). A Pro key unlocks it regardless of any
+ * template.
+ *
+ * `commerce` is a per-site add-on available at any level, so no alias exists
+ * FOR it (parent § D13); it still contributes rows to whichever alias takes
+ * it, through `mergeRoster`.
+ *
+ * Frozen (#5507): the registry composed from this table is also the issuer's
+ * authorization allowlist (spec 5480 § C7). A test needing a different table
+ * passes its own to `resolveTemplate(name, aliases)` rather than mutating
+ * this one.
+ */
+export declare const ALIASES: Readonly<{
+    /**
+     * The Free template, and the mechanism's own proof (parent § D11): it
+     * requires only `marketing`, so the keyless merge path is exercised by a
+     * template we ship anyway rather than by a throwaway fixture. The bare
+     * `organization-product` shape — no differences at all.
+     */
+    readonly "marketing-site-free": {
+        readonly shape: "organization-product";
+        readonly design: "standard";
+        readonly modules: readonly ["marketing"];
+        readonly categories: readonly ["accounting", "legal", "technology"];
+        readonly layout: {
+            readonly announcementBanner: true;
+        };
+    };
+    /**
+     * The Pro flagship. Its module list is OFFERINGS § 4 offering 3's tiers line
+     * — "docs, scheduling and flows modules" — where "flows" is
+     * `signal-collectors` (`MODULE_SURFACES` maps it to `["flows"]`). It drops
+     * the shape's `/blog` teaser because docs-blog contributes the real `/blog`,
+     * and adds the signal-collectors sample rows ahead of the portfolio pair.
+     */
+    readonly "marketing-site": {
+        readonly shape: "organization-product";
+        readonly design: "standard";
+        readonly modules: readonly ["marketing", "docs-blog", "scheduling", "signal-collectors"];
+        readonly categories: readonly ["accounting", "legal", "consulting", "hvac", "roofing", "plumbing", "electrical", "landscaping", "auto-repair", "real-estate", "technology", "medical-specialty"];
+        readonly differences: {
+            readonly drop: readonly ["/blog"];
+            readonly add: readonly import("./module-architecture.js").PageRosterRow[];
+            readonly before: "/portfolio";
+        };
+    };
+    /**
+     * Pro Plus — the Pro list plus `multi-tenant`, which is correctly in the
+     * list because it DOES contribute pages (the org and workspace surfaces).
+     * Its `pageContributions` is nonetheless unset today, deferred to its own
+     * instance, so this template's merged roster carries the same contributed
+     * rows as `marketing-site`'s and no more. That is a module which has
+     * declared no rows yet — visible in the diff — not a merge that dropped
+     * declared rows.
+     */
+    readonly "saas-product": {
+        readonly shape: "organization-product";
+        readonly design: "standard";
+        readonly modules: readonly ["marketing", "docs-blog", "scheduling", "signal-collectors", "multi-tenant"];
+        readonly categories: readonly ["technology", "medical-specialty"];
+        readonly differences: {
+            readonly drop: readonly ["/blog"];
+            readonly add: readonly import("./module-architecture.js").PageRosterRow[];
+            readonly before: "/portfolio";
+        };
+    };
+    /**
+     * The second Pro template (#5589) — the reports-first, scroll-snap deck
+     * site. NOT `marketing-site` plus a module: its `modules` omit `docs-blog`,
+     * so the two Pro templates are siblings under `_base` (#5618 D2), never a
+     * lineage. Level still derives from `modules`: `scheduling` and
+     * `signal-collectors` are paid, so `templateDelivery` returns `"paid"`
+     * exactly as it does for `marketing-site`.
+     *
+     * It composes the `organization-service` shape roster (#6757) rather than
+     * the organization-product one: the deck home replaces the document-scroll
+     * home, and `/how-it-works`, the product page, `/pricing` and `/sign-in`
+     * are not pages this site has. The roster is what the
+     * template IS, so an unrostered page has neither a route directory
+     * (`rosterSurfaces`) nor its `_base`/overlay seed (#6646 D1).
+     *
+     * It declares NO `layout` block (#6638): the deck home, mark-only nav and
+     * centered footer are the `minimalism` design's, supplied by
+     * `DESIGN_LAYOUTS` from `design:` — the look any shape can wear. The
+     * roster rows the `organization-service` shape does not derive
+     * (`/reports`, `/referral`) are recorded with their reasons in this
+     * template's TEMPLATE-MANIFEST.md § 3a.
+     *
+     * `/reports` and `/referral` carry no `GATEABLE_SURFACES` entry and need
+     * none: both are single-segment `LandingPage` slugs served by the generic
+     * `[slug]` route (#5469 D2), the same mechanism Free's `/how-it-works`
+     * uses. `/reports/[slug]` (the reader) is the signal-collectors module's
+     * own contributed row.
+     *
+     * `/services/[slug]` declares its seed DIRECTORY as `contentDir`
+     * (`content/en/Service`, as `routes-map.ts` records it). The three
+     * samples ride the template tree unmapped, landing at that directory.
+     *
+     * Since #6757, `organization-service` carries a real standard roster
+     * (D1), so this alias's `differences` is additions and drops only: it
+     * drops the `/blog` teaser (a Pro alias does not upsell its own level,
+     * D8) and the portfolio pair (the reports are the proof, not a
+     * portfolio), adds the signal-collectors samples, and INSERTS its two own
+     * rows — `/reports` before `/about`, `/referral` before `/faq` (D7) — to
+     * reproduce its pre-#6757 row order (§ 1.2) exactly.
+     */
+    readonly "minimalism-site": {
+        readonly shape: "organization-service";
+        readonly design: "minimalism";
+        readonly modules: readonly ["marketing", "scheduling", "signal-collectors"];
+        readonly categories: readonly ["real-estate", "technology", "legal"];
+        readonly differences: {
+            readonly drop: readonly ["/blog", "/portfolio", "/portfolio/[slug]"];
+            readonly add: readonly import("./module-architecture.js").PageRosterRow[];
+            readonly insert: readonly [{
+                readonly before: "/about";
+                readonly rows: readonly [import("./module-architecture.js").PageRosterRow];
+            }, {
+                readonly before: "/faq";
+                readonly rows: readonly [import("./module-architecture.js").PageRosterRow];
+            }];
+        };
+    };
+}>;
+/**
+ * The coordinates a keyless `--shape S` builds (#6757 D5) — the composed
+ * FREE manifest per shape, for a shape with no `--template` alias of its
+ * own. Frozen and `Partial`; `organization-product` needs none — its
+ * keyless tree is `marketing-site-free`'s (#6754 AC-2).
+ *
+ * No `differences` (a bare shape is its standard roster, D1) and no
+ * `layout`. Every category is a leaf of `packages/schema/src/categories.ts`,
+ * as `TemplateManifest.categories` requires. `person-service`'s single
+ * `consulting` category is the operator's disposition (2026-09-26,
+ * ai-launch-kit-internal#6758): the leaf did not exist when #6758's spec was
+ * written, and adding it replaced that spec's `["accounting", "legal",
+ * "technology"]` author-pick stand-in.
+ */
+export declare const SHAPE_STARTER_ALIASES: Readonly<Partial<Record<BuildableShape, TemplateAlias>>>;