@jskit-ai/connectors-catalog 0.1.1

package/docs/gmail.md

@@ -0,0 +1,133 @@
+# Gmail setup and runtime
+
+Documentation checked: 8 September 2026. Automated tests use simulated provider
+responses and real private JSON state; live provider use is outside this delivery.
+
+## Registration and manual setup
+
+Follow all numbered steps in [Google registration setup](google-oauth.md).
+For this connector, choose **Gmail API** in APIs & Services → Library and enable
+`gmail.googleapis.com` in the selected Cloud project. Create a Web application client
+with the exact backend callback URI. Set the client ID, secret reference and
+callback URL reference in the same registration fields used by the CLI.
+
+In Google Auth Platform → Data Access, select
+`https://www.googleapis.com/auth/gmail.readonly` (required by this connector).
+The captured defaults also select `gmail.send`, `gmail.compose` and `gmail.modify`.
+Remove optional permissions your application does not need; verification only reads the profile; writes require explicit app operations.
+The UI exposes additional documented scopes for applications that need them;
+those scopes do not add operations to this fragment. Use External plus explicit
+test users while testing outside an eligible internal Workspace audience.
+
+## Fields and useful fragment
+
+Provider ID: `gmail`. Import its provider from
+`@jskit-ai/connectors-catalog/server/gmail`. Display name, scopes, account mode,
+Client ID/secret and callback references follow the shared field mapping.
+Membership and project access are enforced by the host/application policy,
+not by storing untrusted people IDs in application source.
+
+Operations include profile, message/search/attachment reads, drafts, explicit send, labels and reversible mailbox actions listed below.
+Verification input: `{}`.
+
+The profile read returns the authenticated mailbox address and message count. Message listing accepts maxResults (1–500), pageToken and repeated labelIds; pass nextPageToken to continue. Message get reads headers using format=metadata and requires a message id. Use messages.read for full/raw content, attachments.get for external MIME parts and messages.search for q. These operations exclude gmail.metadata, which cannot authorize bodies or search.
+
+The first read must succeed before Connected is returned. Invalid resource
+identifiers fail before opening consent. Denied scopes, wrong account context,
+replayed callbacks and provider rate limits are covered by the automated tests.
+See the [official operation reference](https://developers.google.com/workspace/gmail/api/reference/rest/v1/users/getProfile) for the response and resource
+permission requirements; the implementation also checks Google's public API
+discovery document for request paths and supported scope strings.
+
+## Automation and application setup
+
+Classification: **assisted**, as detailed in the common Google guide. An
+operator-authorized AI can check/create the Cloud project and enable
+`gmail.googleapis.com` with Service Usage or gcloud. It can prepare this connector's
+JSON and callback/scope values. Web-client creation, branding, audience,
+provider review and account consent remain the documented console/operator
+steps; this adapter does not invent an API for them.
+
+The application owns the Cloud project selection, registration, callback and
+private secret bindings. It uses the same setup from a CLI or either editor.
+Follow the common guide for rotation, revocation, domain changes and recovery.
+Provider quotas belong to the selected Cloud project and resources; editor
+subscription level does not allocate a shared registration.
+
+## AI/CLI wiring
+
+Use the file-store composition from the [connection pattern](../patterns/api-key-connection/PATTERN.md),
+replace the API-key authentication with `oauth2` plus a registrationRef, and
+register this provider. Use beginAuthorization / completeAuthorization instead
+of connectApiKey, with the verification input above. The existing application
+owns authenticated callback routes and its permission policy. Configuration,
+OAuth, refresh, provider requests and storage remain library imports.
+
+## Mailbox workflows and permission boundaries
+
+| Operations | Inputs and required permission alternatives |
+|---|---|
+| `messages.read` | `id`, optional full/raw `format`; readonly, modify or full-mail |
+| `messages.search` | `q`, maxResults/pageToken/labelIds/includeSpamTrash; same body-read permissions |
+| `attachments.get` | `messageId`, attachment `id` from a MIME part; same body-read permissions |
+| `messages.send` | base64url MIME `raw`, optional `threadId`; send, compose, modify or full-mail |
+| `messages.modify` | `id`, addLabelIds/removeLabelIds (up to 100 each); modify or full-mail |
+| `messages.trash`, `messages.untrash` | `id`; modify or full-mail |
+| `drafts.list`, `drafts.get` | Pagination or draft `id`; readonly, compose, modify or full-mail |
+| `drafts.create`, `drafts.update` | `raw`, optional threadId; update also draft `id`; compose, modify or full-mail |
+| `drafts.send`, `drafts.delete` | draft `id`; compose, modify or full-mail |
+| `labels.list` | No input; readonly, metadata, labels, modify or full-mail |
+| `labels.create`, `labels.update`, `labels.delete` | `name`, id+name, or id; labels, modify or full-mail |
+
+The runtime checks both configured and actually granted OAuth scopes before
+sending an operation. Adding a scope in configuration requires a new consent.
+An app user's connection uses `users/me`: the app cannot select another mailbox
+by passing an email address. Shared connections still require app authorization
+before exposing mail to visitors.
+
+Read the returned MIME tree recursively. Inline body parts and attachment
+responses carry base64url data; attachments may be separate parts. The app's
+framework should parse MIME, sanitize HTML, control remote images and supply
+safe download filenames. The connector does not render email or write files.
+`messages.get` remains the explicitly metadata-only operation; `messages.read`
+returns full/raw content. Listing and search return IDs, followed by reads as
+needed; follow nextPageToken, not resultSizeEstimate, for pagination.
+
+```js
+const page = await connections.invoke({ context, integrationId: "gmail",
+  operation: "messages.search", input: { q: "in:inbox is:unread", maxResults: 20 } });
+const message = await connections.invoke({ context, integrationId: "gmail",
+  operation: "messages.read", input: { id: page.messages[0].id } });
+// After explicit app authorization, mark read and archive:
+await connections.invoke({ context, integrationId: "gmail",
+  operation: "messages.modify", input: { id: message.id,
+    removeLabelIds: ["UNREAD", "INBOX"] } });
+```
+
+Handle an empty messages array before choosing an item. Build outgoing MIME
+using your framework's mail library, then encode it as base64url in `raw`.
+This adapter bounds raw input to 14 million characters; use a framework-native
+upload flow for larger messages. The From address must be authorized for the
+connected mailbox. Replies need valid In-Reply-To/References headers, matching
+subject and threadId; setting threadId alone does not guarantee threading.
+Draft updates replace the draft's message. Deleting a draft or label is explicit;
+label deletion removes that label, not its messages. Trash is reversible here;
+permanent message deletion is not implemented.
+
+A send response identifies an accepted message, not final delivery. Do not
+blindly retry an uncertain send: inspect Sent and reconcile using your app's
+record first. The app owns duplicate prevention and any delivery/bounce handling.
+
+CLI users use the same JSON and private Env with optional JSKIT libraries.
+Other frameworks use their native OAuth and MIME tools with the same settings
+and [Gmail REST methods](https://developers.google.com/workspace/gmail/api/reference/rest).
+An AI can wire those operations using the provider schema and this guide without
+Vibe64 running. There is no shared Vibe64 mailbox or Google registration.
+
+**LIMITATIONS:** no background/history sync, push watch service, mail-client UI,
+permanent message deletion or mailbox-settings administration. MIME composition
+and rendering belong to the framework; editor assistant attachment is deferred.
+Example: a booking app can read a customer's message, draft a reply, explicitly
+send it and archive the thread's selected message; installing the connector does
+not build the inbox UI or keep a local mailbox synchronized. Google approval,
+real delivery and live mailbox permissions remain untested.

package/docs/gong.md

@@ -0,0 +1,205 @@
+# Gong
+
+Import `gongProvider` from `@jskit-ai/connectors-catalog/server/gong`.
+This provider verifies a company API key and reads users, calls, transcripts and statistics. It
+implements the access-key form, including the optional company API URL.
+OAuth, MCP and write operations remain outside this provider.
+
+## Create credentials manually
+
+1. Sign into Gong as a technical administrator. Open **Admin center → Settings**,
+   then **API** in the **Ecosystem** area.
+2. Choose **+ Get API key**, name it, and optionally set its lifetime and allowed
+   IP addresses. Use the backend's outbound IPs when restricting network access.
+3. Choose **Get API key**. Copy the access-key identifier into the editor and
+   store its one-time secret as `GONG_ACCESS_SECRET` in the application
+   environment. Enter `env:GONG_ACCESS_SECRET` in the secret-reference field.
+   In the editor, **Save configuration**, then **Set credential in Env**;
+   paste the secret as `GONG_ACCESS_SECRET` and save there. Finish with **Done**
+   in Gong only after preserving the secret. Return and choose **Connect account**.
+   The secret cannot be retrieved after closing.
+4. For later changes, use the key row's actions menu and **Edit**, then save.
+   Revocation is available there through **Delete**, its acknowledgement and
+   **Delete API**. Local connector disconnect does not revoke Gong's key.
+   These controls were updated in August 2026, so older accounts may differ.
+   [Key management](https://help.gong.io/docs/receive-access-to-the-api).
+
+The identifier and secret form an HTTP Basic credential. A secret alone, an
+OAuth client secret or an OAuth bearer token is not this credential type.
+[API authentication](https://help.gong.io/apidocs/introduction-2).
+
+## Portable file and UI fields
+
+```json
+{
+  "schemaVersion": 1,
+  "registrations": {},
+  "integrations": {
+    "sales": {
+      "provider": "gong",
+      "displayName": "Sales team directory",
+      "accountMode": "shared",
+      "scopes": [],
+      "authentication": {
+        "method": "api-key",
+        "secretRef": "env:GONG_ACCESS_SECRET"
+      },
+      "settings": {
+        "accessKey": "YOUR_ACCESS_KEY_IDENTIFIER",
+        "apiBaseUrl": "https://api.gong.io"
+      }
+    }
+  }
+}
+```
+
+Replace the identifier with the value from Gong. The shared fields expose
+**Access key**, **Access key secret reference** and **API base URL (optional)**.
+CLI and editor use the same settings schema. The key identifier is required;
+the secret remains outside source. Whitespace around pasted settings is trimmed.
+Embedded whitespace, control characters and colons are rejected in the identifier.
+The local identifier limit is 512 characters, not a claim about Gong's issued
+key length.
+
+Omit or clear the base-URL field to save the default `https://api.gong.io`.
+This is the origin in Gong's Basic-authentication example.
+[Directory example](https://help.gong.io/docs/uploading-calls-from-a-non-integrated-telephony-system).
+When the API settings provide a company URL, use that value, for example
+`https://company-17.api.gong.io`. Gong also documents customer-specific API
+origins in its OAuth integration guide. The adapter accepts the default host or
+one DNS label before `.api.gong.io`, using HTTPS, optionally ending with `/`.
+Paths, queries, fragments, ports, embedded credentials and unrelated domains
+are rejected. This is an explicit fragment boundary; it does not support
+arbitrary proxies. Changing the key identifier or host requires verification
+again. Requests never fall back to another customer or the default origin.
+
+## Library and AI wiring
+
+Use the [API-key composition pattern](../patterns/api-key-connection/PATTERN.md)
+with `providers: [gongProvider]`, the file connection store, an environment
+reference resolver and the application's authorization policy. Both
+configuration and runtime state can remain text files; the CLI needs no editor
+or database process.
+
+```js
+await connections.connectApiKey({ context, integrationId: "sales" });
+const directory = await connections.invoke({
+  context, integrationId: "sales", operation: "users.list",
+  input: { includeAvatars: false }
+});
+```
+
+`users.list` performs `GET /v2/users`. Its optional `includeAvatars` flag defaults
+to false, excluding Gong's synthetic employee/support users. It accepts an
+opaque `cursor` of 1–8192 characters. Pass `records.cursor` from the previous
+response to request another page. The runtime preserves users, record counts
+and cursor metadata, returns one page at a time, and does not auto-page or
+accept a destination URL in operation input. An empty user list is valid.
+The endpoint documents `api:users:read` for OAuth; this fragment uses a company
+API key and does not present OAuth scope controls.
+[User API](https://help.gong.io/apidocs/list-all-users-v2users).
+
+Default published API limits are company-wide: three requests per second and
+10,000 per day. A 429 response indicates throttling. The fragment surfaces a
+rate-limit error and does not implement automatic retries or budget allocation.
+[API limits](https://help.gong.io/apidocs/introduction-2).
+The application's user-directory policy must decide who may invoke this shared
+connection; a company API key is not an individual employee's login identity.
+
+## Provisioning feasibility and application registrations
+
+An AI can prepare this JSON, its reference bindings, request code and validation
+without accessing Gong. Initial API-key creation remains a technical-admin UI
+step: the reviewed public documentation does not establish an API for creating
+keys or customer companies. Do not invent such an endpoint. Browser-assisted
+setup requires the operator's existing account and any required approvals.
+
+For a future shared OAuth service, Gong's documented registration path is:
+
+1. Request a developer instance through the form linked in its app guide.
+2. Open **Admin center → Settings → Ecosystem → API → INTEGRATIONS** and choose
+   **Create Integration**.
+3. Supply the name, long/short descriptions, two logo sizes and required scopes.
+   Supply the callback, privacy, terms, help and authorization-start URLs, plus
+   contact emails and organization domains. For directory access choose
+   `api:users:read`; leave frontend embedding disabled unless needed.
+4. Save and retain the issued client ID and secret for this application. Keep
+   the secret in the application backend's private Env.
+
+Gong's OAuth consent is company-wide and does not support user-level grants.
+The token response identifies a customer API origin that a future OAuth adapter
+must retain with that customer's connection. These registration steps do not
+make the current API-key adapter OAuth-capable.
+[App registration](https://help.gong.io/docs/create-an-app-for-gong).
+
+Two keys or client registrations do not override company-wide request limits.
+The application owns its credential selection and usage policy. Independent
+provider capacity requires an
+appropriate Gong account arrangement, rather than just a different app name.
+Do not supply one operator's company key as a universal connection to other
+customers' Gong data. Each company owns its grant and API destination.
+
+This implemented key flow has no callback registration. A separate OAuth
+implementation must use the application's actual registered callback and own
+its grants. It is not implemented by this key adapter.
+
+## Focused evidence
+
+Seven tests use simulated Gong responses and real temporary encrypted JSON state.
+They cover default/customer origins, Basic credentials, file restart, rotation,
+ownership, disconnect, host/key changes, unsafe URL rejection, cursor encoding,
+avatar selection and failures. The public editor check verifies required keys,
+secret references, company URL validation, reload and default restoration.
+No live Gong access, account creation or example application execution is used.
+
+## Call analysis and linked deal context
+
+`calls.extensive` returns metadata, participants, available call summaries/topics,
+interaction statistics and CRM context at call time and now. Supply `callIds`
+(1–100 strings), or an ordered `fromDateTime`/`toDateTime` range with timezone;
+optional `workspaceId` narrows the workspace. Preserve every digit of Gong IDs:
+use strings, never JavaScript numbers. Pass `records.cursor` back as `cursor`
+while retaining the same filters. No automatic paging or media fetch occurs.
+
+`calls.transcripts` uses the same call/date/workspace selection. Join each
+monologue's speakerId to parties in the extensive call data; retain sentence
+start/end timing. Transcripts or analysis may be absent, processing, deleted or
+restricted. An empty result does not prove the account has no calls.
+
+`stats.interaction` takes `fromDate`, `toDate` in YYYY-MM-DD and optional `userIds`.
+Dates use Gong's company timezone; the end is exclusive and cannot exceed the
+provider's current day. Results apply to calls with Whisper enabled. Missing
+metrics are unavailable, not zero. Cursor paging follows the same pattern.
+
+```js
+const result = await connections.invoke({ context, integrationId: "sales",
+  operation: "calls.extensive", input: { callIds: ["7782342274025937895"] } });
+const transcript = await connections.invoke({ context, integrationId: "sales",
+  operation: "calls.transcripts", input: { callIds: [result.calls[0].metaData.id] } });
+```
+
+Check for empty results before selecting a call. Linked CRM objects/fields are
+Gong's existing context; the app can associate a call with its opportunity and
+show available deal changes. This does not establish a CRM connection or provide
+a standalone all-deal timeline. The app owns joins, reporting and call/CRM access
+rules. Company keys must never grant arbitrary visitors company-wide recordings.
+
+`includeMedia: true` explicitly asks Gong for media URLs; default is false.
+These URLs expire after eight hours and require corresponding provider access.
+Treat them as private capabilities. Never attach the Gong Basic credential when
+using a returned media URL. The adapter does not download or archive recordings.
+
+The technical administrator supplies company API access; account verification
+only checks users and does not prove call, transcript, media or statistics access.
+CLI consumers use the same config and private Env. Other frameworks use native
+HTTP Basic against the selected company host and the official
+[call-data](https://help.gong.io/apidocs/retrieve-detailed-call-data-by-various-filters-v2callsextensive-2),
+[transcript](https://help.gong.io/apidocs/retrieve-transcripts-of-calls-by-date-or-callids-v2callstranscript-2)
+and [interaction-statistics](https://help.gong.io/apidocs/retrieve-interaction-stats-for-applicable-users-by-date-v2statsinteraction)
+APIs. No Vibe64 runtime or AI service is involved.
+
+**LIMITATIONS:** no CRM synchronization, standalone deal timeline, recording
+uploads, media archive, OAuth or editor assistant attachment. Example: an app
+can show renewal-call transcripts and the opportunity context already in Gong;
+it cannot connect Salesforce for the customer or create missing CRM history.
+Real company permissions, transcript availability and media downloads are untested.

package/docs/google-ads.md

@@ -0,0 +1,156 @@
+# Google Ads
+
+The fragment uses Google user OAuth and REST v25 to list accessible accounts,
+read account hierarchies and run paged reports. Campaign changes, service-account
+grants and application login are outside this fragment.
+
+## Set up Google Cloud access
+
+Google retired developer tokens on September 9, 2026. API access now belongs to
+the Cloud project owning the OAuth client. Remove `apiAccess` and
+`developerTokenRef` from pre-release configuration; there is no compatibility
+reader. The editor no longer asks for a token or pilot selection.
+[Google migration notice](https://developers.google.com/google-ads/api/docs/api-policy/developer-token).
+
+1. Select or create the application's Google Cloud project. Enable **Google Ads
+   API** through **APIs & Services → Library**.
+2. Open its **Google Ads API Overview** page. Check the access level. If it is
+   Test, expand **Upgrade access level** and apply for Explorer to use production
+   accounts. Higher access has its own approval requirements.
+   [Current setup](https://developers.google.com/google-ads/api/docs/get-started/make-first-call).
+3. In **Google Auth Platform**, configure **Branding**, **Audience** and **Data
+   Access**. Add test users while testing and the
+   `https://www.googleapis.com/auth/adwords` scope. Complete applicable consent
+   publishing and verification before public use.
+4. In **Clients**, create a **Web application** client. Add this project's exact
+   **Suggested callback URL** under **Authorized redirect URIs**. Copy Client ID
+   into the connector form. Save configuration, then use the Env links to store
+   the client secret and identical callback URL under their referenced names.
+   [Web OAuth setup](https://developers.google.com/identity/protocols/oauth2/web-server).
+5. When accessing customers through a manager, enter its ten-digit customer ID
+   without hyphens. Direct account access can leave this blank. The consenting
+   person must have the intended Ads account access. Target customer IDs remain
+   operation inputs, separately authorized by the application.
+6. The application's backend implements the callback and connection lifecycle.
+   Use **Connect account** for a shared account; individual app users connect in
+   the application's own account screen. Initial verification lists directly
+   accessible accounts, not every inherited child account. Disconnect removes
+   local state; revoke Google consent separately when intended.
+
+## Portable configuration
+
+```json
+{
+  "schemaVersion": 1,
+  "integrations": {
+    "ads": {
+      "provider": "google-ads",
+      "displayName": "Advertising reports",
+      "accountMode": "per-user",
+      "scopes": ["https://www.googleapis.com/auth/adwords"],
+      "settings": { "loginCustomerId": "1234567890" },
+      "authentication": { "method": "oauth2", "registrationRef": "ads-client" }
+    }
+  },
+  "registrations": {
+    "ads-client": {
+      "source": "own",
+      "clientId": "replace-with-web-client.apps.googleusercontent.com",
+      "clientSecretRef": "env:GOOGLE_ADS_CLIENT_SECRET",
+      "callbackUrlRef": "env:GOOGLE_ADS_CALLBACK_URL"
+    }
+  }
+}
+```
+
+Replace the placeholders with project-owned resources. Secrets and grants stay
+with the application. CLI, public Vibe64 and Online use the same configuration;
+Laravel implements it with its own framework. Host/domain changes require the
+provider registration and callback Env value to match the application's new
+callback. Keep persistent grants and application identity when moving hosts.
+
+An authorized AI can prepare configuration and enable APIs using Google Cloud's
+normal tooling. OAuth client creation, consent verification and access approval
+require the actual owner's permissions and provider processes. There is no
+universal Vibe64 credential or automatic approval. API quotas follow the Cloud
+project and account limits; a second OAuth client does not imply independent
+capacity. The adwords permission can authorize writes even though this fragment
+only implements reads.
+
+## Runtime composition and limits
+
+Import `googleAdsProvider` from
+`@jskit-ai/connectors-catalog/server/google-ads`. Register it with the existing
+`createConnectionService`, configuration reader, reference resolver, owner policy
+and encrypted file store. The OAuth source pattern provides composition without
+an editor or database. The app owns its login and each reporting action's policy.
+
+| Operation | Input and result |
+|---|---|
+| `customers.listAccessible` | No input; returns Google's `resourceNames`. Missing repeated fields can mean an empty result. This is the connection check. |
+| `customers.listClients` | `customerId`, optional `pageToken`; a fixed `customer_client` query returns hierarchy metadata and levels. It does not recurse automatically. |
+| `reports.search` | `customerId`, `query`, optional `pageToken`; one GAQL Search page, with original result field names and metadata. |
+
+The runtime sends only fixed Google token/API destinations. Search uses POST
+JSON but is a read operation. Its page size is Google's fixed 10,000 rows; the
+caller cannot send `pageSize`, arbitrary headers, destinations or a different
+manager ID. Queries are single-line SELECT text, at most 16,000 characters and
+32,000 UTF-8 bytes. Use GAQL `LIMIT` and approved date ranges to bound reports.
+Keep page tokens with the original query, customer and owner; request each page
+explicitly. 64-bit values stay strings, including money in micros. Preserve that
+precision when displaying or aggregating them. No SQL/GAQL parser or query-cost
+estimator is implied. [REST Search and pagination](https://developers.google.com/google-ads/api/rest/common/search).
+
+The application must authorize account IDs, fields, filters and query inputs
+before invoking the library. Configuration ownership and the manager header do
+not make an arbitrary report endpoint safe for every app user. The host policy
+receives an input snapshot; its mutation cannot change the request. The API scope
+does not replace your application's authorization.
+
+OAuth grants refresh through the shared locked file implementation. Changed
+client identity/settings require reconnecting. Missing OAuth bindings produce `connector_binding_missing`; project approval failures use
+`connector_api_access_invalid` without discarding the user's valid OAuth grant.
+Quota, permission, scope, query and reconnect failures remain distinct. Raw
+provider error bodies and query echoes are not exposed. Requests respect abort
+signals/timeouts and are not replayed automatically. Disconnect removes local
+access; Google account revocation is a separate owner action.
+
+## Verification boundary
+
+Focused tests use controlled OAuth and Ads HTTP responses with the real shared
+validator and encrypted file store. They cover Cloud-project configuration, OAuth/header
+separation, query/page bounds, int64 preservation, empty/malformed results,
+restart, concurrent refresh/rotation, ownership, policy, denied consent, errors
+and interruption. No live accounts, Cloud-project approvals, reports,
+campaign actions or generated applications are used. Provider approval and live
+consent remain separate acceptance work.
+
+## Existing-account Search campaign service
+
+`@jskit-ai/connectors-catalog/server/google-ads-search` exports
+`createGoogleAdsSearchService({ connections, configuration, context, integrationId })`.
+Its reusable operations discover accounts/website conversion goals and targeting,
+validate a saved plan with Google, atomically create a paused Search campaign,
+inspect a current campaign, separately launch/pause it and report last-30-days
+metrics. The application owns the authenticated administrator and connection
+service; CLI apps use this without Vibe64.
+
+Store plans at `extensions.googleAdsSearch[integrationId]`, outside OAuth settings.
+Use `validateGoogleAdsSearchPlan` from the shared `google-ads-search` export. Read
+`patterns/google-ads-search/PATTERN.md` for command composition and boundaries.
+The public editor has preparation/review controls; another framework uses the same
+JSON/Env contract with native Google APIs, not a JSKIT sidecar.
+
+In Google Ads, select an existing active client account, then Goals → Conversions
+→ Summary to select or create a website lead goal. Tag setup gives the global tag
+and successful-lead event; integrate with existing consent/tag management, avoid
+duplicate tags and verify using Tag Assistant. This service can create a website
+lead goal and return snippets; it does not install them automatically. Confirm
+billing/advertiser readiness separately before launching. Creation stays paused;
+a lost write response must be investigated in Google Ads before retrying.
+
+LIMITATIONS: no advertiser account provisioning, Performance Max, Demand Gen or
+live coding-assistant tool attachment. For example, asking chat to create a new
+Ads account and autonomously optimize a PMax campaign remains unsupported. The
+current editor command uses development Env and may affect a real Ads account.
+Fixtures prove composition and request/approval behavior, not Google live approval.