@svadmin/create 0.40.3 → 0.41.0

package/README.md

@@ -119,6 +119,19 @@ bun install
 bun run dev
 ```
 
+## Product-first Vibe Loop
+
+Use a product plan when a feature request is larger than one CRUD resource. The plan keeps business workflows, resources, pages, actions, and navigation separate so generated projects do not expose every backend table as a page.
+
+```bash
+# Read product issues before generating UI
+npx @svadmin/create vibe review ./svadmin.product.json
+
+# Preview the experience for one role; omit --role to inspect all roles
+npx @svadmin/create vibe plan ./svadmin.product.json --role operator
+```
+
+The plan uses schema version `product/v1`. Menu entries are driven by actual business needs and role/task context; svadmin does not apply a global menu-count cap. Generated starters include `PRODUCT.md` alongside `DESIGN.md` and `AGENTS.md`.
 ## Automated Inference CLI / 接口代码推断器
 
 Automatically infer ResourceDefinitions, TypeBox schemas, and Svelte 5 CRUD components from REST endpoints, OpenAPI / Swagger specs, GraphQL endpoints (introspection), or local schema/sample files:

package/blueprints/customer-workspace/vibe-skill.md

@@ -5,7 +5,7 @@ description: Build and refine Svelte admin pages from the installed svadmin page
 
 # svadmin Vibe
 
-Read `DESIGN.md`, `svadmin.vibe.json`, and `svadmin.ai.json`. Select the smallest
+Read `PRODUCT.md`, `DESIGN.md`, `svadmin.vibe.json`, and `svadmin.ai.json`. Run `svadmin vibe review ./svadmin.product.json` before generating a multi-resource feature. Select the smallest
 matching page family from `pages`; inspect its source and the relevant resource
 contract before editing. The catalog is a starting point, not permission to
 replace the customer's workflow with this demo's business model.
@@ -22,6 +22,13 @@ Pass an empty object to search all pages. These tools read shipped references
 only; inspect the current customer's sources separately before making changes.
 The CLI commands remain the fallback when no MCP client is configured.
 
+## Product boundary
+
+- Start from the user's outcome and workflows, not from the complete resource registry.
+- Treat resources as data contracts; only create a surface or menu node when a workflow, role, or business context justifies it.
+- Keep menu count proportional to the actual domain. Never remove required business entries to satisfy a global limit.
+- Keep one dominant action per surface and use the review command to catch dense action/section layouts before markup.
+
 ## Implement
 
 - Read installed `@svadmin/ui/component-registry` metadata and component type

package/blueprints/product-workspace/ARCHITECTURE.md

@@ -0,0 +1,18 @@
+# Product workspace boundaries
+
+Product mode separates product decisions from runtime resources:
+
+- `svadmin.product.json` is the source of truth for roles, workflows, resources,
+  surfaces and menu entries.
+- `src/generated/product-plan.ts` parses the plan at the application boundary.
+- `src/generated/resources.ts` exposes read-only resource metadata to svadmin.
+- `src/generated/navigation.ts` filters product menu entries by role and feature
+  flags. There is no fixed menu count.
+- `src/generated/pages.ts` contains the renderer-neutral page plan.
+- `src/generated/page-routes.ts` registers custom surface routes.
+- `src/product-provider.ts` is an empty in-memory adapter for visual review.
+
+Product actions are metadata until a typed command or provider contract is
+connected. The generated scaffold never claims that a button performed a real
+mutation. Server authorization, tenancy, audit, idempotency and persistence
+remain backend responsibilities.

package/blueprints/product-workspace/README.md

@@ -0,0 +1,14 @@
+# Product workspace
+
+This blueprint is generated from a validated `svadmin.product.json`. It keeps
+product decisions, navigation and page metadata in generated files so the
+application starts with a coherent information architecture instead of a
+database-shaped menu.
+
+The default provider is an empty in-memory provider. It is useful for visual
+review and route acceptance, but it is not a backend, an authorization boundary,
+or a source of business data. Wire an explicit provider and command contract
+before enabling production mutations.
+
+Generated files under `src/generated` are derived artifacts. Edit the product
+plan and regenerate the project rather than editing those files by hand.

package/blueprints/product-workspace/src/App.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+  import { AdminApp } from '@svadmin/ui';
+  import { resolveAdminConfig } from '@svadmin/app';
+  import config from './svadmin.config';
+  import { brand, getDesign } from './design.svelte';
+  import { productMenu } from './generated/navigation';
+  import { productResources } from './generated/resources';
+  import { productPageRoutes } from './generated/page-routes';
+
+  const resolved = resolveAdminConfig(config);
+  const design = $derived(getDesign());
+</script>
+
+<AdminApp
+  providerBundle={resolved.providers}
+  resources={[...productResources]}
+  menu={productMenu}
+  pageRoutes={productPageRoutes}
+  title={brand.name}
+  locale="zh-CN"
+  themeConfig={design.theme}
+  queryClientDefaultOptions={{ queries: { retry: false } }}
+/>

package/blueprints/product-workspace/src/ProductSurfacePage.svelte

@@ -0,0 +1,89 @@
+<script lang="ts">
+  import { productPagePlans, productSurfaceRoutes } from './generated/pages';
+
+  interface Props {
+    route: string;
+    params: Record<string, string | undefined>;
+  }
+
+  let { route }: Props = $props();
+  const page = $derived(productPagePlans.find(candidate => productSurfaceRoutes[route] === candidate.id));
+</script>
+
+<svelte:head>
+  <title>{page?.title ?? 'Product surface'}</title>
+</svelte:head>
+
+<div class="surface-page">
+  {#if page}
+    <header class="surface-hero">
+      <div>
+        <p class="eyebrow">{page.kind}</p>
+        <h1>{page.title}</h1>
+        <p class="purpose">{page.purpose}</p>
+      </div>
+      {#if page.primaryAction}
+        <span class="action-badge">主操作：{page.primaryAction.label}</span>
+      {/if}
+    </header>
+
+    <div class="state-strip">
+      {#each page.states as state (state)}
+        <span class="state">{state}</span>
+      {/each}
+    </div>
+
+    <div class="surface-grid">
+      {#each page.sections as section (section.id)}
+        <section class="surface-card">
+          <div class="card-heading">
+            <h2>{section.title}</h2>
+            <span>区块</span>
+          </div>
+          <p>此区块服务于当前工作流，并展示产品计划声明的资源。</p>
+          {#if section.resourceIds.length}
+            <div class="resource-list">
+              {#each section.resourceIds as resourceId (resourceId)}
+                <span>{resourceId}</span>
+              {/each}
+            </div>
+          {:else}
+            <p class="muted">此区块暂无数据资源，等待接入真实 provider。</p>
+          {/if}
+        </section>
+      {/each}
+    </div>
+
+    <aside class="contract-note">
+      <strong>动作仍是产品元数据</strong>
+      <span>接入 defineCommand 或资源契约后，再启用真实提交、审批和写入。</span>
+    </aside>
+  {:else}
+    <section class="surface-card">
+      <h1>未找到页面计划</h1>
+      <p>路径 {route} 尚未在产品计划中注册。</p>
+    </section>
+  {/if}
+</div>
+
+<style>
+  .surface-page { max-width: 1180px; margin: 0 auto; padding: 32px; color: #172033; }
+  .surface-hero { display: flex; justify-content: space-between; gap: 24px; align-items: flex-end; margin-bottom: 18px; }
+  .eyebrow { margin: 0 0 8px; text-transform: uppercase; letter-spacing: .12em; color: #65708a; font-size: 12px; font-weight: 700; }
+  h1, h2, p { margin-top: 0; }
+  h1 { margin-bottom: 8px; font-size: clamp(28px, 4vw, 46px); letter-spacing: -.03em; }
+  h2 { font-size: 18px; }
+  .purpose { max-width: 700px; color: #65708a; font-size: 16px; line-height: 1.6; }
+  .action-badge, .state, .resource-list span { border-radius: 999px; background: #e8eefc; color: #3558a8; padding: 7px 11px; font-size: 12px; font-weight: 650; }
+  .state-strip { display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 20px; }
+  .state { background: #eef0f3; color: #596273; }
+  .surface-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 16px; }
+  .surface-card { min-height: 150px; padding: 22px; border: 1px solid #e4e7ed; border-radius: 18px; background: #fff; box-shadow: 0 10px 30px rgb(32 45 72 / 5%); }
+  .card-heading { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+  .card-heading span { color: #8a94a7; font-size: 12px; }
+  .surface-card p { color: #65708a; line-height: 1.6; }
+  .resource-list { display: flex; flex-wrap: wrap; gap: 7px; margin-top: 18px; }
+  .muted { color: #98a1b2 !important; font-size: 14px; }
+  .contract-note { display: flex; flex-direction: column; gap: 5px; margin-top: 18px; padding: 16px 18px; border-left: 3px solid #6f8fe8; background: #f0f4ff; color: #33425f; line-height: 1.5; }
+  @media (max-width: 640px) { .surface-page { padding: 20px 16px; } .surface-hero { align-items: flex-start; flex-direction: column; } }
+</style>

package/blueprints/product-workspace/src/app.css

@@ -0,0 +1,6 @@
+@import "@svadmin/ui/app.css";
+
+html { letter-spacing: 0; }
+body { margin: 0; background: #f7f8fa; }
+[data-svadmin-skip-link] { transform: translateY(calc(-100% - 1rem)); }
+[data-svadmin-skip-link]:focus { transform: translateY(0); }

package/blueprints/product-workspace/src/design.svelte.ts

@@ -0,0 +1,7 @@
+import type { ThemeConfig } from '@svadmin/core';
+
+export const brand = $state({ name: 'Product workspace' });
+
+export function getDesign(): { theme: ThemeConfig } {
+  return { theme: { colorPreset: 'neutral', layoutPreset: 'clean-flat' } };
+}

package/blueprints/product-workspace/src/product-provider.ts

@@ -0,0 +1,81 @@
+import { HttpError, type BaseRecord, type DataProvider, type Filter } from '@svadmin/core';
+import { productResources } from './generated/resources';
+
+export type ProductScenario = 'normal' | 'empty' | 'error' | 'loading' | 'denied' | 'readonly';
+
+function matches(row: BaseRecord, filter: Filter): boolean {
+  if (!('field' in filter)) {
+    return filter.operator === 'or'
+      ? filter.value.some(candidate => matches(row, candidate))
+      : filter.value.every(candidate => matches(row, candidate));
+  }
+  const value = row[filter.field];
+  switch (filter.operator) {
+    case 'eq': return value === filter.value;
+    case 'ne': return value !== filter.value;
+    case 'contains': return String(value ?? '').toLowerCase().includes(String(filter.value).toLowerCase());
+    case 'in': return Array.isArray(filter.value) && filter.value.includes(value);
+    case 'null': return value === null || value === undefined;
+    case 'nnull': return value !== null && value !== undefined;
+    default: throw new HttpError('当前脚手架不支持该筛选条件', 400);
+  }
+}
+
+export function createProductProvider(scenario: ProductScenario = 'normal'): DataProvider {
+  const rows: Record<string, BaseRecord[]> = Object.fromEntries(
+    productResources.map(resource => [resource.name, [] as BaseRecord[]]),
+  );
+  async function table(resource: string): Promise<BaseRecord[]> {
+    if (scenario === 'denied') throw new HttpError('无权访问', 403);
+    if (scenario === 'error') throw new HttpError('演示 provider 暂不可用', 503);
+    if (scenario === 'loading') await new Promise(resolve => setTimeout(resolve, 1200));
+    const data = rows[resource];
+    if (!data) throw new HttpError('资源不存在', 404);
+    return data;
+  }
+  function find(data: BaseRecord[], id: string | number): BaseRecord {
+    const row = data.find(record => String(record['id']) === String(id));
+    if (!row) throw new HttpError('记录不存在', 404);
+    return row;
+  }
+  return {
+    getApiUrl: () => 'memory://svadmin-product',
+    async getList({ resource, pagination, sorters = [], filters = [] }) {
+      const data = await table(resource);
+      let result = (scenario === 'empty' ? [] : data).filter(row => filters.every(filter => matches(row, filter)));
+      result = [...result].sort((a, b) => {
+        for (const sorter of sorters) {
+          const order = String(a[sorter.field] ?? '').localeCompare(String(b[sorter.field] ?? ''), 'zh-CN', { numeric: true });
+          if (order) return sorter.order === 'desc' ? -order : order;
+        }
+        return 0;
+      });
+      const total = result.length;
+      if (pagination?.mode !== 'off') {
+        const size = pagination?.pageSize ?? 10;
+        const start = ((pagination?.current ?? 1) - 1) * size;
+        result = result.slice(start, start + size);
+      }
+      return { data: structuredClone(result), total };
+    },
+    async getOne({ resource, id }) { return { data: structuredClone(find(await table(resource), id)) }; },
+    async getMany({ resource, ids }) {
+      return { data: structuredClone((await table(resource)).filter(row => ids.some(id => String(id) === String(row['id'])))) };
+    },
+    async create({ resource, variables }) {
+      if (scenario === 'readonly') throw new HttpError('仅允许查看', 403);
+      const data = await table(resource);
+      const record = { ...(variables as BaseRecord), id: crypto.randomUUID() };
+      data.push(record);
+      return { data: structuredClone(record) };
+    },
+    async update({ resource, id, variables }) {
+      if (scenario === 'readonly') throw new HttpError('仅允许查看', 403);
+      const data = await table(resource);
+      const record = find(data, id);
+      Object.assign(record, variables as BaseRecord);
+      return { data: structuredClone(record) };
+    },
+    async deleteOne() { throw new HttpError('产品脚手架未启用删除', 403); },
+  };
+}

package/blueprints/product-workspace/src/svadmin.config.ts

@@ -0,0 +1,29 @@
+import { createProviderBundle, defineAdminConfig } from '@svadmin/app';
+import { productResources } from './generated/resources';
+import { createProductProvider, type ProductScenario } from './product-provider';
+
+const requested = typeof location !== 'undefined' && import.meta.env.DEV
+  ? new URLSearchParams(location.search).get('scenario')
+  : null;
+const scenarios: readonly string[] = ['normal', 'empty', 'error', 'loading', 'denied', 'readonly'];
+const scenario: ProductScenario = requested !== null && scenarios.includes(requested)
+  ? scenarioFrom(requested)
+  : 'normal';
+
+function scenarioFrom(value: string): ProductScenario {
+  return value as ProductScenario;
+}
+
+export default defineAdminConfig({
+  name: 'product-workspace',
+  providers: createProviderBundle({
+    dataProvider: createProductProvider(scenario),
+    accessControlProvider: {
+      can: async ({ action }) => ({
+        can: scenario !== 'denied' && (scenario !== 'readonly' || ['list', 'show', 'field'].includes(action)),
+      }),
+      options: { buttons: { enableAccessControl: true, hideIfUnauthorized: true } },
+    },
+  }),
+  resources: productResources,
+});

package/blueprints/product-workspace/svadmin.vibe.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "id": "product-workspace",
+  "status": "generated",
+  "framework": "svelte5-vite",
+  "source": "svadmin.product.json",
+  "generated": ["src/generated/product-plan.ts", "src/generated/navigation.ts", "src/generated/pages.ts", "src/generated/resources.ts", "src/generated/page-routes.ts"],
+  "dataMode": "empty-in-memory",
+  "boundaries": ["No production writes", "No fake authorization", "Actions require explicit command contracts", "Menu count follows business needs"]
+}

package/blueprints/product-workspace/vibe-skill.md

@@ -0,0 +1,14 @@
+---
+name: svadmin-vibe
+description: Build product-first Svelte admin surfaces from a validated svadmin.product.json and generated page plans.
+---
+
+# svadmin Vibe
+
+Read PRODUCT.md, DESIGN.md, ARCHITECTURE.md, svadmin.product.json and svadmin.ai.json before changing a generated project. Keep the product plan as the source of truth for roles, workflows, resources, surfaces and menu entries.
+
+Start with the user outcome and workflow. Resources are data contracts and do not automatically become pages or sidebar entries. Menu count follows the business domain; do not remove required entries to satisfy a global limit. Keep one dominant action per surface and use progressive disclosure for secondary actions.
+
+Generated files under src/generated are derived artifacts. Change svadmin.product.json and regenerate instead of editing them by hand. Product actions are metadata until a typed command or provider contract is connected. Never claim that an empty in-memory provider provides persistence, authorization, audit or production data.
+
+Use the installed @svadmin/ui component registry and public type declarations. Keep the Svelte/SvelteKit stack, semantic tokens, responsive layout and state coverage. Verify with bun run check, bun run build and bun run test:ui, then inspect 1440x900 and 1920x1080 captures. Backend authorization, tenancy, audit and durable writes remain server responsibilities.

package/dist/index.js

@@ -17670,7 +17670,7 @@ function buildAdminAiManifest(options) {
       notes: SCAFFOLD_MIGRATION_NOTES
     },
     plugins: [],
-    guidance: ["AGENTS.md", "DESIGN.md"]
+    guidance: ["AGENTS.md", "DESIGN.md", "PRODUCT.md"]
   };
 }
 function buildScaffoldPlatformFiles(options) {
@@ -18685,6 +18685,406 @@ var resources = [
 
 // src/vibe-command.ts
 init_vibe_catalog();
+
+// ../core/src/product-plan.ts
+var PRODUCT_PLAN_SCHEMA_VERSION = "product/v1";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasStringId(value) {
+  return isRecord2(value) && typeof value["id"] === "string" && value["id"].trim().length > 0;
+}
+var PRODUCT_DISCLOSURES = ["visible", "collapsed", "more", "context", "hidden"];
+var PRODUCT_PRIORITIES = ["core", "secondary", "future"];
+var PRODUCT_FREQUENCIES = ["high", "medium", "low", "unknown"];
+var PRODUCT_PLACEMENTS = ["primary", "secondary", "settings", "context", "command", "hidden"];
+var PRODUCT_PAGE_KINDS = ["workbench", "list", "detail", "form", "approval", "import", "settings", "custom"];
+var PRODUCT_STATES = ["empty", "loading", "error", "forbidden", "success"];
+function pushEnumIssue(issues, value, path, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    issues.push({ code: "invalid-enum", path, message: path + " must be one of " + allowed.join(", ") + "." });
+  }
+}
+function pushProductFieldIssues(issues, value, path) {
+  if (!Array.isArray(value)) {
+    issues.push({ code: "missing-array", path, message: path + " must be an array." });
+    return;
+  }
+  const seen = new Set;
+  value.forEach((item, index) => {
+    const itemPath = path + "." + index;
+    if (!isRecord2(item)) {
+      issues.push({ code: "invalid-field", path: itemPath, message: itemPath + " must be an object." });
+      return;
+    }
+    const fieldId = item["id"];
+    if (typeof fieldId !== "string" || fieldId.trim().length === 0) {
+      issues.push({ code: "invalid-id", path: itemPath + ".id", message: "Every product field needs a non-empty string id." });
+      return;
+    }
+    if (seen.has(fieldId)) {
+      issues.push({ code: "duplicate-id", path: itemPath + ".id", message: "Product field id " + fieldId + " is duplicated within its resource." });
+    }
+    seen.add(fieldId);
+    for (const key of ["label", "type"]) {
+      if (typeof item[key] !== "string")
+        issues.push({ code: "invalid-field", path: itemPath + "." + key, message: itemPath + "." + key + " must be a string." });
+    }
+    for (const key of ["readableBy", "writableBy", "usedByWorkflowIds"]) {
+      const candidate = item[key];
+      if (!Array.isArray(candidate) || !candidate.every((entry) => typeof entry === "string")) {
+        issues.push({ code: "invalid-field", path: itemPath + "." + key, message: itemPath + "." + key + " must be an array of strings." });
+      }
+    }
+    for (const key of ["required", "sensitive"]) {
+      if (item[key] !== undefined && typeof item[key] !== "boolean") {
+        issues.push({ code: "invalid-field", path: itemPath + "." + key, message: itemPath + "." + key + " must be a boolean when provided." });
+      }
+    }
+    if (item["disclosure"] !== undefined)
+      pushEnumIssue(issues, item["disclosure"], itemPath + ".disclosure", PRODUCT_DISCLOSURES);
+  });
+}
+function pushEntityIssues(issues, value, path, seen, shape = {}) {
+  if (!Array.isArray(value)) {
+    issues.push({ code: "missing-array", path, message: `${path} must be an array.` });
+    return;
+  }
+  value.forEach((item, index) => {
+    const itemPath = `${path}.${index}`;
+    if (!hasStringId(item)) {
+      issues.push({ code: "invalid-id", path: `${itemPath}.id`, message: "Every product entity needs a non-empty string id." });
+      return;
+    }
+    if (seen.has(item.id)) {
+      issues.push({ code: "duplicate-id", path: `${itemPath}.id`, message: `Product id "${item.id}" is duplicated.` });
+    }
+    seen.add(item.id);
+    const record = isRecord2(item) ? item : undefined;
+    if (!record)
+      return;
+    for (const key of shape.strings ?? []) {
+      if (typeof record[key] !== "string")
+        issues.push({ code: "invalid-field", path: `${itemPath}.${key}`, message: `${itemPath}.${key} must be a string.` });
+    }
+    for (const key of shape.arrays ?? []) {
+      const candidate = record[key];
+      if (!Array.isArray(candidate) || !candidate.every((value) => typeof value === "string")) {
+        issues.push({ code: "invalid-field", path: `${itemPath}.${key}`, message: `${itemPath}.${key} must be an array of strings.` });
+      }
+    }
+  });
+}
+function validateProductPlan(input) {
+  const issues = [];
+  if (!isRecord2(input))
+    return { ok: false, issues: [{ code: "invalid-root", path: "", message: "Product plan must be a JSON object." }] };
+  if (input["schemaVersion"] !== PRODUCT_PLAN_SCHEMA_VERSION) {
+    issues.push({ code: "invalid-version", path: "schemaVersion", message: `Expected ${PRODUCT_PLAN_SCHEMA_VERSION}.` });
+  }
+  if (!isRecord2(input["brief"])) {
+    issues.push({ code: "invalid-root", path: "brief", message: "Product plan brief must be an object." });
+  } else {
+    const brief = input["brief"];
+    for (const key of ["id", "name", "description", "primaryOutcome", "primaryAudience"]) {
+      if (typeof brief[key] !== "string")
+        issues.push({ code: "invalid-field", path: `brief.${key}`, message: `brief.${key} must be a string.` });
+    }
+    for (const key of ["constraints", "nonGoals", "assumptions"]) {
+      const candidate = brief[key];
+      if (!Array.isArray(candidate) || !candidate.every((value) => typeof value === "string"))
+        issues.push({ code: "invalid-field", path: `brief.${key}`, message: `brief.${key} must be an array of strings.` });
+    }
+  }
+  const shapes = {
+    roles: { strings: ["name"], arrays: ["permissions"] },
+    workflows: { strings: ["name", "trigger", "goal", "priority", "frequency"], arrays: ["actorRoleIds", "steps", "successCriteria", "exceptions"] },
+    resources: { strings: ["name", "label"], arrays: ["roleIds", "workflowIds"] },
+    actions: { strings: ["label", "workflowId"], arrays: ["roleIds"] },
+    surfaces: { strings: ["name", "kind", "purpose"], arrays: ["workflowIds", "resourceIds", "roleIds", "actionIds", "sections", "states"] },
+    menu: { strings: ["label", "placement"], arrays: ["workflowIds", "roleIds"] }
+  };
+  for (const key of ["roles", "workflows", "resources", "actions", "surfaces", "menu"]) {
+    pushEntityIssues(issues, input[key], key, new Set, shapes[key]);
+  }
+  const workflows = input["workflows"];
+  if (Array.isArray(workflows))
+    workflows.forEach((workflow, index) => {
+      if (!isRecord2(workflow))
+        return;
+      if (typeof workflow["priority"] === "string")
+        pushEnumIssue(issues, workflow["priority"], "workflows." + index + ".priority", PRODUCT_PRIORITIES);
+      if (typeof workflow["frequency"] === "string")
+        pushEnumIssue(issues, workflow["frequency"], "workflows." + index + ".frequency", PRODUCT_FREQUENCIES);
+    });
+  const resources = input["resources"];
+  if (Array.isArray(resources))
+    resources.forEach((resource, index) => {
+      if (!isRecord2(resource))
+        return;
+      pushProductFieldIssues(issues, resource["fields"], "resources." + index + ".fields");
+      if (resource["menuPlacement"] !== undefined)
+        pushEnumIssue(issues, resource["menuPlacement"], "resources." + index + ".menuPlacement", PRODUCT_PLACEMENTS);
+      if (resource["internal"] !== undefined && typeof resource["internal"] !== "boolean") {
+        issues.push({ code: "invalid-field", path: "resources." + index + ".internal", message: "resources." + index + ".internal must be a boolean when provided." });
+      }
+    });
+  const actions = input["actions"];
+  if (Array.isArray(actions))
+    actions.forEach((action, index) => {
+      if (!isRecord2(action))
+        return;
+      if (action["disclosure"] !== undefined)
+        pushEnumIssue(issues, action["disclosure"], "actions." + index + ".disclosure", PRODUCT_DISCLOSURES);
+      if (action["destructive"] !== undefined && typeof action["destructive"] !== "boolean") {
+        issues.push({ code: "invalid-field", path: "actions." + index + ".destructive", message: "actions." + index + ".destructive must be a boolean when provided." });
+      }
+    });
+  const surfaces = input["surfaces"];
+  if (Array.isArray(surfaces))
+    surfaces.forEach((surface, index) => {
+      if (!isRecord2(surface))
+        return;
+      if (typeof surface["kind"] === "string")
+        pushEnumIssue(issues, surface["kind"], "surfaces." + index + ".kind", PRODUCT_PAGE_KINDS);
+      if (surface["menuPlacement"] !== undefined)
+        pushEnumIssue(issues, surface["menuPlacement"], "surfaces." + index + ".menuPlacement", PRODUCT_PLACEMENTS);
+      if (surface["route"] !== undefined && (typeof surface["route"] !== "string" || surface["route"].trim().length === 0)) {
+        issues.push({ code: "invalid-field", path: "surfaces." + index + ".route", message: "surfaces." + index + ".route must be a non-empty string when provided." });
+      }
+      const states = surface["states"];
+      if (Array.isArray(states))
+        states.forEach((state, stateIndex) => {
+          if (typeof state === "string")
+            pushEnumIssue(issues, state, "surfaces." + index + ".states." + stateIndex, PRODUCT_STATES);
+        });
+    });
+  const menu = input["menu"];
+  if (Array.isArray(menu))
+    menu.forEach((entry, index) => {
+      if (!isRecord2(entry))
+        return;
+      if (typeof entry["placement"] === "string")
+        pushEnumIssue(issues, entry["placement"], "menu." + index + ".placement", PRODUCT_PLACEMENTS);
+      for (const key of ["href", "parentId", "surfaceId", "resourceId", "condition"]) {
+        if (entry[key] !== undefined && typeof entry[key] !== "string") {
+          issues.push({ code: "invalid-field", path: "menu." + index + "." + key, message: "menu." + index + "." + key + " must be a string when provided." });
+        }
+      }
+      if (entry["order"] !== undefined && (typeof entry["order"] !== "number" || !Number.isFinite(entry["order"]))) {
+        issues.push({ code: "invalid-field", path: "menu." + index + ".order", message: "menu." + index + ".order must be a finite number when provided." });
+      }
+    });
+  return issues.length === 0 ? { ok: true, value: input } : { ok: false, issues };
+}
+
+class ProductPlanValidationError extends Error {
+  issues;
+  constructor(issues) {
+    super(`Invalid product plan (${issues.length} issue${issues.length === 1 ? "" : "s"})`);
+    this.name = "ProductPlanValidationError";
+    this.issues = issues;
+  }
+}
+function parseProductPlan(input) {
+  const result = validateProductPlan(input);
+  if (!result.ok)
+    throw new ProductPlanValidationError(result.issues);
+  return result.value;
+}
+
+// ../core/src/product-navigation.ts
+function canSeeByRole(item, roleIds) {
+  return item.roleIds.length === 0 || item.roleIds.some((roleId) => roleIds.includes(roleId));
+}
+function conditionEnabled(condition, flags) {
+  return condition === undefined ? true : flags?.[condition] === true;
+}
+function createNode(item, allItems, context, ancestry = new Set) {
+  const visibleByRole = canSeeByRole(item, context.roleIds);
+  const visibleByCondition = conditionEnabled(item.condition, context.featureFlags);
+  const visible = visibleByRole && visibleByCondition && item.placement !== "hidden";
+  const nextAncestry = new Set(ancestry);
+  nextAncestry.add(item.id);
+  const children = nextAncestry.has(item.id) ? allItems.filter((candidate) => candidate.parentId === item.id && !nextAncestry.has(candidate.id)).sort((left, right) => (left.order ?? 0) - (right.order ?? 0)).map((candidate) => createNode(candidate, allItems, context, nextAncestry)) : [];
+  return {
+    ...item,
+    children,
+    visible,
+    ...visible ? {} : { reason: visibleByRole ? "hidden by business condition or placement" : "current role is not allowed to see this entry" }
+  };
+}
+function buildProductNavigation(plan, context) {
+  return plan.menu.filter((item) => item.parentId === undefined).sort((left, right) => (left.order ?? 0) - (right.order ?? 0)).map((item) => createNode(item, plan.menu, context));
+}
+
+// ../core/src/product-pages.ts
+function buildProductPagePlan(surface, plan) {
+  const actionById = new Map(plan.actions.map((action) => [action.id, action]));
+  const primaryAction = surface.primaryActionId === undefined ? undefined : actionById.get(surface.primaryActionId);
+  const secondaryActions = surface.actionIds.filter((id) => id !== surface.primaryActionId).map((id) => actionById.get(id)).filter((action) => action !== undefined);
+  const sections = surface.sections.length ? surface.sections.map((title, index) => ({ id: `${surface.id}.section.${index + 1}`, title, resourceIds: surface.resourceIds })) : [{ id: `${surface.id}.content`, title: surface.name, resourceIds: surface.resourceIds }];
+  return {
+    id: surface.id,
+    kind: surface.kind,
+    title: surface.name,
+    purpose: surface.purpose,
+    workflowIds: surface.workflowIds,
+    roleIds: surface.roleIds,
+    ...primaryAction === undefined ? {} : { primaryAction },
+    secondaryActions,
+    sections,
+    states: surface.states
+  };
+}
+
+// ../core/src/product-review.ts
+function has2(set, value) {
+  return set.has(value);
+}
+function addIssue(issues, issue) {
+  issues.push(issue);
+}
+function reviewProductPlan(plan) {
+  const issues = [];
+  const roleIds = new Set(plan.roles.map((role) => role.id));
+  const workflowIds = new Set(plan.workflows.map((workflow) => workflow.id));
+  const resourceIds = new Set(plan.resources.map((resource) => resource.id));
+  const surfaceIds = new Set(plan.surfaces.map((surface) => surface.id));
+  const actionIds = new Set(plan.actions.map((action) => action.id));
+  for (const workflow of plan.workflows) {
+    if (!workflow.actorRoleIds.length)
+      addIssue(issues, { code: "workflow.missing-actor", severity: "error", message: `Workflow "${workflow.name}" has no actor role.`, path: `workflows.${workflow.id}.actorRoleIds` });
+    for (const roleId of workflow.actorRoleIds)
+      if (!has2(roleIds, roleId))
+        addIssue(issues, { code: "workflow.unknown-role", severity: "error", message: `Workflow "${workflow.name}" references unknown role "${roleId}".`, path: `workflows.${workflow.id}.actorRoleIds` });
+    if (!workflow.goal.trim())
+      addIssue(issues, { code: "workflow.missing-goal", severity: "error", message: `Workflow "${workflow.name}" has no user goal.`, path: `workflows.${workflow.id}.goal` });
+  }
+  for (const resource of plan.resources) {
+    if (!resource.workflowIds.length && !resource.internal)
+      addIssue(issues, { code: "resource.no-workflow", severity: "warning", message: `Resource "${resource.label}" is not attached to a workflow.`, path: `resources.${resource.id}.workflowIds`, suggestion: "Make it contextual/internal or attach it to a real task." });
+    for (const workflowId of resource.workflowIds)
+      if (!has2(workflowIds, workflowId))
+        addIssue(issues, { code: "resource.unknown-workflow", severity: "error", message: `Resource "${resource.label}" references unknown workflow "${workflowId}".`, path: `resources.${resource.id}.workflowIds` });
+  }
+  for (const surface of plan.surfaces) {
+    reviewSurface(surface, { workflowIds, actionIds, resourceIds }, issues);
+  }
+  const menuById = new Map(plan.menu.map((item) => [item.id, item]));
+  for (const item of plan.menu) {
+    if (item.parentId !== undefined && !menuById.has(item.parentId)) {
+      addIssue(issues, { code: "menu.unknown-parent", severity: "error", message: `Menu item "${item.label}" references unknown parent "${item.parentId}".`, path: `menu.${item.id}.parentId` });
+    }
+  }
+  const visiting = new Set;
+  const visited = new Set;
+  const visitMenu = (id) => {
+    if (visiting.has(id)) {
+      addIssue(issues, { code: "menu.cycle", severity: "error", message: `Menu hierarchy contains a cycle at "${id}".`, path: `menu.${id}.parentId` });
+      return;
+    }
+    if (visited.has(id))
+      return;
+    visiting.add(id);
+    const parentId = menuById.get(id)?.parentId;
+    if (parentId !== undefined && menuById.has(parentId))
+      visitMenu(parentId);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const item of plan.menu)
+    visitMenu(item.id);
+  for (const item of plan.menu) {
+    if (!item.workflowIds.length && !item.resourceId && !item.surfaceId)
+      addIssue(issues, { code: "menu.no-business-target", severity: "warning", message: `Menu item "${item.label}" has no workflow, resource or surface target.`, path: `menu.${item.id}`, suggestion: "Keep it only for an intentional external/system entry." });
+    if (item.surfaceId && !has2(surfaceIds, item.surfaceId))
+      addIssue(issues, { code: "menu.unknown-surface", severity: "error", message: `Menu item "${item.label}" references unknown surface.`, path: `menu.${item.id}.surfaceId` });
+    if (item.resourceId && !has2(resourceIds, item.resourceId))
+      addIssue(issues, { code: "menu.unknown-resource", severity: "error", message: `Menu item "${item.label}" references unknown resource.`, path: `menu.${item.id}.resourceId` });
+    if (!item.roleIds.length && item.placement !== "hidden")
+      addIssue(issues, { code: "menu.public-entry", severity: "info", message: `Menu item "${item.label}" is public at the UI hint layer.`, path: `menu.${item.id}.roleIds`, suggestion: "Keep server authorization independent from menu visibility." });
+  }
+  for (const action of plan.actions) {
+    if (!has2(workflowIds, action.workflowId))
+      addIssue(issues, { code: "action.unknown-workflow", severity: "error", message: `Action "${action.label}" references unknown workflow.`, path: `actions.${action.id}.workflowId` });
+    if (!action.roleIds.length)
+      addIssue(issues, { code: "action.missing-roles", severity: "warning", message: `Action "${action.label}" has no role visibility contract.`, path: `actions.${action.id}.roleIds` });
+  }
+  const served = new Set;
+  plan.surfaces.forEach((surface) => surface.workflowIds.forEach((id) => served.add(id)));
+  plan.menu.forEach((item) => item.workflowIds.forEach((id) => served.add(id)));
+  const unserved = plan.workflows.filter((workflow) => !served.has(workflow.id));
+  unserved.forEach((workflow) => addIssue(issues, { code: "workflow.unserved", severity: workflow.priority === "core" ? "error" : "warning", message: `Workflow "${workflow.name}" has no page or menu entry.`, path: `workflows.${workflow.id}`, suggestion: "Add a surface or contextual entry, or mark the workflow as deferred." }));
+  const roleVisibilityGaps = plan.workflows.filter((workflow) => workflow.actorRoleIds.length > 0 && !plan.surfaces.some((surface) => surface.workflowIds.includes(workflow.id) && (surface.roleIds.length === 0 || workflow.actorRoleIds.some((roleId) => surface.roleIds.includes(roleId))))).length;
+  const orphanResourceCount = plan.resources.filter((resource) => resource.workflowIds.length === 0 && !resource.internal).length;
+  const errors = issues.filter((issue) => issue.severity === "error");
+  return {
+    ok: errors.length === 0,
+    issues,
+    metrics: {
+      resourceCount: plan.resources.length,
+      workflowCount: plan.workflows.length,
+      surfaceCount: plan.surfaces.length,
+      menuNodeCount: plan.menu.length,
+      orphanResourceCount,
+      unservedWorkflowCount: unserved.length,
+      roleVisibilityGaps
+    }
+  };
+}
+function reviewSurface(surface, refs, issues) {
+  if (!surface.purpose.trim())
+    addIssue(issues, { code: "surface.missing-purpose", severity: "error", message: `Surface "${surface.name}" has no purpose.`, path: `surfaces.${surface.id}.purpose` });
+  if (!surface.workflowIds.length)
+    addIssue(issues, { code: "surface.no-workflow", severity: "warning", message: `Surface "${surface.name}" is not attached to a workflow.`, path: `surfaces.${surface.id}.workflowIds` });
+  surface.workflowIds.forEach((id) => {
+    if (!refs.workflowIds.has(id))
+      addIssue(issues, { code: "surface.unknown-workflow", severity: "error", message: `Surface "${surface.name}" references unknown workflow "${id}".`, path: `surfaces.${surface.id}.workflowIds` });
+  });
+  surface.resourceIds.forEach((id) => {
+    if (!refs.resourceIds.has(id))
+      addIssue(issues, { code: "surface.unknown-resource", severity: "error", message: `Surface "${surface.name}" references unknown resource "${id}".`, path: `surfaces.${surface.id}.resourceIds` });
+  });
+  surface.actionIds.forEach((id) => {
+    if (!refs.actionIds.has(id))
+      addIssue(issues, { code: "surface.unknown-action", severity: "error", message: `Surface "${surface.name}" references unknown action "${id}".`, path: `surfaces.${surface.id}.actionIds` });
+  });
+  if (surface.primaryActionId && !refs.actionIds.has(surface.primaryActionId))
+    addIssue(issues, { code: "surface.unknown-primary-action", severity: "error", message: `Surface "${surface.name}" references unknown primary action.`, path: `surfaces.${surface.id}.primaryActionId` });
+  if (!surface.states.length)
+    addIssue(issues, { code: "surface.missing-states", severity: "warning", message: `Surface "${surface.name}" does not declare empty/loading/error/permission states.`, path: `surfaces.${surface.id}.states`, suggestion: "Declare the states the Svelte view must implement." });
+  if (surface.sections.length > 6)
+    addIssue(issues, { code: "surface.section-density", severity: "warning", message: `Surface "${surface.name}" contains ${surface.sections.length} sections.`, path: `surfaces.${surface.id}.sections`, suggestion: "Group related information or use progressive disclosure." });
+  if (surface.actionIds.length > 4)
+    addIssue(issues, { code: "surface.action-density", severity: "warning", message: `Surface "${surface.name}" exposes ${surface.actionIds.length} actions.`, path: `surfaces.${surface.id}.actionIds`, suggestion: "Keep one primary action and move secondary actions into context or More." });
+}
+
+// ../core/src/product-pipeline.ts
+function runProductPipeline(input) {
+  const navigation = buildProductNavigation(input.plan, input.navigation);
+  const visibleSurfaceIds = input.surfaceIds === undefined ? undefined : new Set(input.surfaceIds);
+  const pages = input.plan.surfaces.filter((surface) => visibleSurfaceIds === undefined || visibleSurfaceIds.has(surface.id)).filter((surface) => surface.roleIds.length === 0 || surface.roleIds.some((roleId) => input.navigation.roleIds.includes(roleId))).map((surface) => buildProductPagePlan(surface, input.plan));
+  return { navigation, pages, productReview: reviewProductPlan(input.plan) };
+}
+function formatProductPreview(output) {
+  const lines = ["Navigation:"];
+  for (const node of output.navigation) {
+    if (!node.visible)
+      continue;
+    lines.push(`- ${node.label}`);
+    for (const child of node.children)
+      if (child.visible)
+        lines.push(`  - ${child.label}`);
+  }
+  lines.push("", "Pages:");
+  output.pages.forEach((page) => lines.push(`- ${page.title}: ${page.purpose}`));
+  lines.push("", `Product review: ${output.productReview.ok ? "pass" : "fail"}`);
+  return lines.join(`
+`);
+}
+
+// src/vibe-command.ts
 var PRESETS = ["operations", "enterprise", "collaboration"];
 function parseVibeArguments(args) {
   const [command, ...rest] = args;
@@ -18692,6 +19092,31 @@ function parseVibeArguments(args) {
     return { command };
   if (command === "catalog" && rest.length === 0)
     return { command };
+  if (command === "plan" || command === "review") {
+    const positional = [];
+    const roleIds = [];
+    for (let i = 0;i < rest.length; i++) {
+      const arg = rest[i];
+      if (arg === undefined)
+        continue;
+      if (arg === "--role") {
+        const roleId = rest[++i];
+        if (!roleId?.trim())
+          throw new Error(`Missing value for --role`);
+        roleIds.push(roleId);
+      } else if (arg.startsWith("-")) {
+        throw new Error(`Unknown option: ${arg}`);
+      } else {
+        positional.push(arg);
+      }
+    }
+    if (positional.length !== 1)
+      throw new Error(`vibe ${command} requires exactly one product plan JSON file`);
+    const planFile = positional[0];
+    if (planFile === undefined)
+      throw new Error("Missing product plan JSON file");
+    return { command, planFile: path6.resolve(planFile), roleIds };
+  }
   if (command === "catalog" && rest.length === 2 && rest[0] === "--query" && rest[1]?.trim()) {
     return { command, query: rest[1] };
   }
@@ -18699,9 +19124,11 @@ function parseVibeArguments(args) {
     return { command, page: rest[0] };
   }
   if (command !== "init")
-    throw new Error("Usage: vibe mcp | vibe catalog [--query <keywords>] | vibe inspect <page> | vibe init <directory> [--preset operations|enterprise|collaboration] [--write]");
+    throw new Error("Usage: vibe mcp | vibe catalog [--query <keywords>] | vibe inspect <page> | vibe plan <product-plan.json> [--role <role-id>] | vibe review <product-plan.json> | vibe init <directory> [--preset operations|enterprise|collaboration] [--product-plan <file>] [--role <role-id>] [--write]");
   let preset = "enterprise";
   let write = false;
+  let productPlanFile;
+  const roleIds = [];
   const positional = [];
   for (let i = 0;i < rest.length; i++) {
     const arg = rest[i];
@@ -18714,6 +19141,16 @@ function parseVibeArguments(args) {
       if (!PRESETS.some((p) => p === value))
         throw new Error(`Unknown design preset: ${value ?? "(missing)"}`);
       preset = value;
+    } else if (arg === "--product-plan" || arg === "--plan") {
+      const value = rest[++i];
+      if (!value?.trim())
+        throw new Error(`Missing value for ${arg}`);
+      productPlanFile = path6.resolve(value);
+    } else if (arg === "--role") {
+      const value = rest[++i];
+      if (!value?.trim())
+        throw new Error("Missing value for --role");
+      roleIds.push(value);
     } else if (arg.startsWith("-"))
       throw new Error(`Unknown option: ${arg}`);
     else
@@ -18724,7 +19161,7 @@ function parseVibeArguments(args) {
   const directory = positional[0];
   if (directory === undefined)
     throw new Error("Missing project directory");
-  return { command, directory: path6.resolve(directory), preset, write };
+  return { command, directory: path6.resolve(directory), preset, write, productPlanFile, roleIds };
 }
 function readTree(directory, prefix = "") {
   const files = {};
@@ -18740,8 +19177,119 @@ function readTree(directory, prefix = "") {
   }
   return files;
 }
-function planVibeProject(packageRoot, manifest, preset) {
-  const blueprint = path6.join(packageRoot, "blueprints/customer-workspace");
+function productRoute(surface) {
+  return surface.route ?? "/workflows/" + surface.id;
+}
+function buildProductGeneratedFiles(plan, selectedRoleIds) {
+  const allRoleIds = plan.roles.map((role) => role.id);
+  const roleIds = selectedRoleIds.length ? selectedRoleIds : allRoleIds;
+  const planJson = JSON.stringify(plan, null, 2);
+  const summary = [
+    "# " + plan.brief.name,
+    "",
+    plan.brief.description,
+    "",
+    `## Primary outcome
+` + plan.brief.primaryOutcome,
+    `## Audience
+` + plan.brief.primaryAudience,
+    `## Roles
+` + (plan.roles.map((role) => "- **" + role.name + "** (" + role.id + ")：" + (role.description ?? "未提供描述")).join(`
+`) || "- 未定义角色"),
+    `## Workflows
+` + (plan.workflows.map((workflow) => "- **" + workflow.name + "**：" + workflow.goal + "（" + workflow.priority + " / " + workflow.frequency + "）").join(`
+`) || "- 未定义工作流"),
+    `## Surfaces
+` + (plan.surfaces.map((surface) => "- **" + surface.name + "**：" + productRoute(surface) + "，" + surface.purpose).join(`
+`) || "- 未定义页面"),
+    `## Menu
+` + (plan.menu.map((item) => "- " + item.label + "（" + item.placement + "）").join(`
+`) || "- 未定义菜单入口"),
+    "## Generation notes",
+    "- Generated resources are read-only metadata until an explicit contract is added.",
+    "- Product actions are metadata and do not imply backend mutations.",
+    "- Initial visible roles: " + (roleIds.join(", ") || "all") + "."
+  ].join(`
+
+`) + `
+`;
+  const resourcesSource = [
+    "import type { FieldDefinition, ResourceDefinition } from '@svadmin/core';",
+    "import { productPlan } from './product-plan';",
+    "",
+    "const supportedFieldTypes = new Set<string>(['text','number','boolean','date','time','datetime','daterange','select','multiselect','tags','textarea','richtext','image','images','json','relation','color','url','email','phone','currency','percent','file','markdown','password','array','tree-select','treeselect','cascader','transfer','rate','rating','avatar','copy','code']);",
+    "function toFieldType(type: string): FieldDefinition['type'] {",
+    "  return (supportedFieldTypes.has(type) ? type : 'text') as FieldDefinition['type'];",
+    "}",
+    "function toField(field: (typeof productPlan.resources)[number]['fields'][number]): FieldDefinition {",
+    "  const hidden = field.sensitive === true || field.disclosure === 'hidden';",
+    "  return { key: field.id, label: field.label, type: toFieldType(field.type), required: field.required, showInList: !hidden, showInShow: !hidden, showInForm: !hidden, showInCreate: !hidden, showInEdit: !hidden };",
+    "}",
+    "export const productResources: ResourceDefinition[] = productPlan.resources.map(resource => ({",
+    "  name: resource.runtimeName ?? resource.name, label: resource.label,",
+    "  icon: resource.menuPlacement === 'settings' ? 'settings' : undefined,",
+    "  fields: resource.fields.map(toField), canCreate: false, canEdit: false, canDelete: false, canShow: true,",
+    "  showInMenu: resource.internal !== true && resource.menuPlacement !== 'hidden' && resource.menuPlacement !== 'context' && resource.menuPlacement !== 'command',",
+    "}));",
+    ""
+  ].join(`
+`);
+  const generatedPlan = [
+    "import { parseProductPlan, type ProductPlan } from '@svadmin/core/product-plan';",
+    "",
+    "export const productPlan: ProductPlan = parseProductPlan(" + planJson + ");",
+    ""
+  ].join(`
+`);
+  const generatedNavigation = [
+    "import type { MenuItem } from '@svadmin/core';",
+    "import { buildProductMenuItems } from '@svadmin/core/product-navigation';",
+    "import { productPlan } from './product-plan';",
+    "",
+    "export const ALL_PRODUCT_ROLE_IDS = " + JSON.stringify(allRoleIds) + " as const;",
+    "export const INITIAL_PRODUCT_ROLE_IDS = " + JSON.stringify(roleIds) + " as const;",
+    "export function createProductMenu(roleIds: readonly string[] = INITIAL_PRODUCT_ROLE_IDS, featureFlags: Readonly<Record<string, boolean>> = {}): MenuItem[] {",
+    "  return buildProductMenuItems(productPlan, { roleIds, featureFlags });",
+    "}",
+    "export const productMenu = createProductMenu();",
+    ""
+  ].join(`
+`);
+  const generatedPages = [
+    "import { runProductPipeline } from '@svadmin/core/product-pipeline';",
+    "import { productPlan } from './product-plan';",
+    "import { INITIAL_PRODUCT_ROLE_IDS } from './navigation';",
+    "",
+    "export const productPipeline = runProductPipeline({ plan: productPlan, navigation: { roleIds: [...INITIAL_PRODUCT_ROLE_IDS] } });",
+    "export const productPagePlans = productPipeline.pages;",
+    "export const productSurfaceRoutes = Object.fromEntries(productPlan.surfaces.map(surface => [surface.route ?? '/workflows/' + surface.id, surface.id])) as Record<string, string>;",
+    ""
+  ].join(`
+`);
+  const generatedRoutes = [
+    "import type { AdminPageRoute } from '@svadmin/ui';",
+    "import ProductSurfacePage from '../ProductSurfacePage.svelte';",
+    "import { productSurfaceRoutes } from './pages';",
+    "",
+    "export const productPageRoutes: readonly AdminPageRoute[] = Object.keys(productSurfaceRoutes).map(path => ({ path, component: ProductSurfacePage }));",
+    ""
+  ].join(`
+`);
+  return {
+    "svadmin.product.json": planJson + `
+`,
+    "PRODUCT.md": summary,
+    "src/generated/product-plan.ts": generatedPlan,
+    "src/generated/resources.ts": resourcesSource,
+    "src/generated/navigation.ts": generatedNavigation,
+    "src/generated/pages.ts": generatedPages,
+    "src/generated/page-routes.ts": generatedRoutes,
+    "src/generated/README.md": `Generated product files. Derived from svadmin.product.json; regenerate instead of editing by hand.
+`
+  };
+}
+function planVibeProject(packageRoot, manifest, preset, options = {}) {
+  const blueprint = path6.join(packageRoot, options.productPlan ? "blueprints/product-workspace" : "blueprints/customer-workspace");
   const files = readTree(blueprint);
   const template = path6.join(packageRoot, "template");
   for (const name of ["index.html", "svelte.config.js", "tsconfig.json", "vite.config.ts", "src/main.ts", "src/vite-env.d.ts"]) {
@@ -18752,15 +19300,19 @@ function planVibeProject(packageRoot, manifest, preset) {
   }
   files["DESIGN.md"] = fs6.readFileSync(path6.join(packageRoot, "guidance/DESIGN.md"), "utf8");
   files["AGENTS.md"] = fs6.readFileSync(path6.join(packageRoot, "guidance/AGENTS.md"), "utf8");
+  files["PRODUCT.md"] = fs6.readFileSync(path6.join(packageRoot, "guidance/PRODUCT.md"), "utf8");
+  if (options.productPlan)
+    Object.assign(files, buildProductGeneratedFiles(options.productPlan, options.roleIds ?? []));
   const skill = files["vibe-skill.md"];
   if (typeof skill !== "string")
     throw new Error("The shipped vibe skill is missing");
   files[".agents/skills/svadmin-vibe/SKILL.md"] = skill;
   delete files["vibe-skill.md"];
-  files["src/design-selection.ts"] = `export const initialPreset = '${preset}' as const;
+  if (!options.productPlan)
+    files["src/design-selection.ts"] = `export const initialPreset = '${preset}' as const;
 `;
   const pkg = createProjectPackageJson(manifest, {
-    projectName: "svadmin-customer-workspace",
+    projectName: options.productPlan ? "svadmin-product-workspace" : "svadmin-customer-workspace",
     dataProvider: "none",
     authProvider: "none"
   });
