@typeroll/mcp-server 0.44.74 → 0.45.0

package/dist/init.js

@@ -104,6 +104,12 @@ This project is wired to a Typeroll site through \`@typeroll/mcp-server\`.
 - **Connection** is configured in \`.mcp.json\`. Fill in \`TYPEROLL_API_KEY\`
   (create one in the portal under Settings → API keys) and
   \`TYPEROLL_SITE_ID\`.
+- **One Page model (Core 0.2.0 / MCP 0.45.0).** Every article, checklist,
+  directory entry and ordinary page is a Page. A \`content_type\` supplies its
+  schema, URL pattern and default Page template; custom values live in \`fields\`.
+  Use \`create_page\`, \`list_pages content_type=...\` and Page IDs everywhere.
+  Use the same \`version\` for Pages, types, templates and previews. Existing
+  installations require the schema 2 migration before using this model.
 - **Discover before you write.** Call \`get_site\`, \`read_site_settings\`,
   \`list_pages\`, and \`list_block_types\` before proposing changes so you
   mirror the site's conventions.

package/dist/server.js

@@ -11,7 +11,8 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { pageTools } from './tools/pages.js';
 import { partialTools } from './tools/partials.js';
-import { collectionTools } from './tools/collections.js';
+import { contentTypeTools } from './tools/content-types.js';
+import { pageTemplateTools } from './tools/page-templates.js';
 import { mediaTools } from './tools/media.js';
 import { redirectTools } from './tools/redirects.js';
 import { migrationTools } from './tools/migration.js';
@@ -44,6 +45,8 @@ const PERM_RANK = { read: 0, write: 1, admin: 2 };
  * mutates.
  */
 function effectFor(name) {
+    if (name === 'page_completeness')
+        return 'read';
     if (name === 'list_apps'
         || name === 'read_app'
         || name === 'update_app'
@@ -75,8 +78,11 @@ const DEFAULT_INFO = { name: 'typeroll', version: VERSION };
  */
 export const SERVER_INSTRUCTIONS = `
 Typeroll MCP — operating manual. You're managing a Typeroll site (a static-site
-CMS: database content compiles to a fast static site on a deploy). The full
-playbook ships with this server — use it:
+CMS: database content compiles to a fast static site on a deploy). Every article,
+checklist, directory entry and ordinary page is a Page. Content types supply
+custom field schemas, URL patterns and default Page templates. Use Page IDs and
+list_pages with content_type filters; use the same version for all operations.
+The full playbook ships with this server — use it:
 
 0. For the complete operating context (data model, conventions, safety
    boundaries, tool-family reference), call read_guide once. list_skills +
@@ -90,12 +96,13 @@ playbook ships with this server — use it:
    or field names — they're per-site. For installed Extension config, call
    list_extension_installations then read_extension_installation before an
    update.
-3. THE BUFFER MODEL: every content write (pages, blocks, partials,
-   collection items) lands in an unsaved per-doc DRAFT — deploys and plain
+3. THE BUFFER MODEL: content edits to Pages, blocks and partials land in an
+   unsaved per-doc DRAFT — deploys and plain
    previews see saved content only. Iterate freely, view your drafts with
    include_working_copy on the preview tools, then SAVE explicitly:
    commit_working_copy (or save:true on the write call) when the user
-   approves. Status changes and structural ops apply immediately.
+   approves. Status changes and structural ops apply immediately, including
+   Content type and Page template definitions and change_page_content_type.
 4. Branch first for anything larger than a small edit: create_branch, pass
    version=<id> on every subsequent call, merge_branch once approved. Nothing
    touches the live site until then.
