@svadmin/create 0.40.3 → 0.41.1

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,488 @@ 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: index === 0 ? 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));
+  const runtimeNames = new Map;
+  for (const resource of plan.resources) {
+    const runtimeName = resource.runtimeName ?? resource.name;
+    const previous = runtimeNames.get(runtimeName);
+    if (previous !== undefined) {
+      addIssue(issues, {
+        code: "resource.duplicate-runtime-name",
+        severity: "error",
+        message: `Resources "${resource.label}" and "${previous}" resolve to the same runtime name "${runtimeName}".`,
+        path: `resources.${resource.id}.runtimeName`,
+        suggestion: "Give every generated resource route a unique runtime name."
+      });
+    } else {
+      runtimeNames.set(runtimeName, resource.label);
+    }
+  }
+  const surfaceRoutes = new Map;
+  for (const surface of plan.surfaces) {
+    const route = surface.route ?? `/workflows/${surface.id}`;
+    const previous = surfaceRoutes.get(route);
+    if (previous !== undefined) {
+      addIssue(issues, {
+        code: "surface.duplicate-route",
+        severity: "error",
+        message: `Surfaces "${surface.name}" and "${previous}" resolve to the same route "${route}".`,
+        path: `surfaces.${surface.id}.route`,
+        suggestion: "Give every generated surface a unique route."
+      });
+    } else {
+      surfaceRoutes.set(route, surface.name);
+    }
+  }
+  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 roleId of resource.roleIds)
+      if (!has2(roleIds, roleId))
+        addIssue(issues, { code: "resource.unknown-role", severity: "error", message: `Resource "${resource.label}" references unknown role "${roleId}".`, path: `resources.${resource.id}.roleIds` });
+    resource.fields.forEach((field) => {
+      for (const roleId of field.readableBy)
+        if (!has2(roleIds, roleId))
+          addIssue(issues, { code: "field.unknown-role", severity: "error", message: `Field "${field.label}" references unknown readable role "${roleId}".`, path: `resources.${resource.id}.fields.${field.id}.readableBy` });
+      for (const roleId of field.writableBy)
+        if (!has2(roleIds, roleId))
+          addIssue(issues, { code: "field.unknown-role", severity: "error", message: `Field "${field.label}" references unknown writable role "${roleId}".`, path: `resources.${resource.id}.fields.${field.id}.writableBy` });
+      for (const workflowId of field.usedByWorkflowIds)
+        if (!has2(workflowIds, workflowId))
+          addIssue(issues, { code: "field.unknown-workflow", severity: "error", message: `Field "${field.label}" references unknown workflow "${workflowId}".`, path: `resources.${resource.id}.fields.${field.id}.usedByWorkflowIds` });
+    });
+  }
+  for (const surface of plan.surfaces) {
+    reviewSurface(surface, { workflowIds, actionIds, resourceIds, roleIds, surfaceIds }, issues);
+  }
+  const visitingSurfaces = new Set;
+  const visitedSurfaces = new Set;
+  const visitSurface = (id) => {
+    if (visitingSurfaces.has(id)) {
+      addIssue(issues, { code: "surface.cycle", severity: "error", message: `Surface hierarchy contains a cycle at "${id}".`, path: `surfaces.${id}.parentSurfaceId` });
+      return;
+    }
+    if (visitedSurfaces.has(id))
+      return;
+    visitingSurfaces.add(id);
+    const parentId = plan.surfaces.find((surface) => surface.id === id)?.parentSurfaceId;
+    if (parentId !== undefined && surfaceIds.has(parentId))
+      visitSurface(parentId);
+    visitingSurfaces.delete(id);
+    visitedSurfaces.add(id);
+  };
+  for (const surface of plan.surfaces)
+    visitSurface(surface.id);
+  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` });
+    for (const workflowId of item.workflowIds)
+      if (!has2(workflowIds, workflowId))
+        addIssue(issues, { code: "menu.unknown-workflow", severity: "error", message: `Menu item "${item.label}" references unknown workflow "${workflowId}".`, path: `menu.${item.id}.workflowIds` });
+    for (const roleId of item.roleIds)
+      if (!has2(roleIds, roleId))
+        addIssue(issues, { code: "menu.unknown-role", severity: "error", message: `Menu item "${item.label}" references unknown role "${roleId}".`, path: `menu.${item.id}.roleIds` });
+    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` });
+    for (const roleId of action.roleIds)
+      if (!has2(roleIds, roleId))
+        addIssue(issues, { code: "action.unknown-role", severity: "error", message: `Action "${action.label}" references unknown role "${roleId}".`, path: `actions.${action.id}.roleIds` });
+    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` });
+  for (const roleId of surface.roleIds)
+    if (!refs.roleIds.has(roleId))
+      addIssue(issues, { code: "surface.unknown-role", severity: "error", message: `Surface "${surface.name}" references unknown role "${roleId}".`, path: `surfaces.${surface.id}.roleIds` });
+  if (surface.parentSurfaceId !== undefined && !refs.surfaceIds.has(surface.parentSurfaceId))
+    addIssue(issues, { code: "surface.unknown-parent", severity: "error", message: `Surface "${surface.name}" references unknown parent surface "${surface.parentSurfaceId}".`, path: `surfaces.${surface.id}.parentSurfaceId` });
+  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 +19174,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 +19206,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 +19223,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 +19243,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 +19259,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 +19382,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 +19411,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 +19489,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 +19655,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)));
 }