@@ -18777,31 +19329,36 @@ function planVibeProject(packageRoot, manifest, preset) {
     authProvider: "none",
     ...manifest.dependencies["@svadmin/core"] === undefined ? {} : { coreVersionRange: manifest.dependencies["@svadmin/core"] }
   });
-  ai.resources = resources.map((resource) => ({
-    name: resource.name,
-    label: resource.label ?? resource.name,
-    fields: (resource.fields ?? []).map((field) => ({
-      key: field.key,
-      label: field.label,
-      type: field.type,
-      required: field.required ?? false
-    })),
-    operations: uiOnlyResources.includes(resource.name) ? [] : [
-      "list",
-      ...resource.canShow === false ? [] : ["show"],
-      ...resource.canCreate === false ? [] : ["create"],
-      ...resource.canEdit === false ? [] : ["edit"]
-    ]
-  }));
-  ai.routes = ai.resources.map((resource) => ({
-    resource: resource.name,
-    path: `/${resource.name}`,
-    operations: uiOnlyResources.includes(resource.name) ? ["list"] : resource.operations
-  }));
+  if (options.productPlan) {
+    ai.resources = options.productPlan.resources.map((resource) => ({ name: resource.runtimeName ?? resource.name, label: resource.label, fields: resource.fields.map((field) => ({ key: field.id, label: field.label, type: field.type, required: field.required ?? false })), operations: ["list", "show"] }));
+    ai.routes = options.productPlan.surfaces.map((surface) => ({ resource: surface.resourceIds[0] ?? "", path: productRoute(surface), operations: ["list", "show"] }));
+  } else {
+    ai.resources = resources.map((resource) => ({
+      name: resource.name,
+      label: resource.label ?? resource.name,
+      fields: (resource.fields ?? []).map((field) => ({
+        key: field.key,
+        label: field.label,
+        type: field.type,
+        required: field.required ?? false
+      })),
+      operations: uiOnlyResources.includes(resource.name) ? [] : [
+        "list",
+        ...resource.canShow === false ? [] : ["show"],
+        ...resource.canCreate === false ? [] : ["create"],
+        ...resource.canEdit === false ? [] : ["edit"]
+      ]
+    }));
+    ai.routes = ai.resources.map((resource) => ({
+      resource: resource.name,
+      path: `/${resource.name}`,
+      operations: uiOnlyResources.includes(resource.name) ? ["list"] : resource.operations
+    }));
+  }
   ai.providers.data = { choice: "none", package: null, capabilities: ["in-memory-demo", "data", "filter", "sort", "pagination"] };
   ai.project.commands = pkg.scripts;
   ai.project.testCommand = "bun run test:ui";
