Open-source AI browser agent for Chrome and Firefox (monorepo) đź§
JavaScript ai-agentai-agentsai-toolsbrowser-aibrowser-automationbrowser-extensionchrome-aichrome-devtoolschrome-extensionchrome-extensionsfirefox-addonfirefox-addonsfirefox-extensionfirefox-extensionsgemmagemma4minimaxoffline-aioffline-llmqwen
Tighten CMS prompt budgets and verify per-run skill reset
Emre Sokullu78003fdfc99d
diff --git a/docs/cms-api-first.md b/docs/cms-api-first.mdindex 0ae64c207..880d4add4 100644--- a/docs/cms-api-first.md+++ b/docs/cms-api-first.md@@ -25,6 +25,15 @@ identify them from subsequent UI/API evidence, use the narrow shared CMS rule,and in Mid/Full select the appropriate catalog entry. Mere branding in publiccontent does not authorize an admin workflow.+Loading is semantic selection by the planner/model, not a hard runtime check that+the CMS is installed and a content task exists. A CMS URL alone does not activate+its full recipe; URL-matched adapter notes can appear before a content task is+selected. The normal new-run reset clears active skills. The always-visible+catalog contains summaries, not nine recipes. Budget tests cap the nine-entry+loader description at 2,000 characters, one loaded recipe at 12,000, a specific+CMS adapter at 1,300 and an unconfirmed editor candidate at 450. Character budgets+are not token counts or a guarantee about model behavior.+All nine Markdown files and the CMS adapter module are byte-identical acrossChrome/Firefox. Browser-specific agent/tool code keeps its existing differences;only the corresponding guidance changes are mirrored.diff --git a/src/chrome/skills/cms-contentful.md b/src/chrome/skills/cms-contentful.mdindex 306a61784..77fb02486 100644--- a/src/chrome/skills/cms-contentful.md+++ b/src/chrome/skills/cms-contentful.md@@ -1,10 +1,8 @@# Contentful content (API-first)-Entries, localized fields, links, drafts and publication in existing Contentful content models via CMA.-```webbrain-skill{- "summary": "Entries, localized fields, links, drafts and publication in existing Contentful content models via CMA.",+ "summary": "Contentful entries, locales, links and CMA publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Entries, localized fields, links, drafts and publication in existing Contentful## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -169,46 +146,32 @@ Do not trigger a front-end deployment or a release/bulk publish.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-drupal.md b/src/chrome/skills/cms-drupal.mdindex 1798e672b..1535e8b9b 100644--- a/src/chrome/skills/cms-drupal.md+++ b/src/chrome/skills/cms-drupal.md@@ -1,10 +1,8 @@# Drupal content (API-first)-Articles, pages, existing custom bundles and taxonomy through Drupal JSON:API.-```webbrain-skill{- "summary": "Articles, pages, existing custom bundles and taxonomy through Drupal JSON:API.",+ "summary": "Drupal nodes and taxonomy through authorized JSON:API.","modes": ["ask","act",@@ -19,60 +17,39 @@ Articles, pages, existing custom bundles and taxonomy through Drupal JSON:API.## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -162,46 +139,32 @@ JSON:API data, including moderation and access restrictions.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-ghost.md b/src/chrome/skills/cms-ghost.mdindex 5e0b6b24d..e0c0ce9a1 100644--- a/src/chrome/skills/cms-ghost.md+++ b/src/chrome/skills/cms-ghost.md@@ -1,10 +1,8 @@# Ghost content (API-first)-Posts, pages, tags, drafts and web publication through the official Ghost Admin API.-```webbrain-skill{- "summary": "Posts, pages, tags, drafts and web publication through the official Ghost Admin API.",+ "summary": "Ghost posts, pages and tags: draft, edit, verify, publish.","modes": ["ask","act",@@ -19,60 +17,39 @@ Posts, pages, tags, drafts and web publication through the official Ghost Admin## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -150,46 +127,32 @@ flattening the article into plain text.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-joomla.md b/src/chrome/skills/cms-joomla.mdindex e5df933d1..0dc52e50d 100644--- a/src/chrome/skills/cms-joomla.md+++ b/src/chrome/skills/cms-joomla.md@@ -1,10 +1,8 @@# Joomla content (API-first)-Articles, categories and supported publication-state changes through Joomla Web Services.-```webbrain-skill{- "summary": "Articles, categories and supported publication-state changes through Joomla Web Services.",+ "summary": "Joomla articles and categories through Web Services.","modes": ["ask","act",@@ -19,60 +17,39 @@ Articles, categories and supported publication-state changes through Joomla Web## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -159,46 +136,32 @@ report those facts without changing site configuration.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-sanity.md b/src/chrome/skills/cms-sanity.mdindex 7ec297172..6b8a89c05 100644--- a/src/chrome/skills/cms-sanity.md+++ b/src/chrome/skills/cms-sanity.md@@ -1,10 +1,8 @@# Sanity content (API-first)-Schema-preserving Content Lake documents, references, drafts and publication through official Mutation/Actions APIs.-```webbrain-skill{- "summary": "Schema-preserving Content Lake documents, references, drafts and publication through official Mutation/Actions APIs.",+ "summary": "Sanity documents, Portable Text, drafts and publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Schema-preserving Content Lake documents, references, drafts and publication thr## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -179,46 +156,32 @@ refs after switching. Publishing to Content Lake does not deploy a consuming sit## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-shopify.md b/src/chrome/skills/cms-shopify.mdindex 7999f3377..d74655d79 100644--- a/src/chrome/skills/cms-shopify.md+++ b/src/chrome/skills/cms-shopify.md@@ -1,10 +1,8 @@# Shopify content (API-first)-Blogs, articles and store content pages through Shopify GraphQL Admin API; preserves draft and publication intent.-```webbrain-skill{- "summary": "Blogs, articles and store content pages through Shopify GraphQL Admin API; preserves draft and publication intent.",+ "summary": "Shopify blogs, articles and pages through Admin GraphQL.","modes": ["ask","act",@@ -19,60 +17,39 @@ Blogs, articles and store content pages through Shopify GraphQL Admin API; prese## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -168,46 +145,32 @@ shop settings. Never use product/publication APIs to publish editorial content.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-strapi.md b/src/chrome/skills/cms-strapi.mdindex d9f9bd68d..e62582c23 100644--- a/src/chrome/skills/cms-strapi.md+++ b/src/chrome/skills/cms-strapi.md@@ -1,10 +1,8 @@# Strapi content (API-first)-Existing Strapi content types, relations and supported Draft & Publish through the Content API.-```webbrain-skill{- "summary": "Existing Strapi content types, relations and supported Draft & Publish through the Content API.",+ "summary": "Strapi content, relations, locales and draft/publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Existing Strapi content types, relations and supported Draft & Publish through t## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -160,46 +137,32 @@ update an API consumed by a separate front-end; do not trigger its deployment.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-webflow.md b/src/chrome/skills/cms-webflow.mdindex ce65efeb5..d7c5ae661 100644--- a/src/chrome/skills/cms-webflow.md+++ b/src/chrome/skills/cms-webflow.md@@ -1,10 +1,8 @@# Webflow content (API-first)-Collection items, references, locales, staged drafts and item publication through Webflow Data API v2.-```webbrain-skill{- "summary": "Collection items, references, locales, staged drafts and item publication through Webflow Data API v2.",+ "summary": "Webflow collection items, references and item publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Collection items, references, locales, staged drafts and item publication throug## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -156,46 +133,32 @@ for Designer or site-wide changes; verify actual visibility independently.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/skills/cms-wix.md b/src/chrome/skills/cms-wix.mdindex 94cc17f33..9deaf88d9 100644--- a/src/chrome/skills/cms-wix.md+++ b/src/chrome/skills/cms-wix.md@@ -1,10 +1,8 @@# Wix content (API-first)-Wix Blog drafts, posts, categories, tags and publication with existing authorized API access.-```webbrain-skill{- "summary": "Wix Blog drafts, posts, categories, tags and publication with existing authorized API access.",+ "summary": "Wix Blog drafts, posts, categories, tags and publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Wix Blog drafts, posts, categories, tags and publication with existing authorize## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -164,46 +141,32 @@ Restricted posts can be published yet unavailable anonymously; preserve access.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/chrome/src/agent/agent.js b/src/chrome/src/agent/agent.jsindex bd1978327..9feb48deb 100644--- a/src/chrome/src/agent/agent.js+++ b/src/chrome/src/agent/agent.js@@ -9253,7 +9253,7 @@ Rules: no prose intro, no conclusion, no "this screenshot shows...", no layout d// setting or /allow-api enables it. Inject only once per "allowed run" to// avoid bloating every subsequent turn.if (this.isApiMutationsAllowed(tabId) && !this.apiAllowedInjected.has(tabId)) {- contextLine += `[USER OVERRIDE — API MUTATIONS ALLOWED: The user has authorized API mutations (POST/PUT/PATCH/DELETE via fetch_url or research_url). For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. Ask remains read-only. For a Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity content task, prefer its official API when target, fields, usable auth, CMS rights and task scope are verified; no editor failure is required. Other tasks retain the UI-first rule. You may also reach for the API when UI has failed/is genuinely unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] for repeated successful same-kind UI actions. Before any destructive API call (anything that creates, deletes, transfers, or charges), state the URL, method, and payload in plain text in your response so the user can see what you're about to do.]\n\n`;+ contextLine += `[USER OVERRIDE — API MUTATIONS ALLOWED: The user has authorized API mutations (POST/PUT/PATCH/DELETE via fetch_url or research_url). For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. The nine CMSs named in the system rules follow their conditional API-first recipes. Ask remains read-only. Other tasks retain the UI-first rule. You may also reach for the API when UI has failed/is genuinely unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] for repeated successful same-kind UI actions. Before any destructive API call (anything that creates, deletes, transfers, or charges), state the URL, method, and payload in plain text in your response so the user can see what you're about to do.]\n\n`;this.apiAllowedInjected.add(tabId);}diff --git a/src/chrome/src/agent/cms-adapters.js b/src/chrome/src/agent/cms-adapters.jsindex 657fc591f..b115b421e 100644--- a/src/chrome/src/agent/cms-adapters.js+++ b/src/chrome/src/agent/cms-adapters.js@@ -1,11 +1,9 @@// Routing hints only: a URL match never establishes CMS identity, credentials,// content-task authorization, or API mutation permission.const CMS_NOTES = `-- For a content task, confirm the CMS from the observed admin UI/API evidence, even on a custom domain. Read the official content API's target, model, required fields and access first. Prefer fetch_url before trying the editor when the requested fields, usable auth, CMS rights, task scope and API mutation permission all allow it.-- Ask stays read-only, including with prior API permission. If an otherwise usable API needs permission, request /allow-api once; reuse valid permission and respect refusal. POST reads (including GraphQL queries) also need this gate. /allow-api is neither a CMS token nor a CMS role.-- Cookies only follow the active tab's registrable domain; a dashboard login does not supply bearer auth. Use the verified API origin; never forward secrets to redirects. Tokens/nonces in fetch_url arguments/results can reach the model and traces. With Strict Secret Handling, use UI if no existing opaque mechanism works; never ask to disable it or scrape tokens.-- Read before editing, keep the same ID/type/locale/relations, use available version checks, and preserve live status. Create a draft first where supported; never replace a missing draft path with public creation. After timeout or partial success, find the existing record before retrying or switching to UI. Read back fields/status and check the target URL; CMS publication and website visibility are separate. No site-wide publish, deploy or email.-- If auth, required fields or safe drafts are unavailable, use the observed editor/Code/Text view and refresh AX refs after switching. Preserve the same record and URL parameters; do not loop on inaccessible iframes/canvases. Do not install plugins, change settings or grant scopes. Use a relevant enabled CMS recipe when available.`;+- Only for the user's content task on an observed CMS: verify official API target/model/fields, existing auth and rights. Prefer fetch_url when task scope and API permission allow, before editor failure. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal.+- Dashboard cookies are not tokens. Use verified origins; never forward auth across redirects. Arguments/results may expose tokens to model/traces. Strict Secret Handling without safe existing auth means UI; no token scraping, new grants or setup.+- Preserve ID/type/locale/native content/relations and live state. Draft first; reconcile uncertain writes before retry/UI. Read back fields/state and distinguish CMS publication from website visibility. No site-wide publish/deploy/email. Use an observed editor/Code/Text fallback, refresh refs and avoid iframe loops.`;function route(test) {return (url) => {@@ -48,5 +46,5 @@ CMS_ADAPTERS.push({name: 'cms-editor-candidate',category: 'general',matches: route(u => /\/(?:admin|administrator|studio|desk)(?:\/|$)/.test(u.pathname)),- notes: `- This URL is only an editor candidate. Apply the following guidance ONLY after observing Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity; otherwise use the site's ordinary UI rules.${CMS_NOTES}`,+ notes: '- Editor candidate only. Apply CMS guidance ONLY after observing Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity and a matching content task; otherwise use ordinary UI rules. For a confirmed CMS, fetch_url needs verified fields/target/auth/rights and task/API permission. Ask stays read-only. Strict without safe auth means UI. Reconcile uncertain writes before fallback and preserve the record ID.',});diff --git a/src/chrome/src/agent/planner.js b/src/chrome/src/agent/planner.jsindex ff6182a80..e1fca207c 100644--- a/src/chrome/src/agent/planner.js+++ b/src/chrome/src/agent/planner.js@@ -385,7 +385,7 @@ ${PLANNER_RESPONSE_LANGUAGE_RULES}- press_keys supports only unmodified Escape, Tab, Enter, arrow keys, and ; (semicolon, for page shortcuts such as Gmail Expand all). Never plan Ctrl/Cmd/Alt/Shift combinations or browser UI shortcuts. To select one literal page-text match, plan find_text instead of Ctrl/Cmd+F. Each find_text call replaces the previous selection and does not open browser Find UI; never plan sequential calls as simultaneous highlights.- For Instagram /p/<id>/ carousel enumeration, plan strictly increasing carousel_navigate indexes unless the latest user request explicitly asks for reverse traversal, in which case use strictly decreasing indexes. Never plan ArrowLeft/ArrowRight, coordinate clicks, Previous/Next, or go_back for slide traversal.- For an exact count across a Gmail label or search-result set, first establish and verify the intended search query, then plan one gmail_count_results call. Never plan clicks on "1-50 of many", Oldest, guessed date buckets, or manual /pN navigation; the helper performs verified bracketing and binary search. Its result counts Gmail conversations, not automatically unique emails or deduplicated entities such as pull requests.-- For Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity content tasks, plan read-only capability/auth discovery then the official API when the requested fields, target, CMS rights and task authorization allow it; mutation dispatch still requires API permission and a writable mode. Use the relevant enabled CMS skill; do not require editor failure. Never infer API credentials from dashboard login.+- For a matching enabled cms-* recipe, discover API/auth capability first and load only that recipe. API writes require verified target/fields/rights/task scope, usable auth, mutation permission and writable mode; editor failure is not required.- For repeated same-kind UI mutations (for example following many users), plan visible UI first with bounded batches, verification, progress_update, and wait_for_stable pacing; do not plan one huge same-shape click/tool batch.- Do not invent a prerequisite to discover a raw identifier (email address, account ID, username, or similar) when the target UI provides a name-based contact/entity picker and the user already supplied a human-readable name. Plan to use the picker first. Inspect surrounding pages or messages for the raw identifier only if the picker fails, returns multiple ambiguous matches, or the user explicitly asked for the identifier itself.- Set confidence from 0.0 to 1.0 for how clear and safe this plan is. Use 0.90+ only when the task, page state, and next steps are straightforward; use lower scores for ambiguity, destructive changes, payments, credentials, bulk mutations, or uncertain page state.diff --git a/src/chrome/src/agent/tools.js b/src/chrome/src/agent/tools.jsindex 2ff73ff0a..ce4e38913 100644--- a/src/chrome/src/agent/tools.js+++ b/src/chrome/src/agent/tools.js@@ -2177,12 +2177,12 @@ DON'T REDO WORK YOU'VE ALREADY DONE — read this:- Watch for the loop: doubt → re-navigate to source → re-fetch / re-download → end up further from the goal. If you're about to navigate to a URL or path you've already used this session, STOP and read your scratchpad first.UI vs API — read this carefully:-- For content tasks in a confirmed Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity admin (including custom domains identified from UI/API evidence), prefer the official content API after read-only discovery when fields, target, usable auth, CMS rights, task scope and API mutation permission allow it; do not wait for editor failure. Use the relevant enabled recipe when available. If only mutation permission is missing, ask for /allow-api once; reuse valid permission and respect refusal. Ask remains read-only; even GraphQL query POSTs are gated. If auth/fields or Strict Secret Handling prevent safe use, use the observed editor.+- For Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity content tasks, follow the matching adapter/recipe: official API first when target, fields, auth, CMS rights, task scope and API permission allow. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal. Otherwise use the observed editor.- For ANY action that creates, modifies, deletes, sends, submits, buys, transfers, posts, or publishes anything: ALWAYS go through the visible UI of the current page by default. NEVER call REST/GraphQL/API endpoints directly via \`fetch_url\` with POST/PUT/PATCH/DELETE unless one of the explicit exceptions below applies.- The user wants to see what's happening. They want to verify before clicking the final button. They want the action to look exactly like a human did it through the page, not like a script ran in the background. UI flows also generally Just Work with the user's existing session, while API endpoints often require separate tokens the user hasn't configured.- TWO exceptions where API mutations are allowed:(1) The user explicitly says "use the API" or "call the endpoint directly" or "POST to /foo" in their message — do what they asked once API mutation permission is enabled; an explicit request does not bypass the runtime permission gate.- (2) The [USER OVERRIDE — API MUTATIONS ALLOWED] context note is present. It can come from /allow-api for this conversation or the user's persistent setting. When present, for WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. For the nine CMS content APIs described above, prefer the API under their stated conditions without waiting for editor failure. Other tasks retain the UI-first rule. You may also use API mutations when UI is genuinely failing/unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] showing repeated successful same-kind UI actions and matching background API requests. Without this authorization, mutating fetch_url/research_url calls are blocked. Before any destructive API call (anything that creates, deletes, transfers, or charges money), state the URL, method, and payload in plain text in your response so the user can see what you're about to do.+ (2) The [USER OVERRIDE — API MUTATIONS ALLOWED] context note is present. It can come from /allow-api for this conversation or the user's persistent setting. When present, for WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. The nine CMSs above follow their conditional API-first rule. Other tasks retain the UI-first rule. You may also use API mutations when UI is genuinely failing/unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] showing repeated successful same-kind UI actions and matching background API requests. Without this authorization, mutating fetch_url/research_url calls are blocked. Before any destructive API call (anything that creates, deletes, transfers, or charges money), state the URL, method, and payload in plain text in your response so the user can see what you're about to do.- For READING data (looking things up, fetching a README, comparing prices across sites, checking a status page, gathering research), \`fetch_url\` and \`research_url\` are the RIGHT tool. Reading is not the same as acting.- Examples of the rule:- "Create a release on GitHub" → navigate to /releases/new, click the button, fill the form, click Publish. Don't POST to api.github.com/repos/.../releases.@@ -2329,7 +2329,7 @@ RULES:5. Click by ref_id: click_ax({ref_id:"ref_N"}). For native checkboxes, use set_checked({ref_id:"ref_N", checked:true|false}) instead of toggling. Fallback: click({text:"Submit"}).6. When done, call done({summary:"...", outcome:"success"}). Verify success first.7. If stuck after 2 attempts, try a different approach. Never repeat the same failing action 3 times.-8. Use the visible UI by default. For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API when mutations are authorized, required fields and session are verified, and Strict secret handling is off; follow the WordPress adapter. Without API authorization, do not send POST/PUT/PATCH/DELETE. If this route is unavailable, use an existing editor. For content tasks in a confirmed Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity admin (including custom domains identified from UI/API evidence), prefer the official content API after read-only discovery when fields, target, usable auth, CMS rights, task scope and API mutation permission allow it; do not wait for editor failure. Use the relevant enabled recipe when available. If only mutation permission is missing, ask for /allow-api once; reuse valid permission and respect refusal. Ask remains read-only; even GraphQL query POSTs are gated. If auth/fields or Strict Secret Handling prevent safe use, use the observed editor. Keep record IDs/type/locale/relations, create drafts first, reconcile timeout before retry/UI fallback, and verify saved fields/status and live visibility separately. Never site-publish/deploy/send email as a shortcut.+8. Use the visible UI by default. For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API when mutations are authorized, required fields and session are verified, and Strict secret handling is off; follow the WordPress adapter. Without API authorization, do not send POST/PUT/PATCH/DELETE. If this route is unavailable, use an existing editor. For Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity content tasks, follow the matching adapter/recipe: official API first when target, fields, auth, CMS rights, task scope and API permission allow. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal. Otherwise use the observed editor. Preserve IDs/content/state; draft first, reconcile uncertain writes, verify. No site-wide publish/deploy/email.9. For long tasks, use scratchpad_write to remember facts between steps. For repeated item/action tasks, use progress_update/progress_read and close all pending/acted rows before done.10. For loop tasks, keep using tools in this run; never say "I'll continue" unless you are actually making more tool calls.11. You cannot schedule, sleep, set timers, or check back later in compact mode. If something must wait for an external event, call done({summary:"...", outcome:"partial"}) with the current state and ask the user to re-invoke you.@@ -2471,7 +2471,7 @@ FORMS & MODALS:IFRAMES & UI-vs-API:- Cross-origin iframes (Stripe, payment widgets, embedded forms) are NOT a blocker. Start with iframe_read to enumerate labels and matchIndex values; iframe_click/type fail closed on ambiguity. If the embed remains hard to target and no fields have been changed, use promote_iframe({urlFilter}) to load it standalone in the current run tab. After iframe form edits, call verify_form({urlFilter}) and compare labels/values before done, even when the user will submit later.-- For content tasks in a confirmed Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity admin (including custom domains identified from UI/API evidence), prefer the official content API after read-only discovery when fields, target, usable auth, CMS rights, task scope and API mutation permission allow it; do not wait for editor failure. Use the relevant enabled recipe when available. If only mutation permission is missing, ask for /allow-api once; reuse valid permission and respect refusal. Ask remains read-only; even GraphQL query POSTs are gated. If auth/fields or Strict Secret Handling prevent safe use, use the observed editor.+- For Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity content tasks, follow the matching adapter/recipe: official API first when target, fields, auth, CMS rights, task scope and API permission allow. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal. Otherwise use the observed editor.- For other actions that create, modify, delete, send, submit, buy, transfer, or post: go through the visible UI unless API mutations are authorized and either the WordPress or the CMS content exception above applies, UI is failing/unworkable, or WebBrain reports a [BULK API MUTATION PATTERN]. For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. Other tasks retain the UI-first rule. Do NOT call REST/GraphQL endpoints via fetch_url or research_url with POST/PUT/PATCH/DELETE without that authorization. Reading data (fetch_url / research_url GET) is fine.SCRATCHPAD & DON'T REDO WORK:diff --git a/src/firefox/skills/cms-contentful.md b/src/firefox/skills/cms-contentful.mdindex 306a61784..77fb02486 100644--- a/src/firefox/skills/cms-contentful.md+++ b/src/firefox/skills/cms-contentful.md@@ -1,10 +1,8 @@# Contentful content (API-first)-Entries, localized fields, links, drafts and publication in existing Contentful content models via CMA.-```webbrain-skill{- "summary": "Entries, localized fields, links, drafts and publication in existing Contentful content models via CMA.",+ "summary": "Contentful entries, locales, links and CMA publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Entries, localized fields, links, drafts and publication in existing Contentful## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -169,46 +146,32 @@ Do not trigger a front-end deployment or a release/bulk publish.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-drupal.md b/src/firefox/skills/cms-drupal.mdindex 1798e672b..1535e8b9b 100644--- a/src/firefox/skills/cms-drupal.md+++ b/src/firefox/skills/cms-drupal.md@@ -1,10 +1,8 @@# Drupal content (API-first)-Articles, pages, existing custom bundles and taxonomy through Drupal JSON:API.-```webbrain-skill{- "summary": "Articles, pages, existing custom bundles and taxonomy through Drupal JSON:API.",+ "summary": "Drupal nodes and taxonomy through authorized JSON:API.","modes": ["ask","act",@@ -19,60 +17,39 @@ Articles, pages, existing custom bundles and taxonomy through Drupal JSON:API.## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -162,46 +139,32 @@ JSON:API data, including moderation and access restrictions.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-ghost.md b/src/firefox/skills/cms-ghost.mdindex 5e0b6b24d..e0c0ce9a1 100644--- a/src/firefox/skills/cms-ghost.md+++ b/src/firefox/skills/cms-ghost.md@@ -1,10 +1,8 @@# Ghost content (API-first)-Posts, pages, tags, drafts and web publication through the official Ghost Admin API.-```webbrain-skill{- "summary": "Posts, pages, tags, drafts and web publication through the official Ghost Admin API.",+ "summary": "Ghost posts, pages and tags: draft, edit, verify, publish.","modes": ["ask","act",@@ -19,60 +17,39 @@ Posts, pages, tags, drafts and web publication through the official Ghost Admin## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -150,46 +127,32 @@ flattening the article into plain text.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-joomla.md b/src/firefox/skills/cms-joomla.mdindex e5df933d1..0dc52e50d 100644--- a/src/firefox/skills/cms-joomla.md+++ b/src/firefox/skills/cms-joomla.md@@ -1,10 +1,8 @@# Joomla content (API-first)-Articles, categories and supported publication-state changes through Joomla Web Services.-```webbrain-skill{- "summary": "Articles, categories and supported publication-state changes through Joomla Web Services.",+ "summary": "Joomla articles and categories through Web Services.","modes": ["ask","act",@@ -19,60 +17,39 @@ Articles, categories and supported publication-state changes through Joomla Web## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -159,46 +136,32 @@ report those facts without changing site configuration.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-sanity.md b/src/firefox/skills/cms-sanity.mdindex 7ec297172..6b8a89c05 100644--- a/src/firefox/skills/cms-sanity.md+++ b/src/firefox/skills/cms-sanity.md@@ -1,10 +1,8 @@# Sanity content (API-first)-Schema-preserving Content Lake documents, references, drafts and publication through official Mutation/Actions APIs.-```webbrain-skill{- "summary": "Schema-preserving Content Lake documents, references, drafts and publication through official Mutation/Actions APIs.",+ "summary": "Sanity documents, Portable Text, drafts and publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Schema-preserving Content Lake documents, references, drafts and publication thr## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -179,46 +156,32 @@ refs after switching. Publishing to Content Lake does not deploy a consuming sit## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-shopify.md b/src/firefox/skills/cms-shopify.mdindex 7999f3377..d74655d79 100644--- a/src/firefox/skills/cms-shopify.md+++ b/src/firefox/skills/cms-shopify.md@@ -1,10 +1,8 @@# Shopify content (API-first)-Blogs, articles and store content pages through Shopify GraphQL Admin API; preserves draft and publication intent.-```webbrain-skill{- "summary": "Blogs, articles and store content pages through Shopify GraphQL Admin API; preserves draft and publication intent.",+ "summary": "Shopify blogs, articles and pages through Admin GraphQL.","modes": ["ask","act",@@ -19,60 +17,39 @@ Blogs, articles and store content pages through Shopify GraphQL Admin API; prese## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -168,46 +145,32 @@ shop settings. Never use product/publication APIs to publish editorial content.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-strapi.md b/src/firefox/skills/cms-strapi.mdindex d9f9bd68d..e62582c23 100644--- a/src/firefox/skills/cms-strapi.md+++ b/src/firefox/skills/cms-strapi.md@@ -1,10 +1,8 @@# Strapi content (API-first)-Existing Strapi content types, relations and supported Draft & Publish through the Content API.-```webbrain-skill{- "summary": "Existing Strapi content types, relations and supported Draft & Publish through the Content API.",+ "summary": "Strapi content, relations, locales and draft/publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Existing Strapi content types, relations and supported Draft & Publish through t## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -160,46 +137,32 @@ update an API consumed by a separate front-end; do not trigger its deployment.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-webflow.md b/src/firefox/skills/cms-webflow.mdindex ce65efeb5..d7c5ae661 100644--- a/src/firefox/skills/cms-webflow.md+++ b/src/firefox/skills/cms-webflow.md@@ -1,10 +1,8 @@# Webflow content (API-first)-Collection items, references, locales, staged drafts and item publication through Webflow Data API v2.-```webbrain-skill{- "summary": "Collection items, references, locales, staged drafts and item publication through Webflow Data API v2.",+ "summary": "Webflow collection items, references and item publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Collection items, references, locales, staged drafts and item publication throug## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -156,46 +133,32 @@ for Designer or site-wide changes; verify actual visibility independently.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/skills/cms-wix.md b/src/firefox/skills/cms-wix.mdindex 94cc17f33..9deaf88d9 100644--- a/src/firefox/skills/cms-wix.md+++ b/src/firefox/skills/cms-wix.md@@ -1,10 +1,8 @@# Wix content (API-first)-Wix Blog drafts, posts, categories, tags and publication with existing authorized API access.-```webbrain-skill{- "summary": "Wix Blog drafts, posts, categories, tags and publication with existing authorized API access.",+ "summary": "Wix Blog drafts, posts, categories, tags and publication.","modes": ["ask","act",@@ -19,60 +17,39 @@ Wix Blog drafts, posts, categories, tags and publication with existing authorize## API-first decision and permission boundary-Use this recipe only for the user's content task on an identified CMS, including-custom domains confirmed by observed admin UI and official API evidence. Prefer-`fetch_url` after read-only discovery when the API supports every required field,-the site/account and target are known, usable authentication and CMS rights exist,-the task authorizes the change, WebBrain API mutation permission is active, and-the run is Act/Dev. Do not wait for the editor to fail.--If only WebBrain mutation permission is missing, request `/allow-api` once.-Reuse prior valid permission (conversation or persistent setting); after refusal,-do not ask again for the same request: use the permitted editor route. Task-authorization, `/allow-api`, and CMS credentials/roles are separate conditions.-Ask is read-only even with prior API approval. All POST/PUT/PATCH/DELETE requests-through `fetch_url` remain gated, including read-only GraphQL/query POSTs. Do not-encode a mutation in GET, use private endpoints, `execute_js`, or another tool to-bypass a denial. Describe consequential requests with secrets omitted.--Manage existing content models only. No schema/model changes, plugin or theme-installation, site design/settings, users/roles, app grants, payments, orders,-customers, subscriber mail, bulk releases or deployments. A content task does not-authorize enabling API writes or creating credentials. Explain missing setup and-use an existing permitted UI surface first.+For the user's content task on this confirmed CMS, prefer the official API before+editor failure only when target/model/fields, existing auth, CMS rights, task+scope, WebBrain mutation permission and Act/Dev mode all permit it. Confirm custom+domains from observed admin/API evidence. Request `/allow-api` once if it is the+remaining blocker; reuse valid grants and respect refusal. It grants neither CMS+credentials nor roles. Ask stays read-only, including GraphQL/query POSTs.+Never bypass a gate through GET mutations, private endpoints or another tool.++Existing content models only: no schemas, plugins/themes, site design/settings,+users/roles, app grants, commerce/customer data, email, bulk releases or deploys.+A content task does not authorize credential creation or enabling API writes.## Tools, secrets and trace limits-This is an instruction-only recipe, with no new tools, OAuth flow, token signer,-credential store or auth broker. `fetch_url` accepts `url`, `method`, string-valued-`headers` and a serialized JSON `body`. It runs in the extension background;-cookies attach only within the active tab's registrable domain and still obey-browser cookie rules. That is not proof of session authorization on an API.-Do not copy cookies or scrape localStorage/network tokens. Origin/Referer are-browser-controlled: merely putting them in headers does not guarantee success.--Use HTTPS at the verified API origin, including its site/project binding. Never-send auth to a guessed host, user-content URL, HTTP downgrade or redirect target.-The tool rejects redirects before following them; rediscover the canonical root-without secrets rather than forwarding headers. Existing opaque same-origin-`replayRequestId` material is usable only when the runtime actually offers it and-its captured operation fits this task; it is not a general auth mechanism.--Tokens/nonces typed in chat, placed in tool arguments, or returned by a discovery-request can enter the configured model conversation and enabled raw traces.-There is no guaranteed secret injection/redaction path for arbitrary CMS headers.-Never store secrets in skill text, scratchpad, memory, URLs or summaries. With-Strict Secret Handling, if browser-managed cookies or an already available opaque-mechanism cannot complete the request, use UI. Do not automatically ask to disable-that setting. All examples below contain placeholders, never usable credentials.--`fetch_url` returns bounded `json`/`text` strings, not a parsed object; read all-necessary fields using exact `nextOffset` continuation on **GET reads**. Never-repeat a write just to paginate its response: read the returned record through-the documented read/query route instead.-Generic response headers such as ETag and Retry-After are not exposed (only safe-range/length metadata). Use version fields in JSON when offered; if a required-header-only precondition is inaccessible, use the editor instead of inventing it.+Use existing `fetch_url`: string-valued headers and serialized JSON body, with+bounded `json`/`text` result strings. GET reads support exact `nextOffset`+continuation; never replay a mutation to recover a truncated response. Use its+documented read/query route. ETag/Retry-After are not exposed: use available JSON+versions, or UI when a required precondition cannot be obtained.++Background cookies follow only the active tab's registrable domain; dashboard+login does not prove API auth. Origin/Referer remain browser-controlled. Use the+verified HTTPS API origin and site binding; rejected redirects require discovery+without secrets. Never forward auth to guessed/user-content/redirect hosts.+No OAuth, signer, broker, credential store or token scraping is supplied. Opaque+`replayRequestId` is usable only if already offered for a compatible same-origin+operation, never as a general auth route.++Tokens/nonces in chat, arguments or discovery results can reach the model and raw+traces; arbitrary CMS headers have no guaranteed opaque injection/redaction.+Never put secrets in skills, scratchpad, memory, URLs or summaries. With+Strict Secret Handling, use UI if existing browser/opaque auth cannot work;+never ask to disable it. Describe requests without secrets. Examples are placeholders.## Scope and API/auth prerequisites@@ -164,46 +141,32 @@ Restricted posts can be published yet unavailable anonymously; preserve access.## Recovery, verification and UI fallback-Keep a non-secret operation receipt: API origin, site/project scope, content type,-locale, record ID (and draft/published mapping), revision, intended fields and-whether a mutation was dispatched. Read before editing; change only requested-fields and preserve all others and their relations. A partial/truncated read is-not enough to replace rich content. Never silently drop unsupported fields or-convert rich text lossily. Do not demote/unpublish a live record to simplify an-edit. If the API has no safe draft route, use UI instead of direct public create.--A timeout or disconnected response can follow a successful write. Do not blindly-repeat create/publish, even with a new ID. Investigate the known ID first; otherwise-use the service's bounded exact queries plus type, locale, parent, slug and time.-Multiple candidates are ambiguous: ask for the target, never pick one randomly.-Resume the existing draft/partial update. Use a documented idempotency mechanism-only where the endpoint supports it; do not invent an Idempotency-Key header.-Reconcile partial success **before** moving to UI. Stop repeated 401/403 requests;-explain missing auth/rights. Re-read on revision conflicts; never force overwrite.-For 429/temporary failures, follow service guidance with bounded backoff; when-headers are not exposed report that limit, and do not retry an uncertain mutation-until its outcome is reconciled. Compact cannot wait/schedule: report partial and-let the user resume later when waiting is necessary.--After create/update, read the same record through its supported read/query API.-Verify type, all requested fields, language, relationships/taxonomy, rich content-and draft status. A draft-only task-stops here. Publish only the same verified content when the user requested it;-account for live effects of edits and pending changes already in the draft.-After publish, re-read the publication state and, where possible, inspect the-actual target URL for the intended content. HTTP success alone proves neither-content correctness nor publication. Report “published in CMS” separately from-“visible on the website,” especially for headless sites. Never trigger a deploy,-site-wide publish or subscriber email to make content appear.--When the API cannot carry required fields or safe auth, open the **observed** CMS-editor for this same record. Preserve ID/type, language, content, taxonomy and-required URL parameters. Try an existing Code/Text or standard editor surface if-iframe/canvas access fails; refresh AX refs after switching. Do not repeatedly-read an inaccessible editor. A guessed URL/editor parameter is not proof that an-alternative exists or a save/publish worked. Verify persisted content and status-after UI actions too. If neither route is usable, report the existing partial-record and precise blocker without claiming completion.+Keep a non-secret receipt: origin/site, type, locale, ID/draft mapping, revision,+intended fields and whether a mutation was dispatched. Read complete required+content first; preserve native rich text, media, relations and untouched fields.+Never demote/unpublish live content to edit it. New content needs a safe draft+path; otherwise use UI, not direct public creation.++Timeout/partial success can follow a committed write. Reconcile the known ID or+exact scoped type/locale/parent/slug/time matches before retrying or switching to+UI. Resume the existing draft; ambiguous matches need clarification. Never invent+idempotency headers or retry with a new ID. Stop repeated 401/403s. Re-read and+reconcile version conflicts. Use bounded service backoff for 429/temporary errors,+without replaying uncertain writes; do not fabricate unavailable response headers.+Compact cannot wait/schedule: report partial progress for a later user resume.++Read back the same record through its supported API, verifying requested fields,+type, locale, rich content, relations and state. Draft-only tasks stop there.+Publish only that verified content when requested, accounting for all pending+draft changes and live effects. Re-read publication state and check the target+URL where possible. HTTP success is insufficient; report CMS publication and+website visibility separately. Never trigger deploy/site-wide publish/email.++For unsupported fields/auth/workflows, use the observed editor for the same record,+preserving ID/type/locale, content/taxonomy and required URL parameters. After an+inaccessible iframe/canvas, try an observed Code/Text/standard editor and refresh+AX refs; do not loop or guess editor URLs. Verify UI saves too. If both routes+fail, report the existing partial record and blocker without claiming completion.## Official sources (reviewed 2026-09-30)diff --git a/src/firefox/src/agent/agent.js b/src/firefox/src/agent/agent.jsindex e72da6308..53223990f 100644--- a/src/firefox/src/agent/agent.js+++ b/src/firefox/src/agent/agent.js@@ -14477,7 +14477,7 @@ Rules: no prose intro, no conclusion, no "this screenshot shows...", no layout d}if (this.isApiMutationsAllowed(tabId) && !this.apiAllowedInjected.has(tabId)) {- contextLine += `[USER OVERRIDE — API MUTATIONS ALLOWED: The user has authorized API mutations (POST/PUT/PATCH/DELETE via fetch_url or research_url). For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. Ask remains read-only. For a Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity content task, prefer its official API when target, fields, usable auth, CMS rights and task scope are verified; no editor failure is required. Other tasks retain the UI-first rule. You may also reach for the API when UI has failed/is genuinely unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] for repeated successful same-kind UI actions. Before any destructive API call, state the URL, method, and payload in plain text in your response so the user can see what you're about to do.]\n\n`;+ contextLine += `[USER OVERRIDE — API MUTATIONS ALLOWED: The user has authorized API mutations (POST/PUT/PATCH/DELETE via fetch_url or research_url). For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. The nine CMSs named in the system rules follow their conditional API-first recipes. Ask remains read-only. Other tasks retain the UI-first rule. You may also reach for the API when UI has failed/is genuinely unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] for repeated successful same-kind UI actions. Before any destructive API call, state the URL, method, and payload in plain text in your response so the user can see what you're about to do.]\n\n`;this.apiAllowedInjected.add(tabId);}diff --git a/src/firefox/src/agent/cms-adapters.js b/src/firefox/src/agent/cms-adapters.jsindex 657fc591f..b115b421e 100644--- a/src/firefox/src/agent/cms-adapters.js+++ b/src/firefox/src/agent/cms-adapters.js@@ -1,11 +1,9 @@// Routing hints only: a URL match never establishes CMS identity, credentials,// content-task authorization, or API mutation permission.const CMS_NOTES = `-- For a content task, confirm the CMS from the observed admin UI/API evidence, even on a custom domain. Read the official content API's target, model, required fields and access first. Prefer fetch_url before trying the editor when the requested fields, usable auth, CMS rights, task scope and API mutation permission all allow it.-- Ask stays read-only, including with prior API permission. If an otherwise usable API needs permission, request /allow-api once; reuse valid permission and respect refusal. POST reads (including GraphQL queries) also need this gate. /allow-api is neither a CMS token nor a CMS role.-- Cookies only follow the active tab's registrable domain; a dashboard login does not supply bearer auth. Use the verified API origin; never forward secrets to redirects. Tokens/nonces in fetch_url arguments/results can reach the model and traces. With Strict Secret Handling, use UI if no existing opaque mechanism works; never ask to disable it or scrape tokens.-- Read before editing, keep the same ID/type/locale/relations, use available version checks, and preserve live status. Create a draft first where supported; never replace a missing draft path with public creation. After timeout or partial success, find the existing record before retrying or switching to UI. Read back fields/status and check the target URL; CMS publication and website visibility are separate. No site-wide publish, deploy or email.-- If auth, required fields or safe drafts are unavailable, use the observed editor/Code/Text view and refresh AX refs after switching. Preserve the same record and URL parameters; do not loop on inaccessible iframes/canvases. Do not install plugins, change settings or grant scopes. Use a relevant enabled CMS recipe when available.`;+- Only for the user's content task on an observed CMS: verify official API target/model/fields, existing auth and rights. Prefer fetch_url when task scope and API permission allow, before editor failure. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal.+- Dashboard cookies are not tokens. Use verified origins; never forward auth across redirects. Arguments/results may expose tokens to model/traces. Strict Secret Handling without safe existing auth means UI; no token scraping, new grants or setup.+- Preserve ID/type/locale/native content/relations and live state. Draft first; reconcile uncertain writes before retry/UI. Read back fields/state and distinguish CMS publication from website visibility. No site-wide publish/deploy/email. Use an observed editor/Code/Text fallback, refresh refs and avoid iframe loops.`;function route(test) {return (url) => {@@ -48,5 +46,5 @@ CMS_ADAPTERS.push({name: 'cms-editor-candidate',category: 'general',matches: route(u => /\/(?:admin|administrator|studio|desk)(?:\/|$)/.test(u.pathname)),- notes: `- This URL is only an editor candidate. Apply the following guidance ONLY after observing Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity; otherwise use the site's ordinary UI rules.${CMS_NOTES}`,+ notes: '- Editor candidate only. Apply CMS guidance ONLY after observing Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity and a matching content task; otherwise use ordinary UI rules. For a confirmed CMS, fetch_url needs verified fields/target/auth/rights and task/API permission. Ask stays read-only. Strict without safe auth means UI. Reconcile uncertain writes before fallback and preserve the record ID.',});diff --git a/src/firefox/src/agent/planner.js b/src/firefox/src/agent/planner.jsindex ff6182a80..e1fca207c 100644--- a/src/firefox/src/agent/planner.js+++ b/src/firefox/src/agent/planner.js@@ -385,7 +385,7 @@ ${PLANNER_RESPONSE_LANGUAGE_RULES}- press_keys supports only unmodified Escape, Tab, Enter, arrow keys, and ; (semicolon, for page shortcuts such as Gmail Expand all). Never plan Ctrl/Cmd/Alt/Shift combinations or browser UI shortcuts. To select one literal page-text match, plan find_text instead of Ctrl/Cmd+F. Each find_text call replaces the previous selection and does not open browser Find UI; never plan sequential calls as simultaneous highlights.- For Instagram /p/<id>/ carousel enumeration, plan strictly increasing carousel_navigate indexes unless the latest user request explicitly asks for reverse traversal, in which case use strictly decreasing indexes. Never plan ArrowLeft/ArrowRight, coordinate clicks, Previous/Next, or go_back for slide traversal.- For an exact count across a Gmail label or search-result set, first establish and verify the intended search query, then plan one gmail_count_results call. Never plan clicks on "1-50 of many", Oldest, guessed date buckets, or manual /pN navigation; the helper performs verified bracketing and binary search. Its result counts Gmail conversations, not automatically unique emails or deduplicated entities such as pull requests.-- For Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity content tasks, plan read-only capability/auth discovery then the official API when the requested fields, target, CMS rights and task authorization allow it; mutation dispatch still requires API permission and a writable mode. Use the relevant enabled CMS skill; do not require editor failure. Never infer API credentials from dashboard login.+- For a matching enabled cms-* recipe, discover API/auth capability first and load only that recipe. API writes require verified target/fields/rights/task scope, usable auth, mutation permission and writable mode; editor failure is not required.- For repeated same-kind UI mutations (for example following many users), plan visible UI first with bounded batches, verification, progress_update, and wait_for_stable pacing; do not plan one huge same-shape click/tool batch.- Do not invent a prerequisite to discover a raw identifier (email address, account ID, username, or similar) when the target UI provides a name-based contact/entity picker and the user already supplied a human-readable name. Plan to use the picker first. Inspect surrounding pages or messages for the raw identifier only if the picker fails, returns multiple ambiguous matches, or the user explicitly asked for the identifier itself.- Set confidence from 0.0 to 1.0 for how clear and safe this plan is. Use 0.90+ only when the task, page state, and next steps are straightforward; use lower scores for ambiguity, destructive changes, payments, credentials, bulk mutations, or uncertain page state.diff --git a/src/firefox/src/agent/tools.js b/src/firefox/src/agent/tools.jsindex 811f50ef3..1c09d5739 100644--- a/src/firefox/src/agent/tools.js+++ b/src/firefox/src/agent/tools.js@@ -1802,7 +1802,7 @@ RULES:5. Fill forms one field at a time. Prefer set_field({ref_id, text}) for text fields; it focuses, clears, types, and can submit.6. Click by ref_id with click_ax({ref_id:"ref_N"}). For native checkboxes, use set_checked({ref_id:"ref_N", checked:true|false}) instead of toggling. Fallback to click({text:"Submit"}) when no ref_id works.7. For long tasks, use scratchpad_write to remember facts between steps. For repeated item/action tasks, use progress_update/progress_read and close all pending/acted rows before done.-8. Use the visible UI by default. For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API when mutations are authorized, required fields and session are verified, and Strict secret handling is off; follow the WordPress adapter. Without API authorization, do not send POST/PUT/PATCH/DELETE. If this route is unavailable, use an existing editor. For content tasks in a confirmed Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity admin (including custom domains identified from UI/API evidence), prefer the official content API after read-only discovery when fields, target, usable auth, CMS rights, task scope and API mutation permission allow it; do not wait for editor failure. Use the relevant enabled recipe when available. If only mutation permission is missing, ask for /allow-api once; reuse valid permission and respect refusal. Ask remains read-only; even GraphQL query POSTs are gated. If auth/fields or Strict Secret Handling prevent safe use, use the observed editor. Keep record IDs/type/locale/relations, create drafts first, reconcile timeout before retry/UI fallback, and verify saved fields/status and live visibility separately. Never site-publish/deploy/send email as a shortcut.+8. Use the visible UI by default. For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API when mutations are authorized, required fields and session are verified, and Strict secret handling is off; follow the WordPress adapter. Without API authorization, do not send POST/PUT/PATCH/DELETE. If this route is unavailable, use an existing editor. For Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity content tasks, follow the matching adapter/recipe: official API first when target, fields, auth, CMS rights, task scope and API permission allow. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal. Otherwise use the observed editor. Preserve IDs/content/state; draft first, reconcile uncertain writes, verify. No site-wide publish/deploy/email.9. If stuck after 2 attempts, try a different tool or route. Never repeat the same failing action 3 times.10. For loop tasks, keep using tools in this run; never say "I'll continue" unless you are actually making more tool calls.11. You cannot schedule, sleep, set timers, or check back later in compact mode. If something must wait for an external event, call done({summary:"...", outcome:"partial"}) with the current state and ask the user to re-invoke you.@@ -2027,12 +2027,12 @@ DON'T REDO WORK YOU'VE ALREADY DONE — read this:- Watch for the loop: doubt → re-navigate to source → re-fetch / re-download → end up further from the goal. If you're about to navigate to a URL or path you've already used this session, STOP and read your scratchpad first.UI vs API — read this carefully:-- For content tasks in a confirmed Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity admin (including custom domains identified from UI/API evidence), prefer the official content API after read-only discovery when fields, target, usable auth, CMS rights, task scope and API mutation permission allow it; do not wait for editor failure. Use the relevant enabled recipe when available. If only mutation permission is missing, ask for /allow-api once; reuse valid permission and respect refusal. Ask remains read-only; even GraphQL query POSTs are gated. If auth/fields or Strict Secret Handling prevent safe use, use the observed editor.+- For Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity content tasks, follow the matching adapter/recipe: official API first when target, fields, auth, CMS rights, task scope and API permission allow. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal. Otherwise use the observed editor.- For ANY action that creates, modifies, deletes, sends, submits, buys, transfers, posts, or publishes: ALWAYS go through the visible UI by default. NEVER call REST/GraphQL/API endpoints directly via \`fetch_url\` with POST/PUT/PATCH/DELETE unless one of the explicit exceptions below applies.- The user wants to see what's happening, verify before submission, and have actions look like a human did them through the page. UI flows also work with the user's existing session, while API endpoints often require separate tokens.- TWO exceptions where API mutations are allowed:(1) The user explicitly says "use the API" or "POST to /foo" — do what they asked once API mutation permission is enabled; an explicit request does not bypass the runtime permission gate.- (2) The [USER OVERRIDE — API MUTATIONS ALLOWED] context note is present. It can come from /allow-api for this conversation or the user's persistent setting. When present, for WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. For the nine CMS content APIs described above, prefer the API under their stated conditions without waiting for editor failure. Other tasks retain the UI-first rule. You may also use API mutations when UI is genuinely failing/unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] showing repeated successful same-kind UI actions and matching background API requests. Without this authorization, mutating fetch_url/research_url calls are blocked. Before any destructive API call, state the URL, method, and payload in plain text in your response.+ (2) The [USER OVERRIDE — API MUTATIONS ALLOWED] context note is present. It can come from /allow-api for this conversation or the user's persistent setting. When present, for WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. The nine CMSs above follow their conditional API-first rule. Other tasks retain the UI-first rule. You may also use API mutations when UI is genuinely failing/unworkable, or when WebBrain reports a [BULK API MUTATION PATTERN] showing repeated successful same-kind UI actions and matching background API requests. Without this authorization, mutating fetch_url/research_url calls are blocked. Before any destructive API call, state the URL, method, and payload in plain text in your response.- For READING data (looking things up, fetching a README, comparing prices, checking a status page), \`fetch_url\` and \`research_url\` are the RIGHT tool. Reading is fine.- Examples:- "Create a release on GitHub" → navigate to /releases/new, fill the form, click Publish. NOT a POST to api.github.com.@@ -2229,7 +2229,7 @@ FORMS & MODALS:IFRAMES & UI-vs-API:- Cross-origin iframes (Stripe, payment widgets, embedded forms) are NOT a blocker. Start with iframe_read to enumerate labels and matchIndex values; iframe_click/type fail closed on ambiguity. If the embed remains hard to target and no fields have been changed, use promote_iframe({urlFilter}) to load it standalone in the current run tab. After iframe form edits, call verify_form({urlFilter}) and compare labels/values before done, even when the user will submit later.-- For content tasks in a confirmed Ghost, Drupal, Joomla, Webflow, Shopify, Wix, Strapi, Contentful or Sanity admin (including custom domains identified from UI/API evidence), prefer the official content API after read-only discovery when fields, target, usable auth, CMS rights, task scope and API mutation permission allow it; do not wait for editor failure. Use the relevant enabled recipe when available. If only mutation permission is missing, ask for /allow-api once; reuse valid permission and respect refusal. Ask remains read-only; even GraphQL query POSTs are gated. If auth/fields or Strict Secret Handling prevent safe use, use the observed editor.+- For Ghost/Drupal/Joomla/Webflow/Shopify/Wix/Strapi/Contentful/Sanity content tasks, follow the matching adapter/recipe: official API first when target, fields, auth, CMS rights, task scope and API permission allow. Ask stays read-only, including query POSTs. Request /allow-api once only for an otherwise usable API; reuse grants/respect refusal. Otherwise use the observed editor.- For other actions that create, modify, delete, send, submit, buy, transfer, or post: go through the visible UI unless API mutations are authorized and either the WordPress or the CMS content exception above applies, UI is failing/unworkable, or WebBrain reports a [BULK API MUTATION PATTERN]. For WordPress posts, pages, REST-enabled custom types and their taxonomy, prefer the API first when the required fields and signed-in session are verified and Strict secret handling is off; follow the WordPress adapter/skill and reconcile uncertain writes before retrying. Other tasks retain the UI-first rule. Do NOT call REST/GraphQL endpoints via fetch_url or research_url with POST/PUT/PATCH/DELETE without that authorization. Reading data (fetch_url / research_url GET) is fine.SCRATCHPAD & DON'T REDO WORK:diff --git a/test/cms-api-first.mjs b/test/cms-api-first.mjsindex f867f410b..9db2a4343 100644--- a/test/cms-api-first.mjs+++ b/test/cms-api-first.mjs@@ -129,6 +129,7 @@ for (const v of variants) {for (const id of ids) {const loaded = skills.buildCustomSkillsPrompt(all, { tier, mode, activeSkillIds: [id] });assert.equal((loaded.match(/<skill /g) || []).length, 1);+ assert.ok(loaded.length <= 12000, `${id}: loaded recipe exceeds CMS prompt budget`);assert.ok(loaded.includes(`skills/${id}.md`));assert.equal(loaded.includes('<SERIALIZED_VALID_LEXICAL_JSON>'), id === 'cms-ghost');}@@ -139,6 +140,8 @@ for (const v of variants) {assert.ok(normalized.every(s => s.tools.length === 0 && s.summary.length <= 200));const loader = skills.buildSkillLoaderDefinition(all, { mode: 'act', tier: 'full' });for (const id of ids) assert.ok(loader.function.parameters.properties.skill_id.enum.includes(id));+ const cmsCatalog = skills.buildSkillLoaderDefinition(all.filter(s => ids.includes(s.id)), { mode: 'act', tier: 'full' });+ assert.ok(cmsCatalog.function.description.length <= 2000, 'CMS catalog exceeds summary budget');});test(`${browser}: runtime load_skill activation keeps unrelated recipes out`, async () => {@@ -150,6 +153,9 @@ for (const v of variants) {assert.equal(result.success, true);assert.ok(agent.activeSkillIds.get(18).has('cms-contentful'));for (const id of ids.filter(x => x !== 'cms-contentful')) assert.equal(agent.activeSkillIds.get(18).has(id), false);+ agent._resetActiveSkillsForRun(18, { refreshPrompt: false });+ assert.equal(agent.activeSkillIds.has(18), false, 'the next run must not retain the CMS recipe');+ assert.equal(skills.buildCustomSkillsPrompt(records(v), { tier, activeSkillIds: agent.activeSkillIds.get(18) }), '');}});@@ -164,10 +170,11 @@ for (const v of variants) {assert.ok(adapter?.name.startsWith('cms-'), `${f.cms}: missing adapter`);assert.ok(adapter.notes.includes('fetch_url'));assert.doesNotMatch(adapter.notes, /load_skill/);- assert.ok(adapter.notes.length < 3200);+ assert.ok(adapter.notes.length <= 1300);}assert.equal(v.adapters.getActiveAdapter('https://news.example.test/admin')?.name, 'cms-editor-candidate');assert.match(v.adapters.getActiveAdapter('https://news.example.test/admin').notes, /ONLY after observing/);+ assert.ok(v.adapters.getActiveAdapter('https://news.example.test/admin').notes.length <= 450);for (const url of ['https://news.example.test/article/ghost', 'https://shopify.com.evil.test/', 'https://wix.com.evil.test/', 'file:///ghost/']) {assert.ok(!v.adapters.getActiveAdapter(url)?.name.startsWith('cms-'), url);}