@@ -126,7 +133,8 @@ export function buildServer(options) {
         ...blockTypeTools,
         ...pageBlockTools,
         ...workingCopyTools,
-        ...collectionTools,
+        ...contentTypeTools,
+        ...pageTemplateTools,
         ...mediaTools,
         ...redirectTools,
         ...migrationTools,

package/dist/tools/bulk.js

@@ -6,7 +6,7 @@ function v(version) {
 export const bulkTools = [
     {
         name: 'check_internal_links',
-        description: 'Check internal hrefs against the versioned database before deploy. Covers published pages, partials, collection templates/items, page templates, generated collection/facet routes, media URLs and redirect chains. Returns every broken source/href pair without requesting the live site.',
+        description: 'Check internal hrefs against the versioned database before deploy. Covers published Pages of every content type, partials, Page templates, generated facet routes, media URLs and redirect chains. Returns every broken source/href pair without requesting the live site.',
         inputSchema: { version: versionParam },
         handler: withErrorBoundary(async (args, { client, siteId }) => {
             return ok(await client.get(siteId, 'internal-links', v(args.version)));
@@ -14,15 +14,14 @@ export const bulkTools = [
     },
     {
         name: 'bulk_replace_text',
-        description: 'Replace a literal substring or regex across pages, collection-item schema fields, and partials. ALWAYS run with dry_run=true first and show sample_diffs before the real call. Defaults to scope=pages for backwards compatibility. BUFFER MODEL: replacements land in unsaved DRAFTS; save=true commits each touched resource through the canonical save path.',
+        description: 'Replace a literal substring or regex across Page bodies, custom Page fields, and partials. ALWAYS run with dry_run=true first and show sample_diffs before the real call. Defaults to scope=pages. BUFFER MODEL: replacements land in unsaved DRAFTS; save=true commits each touched resource through the canonical save path.',
         inputSchema: {
             pattern: z.string().min(1).describe('Literal substring (default) or JS regex source if regex=true.'),
             replacement: z.string(),
             regex: z.boolean().optional().describe('Treat pattern as a regex source. Always case-insensitive + global.'),
-            scope: z.enum(['pages', 'collection_items', 'partials', 'all']).optional().describe('Resource family to scan. Defaults to pages.'),
+            scope: z.enum(['pages', 'partials', 'all']).optional().describe('Resource family to scan. Defaults to pages.'),
             page_ids: z.array(z.string()).optional().describe('Restrict to these page ids. Omit to apply to every matching page.'),
-            collection: z.string().optional().describe('Restrict collection-item replacement to this collection.'),
-            item_ids: z.array(z.string()).optional().describe('Restrict to item ids. Requires collection.'),
+            content_type: z.string().optional().describe('Restrict replacement to Pages of this content type.'),
             partial_ids: z.array(z.string()).optional().describe('Restrict to partial ids.'),
             dry_run: z.boolean().optional(),
             save: z.boolean().optional().describe('Commit every touched page\'s draft in the same call — the usual choice after the user approved the dry-run diffs.'),

package/dist/tools/content-types.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { ok, withErrorBoundary, versionParam } from './helpers.js';
+const schema = z.array(z.object({ name: z.string(), label: z.string(), type: z.string() }).passthrough());
+const fields = {
+    label_singular: z.string().optional(), label_plural: z.string().optional(), fields: schema.optional(),
+    page_field_rules: z.record(z.object({ label: z.string().optional(), writable_by: z.array(z.enum(['portal', 'owner', 'agent', 'app', 'import'])) })).optional(),
+    allowed_templates: z.array(z.string()).nullable().optional().describe('Allowed Page template IDs, including the default. Null allows all compatible templates; an empty list permits no template.'),
+    route_template: z.string().optional(), template: z.string().optional(), schema_type: z.string().optional(),
+    schema_field_map: z.record(z.string()).optional(),
+    icon: z.string().optional(), sort_field: z.string().optional(), sort_dir: z.enum(['asc', 'desc']).optional(),
+    facets: z.array(z.record(z.unknown())).optional(), facet_combinations: z.array(z.record(z.unknown())).optional(),
+};
+export const contentTypeTools = [
+    { name: 'page_completeness', description: 'Report missing, unverified and stale fields for Pages of one content type, with per-field counts and worst-first Page IDs. Read-only; agent-writable fields only by default.', inputSchema: { content_type: z.string(), limit: z.number().int().min(1).max(200).optional(), stale_after_days: z.number().min(0).optional(), agent_writable_only: z.boolean().optional(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => { const { content_type, ...query } = args; return ok(await client.get(siteId, `content-types/${encodeURIComponent(content_type)}/completeness`, query)); }) },
+    { name: 'change_page_content_type', description: 'Change a saved Page to another content type. Preserves its identity, block body, status and existing URL. Save or discard its working copy first. If supplied, fields replaces the complete custom fields object; omitted fields are kept and must be valid for the new type. Snapshots a revision before changing.', inputSchema: { page_id: z.string(), content_type: z.string(), fields: z.record(z.unknown()).optional(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => { const { page_id, version, ...body } = args; return ok(await client.post(siteId, `pages/${encodeURIComponent(page_id)}/content-type`, body, { version })); }) },
+    { name: 'list_content_types', description: 'List the field schemas, URL patterns, sorting, allowed templates and default templates for Pages. All content is a Page; use list_pages with content_type to filter.', inputSchema: { version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.get(siteId, 'content-types', { version: args.version }))) },
+    { name: 'read_content_type', description: 'Read one Page content type.', inputSchema: { name: z.string(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.get(siteId, `content-types/${encodeURIComponent(args.name)}`, { version: args.version }))) },
+    { name: 'create_content_type', description: 'Create a Page content type. Title, slug, block body, SEO and status are built in; fields defines custom fields only. An empty route_template means pages of this type have no public URL.', inputSchema: { name: z.string(), ...fields, label_singular: z.string(), label_plural: z.string(), fields: schema, route_template: z.string(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => { const { version, ...body } = args; return ok(await client.post(siteId, 'content-types', body, { version })); }) },
+    { name: 'update_content_type', description: 'Update a Page content type. Changes affect all its pages at the next publication; explicit per-page paths remain overrides. The default template must be allowed; removing templates used by saved Pages is rejected.', inputSchema: { name: z.string(), patch: z.object(fields), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.patch(siteId, `content-types/${encodeURIComponent(args.name)}`, args.patch, { version: args.version }))) },
+    { name: 'delete_content_type', description: 'Delete an unused content type. Reassign or delete its pages first; the standard Page type cannot be deleted.', inputSchema: { name: z.string(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.del(siteId, `content-types/${encodeURIComponent(args.name)}`, { version: args.version }))) },
+];

package/dist/tools/deploy.js

@@ -12,7 +12,7 @@ export const deployTools = [
     },
     {
         name: 'trigger_deploy',
-        description: "Enqueue a deploy (static-page build → hosting) of the currently active version. Returns a job_id immediately; poll get_deploy_status until the status leaves queued/running. NOT for previewing iterative design/content edits — that's what get_preview_link is for (it renders live from the DB with no build). Reserve trigger_deploy for publishing, a stakeholder link to the compiled site, or pre-merge validation. Deploys build SAVED content only — unsaved drafts (working copies) are excluded, so commit_working_copy (or save:true on your writes) before deploying, or your changes won't ship. With `dry_run: true`, the deploy runs through every step EXCEPT the hosting-adapter upload — useful for validating a structural change (new collection routes, schema bump, mode switch) without risking the live site. A dry_run job that succeeds proves the build is clean; one that fails returns the same astro stack-trace in get_deploy_status.error as a real deploy would.",
+        description: "Enqueue a deploy (static-page build → hosting) of the currently active version. Returns a job_id immediately; poll get_deploy_status until the status leaves queued/running. NOT for previewing iterative design/content edits — that's what get_preview_link is for (it renders live from the DB with no build). Reserve trigger_deploy for publishing, a stakeholder link to the compiled site, or pre-merge validation. Deploys build SAVED content only — unsaved drafts (working copies) are excluded, so commit_working_copy (or save:true on your writes) before deploying, or your changes won't ship. With `dry_run: true`, the deploy runs through every step EXCEPT the hosting-adapter upload — useful for validating a structural change (new content-type routes, schema bump, mode switch) without risking the live site. A dry_run job that succeeds proves the build is clean; one that fails returns the same astro stack-trace in get_deploy_status.error as a real deploy would.",
         inputSchema: {
             environment: z.enum(['production', 'staging']).optional(),
             dry_run: z.boolean().optional().describe('Run the build but skip the CDN upload. The job ends in succeeded/failed the same way a real deploy does.'),

package/dist/tools/migration.js

@@ -63,7 +63,7 @@ export const migrationTools = [
     },
     {
         name: 'list_migration_urls',
-        description: "The legacy site's URL inventory with LIVE coverage status. Every entry is classified on read against the site's current pages + redirects: `migrated` (a page/collection item answers at that path), `redirected` (a redirect rule covers it), `excluded` (signed off as an intentional 404), `unhandled` (nothing covers it — the work list). Returns a summary over the whole inventory plus a page of entries, sorted worst-first then by GSC clicks. Use `status: \"unhandled\"` to get exactly what's left to do before cutover. Coverage is computed, never stored, so it's current the moment you create a redirect.",
+        description: "The legacy site's URL inventory with LIVE coverage status. Every entry is classified on read against the site's current pages + redirects: `migrated` (a Page answers at that path), `redirected` (a redirect rule covers it), `excluded` (signed off as an intentional 404), `unhandled` (nothing covers it — the work list). Returns a summary over the whole inventory plus a page of entries, sorted worst-first then by GSC clicks. Use `status: \"unhandled\"` to get exactly what's left to do before cutover. Coverage is computed, never stored, so it's current the moment you create a redirect.",
         inputSchema: {
             status: STATUS.optional().describe('Only return entries with this coverage status.'),
             limit: z.number().int().positive().max(1000).optional().describe('Default 200.'),
@@ -154,11 +154,10 @@ export const migrationTools = [
         name: 'repair_migration_plain_text',
         description: 'Repair legacy WordPress entity encoding and HTML markup in fields whose contract is plain text. ONLY title, seo_title, seo_description and excerpt are eligible; rich content, slugs, paths and URLs are never changed. ALWAYS run the dry-run first (the default), show every returned before/after diff and conflict to the user, and obtain approval before calling again with dry_run:false. Existing working copies are skipped so another editor\'s draft cannot be overwritten or accidentally saved. save:false stages working copies for portal review; save:true commits through the normal revision and validation path.',
         inputSchema: {
-            scope: z.enum(['pages', 'collection_items', 'all']).optional().describe('Defaults to all.'),
+            scope: z.enum(['pages', 'all']).optional().describe('Defaults to all.'),
             fields: z.array(PLAIN_TEXT_REPAIR_FIELD).min(1).max(4).optional().describe('Narrow the fixed plain-text allowlist.'),
             page_ids: z.array(z.string().min(1)).min(1).max(2000).optional(),
-            collection: z.string().min(1).optional(),
-            item_ids: z.array(z.string().min(1)).min(1).max(2000).optional().describe('Requires collection.'),
+            content_type: z.string().min(1).optional(),
             dry_run: z.boolean().optional().describe('Defaults to true. Set false only after the user reviews the dry-run.'),
             save: z.boolean().optional().describe('With dry_run:false, commit repaired working copies immediately. Defaults to false.'),
             diff_limit: z.number().int().min(1).max(2000).optional().describe('Exact field diffs returned; default 500.'),

package/dist/tools/page-blocks.js

@@ -28,9 +28,9 @@ const blockSchema = z.object({
  * `{ kind: 'page', id: page_id }`.
  */
 const targetSchema = z.object({
-    kind: z.enum(['page', 'partial', 'template', 'item_template']),
+    kind: z.enum(['page', 'partial', 'template']),
     id: z.string(),
-}).describe('Address a container. kind=page|partial|template|item_template. Pages: id is the page id. Partials: id is "header"|"footer"|<free-block id>. Templates: id is the PageTemplate id. item_template: id is the COLLECTION NAME — the block tree is the collection\'s per-item layout (e.g. blog post body bound to {{item.title}}, {{item.body}}, etc.).');
+}).describe('Address a page, partial or PageTemplate by its ID. All content uses kind=page; the same block editor applies to every content type.');
 function v(version) {
     return version ? { version } : undefined;
 }

package/dist/tools/page-templates.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ok, withErrorBoundary, versionParam } from './helpers.js';
+const fields = {
+    label: z.string().optional(), icon: z.string().optional(), applies_to: z.string().optional(),
+    blocks: z.array(z.any()).optional(), status: z.enum(['draft', 'published']).optional(),
+};
+export const pageTemplateTools = [
+    { name: 'list_page_templates', description: 'List reusable Page templates in the selected version, including inherited templates.', inputSchema: { version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.get(siteId, 'page-templates', { version: args.version }))) },
+    { name: 'read_page_template', description: 'Read one reusable Page template and its block tree.', inputSchema: { template_id: z.string(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.get(siteId, `page-templates/${encodeURIComponent(args.template_id)}`, { version: args.version }))) },
+    { name: 'create_page_template', description: 'Create a reusable template. Choose a starter or provide blocks, including template_content_slot for the Page body. Assign its ID to a content type’s template or a Page’s template.', inputSchema: { name: z.string(), ...fields, starter: z.enum(['blog', 'article', 'checklist', 'team', 'events', 'products', 'custom']).optional(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => { const { version, ...body } = args; return ok(await client.post(siteId, 'page-templates', body, { version })); }) },
+    { name: 'update_page_template', description: 'Update a reusable Page template. The change is saved immediately and affects its Pages on the next publication. A version isolates the edit from main.', inputSchema: { template_id: z.string(), patch: z.object(fields), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.patch(siteId, `page-templates/${encodeURIComponent(args.template_id)}`, args.patch, { version: args.version }))) },
+    { name: 'delete_page_template', description: 'Delete an unused Page template. Reassign any Pages or content types using it first.', inputSchema: { template_id: z.string(), version: versionParam },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.del(siteId, `page-templates/${encodeURIComponent(args.template_id)}`, { version: args.version }))) },
+];

package/dist/tools/pages.js

@@ -10,6 +10,9 @@ export const pageTools = [
         description: 'List pages on the active site. Returns id, title, slug, status, and SEO summary (no html_content by default — use read_page or batch_read_pages for body content). Supports filtering by status and forward-cursor pagination. Pass full=true to include html_content + blocks in the response.',
         inputSchema: {
             status: z.enum(['draft', 'review', 'unlisted', 'published', 'all']).optional(),
+            sort_by: z.string().optional().describe('Sort field; defaults to the selected content type’s order. Unfiltered lists use stable Page IDs.'),
+            sort_order: z.enum(['asc', 'desc']).optional(),
+            content_type: z.string().optional().describe('Filter Pages by content type ID.'),
             limit: z.number().int().min(1).max(200).optional(),
             cursor: z.string().optional(),
             full: z.boolean().optional().describe('Set true to include html_content + blocks. Default false (summary only) to avoid large payloads on sites with many pages.'),
@@ -18,6 +21,9 @@ export const pageTools = [
         handler: withErrorBoundary(async (args, { client, siteId }) => {
             const res = await client.get(siteId, 'pages', {
                 status: args.status,
+                content_type: args.content_type,
+                sort_by: args.sort_by,
+                sort_order: args.sort_order,
                 limit: args.limit,
                 cursor: args.cursor,
                 full: args.full ? 'true' : undefined,
@@ -69,13 +75,15 @@ export const pageTools = [
             'the server stores it under id "home" with slug "". ' +
             'Slug must be a single path segment (no slashes). For nested URLs like ' +
             '/erbjudanden/sommar or /tjanster/design, set the optional `path` field explicitly — ' +
-            'e.g. path="/erbjudanden/sommar". For many similar items use a collection with route_template ' +
+            'e.g. path="/erbjudanden/sommar". For pages with the same schema use a content type with route_template ' +
             '(see tr-blog / tr-directory), but for a small group of bespoke pages sharing a URL prefix, ' +
             '`path` is the right primitive. ' +
             'Returns the created page (blocks for blocks-mode, html_content for html-mode) including ' +
             '`url` (the resolved live URL).',
         inputSchema: {
             title: z.string().min(1),
+            content_type: z.string().optional().describe('Content type ID; defaults to page.'),
+            fields: z.record(z.unknown()).optional().describe('Custom field values defined by the content type.'),
             slug: z.string().optional().describe('URL slug — single path segment, no slashes (e.g. "about", "kontakt"). Empty string "" = homepage. For nested URLs set the `path` field explicitly — `slug` stays a leaf id.'),
             path: z.string().optional().describe('Optional explicit URL path for nested pages (e.g. "/erbjudanden/sommar-2026"). When set, takes precedence over slug for routing. Must start with "/", lowercase a-z/0-9/-/_/ only, no "..", no "//", no trailing slash. Slug is still required as the leaf id but two pages CAN share a slug under different paths.'),
             content_mode: z.enum(['blocks', 'html']).optional().describe('Default "blocks". "blocks" stores a Block[] tree (the modern default — supports the full ~40-block library, page templates, and the responsive system). "html" stores raw markup in html_content (legacy path, still fully supported for imported content or hand-written HTML). Passing html_content without content_mode also opts into "html".'),
@@ -94,7 +102,8 @@ export const pageTools = [
             kind: z.enum(['page', 'article']).optional(),
             author: z.string().optional(),
             language: z.string().optional().describe('BCP-47 tag overriding the site default (e.g. "en" on an otherwise Swedish site).'),
-            template: z.string().optional().describe('Page template id (PageTemplate). Wraps the body in the template tree at render time.'),
+            sort_order: z.number().finite().optional().describe('Manual Page order; lower numbers come first in ascending lists. Content types and listings choose how to sort.'),
+            template: z.string().nullable().optional().describe('Allowed Page template ID; null uses the content type default.'),
             image_sizes_default: z.string().optional().describe('Per-page default `sizes` for responsive images (e.g. "(max-width: 640px) 360px, 560px"). Overrides the site setting; a per-<img> `sizes` attr still wins. Set when this page\'s images render narrower than the generic default so the browser stops over-fetching.'),
             custom_css: z.string().optional().describe('Per-page CSS, injected into <head> as a <style> AFTER the site-level custom_css (so it overrides site styling). This is the RIGHT home for page-specific styling — page metadata, not content. Put a page\'s <style> here instead of stuffing it into a core/html block (which is opaque and un-editable in the visual editor).'),
             version: versionParam,
@@ -113,6 +122,7 @@ export const pageTools = [
             patch: z
                 .object({
                 title: z.string().optional(),
+                fields: z.record(z.unknown()).optional(),
                 slug: z.string().optional(),
                 html_content: z.string().optional(),
                 blocks: z.array(z.any()).optional().describe('Block tree, only used when content_mode="blocks".'),
@@ -149,7 +159,8 @@ export const pageTools = [
                     url: z.string().optional(),
                 })
                     .optional(),
-                template: z.string().optional(),
+                sort_order: z.number().finite().nullable().optional(),
+                template: z.string().nullable().optional().describe('Allowed template ID; null restores the content type default.'),
             })
                 .passthrough(),
             save: z.boolean().optional().describe('Also SAVE (commit) the draft in the same call — use for pre-approved or batch changes. Without it, changes stay in the unsaved draft until commit_working_copy.'),
@@ -221,6 +232,8 @@ export const pageTools = [
             const srcMode = src.content_mode ?? 'html';
             const body = {
                 title: args.title,
+                content_type: src.content_type,
+                fields: src.fields,
                 content_mode: srcMode,
                 html_content: srcMode === 'html' ? src.html_content : '',
                 blocks: srcMode === 'blocks' ? (src.blocks ?? []) : undefined,

package/dist/tools/preview.js

@@ -17,12 +17,10 @@ export const previewTools = [
     },
     {
         name: 'get_preview_link',
-        description: 'Mint a signed URL the user (or your own browser tool) can open to SEE the rendered preview. Renders LIVE from the database with NO build — this is the PREFERRED way to preview design/content changes as you iterate; reach for this, not trigger_deploy, when previewing. BUFFER MODEL: your edits are unsaved drafts, so for the iteration loop mint the link with include_working_copy:true (drafts visible); a plain link shows SAVED content only — right for stakeholders reviewing what will deploy. Mint ONCE and REUSE that single URL across edits — internal links keep the token so it navigates the whole branch, and it stays valid until the TTL lapses (24h default and max). Target a page (page_id), a collection item (collection_name + item_id), or a raw slug; omit all for the home page. (For a permanent public link, complete Publishing setup and wait for a verified deployment on the organization or site domain.)',
+        description: 'Mint a signed URL the user (or your own browser tool) can open to SEE the rendered preview. Renders LIVE from the database with NO build — this is the PREFERRED way to preview design/content changes as you iterate; reach for this, not trigger_deploy, when previewing. BUFFER MODEL: your edits are unsaved drafts, so for the iteration loop mint the link with include_working_copy:true (drafts visible); a plain link shows SAVED content only — right for stakeholders reviewing what will deploy. Mint ONCE and REUSE that single URL across edits — internal links keep the token so it navigates the whole branch, and it stays valid until the TTL lapses (24h default and max). Target a page (page_id), or a raw slug; omit all for the home page. (For a permanent public link, complete Publishing setup and wait for a verified deployment on the organization or site domain.)',
         inputSchema: {
             page_id: z.string().optional(),
             slug: z.string().optional(),
-            collection_name: z.string().optional(),
-            item_id: z.string().optional(),
             ttl_seconds: z.number().int().min(60).max(86_400).optional(),
             include_working_copy: z
                 .boolean()

package/dist/tools/sites.js

@@ -28,7 +28,7 @@ export const siteTools = [
     },
     {
         name: 'get_site_capabilities',
-        description: "Discover what the site-template renderer supports for this site. Returns a manifest of feature flags (blocks-mode, x-include, collection routes, custom block scripts, dry-run deploys, etc.) plus template_capabilities_version + the core block type ids. Call this when you're about to do something structural (set route_template on a collection, switch a page to blocks-mode, install a custom block type) and want to feature-detect rather than guess. The manifest is platform-wide today; per-site custom templates land later.",
+        description: "Discover what the site-template renderer supports for this site. Returns a manifest of feature flags (blocks-mode, x-include, content-type routes, custom block scripts, dry-run deploys, etc.) plus template_capabilities_version + the core block type ids. Call this when you're about to do something structural (set route_template on a content type, switch a page to blocks-mode, install a custom block type) and want to feature-detect rather than guess. The manifest is platform-wide today; per-site custom templates land later.",
         handler: withErrorBoundary(async (_args, { client, siteId }) => {
             const res = await client.get(siteId, 'capabilities');
             return ok(res);

package/dist/tools/working-copy.js

@@ -17,16 +17,10 @@ function v(version) {
     return version ? { version } : undefined;
 }
 const wcTargetSchema = z.object({
-    kind: z.enum(['page', 'partial', 'item']),
+    kind: z.enum(['page', 'partial']),
     id: z.string(),
-    collection: z.string().optional().describe('Required when kind="item": the collection name.'),
-}).describe('Which doc\'s draft: page {id}, partial {id}, or collection item ({collection} + {id}). Templates/item templates have no drafts (their writes apply directly).');
+}).describe('Which doc\'s draft: page {id} or partial {id}. Templates have no drafts (their writes apply directly).');
 function wcPath(t) {
-    if (t.kind === 'item') {
-        if (!t.collection)
-            throw new Error('collection is required when kind="item"');
-        return `working-copy/item/${encodeURIComponent(t.collection)}/${encodeURIComponent(t.id)}`;
-    }
     return `working-copy/${t.kind}/${encodeURIComponent(t.id)}`;
 }
 export const workingCopyTools = [

package/dist/version.js

@@ -8,4 +8,4 @@
 //
 // Keep it in lockstep with package.json: tests/version.test.ts asserts
 // VERSION === package.json.version, so a bump that forgets this line fails CI.
-export const VERSION = '0.44.74';
+export const VERSION = '0.45.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeroll/mcp-server",
-  "version": "0.44.74",
+  "version": "0.45.0",
   "description": "Typeroll CMS MCP server – connect AI agents to the REST API to manage content and publish static websites.",
   "license": "MIT",
   "repository": {

package/skills/README.md

@@ -46,11 +46,10 @@ ln -s "$PWD/skills/tr-migrate-wp.md" ~/.claude/skills/
 
 | File | When it triggers | What it does |
 |---|---|---|
-| `tr-blog.md`              | "add a blog", "set up news", "article/podcast section" | Collection schema with `item_template_html` + `route_template` → seed items → listing page with marker block → deploy. **No per-article `create_page` needed** — items materialise their own URLs. |
+| `tr-blog.md` | "add a blog", "set up news" | Articles are Pages of a content type, sharing a native template and Page listing. |
 | `tr-forms.md`             | "contact form", "add a form", "booking form"           | Form definition → embed HTML with signed token → inline JS feedback → deploy. |
-| `tr-directory.md`         | Building a directory site, importing structured data   | Schema → items → per-item URLs via `route_template` → listing page → preview → deploy. |
-| `tr-collection-template.md` | Rich per-item detail pages: audio players, chapter lists, guest cards, image galleries — anything needing loops/nested data | Pre-render HTML into `*_html` fields when Mustache's `{{field}}` / `{{#field}}` aren't enough. Concrete recipes per pattern. |
-| `tr-page-template.md`     | Several pages share structure (category landings, service-detail variants) | Partials + `<x-include>` for HTML mode; formal `PageTemplate` via `set_page_template` for block mode. Refactor existing duplication. |
+| `tr-directory.md`         | Building a directory site, importing structured data   | Content type → Pages → URLs via `route_template` → listing page → preview → deploy. |
+| `tr-page-template.md` | Reusable Page templates: audio players, chapter lists, guest cards, image galleries — anything needing loops/nested data | Compose native blocks around `template_content_slot`; bind Page metadata, structured fields and references. |
 | `tr-seo.md`               | "SEO", "meta descriptions", "structured data"          | Audit → fix titles/descriptions → OG images → JSON-LD → robots.txt → deploy. |
 
 ### Importera innehåll
@@ -59,12 +58,12 @@ ln -s "$PWD/skills/tr-migrate-wp.md" ~/.claude/skills/
 |---|---|---|
 | `tr-migrate-wp.md`     | "migrate from WordPress", a wp-json URL is mentioned     | Walks the WP REST, rebuilds each page in the target's design, transfers media, sets redirects, leaves everything as drafts for review. |
 | `tr-migrate-multisite.md` | "multisite", "our .se/.de/.co.uk sites", migrating several sites at once | One site per domain; per-site URL inventory, design replicated via `.tcblocks`, path preservation, hreflang clusters, and a parity check against the deployed site before DNS moves. |
-| `tr-migrate-astro.md`  | "migrate an Astro site", "import from src/content"       | Lifts Astro Content Collections (`src/content/*`) into Typeroll collections — zod schema → field list, frontmatter → field values, markdown body → richtext field. Translates standalone `src/pages/*` into Typeroll pages, maps `src/layouts` chunks into partials. |
+| `tr-migrate-astro.md`  | "migrate an Astro site", "import from src/content"       | Lifts Astro Content Collections (`src/content/*`) into Typeroll content types — zod schema → field list, frontmatter → field values, Markdown body → Page blocks. Translates standalone `src/pages/*` into Typeroll pages, maps `src/layouts` chunks into partials. |
 | `tr-import-url.md`     | "import from Squarespace/Wix/Webflow", any non-WP URL    | Fetch → clean → adapt to target design → media transfer → draft pages → redirects → deploy. |
 
 ## Prerequisites for every skill
 
-1. `@typeroll/mcp-server` configured in `.claude.json` with a valid
+1. `@typeroll/mcp-server` configured in the agent’s MCP settings with a valid
    `TYPEROLL_API_KEY` and `TYPEROLL_API_URL`.
 2. The agent has read `AGENTS.md` (ships with the MCP package — see
    `node_modules/@typeroll/mcp-server/AGENTS.md` after install, or
@@ -78,7 +77,7 @@ If those are missing, every skill will fail at the first MCP call with
 Skills are markdown files that the agent loads on demand. Each one
 should include:
 
-- A `description:` frontmatter explaining when to load it (Claude uses
+- A `description:` frontmatter explaining when to load it (agents use
   this to pick the right skill).
 - A clear set of preconditions (what MCP tools must work, what state the
   agent needs to know).

package/skills/tr-blog.md

@@ -1,145 +1,61 @@
 ---
 name: tr-blog
-description: Use when the user wants to set up a blog, news section, podcast feed, or any time-ordered article-style content on a Typeroll site. Triggers on "add a blog", "set up news", "article section", "create posts", "podcast", "inlägg", "nyheter", "avsnitt", or any feed-of-dated-entries pattern.
+description: Set up a blog, news section or dated article series using Pages, a content type, shared templates and a dynamic listing.
 ---
 
-# Set up a blog / news section
+# Build a blog with Pages
 
-> **The buffer model (draft writes).** Every content write in this recipe
-> (pages, blocks, partials, collection items) lands in an unsaved per-doc
-> DRAFT — deploys and plain previews only see SAVED content. For recipe-style
-> build work, pass `save: true` on write calls (the work is pre-approved by
-> the task itself), or run `commit_working_copy` per doc before any
-> `trigger_deploy`. Preview your drafts with `include_working_copy: true`.
+Every article is a Page. A Content type supplies its extra fields, URL pattern
+and default template. Do not create a separate item store or generate listing
+HTML by hand.
 
+1. Read `get_site_capabilities`, `list_block_types`, `list_content_types` and
+   `list_page_templates`. For a substantial change, create a site version and
+   pass its ID as `version` on every supported operation.
+2. Create an editable shared template:
 
-A blog in Typeroll is a **collection with `item_template_blocks` +
-`route_template`**. Every published item materialises as its own static page at
-build time — there is **no need to call `create_page` per article**. Start with
-the native `article` preset; the listing is a block-mode page with
-`core/collection_list` and updates at build time.
-
-If you find yourself about to create 20 pages for 20 articles, stop — you're using the old pattern. The recipe below is the right one.
-
-## Preconditions
-
-- Site exists with working header/footer.
-- Collection name picked (`blog`, `news`, `artiklar`, `podcast`, `avsnitt`).
-- URL structure picked: `/blog/{slug}`, `/news/{slug}`, `/podd/{slug}`. Changing later renames every URL.
+```json
+{ "name": "article-layout", "label": "Article", "starter": "article", "status": "published" }
+```
 
-## Recipe
+Send it to `create_page_template`. Use block tools with
+`target: { kind: "template", id: "article-layout" }` to refine the layout.
 
-### 1. Create the collection with a native item composition
+3. Call `create_content_type`:
 
-```
-create_collection {
-  "name": "blog",
-  "label_singular": "Artikel",
-  "label_plural": "Artiklar",
-  "icon": "📝",
-  "slug_field": "slug",
-  "sort_field": "published_at",
-  "sort_dir": "desc",
-  "route_template": "/blog/{slug}",
-  "template_kind": "article",
+```json
+{
+  "name": "articles", "label_singular": "Article", "label_plural": "Articles",
+  "route_template": "/articles/{slug}", "template": "article-layout",
+  "sort_field": "date_published", "sort_dir": "desc",
   "fields": [
-    {"name": "title",   "type": "text",     "label": "Rubrik",    "required": true},
-    {"name": "slug",    "type": "text",     "label": "URL-slug",  "required": true},
-    {"name": "published_at", "type": "date", "label": "Datum", "required": true},
-    {"name": "author",  "type": "text",     "label": "Författare"},
-    {"name": "excerpt", "type": "textarea", "label": "Ingress"},
-    {"name": "body",    "type": "richtext", "label": "Brödtext"},
-    {"name": "featured_image", "type": "image", "label": "Omslagsbild"}
+    { "name": "excerpt", "label": "Summary", "type": "textarea" },
+    { "name": "featured_image", "label": "Cover image", "type": "image" }
   ]
 }
 ```
 
-The preset writes an ordinary, editable `item_template_blocks` tree with
-breadcrumbs, title/date, body, and a server-rendered outline. Localize labels
-or change field mappings in the collection template editor.
-
-**Field name rule:** ASCII only, lowercase, `[a-z][a-z0-9_-]*`. `ä→a`, `ö→o`, `å→a` for the `name`; the `label` can be anything.
-
-### 2. Seed with real content
-
-```
-create_collection_item collection="blog" status="published" fields={
-  "title":   "Vår designfilosofi",
-  "slug":    "var-designfilosofi",
-  "published_at": "2025-05-15",
-  "author":  "Anna Lindström",
-  "excerpt": "Vi tror på enkelhet med syfte — varje beslut ska kunna motiveras.",
-  "body":    "<p>Lång brödtext här...</p><h2>En underrubrik</h2><p>Mer text...</p>",
-  "featured_image": "https://cdn.typeroll.com/..."
-}
-```
-
-If `featured_image` is a URL from elsewhere, upload it first via `upload_media_from_url` and use the returned CDN URL.
-
-Each published item with this collection's `route_template` automatically becomes `/blog/{slug}` at deploy time — you do **not** need to call `create_page`.
-
-### 3. Build the native listing page once
-
-```
-create_page title="Artiklar" slug="blog" status="published" content_mode="blocks" blocks=[
-  {"id":"articles-heading","type":"core/heading","data":{"text":"Artiklar","level":"h1","size":"auto","align":"left"}},
-  {"id":"articles-list","type":"core/collection_list","data":{"collection":"blog","sort_by":"published_at","sort_order":"desc","item_block":"core/post_card","layout":"grid","cols":3,"gap":"md"}}
-]
-```
-
-The list resolves from current collection data on every preview/build. No
-generated HTML marker or regeneration call is needed.
-
-### 4. Update the header partial to link to the listing
-
-```
-read_partial partial_id="header"
-replace_partial partial_id="header" html_content="<updated with /blog link>"
-```
-
-### 5. Preview a single article
-
-```
-get_preview_link collection_name="blog" item_id="<id>"
-```
-
-The returned URL renders the native item block tree from current database content.
-
-### 6. Deploy
-
-```
-trigger_deploy
-get_deploy_status job_id=<id>
-```
-
-The build produces one HTML file per published article at `/blog/<slug>` plus the listing at `/blog`, and includes them all in `sitemap.xml`.
-
-## Adding a new article later
-
-```
-create_collection_item collection="blog" status="published" fields={ ... }
-trigger_deploy
-```
-
-Two calls. No per-article `create_page`, listing regeneration, or HTML diffing.
-
-## Pitfalls
-
-- **Don't fall back to "one page per article".** Collection item routes keep
-  design, sitemap, preview, and nested URL handling centralized. `create_page`
-  rejects slashes in `slug`; use the collection's `route_template`.
-- **Slugs must be unique within the collection.** An item whose route tokens
-  are missing cannot receive a static detail URL.
-- **Don't use non-ASCII field names.** `datum` not `Datum`; `forfattare` not `författare` in the `name`. The `label` is free-form.
-- **Template too clever.** First compose current native blocks and run the
-  composition preflight. Use custom/HTML-backed behavior only when it is
-  genuinely business-specific, not to repair a generic Core gap.
-
-## When you want a page that ISN'T a collection item
-
-A normal `create_page` is still right for:
-- The blog's about/contact pages.
-- Editorial standalone features.
-- Anything that doesn't fit the "list of dated entries" mould.
-
-Just don't use `create_page` *for the entries themselves*.
+Title, slug, author, date, SEO, status and body are built-in Page values. Keep
+only custom values in `fields`.
+
+4. Call `create_page` for each article with its `title`, `slug`,
+   `content_type: "articles"`, `status`, `date_published`, `fields` and `blocks`.
+   Use native heading, prose, image, list and table blocks. Store its returned
+   Page ID; use it for every later operation.
+5. Create the archive as another Page with `core/page_list`, using
+   `data: { content_type: "articles", sort_by: "date_published", sort_order: "desc", paginate: 10 }`.
+   A homepage teaser can use `limit: 6` instead. Both resolve saved Pages at
+   render time; adding an article needs no listing regeneration.
+6. Link to the archive from navigation. Preview representative articles and
+   the archive on desktop and mobile with `get_preview_link page_id=...`.
+7. Save any working copies before publication. `update_page` and block edits
+   need `save: true` or `commit_working_copy`; new Pages and template definitions
+   are saved immediately. Deploy only within the user's authorized scope and
+   verify the returned job and public URL.
+
+Use the organization's connected media storage before importing remote images.
+Do not hardcode a Typeroll media hostname. Use the returned media URL.
+
+A published Page with complete route tokens becomes one static detail page.
+Draft/review Pages stay private. Unlisted Pages have a public URL but are omitted
+from listings and search indexes. The selected version's robots policy applies.

package/skills/tr-brand.md

@@ -6,7 +6,7 @@ description: Use when the user asks to create a brand identity, design system, o
 # Design a brand identity for a Typeroll site
 
 > **The buffer model (draft writes).** Every content write in this recipe
-> (pages, blocks, partials, collection items) lands in an unsaved per-doc
+> (pages, blocks and partials) lands in an unsaved per-doc
 > DRAFT — deploys and plain previews only see SAVED content. For recipe-style
 > build work, pass `save: true` on write calls (the work is pre-approved by
 > the task itself), or run `commit_working_copy` per doc before any
@@ -177,7 +177,7 @@ Then reference `var(--brand-gradient)` etc. in page HTML and partials.
 
 ## Step 4b — Section + layout design defaults
 
-These are non-negotiable defaults the rest of the platform skills inherit (`tr-new-site`, `tr-directory`, `tr-collection-template`). Apply them on every page that has visible sections — they're battle-tested across real customer migrations.
+These are non-negotiable defaults the rest of the platform skills inherit (`tr-new-site`, `tr-directory`, `tr-page-template`). Apply them on every page that has visible sections — they're battle-tested across real customer migrations.
 
 ### One signal per section boundary