-  ai.guidance = [...ai.guidance, "svadmin.vibe.json", "ARCHITECTURE.md", ".agents/skills/svadmin-vibe/SKILL.md"];
+  ai.guidance = [...ai.guidance, "PRODUCT.md", "svadmin.vibe.json", "ARCHITECTURE.md", ".agents/skills/svadmin-vibe/SKILL.md"];
   files["svadmin.ai.json"] = `${JSON.stringify(ai, null, 2)}
 `;
   files["svadmin.schema.json"] = `${JSON.stringify(buildAdminSchemaJson(), null, 2)}
@@ -18850,10 +19407,35 @@ async function vibeCommand(args, packageRoot, manifest) {
     console.log(JSON.stringify(inspectVibePage(packageRoot, options.page), null, 2));
     return;
   }
+  if (options.command === "review" || options.command === "plan") {
+    const input = JSON.parse(fs6.readFileSync(options.planFile, "utf8"));
+    const plan = parseProductPlan(input);
+    if (options.command === "review") {
+      console.log(JSON.stringify(reviewProductPlan(plan), null, 2));
+      return;
+    }
+    const roleIds = options.roleIds.length ? options.roleIds : plan.roles.map((role) => role.id);
+    console.log(formatProductPreview(runProductPipeline({ plan, navigation: { roleIds } })));
+    return;
+  }
+  if (options.command !== "init")
+    throw new Error("Unsupported vibe command");
   if (fs6.existsSync(options.directory))
     throw new Error("The target already exists. Choose a new directory; existing projects are never overwritten.");
-  const files = planVibeProject(packageRoot, manifest, options.preset);
-  console.log(`svadmin vibe: customer-workspace / ${options.preset}
+  let productPlan;
+  if (options.productPlanFile) {
+    const input = JSON.parse(fs6.readFileSync(options.productPlanFile, "utf8"));
+    productPlan = parseProductPlan(input);
+    const report = reviewProductPlan(productPlan);
+    if (!report.ok)
+      throw new Error(`Product plan review failed:
+` + JSON.stringify(report, null, 2));
+    if (report.issues.length)
+      console.warn("Product plan review warnings: " + report.issues.length);
+  }
+  const productOptions = { roleIds: options.roleIds, ...productPlan === undefined ? {} : { productPlan } };
+  const files = planVibeProject(packageRoot, manifest, options.preset, productOptions);
+  console.log(`svadmin vibe: ${productPlan ? "product-workspace" : "customer-workspace"} / ${options.preset}
 ${options.directory}`);
   for (const file of Object.keys(files).sort())
     console.log(`  add ${file}`);
