@typeroll/mcp-server 0.45.77 → 0.45.79

package/dist/tools/deploy.js

@@ -15,6 +15,7 @@ export const deployTools = [
         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. Customer publishing freezes a consistent saved source, then resumes source/Git/build-dispatch checkpoints without recapturing later edits. GitHub or Cloudflare performs rendering and media work. With dry_run:true, customer publishing validates frozen source without a Git push or external build; it does not prove an Astro build succeeds. Other self-hosted adapters may build locally without upload. Check the reported phase.",
         inputSchema: {
             environment: z.enum(['production', 'staging']).optional(),
+            allow_unsaved: z.boolean().optional().describe('Explicitly publish saved content while leaving the reported unsaved Pages/partials untouched. Only after owner confirmation.'),
             dry_run: z.boolean().optional().describe('Validate without publishing. Customer publishing checks frozen source only; other adapters may build locally without upload.'),
             version: versionParam,
         },
@@ -40,7 +41,7 @@ export const deployTools = [
     },
     {
         name: 'get_deploy_status',
-        description: "Status of a single deploy job. Returns { job, queued_for_seconds, queue_timeout_seconds }. job.status is one of queued | running | succeeded | failed. On a failed build, job.error names the failed step and the cause the step printed, job.failure.code is the reported code (e.g. media_build_process_exit_1) and job.failure.diagnostic holds { cause, lines } (the last 40 lines that step printed, credentials removed). On the Cloudflare build engine job.failure.provider_log also holds { step, build_id, summary, lines } from the provider's build log (last 60 lines). Read them before retrying; retrying does not fix a cause that is in the content or the build engine. Polling cadence: ~5s for queued/running. job.render_report, when present, reports actual HTML mode (full/partial), rendered, reused, total and removed route counts plus a fallback reason. From Core 0.2.17, custom blocks and consumed image metadata are tracked per route; older caches require one full build. It does not measure media or provider startup savings. job.coordinator, when present, reports the last completed CMS phase and duration_ms for that attempt; external build waiting is excluded. Keep observing the same job across checkpoints; do not trigger duplicate deploys. A job stuck in 'queued' for longer than queue_timeout_seconds (default 300s) auto-flips to failed with phase='queue_timeout' — so a single poll past that timestamp returns the terminal state and you can stop polling.",
+        description: "Status of a single deploy job. Optional top-level build_progress reports the exact task status, attempt, step and completed/total files; not an overall percentage or ETA. Returns { job, queued_for_seconds, queue_timeout_seconds }. job.status is one of queued | running | succeeded | failed. On a failed build, job.error names the failed step and the cause the step printed, job.failure.code is the reported code (e.g. media_build_process_exit_1) and job.failure.diagnostic holds { cause, lines } (the last 40 lines that step printed, credentials removed). On the Cloudflare build engine job.failure.provider_log also holds { step, build_id, summary, lines } from the provider's build log (last 60 lines). Read them before retrying; retrying does not fix a cause that is in the content or the build engine. Polling cadence: ~5s for queued/running. job.render_report, when present, reports actual HTML mode (full/partial), rendered, reused, total and removed route counts plus a fallback reason. From Core 0.2.17, custom blocks and consumed image metadata are tracked per route; older caches require one full build. It does not measure media or provider startup savings. job.coordinator, when present, reports the last completed CMS phase and duration_ms for that attempt; external build waiting is excluded. Keep observing the same job across checkpoints; do not trigger duplicate deploys. A job stuck in 'queued' for longer than queue_timeout_seconds (default 300s) auto-flips to failed with phase='queue_timeout' — so a single poll past that timestamp returns the terminal state and you can stop polling.",
         inputSchema: { job_id: z.string(), include_provider: z.boolean().optional().describe('Also read the exact Git commit and Cloudflare build stages for a customer Git publication. Does not return build secrets.') },
         handler: withErrorBoundary(async (args, { client, siteId }) => {
             const res = await client.get(siteId, `deploys/${encodeURIComponent(args.job_id)}`);

package/dist/tools/media.js

@@ -206,7 +206,7 @@ export const mediaTools = [
     },
     {
         name: 'finalize_media',
-        description: 'Post-upload finalize for a single image: (1) applies immutable Cache-Control (public, max-age=31536000) to the R2 original via in-place CopyObject so the CDN caches it for a year, and (2) generates AVIF/WebP responsive variants if not already present. Call this immediately after a successful upload (the presigned PUT does NOT set cache headers — without finalize, Cloudflare defaults to ~4h and every visit re-fetches the original). Idempotent: safe to call twice. Skips variant work when variants already exist on the doc. INTEGRITY: the result always includes the stored original\'s sha256 + size_bytes — compare against your source file to catch transit corruption before referencing the asset. Better: pass expected_sha256 (hash the file yourself first, e.g. `shasum -a 256 file`) and the server rejects a mismatch with a 422 so corrupted bytes never get blessed with immutable cache headers. Truncated SVGs are rejected outright.',
+        description: 'Post-upload finalize for a single image: (1) applies immutable Cache-Control (public, max-age=31536000) to the R2 original via in-place CopyObject so the CDN caches it for a year, and (2) generates AVIF/WebP responsive variants if not already present. Call this immediately after a successful upload (the presigned PUT does NOT set cache headers — without finalize, Cloudflare defaults to ~4h and every visit re-fetches the original). Idempotent: safe to call twice. Skips variant work when variants already exist on the doc. INTEGRITY: the response is { ok, result: { sha256, size_bytes, ... } }; read result.sha256 and result.size_bytes for the stored original — compare against your source file to catch transit corruption before referencing the asset. Better: pass expected_sha256 (hash the file yourself first, e.g. `shasum -a 256 file`) and the server rejects a mismatch with a 422 so corrupted bytes never get blessed with immutable cache headers. Truncated SVGs are rejected outright.',
         inputSchema: {
             media_id: z.string(),
             expected_sha256: z.string().regex(/^[0-9a-fA-F]{64}$/).optional()

package/dist/tools/migration.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ok, withErrorBoundary, versionParam } from './helpers.js';
-const STATUS = z.enum(['migrated', 'redirected', 'excluded', 'unhandled']);
+const STATUS = z.enum(['migrated', 'redirected', 'excluded', 'unhandled', 'matched_draft']);
 const PLAIN_TEXT_REPAIR_FIELD = z.enum(['title', 'seo_title', 'seo_description', 'excerpt']);
 export const migrationTools = [
     {
@@ -8,6 +8,8 @@ export const migrationTools = [
         description: 'Import an explicit sitemap URL into the migration URL inventory. Sitemap indexes are followed recursively; URLs outside source_origin are rejected and reported.',
         inputSchema: {
             url: z.string().url().describe('Absolute URL of a sitemap or sitemap index.'),
+            include_wordpress: z.boolean().optional().describe('Also enumerate public WordPress REST pages/posts/types. No helper installation required; incomplete discovery is reported.'),
+            crawl_pages: z.number().int().min(0).max(50).optional().describe('With include_wordpress, crawl up to this many source pages for same-origin legacy links. Default 0; bounded discovery is not an authoritative old-slug export.'),
             source_origin: z.string().url().optional().describe('Expected legacy-site origin. Defaults to the sitemap origin.'),
         },
         handler: withErrorBoundary(async (args, { client, siteId }) => {
@@ -69,7 +71,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 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), `matched_draft` (a saved but unpublished Page owns the path; not launch-ready), `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.'),

package/dist/tools/pages.js

@@ -223,7 +223,7 @@ export const pageTools = [
     },
     {
         name: 'batch_update_pages',
-        description: 'Apply per-page patches in one call (up to 200 entries). Each entry is { page_id, patch, save?, answer_sources? }; failures are reported per-row, the rest still apply. BUFFER MODEL: content patches land in each page\'s unsaved draft; per-entry save:true (or the top-level save flag) commits — typical for a user-approved sweep. content_mode is rejected per-row; switch each page with set_page_mode.',
+        description: 'Apply per-page patches in one call (up to 200 entries). Each entry is { page_id, patch, save?, answer_sources? }; failures are reported per-row, the rest still apply. BUFFER MODEL: content patches land in each page\'s unsaved draft; per-entry save:true (or the top-level save flag) commits — typical for a user-approved sweep. Returns results with saved (whether this patch reached saved storage), staged (draft field names), and applied_immediately (status/schedule field names). A status-only patch is saved immediately and does not commit earlier drafts. content_mode is rejected per-row; switch each page with set_page_mode.',
         inputSchema: {
             updates: z
                 .array(z.object({

package/dist/tools/preview.js

@@ -17,7 +17,7 @@ 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), or a raw slug; omit all for the home page. Forms on the page can be clicked through end to end — validation, steps, success message or the named redirect target — without creating submissions or running actions ("Preview – nothing is sent"). (For a permanent public link, complete Publishing setup and wait for a verified deployment on the organization or site domain.)',
+        description: 'Returns url (normal wrapper) and frame_url (signed sandboxed frame for rendering-only QA; use the wrapper for Extension host interactions). 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. Forms on the page can be clicked through end to end — validation, steps, success message or the named redirect target — without creating submissions or running actions ("Preview – nothing is sent"). (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(),

package/dist/tools/working-copy.js

@@ -29,7 +29,7 @@ function wcPath(t) {
 export const workingCopyTools = [
     {
         name: 'read_working_copy',
-        description: 'Read a doc\'s unsaved draft (working copy) as a raw field diff — { working_copy: null } means everything is saved. read_page/get_page_blocks already return the draft VIEW; use this when you need to know exactly WHICH fields are unsaved, e.g. before discarding (the draft may hold the user\'s in-progress editor work, not just yours).',
+        description: 'Templates save immediately and do not use this tool. Use target: {kind: page|partial, id: ...}, not page_id. Read a doc\'s unsaved draft (working copy) as a raw field diff — { working_copy: null } means everything is saved. read_page/get_page_blocks already return the draft VIEW; use this when you need to know exactly WHICH fields are unsaved, e.g. before discarding (the draft may hold the user\'s in-progress editor work, not just yours).',
         inputSchema: {
             target: wcTargetSchema,
             version: versionParam,

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.45.77';
+export const VERSION = '0.45.79';

package/dist/workspace.js

@@ -18,7 +18,7 @@ export const workspaceSchema = z.object({
 export const defaultWorkspace = { schema_version: 1, portal: 'https://app.typeroll.com', organization_id: null, site_id: null, version: 'main', tool_mode: 'compact' };
 const lockSchema = z.object({ schema_version: z.literal(1), generator_version: z.string(), files: z.record(z.string(), z.string().regex(/^[a-f0-9]{64}$/)) }).strict();
 const hash = (value) => createHash('sha256').update(value).digest('hex');
-export const ignores = ['.typeroll/', '.env', '.env.*', '!.env.example', '.mcp.json', '.cursor/mcp.json', '.vscode/mcp.json', 'qa/reports/', 'sources/private/'];
+export const ignores = ['.typeroll/', '.env', '.env.*', '!.env.example', '.mcp.json', '.cursor/mcp.json', '.vscode/mcp.json', 'qa/reports/', 'sources/private/', '**/__pycache__/', 'scripts/typeroll/node_modules/'];
 export const agentInstructions = `# Working on this website
 
 Read typeroll.json, brief/site.md, brief/rules.md and decisions.md first. Read
@@ -79,7 +79,8 @@ or launch acceptance. Compare text and design/images separately: preserved dimen
 renewed dimensions to their approved brief. New design never permits rewriting preserved text. Start with workflows/migration.md for the kickoff
 prompt. The agent rebuilds imported HTML using ordinary block tools; the owner
 does not need to manually convert each Page. No automatic converter is available.
-Discover tools and recipes on demand.
+Discover tools and recipes on demand. Read scripts/README.md for version-bound
+pre-deploy and hosted QA tools. Follow workflows/design.md for layout defaults.
 
 ## Project rules and search strategy
 
@@ -115,8 +116,6 @@ export const workspaceTemplates = {
     'workflows/README.md': "# Project routines\n\nRead only the relevant routine and discover current tool schemas through MCP.\nProject files record intent; the CMS owns current content and configuration.\n\n| Task | Project context | On-demand recipe |\n| --- | --- | --- |\n| Guided start | workflows/interview.md, brief/interview.md | Ask one question at a time; resume confirmed answers |\n| New website | workflows/new-site.md, brief/site.md, brief/brand.md, brief/content-model.md | tr-new-site, tr-starter-design |\n| Migration | workflows/migration.md, brief/migration.md | tr-migration-evidence, then tr-migrate-wp or the matching source recipe |\n| Everyday editing | brief/rules.md and the relevant Page | tr-edit-site |\n| SEO | brief/seo.md and current site settings | tr-seo |\n| New reusable block | brief/brand.md and recorded editing needs | tr-custom-blocks |\n| Verification and publication | qa/checklist.md, decisions.md | Current preview/deploy tools and publishing readiness |\n\nAdd project-specific routines here with inputs, steps, acceptance evidence and approval boundaries. Do not copy the complete Typeroll manual or private app guides. Discover enabled app guidance with read_app_documentation. Load a recipe when needed so instructions stay current and context stays small.\n",
     'decisions.md': '# Decisions\n\nRecord date, decision, reason, approved scope and alternatives when useful.\n',
     'sources/README.md': '# Sources\n\nStore research references and copy proposals. Record source URLs and dates.\nPrivate extracts belong in ignored private/ or an approved external store.\nDo not treat local drafts as current CMS content or commit media libraries.\n',
-    'scripts/README.md': '# Project automation\n\nKeep repeatable imports and QA scripts here. Use the authenticated REST API\nfor scripted work; keep credentials outside files and inject them at runtime.\nMCP remains the interactive interface. Typeroll currently has no general site CRUD CLI.\n',
-    'qa/checklist.md': '# Verification\n\n- Confirm Site, Version and deployed/source identity.\n- Read back saved content and inspect desktop/mobile previews.\n- Exercise menus, keyboard focus, links and enabled app states.\n- Verify routes, metadata, media and publishing readiness before launch.\n- Check that structured data (FAQ, recipe, event) matches what each page shows.\n- Record tested pages, viewports, results and unresolved issues.\n- Store screenshots and private runtime reports in ignored reports/.\n- Publishing validation does not prove visual or editorial completeness.\n',
 };
 export async function readWorkspace(dir) {
     try {

package/package.json

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

package/skills/tr-header-footer.md

@@ -5,11 +5,10 @@ description: Build accessible native header and footer partials with the site lo
 
 # Native header and footer compositions
 
-Use block-mode partials for new work. Core 0.1.8 / capability contract 0.43.0
-ships `template/site_logo`, `core/navigation`, layout primitives, and a
-revision-safe partial mode operation. HTML partials remain supported for
-legacy markup, but generic navigation and responsive layout no longer require
-tenant HTML, CSS, or JavaScript.
+Use block-mode partials for new work. Prefer `get_composition_starter`
+for the current native header tree: `template/site_logo`, `core/navigation_menu`
+and `core/navigation_links`. Use the menu's dialog/drawer rather than an inline
+mobile expansion that moves the logo. Existing `core/navigation` remains supported.
 
 ## Preconditions
 
@@ -31,51 +30,106 @@ read it back. Localize both accessible labels and every link label.
 [
   {
     "type": "core/section",
-    "data": { "width": "wide", "padding_y": "sm" },
-    "children": [{
-      "type": "core/container",
-      "data": {
-        "direction": { "mobile": "column", "tablet": "row" },
-        "align_main": "space-between",
-        "align_cross": "center",
-        "gap": "md",
-        "width": "wide",
-        "padding_y": "none",
-        "padding_x": "none"
-      },
-      "children": [
-        { "type": "template/site_logo", "data": { "height": "md", "link_to_home": true } },
-        {
-          "type": "core/navigation",
-          "data": {
-            "aria_label": "Main navigation",
-            "menu_label": "Menu",
-            "links": [
-              { "label": "Home", "href": "/" },
-              { "label": "About", "href": "/about/" },
-              { "label": "Contact", "href": "/contact/" }
+    "data": {
+      "width": "wide",
+      "padding_y": "compact"
+    },
+    "children": [
+      {
+        "type": "core/container",
+        "data": {
+          "direction": "row",
+          "wrap": "nowrap",
+          "align_main": "space-between",
+          "align_cross": "center",
+          "width": "full"
+        },
+        "children": [
+          {
+            "type": "template/site_logo",
+            "data": {
+              "height": "md",
+              "link_to_home": true
+            }
+          },
+          {
+            "type": "core/navigation_menu",
+            "data": {
+              "aria_label": "Main navigation",
+              "menu_label": "Open menu",
+              "close_label": "Close menu",
+              "collapse_below": "1024"
+            },
+            "slots": [
+              [
+                {
+                  "type": "core/navigation_links",
+                  "data": {
+                    "direction": "row",
+                    "links": [
+                      {
+                        "label": "Home",
+                        "href": "/"
+                      },
+                      {
+                        "label": "About",
+                        "href": "/about/"
+                      },
+                      {
+                        "label": "Contact",
+                        "href": "/contact/"
+                      }
+                    ]
+                  }
+                }
+              ],
+              [
+                {
+                  "type": "core/navigation_links",
+                  "data": {
+                    "direction": "column",
+                    "links": [
+                      {
+                        "label": "Home",
+                        "href": "/"
+                      },
+                      {
+                        "label": "About",
+                        "href": "/about/"
+                      },
+                      {
+                        "label": "Contact",
+                        "href": "/contact/"
+                      }
+                    ]
+                  }
+                }
+              ]
             ]
           }
-        }
-      ]
-    }]
+        ]
+      }
+    ]
   }
 ]
 ```
 
-`core/navigation` emits a real `nav` and list in initial HTML, marks the
-matching page with `aria-current="page"`, and progressively enhances to a
-button-controlled mobile menu. Verify Tab and Shift-Tab order, Enter/Space,
-Escape returning focus to the disclosure, visible focus, long translated
-labels, and no horizontal overflow. Without JavaScript the links remain
-visible and usable.
+The first slot is desktop; the second is the optional mobile composition.
+The default is drawer below 1024 px and inline from 1024 px. For responsive
+link fields use matching `responsive_breakpoints` (tablet 768, laptop 1024,
+desktop 1280, wide 1536); do not independently hide all links at the menu boundary.
+Verify 1023/1024 px, Tab/Shift-Tab, Enter/Space, Escape returning focus,
+visible focus, long labels, no-JavaScript links and no horizontal overflow.
 
 ## Footer tree and consent
 
-Use the same tree for `footer`, normally with `padding_y: "lg"`, a small site
-logo, localized footer navigation, and optional contact/prose blocks. The
-footer navigation gets its own accessible label; it is not the main
-navigation landmark.
+Use an accessible footer navigation landmark and `core/navigation_links`, not
+a second header drawer. If the footer has running about text, give it a separate,
+wider column beside a nested link grid. An equal four-column grid is rarely a
+good fit for one dense paragraph and three short link lists. Start with
+`core/columns` ratio `1-2`, put flow containers inside the slots, and tune the
+gap and readable text width to the actual content. Stack on mobile. Inspect at
+390, 1024, 1280 and 1536 px; do not copy one site's pixel values blindly.
 
 Cookie consent is a site feature, not a footer widget. Configure it separately:
 

package/skills/tr-migrate-wp.md

@@ -148,12 +148,28 @@ place. Do not preserve them as classed raw HTML in text blocks.
 
 For each source URL:
 
-a. Fetch from WP. Prefer the helper plugin's authenticated endpoint
-   (`/wp-json/typeroll/v1/...`) if available — it bypasses
-   `show_in_rest=false` and returns ACF + builder fields. Otherwise
-   fall back to `/wp-json/wp/v2/<post-type>?slug=<slug>`.
-
-b. Clean the HTML. Strip Elementor / Gutenberg / Breakdance class
+a. Choose access based on missing evidence, not a mandatory plugin install:
+
+   | Source requirement | Access path |
+   | --- | --- |
+   | Public Pages, posts, media and rendered builder content exposed in REST | Public paginated `/wp-json/wp/v2/pages`, `/posts`, `/media` and rendered HTML can suffice |
+   | SEO exposed in `yoast_head_json`, visible menus/backgrounds | Public REST + rendered HTML/CSS; verify actual coverage |
+   | Private/draft content, REST-hidden types, ACF/custom fields, exact menus | Authenticated helper/export when available and authorized |
+   | REST blocked by security policy | Owner-approved helper/export; do not bypass access controls |
+   | Authoritative old slugs or plugin redirects | Owner export/helper **if supported**; a public crawl only approximates them |
+
+   Do not ask the owner to install the helper when public sources cover the scope.
+   Inventory both Pages and posts (including sitemap-excluded public records),
+   crawl internal links and inspect redirects, menus and CSS background images.
+   Do not claim the helper exports a field without reading its current contract.
+   The helper is distributed through Typeroll's documented package; do not claim
+   WordPress.org availability. Listing it there is separate publication work.
+
+b. Clean the HTML. Parse HTML and discard comments before extracting text or
+   constructing blocks (comments may contain old phone-plugin metadata). Do not
+   use regex tag removal as a text parser. Resolve relative `../` links against
+   the source URL; preserve query strings and fragments. Report missing targets
+   instead of pointing everything at the home page. Strip Elementor / Gutenberg / Breakdance class
    soup. Drop empty `<div>` and `<span>` wrappers. Keep semantic tags,
    tables, iframes from known hosts (YouTube / Vimeo / Calendly).
    Remove every `<script>`: plugin and theme JavaScript is never copied.

package/skills/tr-new-site.md

@@ -165,7 +165,7 @@ it there.
 ### 3. Header + footer partials
 
 **Start from the native preset — don't hand-roll navigation.** Read
-`tr-header-footer` and use its `template/site_logo` + `core/navigation`
+`tr-header-footer` and use its `template/site_logo` + `core/navigation_menu` with `core/navigation_links` slots
 composition. The server-rendered landmark, current-page state, no-JS links,
 mobile disclosure, focus treatment, and responsive behavior are Core
 contracts rather than tenant CSS/JavaScript.
@@ -269,12 +269,10 @@ passing the whole tree inline (`block={ type: 'core/columns', slots:
 slot_index=0|1`. Requires template_capabilities_version ≥ 0.15.2 — on
 older sites use `core/grid` (children flow into columns) instead.
 
-Partial last rows (template_capabilities_version ≥ 0.16.5): when N equal
-cards don't divide by the grid's column count (5 cards, 3 cols), set
-`last_row: 'center'` on the `core/grid` — the orphan row auto-centers.
-NEVER invent a "wide" variant of one peer card to fill the hole, and
-don't hand-roll 6-column CSS tricks; both distort content to patch
-layout. On older sites, pick a column count that divides N.
+Partial last rows: keep `last_row: 'start'` on `core/grid`. Incomplete rows
+stay left-aligned, preserving the reading edge. Center only after an explicit
+owner design request, never as an automatic fix. Do not widen one peer card
+or invent six-column CSS to fill a gap.
 
 Icons (template_capabilities_version ≥ 0.16.0): `type: 'icon'` fields on
 `core/icon`, `core/icon_box`, and `core/step_card` render inline SVG when

package/workspace-templates/qa/checklist.md

@@ -0,0 +1,35 @@
+# Verification
+
+- Confirm Organization, Site, Version and deployed/source identity.
+- Run `python3 scripts/typeroll/check_unsaved.py` before trigger_deploy. Review
+  and explicitly save authorized Pages and partials; templates save immediately.
+- Compare preserved text with capture_text.cjs + compare_text.py and an explicit
+  selector. Check intentional additions, source comments and images separately.
+- Inspect desktop/mobile previews and actual hosted output around breakpoints.
+  Use shootframe.cjs / shoot_hosted.cjs and inspect full screenshots, not only tiles.
+- Exercise menus, keyboard focus, current links, forms and enabled app states.
+  Use card-stacking-check.cjs for whole-card excerpt/media/whitespace targets.
+- Check actual contrast on light/dark/photo backgrounds, image subjects and
+  sharpness, footer balance, left-aligned last rows and heading hierarchy.
+- Check home title/suffix, metadata, canonical/indexing policy and JSON-LD.
+- Run check_url_parity.py and check_assets.py on the deployed candidate; compare
+  final targets with the approved URL map and flatten accidental redirect chains.
+- Treat 403/network/DNS failures as unverified. Do not claim search-bot access
+  from a user-agent string or turn off customer protection without approval.
+- Record tested pages, viewports, revision, results and unresolved issues per QA
+  round. Record product defects in qa/typeroll-platform-feedback.md.
+- Keep screenshots and private runtime reports in ignored qa/reports/.
+- Check publishing readiness and migration launch report. Passing technical
+  validation does not prove visual/editorial completeness or grant launch approval.
+
+Commands/dependencies/limits: scripts/README.md. Design: workflows/design.md.
+Follow existing owner authorization; test publication, traffic cutover and
+indexing have distinct effects but do not require repeated approval if covered.
+
+
+- [ ] Check heading role spacing, slot gap and responsive vertical padding in the browser.
+- [ ] Review global/current navigation colors against the real parent background.
+- [ ] Check intrinsic-width image and full-image hero framing at breakpoint boundaries.
+- [ ] Test click-to-load video with keyboard; no provider request before activation.
+- [ ] Review matched drafts, unpublished targets and redirect chains before launch.
+- [ ] Explicitly save working copies, or obtain approval to publish saved content only.

package/workspace-templates/qa/typeroll-platform-feedback.md

@@ -0,0 +1,11 @@
+# Platform feedback
+
+Record site-specific observations here, without credentials or private exports.
+
+| ID | Priority | Surface / version | Observation | Evidence | Workaround | Status |
+| --- | --- | --- | --- | --- | --- | --- |
+
+For each finding record expected versus actual behavior, minimal reproduction,
+Site/Version, page/block locator, relevant schema, tested widths, source revision
+and whether it blocks launch. Distinguish bugs, capabilities, instructions and
+project choices. Link upstream fixes; verify deployed output before closing them.

package/workspace-templates/scripts/README.md

@@ -0,0 +1,85 @@
+# Repeatable site QA
+
+These optional tools supplement MCP and the platform's publication validator.
+They do not publish, change DNS, approve a launch or replace visual review.
+Python tools use the standard library except contact_sheet.py (Pillow). Browser
+tools require Node.js 22+, Playwright and its Chromium browser. From scripts/typeroll:
+
+```sh
+npm install --no-save --package-lock=false playwright
+npx playwright install chromium
+```
+
+Run the commands below from the **workspace root**. Inject TYPEROLL_API_KEY through
+your private credential manager. Never put it in a file or command argument.
+trlib.py reads portal, organization_id, site_id and version from typeroll.json,
+checks the connected Site/Organization, discovers the live tool schema, and
+passes the Version where supported. It refuses unversioned operations on a
+non-main binding; use the explicit interactive API workflow for organization or
+shared media operations instead. It is a small hosted MCP helper for API keys,
+not a replacement OAuth client or a new general CRUD CLI. REST is also supported
+by Typeroll if your integration already uses it.
+
+## Before publication
+
+```sh
+python3 scripts/typeroll/check_unsaved.py
+```
+
+Exit 1 lists unsaved Pages **and partials**. Review those changes; save only the
+work authorized for this publication, then run again. Templates save immediately.
+A working-copy preview is not proof of saved output. Never auto-save other work.
+
+## After an authorized publication
+
+```sh
+python3 scripts/typeroll/check_url_parity.py https://YOUR-TEST-HOST
+python3 scripts/typeroll/check_assets.py https://YOUR-TEST-HOST
+node scripts/typeroll/shoot_hosted.cjs https://YOUR-TEST-HOST qa/reports/hosted /,/about/ 390 768 1023 1024 1280
+node scripts/typeroll/card-stacking-check.cjs https://YOUR-TEST-HOST/listing/ 390
+```
+
+URL parity reads every migration inventory page and observed spelling, skips
+explicit exclusions unless --show-excluded, keeps origins/query parameters,
+detects loops and flags chains beyond a single redirect (one initial slash
+normalization is allowed). This does **not** prove the final destination is the
+editorially correct page: compare with the approved URL map too. No inventory
+is a failure, not a passing zero-row check. Asset QA uses resolved routes,
+checks published/unlisted Pages, relative URLs, srcset and downloads, uses four
+concurrent HEAD requests and falls back to GET when HEAD is unsupported. CSS
+backgrounds, authenticated assets and dynamically loaded resources need browser QA.
+Neither tool spoofs a search crawler. A 403/DNS/network failure is unverified;
+inspect access policy rather than treating it as a broken migration or a pass.
+
+## Other helpers
+
+- `call.py TOOL '{"argument":"value"}'`: raw MCP result; use `-` to read JSON
+  from stdin. Mutating tools require the same owner authorization as interactive
+  calls. Network failures are not automatically retried for mutations.
+- `trlib.upload(path, content_type, alt)`: direct signed upload and mandatory
+  finalize SHA-256 verification. No image bytes pass through the model or Git.
+- `sweep_blocks.example.py`: dry-run grid normalization across Pages, templates
+  and partials. Review before --apply; refuses to commit existing unsaved work.
+  It is not transactional: a failure can leave a partial draft; inspect before retry.
+- `shootframe.cjs OUT-PREFIX SIGNED-PREVIEW-URL [widths...]`: selects only the
+  Typeroll preview iframe, reports fonts/hosts/overflow. Signed URLs are secrets;
+  pass privately, never paste into committed reports or shell history. Direct-frame
+  capture checks rendering only; test Extension storage/navigation/handoffs in
+  the original wrapper because those features depend on its parent bridge.
+- `layout_trace.cjs URL [width] [selector]`: computed spacing of ancestors and
+  next section. Works with a direct page or Typeroll preview.
+- `contact_sheet.py OUT-PREFIX COLS TILE-WIDTH PNG...`: Pillow contact sheets.
+  It crops tall screenshots; inspect full screenshots too.
+- `capture_text.cjs URL qa/reports/text.json 'main .article-content'` followed by
+  `compare_text.py sources/private/page.html qa/reports/text.json --source-title 'Title'`:
+  word/punctuation diff. A saved single WP REST record (.json) is another source
+  adapter. Select exactly the preserved region, including its template-owned
+  title once. Deliberate shared additions need separate acceptance. Comments,
+  scripts and styles are excluded from source text. It never edits content.
+
+Browser reports exit nonzero for missing images, overflow, unexpected H1 count,
+failed requests or incomplete scrolling. They keep third-party failures visible.
+Network checks retry only a bounded read. All reports, screenshots and source
+exports stay under ignored qa/reports/ or sources/private/. Do not commit signed
+URLs, personal data or customer assets. Adapt scripts deliberately and run tests
+before applying broad changes. The workspace updater preserves your edits.

package/workspace-templates/scripts/typeroll/browser.cjs

@@ -0,0 +1,50 @@
+// Isolated QA browser only. Never persist storage state, cookies or signed URLs.
+const { chromium } = require('playwright');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+async function open(page, url) {
+  await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+  // Select only Typeroll's own preview, never an arbitrary ad/video iframe.
+  const frame = page.locator('iframe[title="Preview"], iframe[title="Site preview"]');
+  if (await frame.count() === 1) {
+    await page.waitForFunction(() => document.querySelector('iframe[title="Preview"], iframe[title="Site preview"]')?.getAttribute('src'), null, { timeout: 15000 });
+    const src = await frame.getAttribute('src');
+    if (!src) throw Error('Preview frame has no source');
+    const target = new URL(src, page.url());
+    if (target.origin !== new URL(page.url()).origin) throw Error('Unexpected preview frame origin');
+    await page.goto(target.href, { waitUntil: 'domcontentloaded', timeout: 60000 });
+  }
+  await page.evaluate(() => document.fonts.ready);
+}
+async function settle(page) {
+  // Bounded for infinite-scroll pages; report coverage rather than hanging.
+  for (let y = 0; y < 30000; y += 600) {
+    await page.evaluate(y => scrollTo(0, y), y);
+    await page.waitForTimeout(100);
+    if (y + 900 >= await page.evaluate(() => document.documentElement.scrollHeight)) break;
+  }
+  await page.evaluate(() => scrollTo(0, 0));
+  await page.waitForTimeout(300);
+}
+async function inspect(page) {
+  return page.evaluate(() => ({
+    overflow: document.documentElement.scrollWidth > innerWidth,
+    h1: document.querySelectorAll('h1').length,
+    title: document.title,
+    robots: document.querySelector('meta[name="robots"]')?.content ?? null,
+    fonts: { body: getComputedStyle(document.body).fontFamily, heading: getComputedStyle(document.querySelector('h1') || document.body).fontFamily },
+    incompleteImages: [...document.images].filter(i => !i.complete || !i.naturalWidth).map(i => new URL(i.currentSrc || i.src, location.href).pathname),
+    scrollCoverageComplete: document.documentElement.scrollHeight <= 30000,
+  }));
+}
+async function screenshot(page, file) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await page.screenshot({ path: file, fullPage: true, animations: 'disabled' });
+}
+function widths(args) {
+  const values = (args.length ? args : ['390', '768', '1023', '1024', '1280']).map(Number);
+  if (values.some(w => !Number.isInteger(w) || w < 240 || w > 4000)) throw Error('Invalid viewport width');
+  return values;
+}
+function fail() { console.error('QA failed; inspect the target privately. URLs and credentials are withheld.'); process.exitCode = 2; }
+module.exports = { chromium, open, settle, inspect, screenshot, widths, fail };

package/workspace-templates/scripts/typeroll/call.py

@@ -0,0 +1,12 @@
+"""One MCP call; output can contain private data. Do not commit it."""
+import argparse
+import json
+import sys
+import trlib
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument('tool')
+parser.add_argument('arguments', nargs='?', default='{}', help='JSON or - for stdin')
+args = parser.parse_args()
+value = json.loads(sys.stdin.read() if args.arguments == '-' else args.arguments)
+print(json.dumps(trlib.call(args.tool, value), ensure_ascii=False, indent=2))

package/workspace-templates/scripts/typeroll/capture_text.cjs

@@ -0,0 +1,17 @@
+// Explicit selector avoids silently excluding the wrong column/sidebar.
+const qa = require('./browser.cjs');
+const fs = require('node:fs/promises');
+const [url, out, selector = 'main'] = process.argv.slice(2);
+(async () => {
+  const browser = await qa.chromium.launch();
+  try {
+    const page = await browser.newPage();
+    await qa.open(page, url); await qa.settle(page);
+    const target = page.locator(selector);
+    if (await target.count() !== 1) throw Error('Select exactly one content region');
+    const value = await target.evaluate(el => ({ text: el.innerText,
+      images: [...el.querySelectorAll('img')].map(i => ({ alt: i.alt, path: new URL(i.currentSrc || i.src, location.href).pathname })) }));
+    await fs.mkdir(require('node:path').dirname(out), { recursive: true });
+    await fs.writeFile(out, JSON.stringify(value, null, 2));
+  } finally { await browser.close(); }
+})().catch(qa.fail);

package/workspace-templates/scripts/typeroll/card-stacking-check.cjs

@@ -0,0 +1,27 @@
+// Check every whole-card target, including excerpt/media/meta, without navigating.
+const qa = require('./browser.cjs');
+const [url, width = '390'] = process.argv.slice(2);
+(async () => {
+  const browser = await qa.chromium.launch();
+  try {
+    const page = await browser.newPage({ viewport: { width: qa.widths([width])[0], height: 900 } });
+    await qa.open(page, url);
+    const cards = page.locator('[data-block="post_card"][data-whole="true"]');
+    const report = [];
+    for (let index = 0; index < await cards.count(); index++) {
+      const card = cards.nth(index);
+      await card.scrollIntoViewIfNeeded();
+      report.push(await card.evaluate(card => {
+        const link = card.querySelector('.block-postcard-title > a');
+        const targets = [card, ...card.querySelectorAll('.block-postcard-excerpt,.block-postcard-meta,.block-postcard-media')];
+        const hits = targets.filter(el => el.getBoundingClientRect().height > 0).map(el => {
+          const r = el.getBoundingClientRect(), x = r.left + r.width / 2, y = r.top + r.height / 2;
+          return { part: el.className || 'card', inViewport: y >= 0 && y < innerHeight, linked: document.elementFromPoint(x, y)?.closest('a') === link };
+        });
+        return { block: card.dataset.blockId || card.dataset.bid || null, title: link?.textContent, hits };
+      }));
+    }
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.length || report.some(r => r.hits.some(h => !h.inViewport || !h.linked))) process.exitCode = 1;
+  } finally { await browser.close(); }
+})().catch(qa.fail);