@@ -18991,7 +19573,7 @@ function upgrade(args) {
   const upgradeExecution = commandArguments.write ? writeProjectPackageJsonUpgrade(packagePath, scaffoldManifest, new Date) : planProjectPackageFileUpgrade(packagePath, scaffoldManifest);
   printUpgradeExecution(upgradeExecution, commandArguments.projectDirectory, packagePath);
 }
-var GUIDANCE_FILES = ["DESIGN.md", "AGENTS.md"];
+var GUIDANCE_FILES = ["DESIGN.md", "AGENTS.md", "PRODUCT.md"];
 function missingGuidanceFiles(projectDirectory) {
   return GUIDANCE_FILES.filter((fileName) => !fs7.existsSync(path7.join(projectDirectory, fileName)));
 }

package/guidance/AGENTS.md

@@ -4,6 +4,17 @@ Read `DESIGN.md` before creating, revising, or reviewing any UI. It is the
 authority for visual language, page hierarchy, feedback ownership, and
 acceptance checks in this project.
 
+## Product-first generation
+
+Read `PRODUCT.md` before converting a schema, API, or feature list into pages. Build the product brief, workflows, resources, actions, surfaces, and menu in that order. Resources are data contracts; they are not automatic pages or menu entries.
+
+- Keep one primary purpose and one dominant next action per surface.
+- Give every core workflow a serving surface or contextual entry.
+- Declare loading, empty, error, forbidden, and success states before writing markup.
+- Menu count is determined by actual business needs. Never apply a fixed global cap; use roles, task frequency, placement, grouping, and context to keep it legible.
+- Run `svadmin vibe review ./svadmin.product.json` before generating UI and `svadmin vibe plan ./svadmin.product.json --role <role-id>` to inspect role-specific navigation.
+- Treat review warnings as prompts for product judgment. Do not silently delete business-required workflows or menu entries to make a count pass.
+
 ## Platform entrypoints
 
 Before generating or modifying application code, read these stable files

package/guidance/PRODUCT.md

@@ -0,0 +1,29 @@
+# Product-first generation rules
+
+svadmin generates an admin application from business decisions, not from a raw resource list. Read this file before turning an API, database schema, or feature request into UI.
+
+## Decision order
+
+1. Write the product brief: primary outcome, audience, constraints, non-goals, and assumptions.
+2. List the real workflows in actor language. Each core workflow needs a trigger, goal, steps, success criteria, exceptions, priority, and frequency.
+3. Register resources as data contracts. A resource can be contextual or internal; it does not automatically become a page or menu item.
+4. Define actions with an owning workflow and role visibility.
+5. Define surfaces by purpose. Keep one primary action per surface, declare empty/loading/error/forbidden/success states, and move secondary actions into context or More.
+6. Define menu nodes last. Every node should point to a workflow, resource, or surface and declare the roles that need it.
+
+## Menu policy
+
+There is no fixed menu-count limit. A small product may need one entry; a large operational product may need many. Do not delete business-required entries to satisfy an arbitrary count. Use role visibility, workflow frequency, placement, grouping, and contextual entries to keep the navigation legible. Backend authorization remains authoritative; menu visibility is only a UI hint.
+
+## CLI review loop
+
+Store the plan as JSON using schema version `product/v1`, then run:
+
+- `svadmin vibe review ./svadmin.product.json` to report orphan resources, unserved workflows, unknown references, missing states, and dense surfaces.
+- `svadmin vibe plan ./svadmin.product.json --role operator` to inspect the role-specific menu and generated page plans.
+
+Fix product review errors before generating Svelte markup. Warnings are review prompts, not automatic page deletion rules.
+
+## Visual acceptance
+
+Generated pages must have one clear purpose, one dominant next action, and an explicit state contract. Prefer the existing `@svadmin/ui` page families and semantic tokens. Inspect long labels, dense tables, empty results, denied permissions, failures, and mobile layouts before accepting the result.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/create",
-  "version": "0.40.3",
+  "version": "0.41.0",
   "description": "Scaffolding tool for svadmin projects",
   "type": "module",
   "bin": {
@@ -30,7 +30,7 @@
     "@types/node": "^26.4.0",
     "@types/prompts": "^2.4.9",
     "typescript": "^7.0.2",
-    "@svadmin/core": "^0.60.0"
+    "@svadmin/core": "^0.61.0"
   },
   "keywords": [
     "svadmin",

package/scaffold-manifest.json

@@ -10,10 +10,10 @@
     "check": "svelte-check --tsconfig ./tsconfig.json"
   },
   "dependencies": {
-    "@svadmin/core": "^0.60.0",
-    "@svadmin/app": "^0.2.3",
-    "@svadmin/ai-elements": "^0.11.1",
-    "@svadmin/ui": "^0.83.2",
+    "@svadmin/core": "^0.61.0",
+    "@svadmin/app": "^0.2.4",
+    "@svadmin/ai-elements": "^0.11.2",
+    "@svadmin/ui": "^0.84.0",
     "typebox": "^1.3.34",
     "@tanstack/svelte-query": "^6.1.48",
     "@lucide/svelte": "^1.35.0"
@@ -42,76 +42,76 @@
         "graphql": "^16.8.0"
       },
       "simple-rest": {
-        "@svadmin/simple-rest": "^0.12.4",
+        "@svadmin/simple-rest": "^0.12.5",
         "@refinedev/simple-rest": "^6.0.1"
       },
       "supabase": {
-        "@svadmin/supabase": "^0.19.1",
+        "@svadmin/supabase": "^0.19.2",
         "@supabase/supabase-js": "^2.112.4",
         "@refinedev/supabase": "^6.0.2"
       },
       "graphql": {
-        "@svadmin/graphql": "^0.12.4",
+        "@svadmin/graphql": "^0.12.5",
         "@refinedev/graphql": "^8.0.1",
         "graphql-request": "^7.4.0",
         "graphql": "^16.8.0"
       },
       "rest": {
-        "@svadmin/rest": "^0.2.3",
+        "@svadmin/rest": "^0.2.4",
         "@refinedev/rest": "^2.1.1",
         "@nestjsx/crud-request": "^5.0.0-alpha.3"
       },
       "airtable": {
-        "@svadmin/airtable": "^0.12.4",
+        "@svadmin/airtable": "^0.12.5",
         "@refinedev/airtable": "^5.0.1"
       },
       "appwrite": {
-        "@svadmin/appwrite": "^0.11.4",
+        "@svadmin/appwrite": "^0.11.5",
         "appwrite": ">=26.2.0",
         "@refinedev/appwrite": "^8.0.1"
       },
       "directus": {
-        "@svadmin/directus": "^0.11.4"
+        "@svadmin/directus": "^0.11.5"
       },
       "drizzle": {
-        "@svadmin/drizzle": "^0.14.1",
+        "@svadmin/drizzle": "^0.14.2",
         "drizzle-orm": "^1.0.0-rc.1",
         "refine-sqlx": "^0.10.3"
       },
       "elysia": {
-        "@svadmin/elysia": "^0.14.4",
+        "@svadmin/elysia": "^0.14.5",
         "elysia": ">=1.4.30",
         "@elysiajs/eden": ">=1.4.9"
       },
       "firebase": {
-        "@svadmin/firebase": "^0.12.4"
+        "@svadmin/firebase": "^0.12.5"
       },
       "hasura": {
-        "@svadmin/hasura": "^0.12.4",
+        "@svadmin/hasura": "^0.12.5",
         "@refinedev/hasura": "^7.0.1",
         "graphql-request": "^7.4.0"
       },
       "medusa": {
-        "@svadmin/medusa": "^0.12.4",
+        "@svadmin/medusa": "^0.12.5",
         "@refinedev/medusa": "^5.0.0"
       },
       "nestjs-query": {
-        "@svadmin/nestjs-query": "^0.12.4",
+        "@svadmin/nestjs-query": "^0.12.5",
         "@refinedev/nestjs-query": "^5.0.0"
       },
       "nestjsx-crud": {
-        "@svadmin/nestjsx-crud": "^0.12.4",
+        "@svadmin/nestjsx-crud": "^0.12.5",
         "@refinedev/nestjsx-crud": "^6.0.1"
       },
       "pocketbase": {
-        "@svadmin/pocketbase": "^0.13.1",
+        "@svadmin/pocketbase": "^0.13.2",
         "pocketbase": ">=0.28.0"
       },
       "sanity": {
-        "@svadmin/sanity": "^0.11.4"
+        "@svadmin/sanity": "^0.11.5"
       },
       "strapi": {
-        "@svadmin/strapi": "^0.12.4",
+        "@svadmin/strapi": "^0.12.5",
         "@refinedev/strapi-v4": "^7.0.1"
       }
     },