* feat(mcp): add code mode to the Sim MCP server
* fix(mcp): stop queued code-mode calls at run end, bound error output, and type union bodies
* fix(mcp): render closed empty objects as Record<string, never>
* fix(mcp): render tuples and open objects in generated contract types
* feat(search): manage sources and permission uploads through the CLI
* fix(search): align source operations and complete CLI imports
* fix(cli): preserve upload errors and support early Node 20
* fix(cli): retain structured upload errors and retry guidance
* feat(search): add GitLab group sources with per-project permissions
* fix(search): preserve GitLab group scope across connection settings
* fix(search): validate current GitLab group access and preserve auth errors
* fix(search): preserve connector setup contracts when changing scope
path.relative returns backslash-separated paths on Windows, so navigation keys and page URLs never matched the forward-slash entries in meta.json and content:generate failed. Normalize the relative path to forward slashes once; no-op on macOS and Linux.
Fixes#10066
* improvement(credentials): hold unsaved keyless subjects so trust policies applied later still match
* fix(credentials): verify Databricks through the organization's egress, keep keyless reconnects on their mode, and harden held-subject renewal
* test(credentials): save on the proof a renewal returns, and record the keyless-subject usage fence
* feat(credentials): configurable audience for keyless AWS, Databricks, Snowflake, Microsoft, and Google credentials
* fix(credentials): check the audience in the connect dialog before showing setup commands
* fix(credentials): name Google's default audience in the keyless catalog hint
* feat(api): attribute polled run failures, deployed input schema, paused-run list, and applied run limits
- GET /v2/workflows/{id}/runs/{runId} reads the failing block back from the run's
recorded trace, withheld when the viewer's permission group hides execution data
- GET /v2/workflows/{id} adds inputSchema for the active deployment's API run input
- GET /v2/workflows/runs/paused lists a workspace's runs waiting on human input,
projecting pause points exactly as the run detail does
- Execute responses report executionTimeoutSeconds; GET /v2/billing/status adds plan limits
* fix(api): respect the paused-run page cap in the CLI and keep waiting pause points under the cap
- CLI generator carries a numeric field's contract maximum; the pager never requests
a page above it while still paging to the caller's total --limit
- Pause point cap keeps points not yet resumed before resumed history, so a run that
paused again is never listed without its waiting point (run detail and paused list)
* improvement(api): reuse FailedTraceBlock and sort pause points once when capping
* fix(api): custom-block trace boundary, legacy pause point arrays, and list point selection
- A custom block is an opaque trace boundary for failing-block attribution
- The paused-run list reads object and legacy array pause_points
- The list selects waiting human points before the per-run cap, reads points in
waves that stop once the page budget is spent, and shares one waiting predicate
- Resume response schemas omit executionTimeoutSeconds
- Drop a non-null assertion from the CLI page cap test
* fix(api): attribute concurrent failures to the stored error's block and never fail a workflow read on its deployment
- Failing-block attribution prefers the span the stored error names, else the
failure that ended first, else none; the block error prefix has one owner
- The workflow read degrades inputSchema to null when the deployment cannot be
read or its schema has an unexpected shape
- Integration cases for time-only, archived, and cross-workspace exclusion
* fix(api): consistent trace walk, block-named error attribution, required applied timeout, and ungated input schema
- Failing-block attribution walks spans as hasUnhandledError does, through
successful blocks, with one shared successful-boundary rule
- An error message headed by the failing block's name is attributed to it even
when the name reads as a run-level failure
- executionTimeoutSeconds is required (nullable) on Execute workflow responses
- The workflow read takes inputSchema from the active version row, not isDeployed
- Pause cap wording: unresolved points are kept in preference, listed earliest first
- Regenerate the CLI API the previous contract wording left stale
* fix(api): parse resume responses with the resume schema in e2e scripts and regenerate the CLI API on staging
- Stop-after and pinned-execute e2e scripts parse resume responses with
v2ResumeWorkflowDataSchema, which omits executionTimeoutSeconds
- Regenerate the CLI API against the merged staging contracts
* fix(api): parse the stop-after e2e resume helper's response with the resume schema
* fix(api): name the failing field once in v2 validation errors
A message that already leads with its field label no longer repeats it after
the location prefix, and the CLI restates the prefix as the flag the caller
typed instead of rewriting it to query.--flag.
* fix(api): call the v2 error id requestId
The id in error bodies is the request id that x-request-id carries and logs
store as requestId; traceId already means the OTel trace id in logs, so a
search by the published value found nothing.
* fix(api): describe what the workflow outline actually omits
Only null values are dropped, every sub-block hidden from agents is dropped
(some are real configuration), and blocks whose parent container is gone are
left out, so point readers at Get workflow state for the full configuration.
* fix(api): prove the workspace schedules list against Postgres
Adds an integration suite for listWorkspaceLiveSchedulesPage: it returns the
rows the per-workflow live list reports, leaves out archived, undeployed and
other-workspace workflows, and pages through createdAt ties without repeats or
gaps. sortBy=createdAt now says that each deploy creates new schedule rows.
* chore(skills): include the optional requestId in the v2 error shape
* fix(cli): pick the handoff for --expires-in and name a refused key
sim login --expires-in without --method failed on servers that offer OAuth,
because OAuth was chosen and then refused the flag; a lifetime now selects the
API-key handoff. A refused handoff key no longer says nothing was stored: it
already exists on the account, so the CLI points at how to revoke it.
* fix(api): publish the workspace logoUrl pattern without a lookahead
RE2-based validators (Go, Rust, many gateways) reject lookaheads, so the
OpenAPI pattern for logoUrl could not be compiled there. The rewrite accepts
and refuses exactly the same values.
* chore(cli-auth): drop the poll-body half of a test that could not fail
The poll contract strips unknown keys and the route never reads them, so
sending access and expiresInDays in the body proved nothing. The test keeps
checking that the approval's access and lifetime reach the mint.
* fix(workflows): refuse withheld blocks before the operations lock
applyWorkflowOperations now hands the persistence primitive a reader, which
skipped its pre-lock withheld-block check, so a refused batch took the row lock
and re-read the graph first. The use case checks the graph it composed before
writing. A failed re-read under the lock is now an internal error instead of a
400 saying the workflow has no state.
* chore(api): document the CONFLICT 409 from Apply workflow operations
* improvement(workflows): prove the operations conflict guard against Postgres
Holds the workflow row lock to force each interleaving: an unchanged workflow
with containers and a migrated legacy block commits, a write that lands after
the base read is refused as a conflict, and of two concurrent applies one
commits and the other is refused with nothing lost.
* chore(api): tighten comments and the field-label check from review
* fix(cli): name a refused handoff key exactly
The poll response now carries the minted key's name (an additive, optional
field), so the CLI tells the caller exactly which key in Settings → API keys
to revoke, falling back to the key id for an older server. Restores the route
context argument the trimmed poll test dropped.
* fix(workflows): run the conflict-guard races on their own connections
The applies and the lock-wait poll started inside the lock holder's
transaction callback, so the transaction tripwire refused them. They now leave
that context, the applies run in a permission-group scope as routes do, and an
apply that settles early is reported without awaiting the ones queued on the
held lock.
* chore(cli-auth): declare the poll key name the server always sends
* fix(workflows): count lock waiters queued behind another waiter
A second FOR UPDATE waiter queues on the first waiter's tuple lock, so
pg_blocking_pids names that waiter rather than the holder; the barrier now
walks the chain.
* fix(cli): probe the endpoint before an --expires-in handoff
--expires-in without --method chose the handoff before the reachability
probe, so a mistyped endpoint printed a pairing code and polled instead of
failing fast. The probe now runs first. A refused key from a server that does
not report its name is described by the name pattern and time it was made.
* feat(api): add traceId and field paths to v2 errors, name the read-only key remedy
* feat(api): publish declared value types on block catalog fields
* feat(api): add workflow outline and workspace schedules reads to v2
* fix(api): type declared catalog inputs as block params and regenerate the docs manifest
* fix(api): compare member responses without their per-request traceId
* improvement(api): tidy catalog field projection default and integration test comment
* docs(api): say the outline's derived fields come from values state already returns
* feat(api): agent identity on v2 meta, scoped CLI pairing keys, and v2 workspace rename
- GET /api/v2/meta adds keyId, userId, workspaceId and links {openapi, docs, mcp};
existing fields unchanged. The API catalog shares the same link source.
- CLI pairing login accepts --read-only and --expires-in <days>. The request rides
the approval URL, is shown on the approval card, is recorded with the approval
and applied at mint; the unauthenticated poll cannot set either. The poll echoes
access and expiresAt, and the CLI refuses to store a key that does not match
what was asked (an older server mints full access). The signed-out login bounce
now keeps scope, workspace, access and expiry instead of dropping them.
sim whoami shows the key's expiry and bound workspace.
- POST /api/v2/credentials/connections returns draftId. Opening a connection link
that is unknown, expired or another account's now explains to sign in as the
creating account, without saying which case applied.
- PATCH /api/v2/workspaces/{workspaceId} renames a workspace or changes its logo
through the existing workspaces.identity.update operation, widened to personal
API keys and OAuth tokens (api:write); Admin still required, workspace keys
still denied. Workspace update operations move into the operations registry.
- Regenerated OpenAPI, MCP catalog, CLI client and CLI docs.
* fix(cli-auth): pass route context in the new approve and poll tests
* test(mcp): expect the identity fields getMeta now returns
* fix(workspaces): count members before the rename so a failed count never hides a committed update
* improvement(cli-auth): reuse the api-key access schema and tidy handoff validation
* fix(api): publish the workspace PATCH body rules and check CLI-minted keys exactly
- PATCH /v2/workspaces/{id}: the body schema publishes minProperties 1, and
logoUrl is a pattern (root-relative path or https URL, protocol-relative
refused) instead of an unpublished refine.
- sim login refuses a minted key whose access or expiry differs from the
request in either direction, with the expiry checked against the requested
days within a clock tolerance.
- sim workspaces update --logo-url documents that clearing the logo goes
through the API or MCP.
* fix(credentials): enforce the saved-credential contract on every credential block, reopen key-based reconnects on their mode, and tighten fixtures and skills
- check-block-registry runs the saved-credential contract for every block with a
saved-credential picker, not only successors; the per-block contract moves to
saved-credential-contract.ts with tests. The host probe gains a path-shaped id and a
per-param shape so mixed-validation builders (Jama, Higgsfield) are probed, not guessed.
- Blocks the widened check caught: Coda, Harmonic, and Oracle Database tools declare
credentialKind 'service-account'; NetSuite pins instanceUrl in authoritativeParams;
Vanta's assetExternalAccountId is a filter, not a host.
- prepareWorkloadIdentity covers every keyless provider (AWS, Databricks added) and
reuses audiences.ts for the provider-id mapping; the AWS and Databricks dialogs reopen
a reconnect on the stored mode.
- Snowflake keyless verification maps an egress refusal to host_not_allowed.
- Neutral token fixtures in new credential tests; subject uniqueness TSDoc; skills
describe native token blocks, the picker shape, keyless setup, and the successor naming
exception.
* docs(credentials): fix keyless setup instructions and copy
- AWS: enter the Role ARN before setting the trust policy, so it never carries
the <AWS_ACCOUNT_ID> placeholder IAM rejects (dialog hint and docs).
- Databricks: the federation-policy command needs an account-level CLI login.
- Google: a valid sample pool ID, ID format hints, user-managed service accounts
only, skip the pool command when the pool exists, and the API list from
Google's guide (adds Resource Manager).
- Bitbucket: workspace and project access tokens need Premium; repository
tokens do not.
- Snowflake: rename SIM_WORKFLOWS if it exists; USERADMIN runs the statement.
- Microsoft keyless dialog says where the federated credential goes.
- Server errors name the trust values for API and CLI callers too; Google
Workspace and Account ID wording; AWS catalog hint mentions stsRegion; the
CLI keyless example uses aws-service-account throughout.
- Self-hosting env vars list every keyless provider.
* fix(credentials): reopen every keyless-capable reconnect on its stored auth mode and reject native credential tools without a policy
- prepareWorkloadIdentity reports the reconnected credential's stored authType
(reconnectAuthType), for an admin of a credential in the same workspace, whether or
not this deployment can sign. reconnectsKeyless is removed from the contract and hook.
The AWS, Databricks, Snowflake, Microsoft and Google dialogs reopen on that mode, so
an assume_role, personal_access_token or certificate credential keeps its auth.
- The saved-credential contract fails a native credential block whose tool has no
oauth policy: the executor would never fill its token.
- The Snowflake hint and docs say where to change SIM_WORKFLOWS; the DocuSign
account_not_found message covers a credential with no Account ID; the docs
baseline's reviewed CLI example entries carry their new byte length; the contract
test fixtures use a real OAuth service id.
Keyless (workload identity) credentials could only be set up in the web
connect dialog. Platform teams scripting their cloud trust now get the
same two steps as an API:
1. POST /api/v2/credentials/workload-identity/subjects
(`sim credentials keyless-subject <providerId>`) issues a random,
per-credential subject and a 24-hour proof bound to the caller, plus
the keylessConfig to fill in and the provider's required fields.
2. The existing create (`sim credentials create … --credentials
@keyless.json`) submits the completed config; Sim verifies the trust
before saving.
- The existing prepare use case now also admits personal API keys and
OAuth tokens with api:write. Workspace keys and delegated callers stay
refused, because the subject must belong to a person.
- Every keyless refusal carries one stable `error.details.code`
(WORKLOAD_IDENTITY_NOT_CONFIGURED, _PROOF_EXPIRED, _PROOF_INVALID,
_SUBJECT_REQUIRED, _SUBJECT_IN_USE, _SUBJECT_UNVERIFIABLE) on a single
refusal error, from create, reconnect and the subjects route alike.
- The provider catalog advertises a `keyless` object (authType and
required/optional config fields) only when the deployment can sign,
and the CLI reads it instead of keeping its own provider table.
Snowflake's keyless config is now accepted by the CLI.
- Provider hints, OpenAPI, MCP tool descriptions, CLI help and the five
credential docs pages describe the flow the same way.
- AWS and Databricks keyless create and reconnect also refuse with
WORKLOAD_IDENTITY_NOT_CONFIGURED when the deployment cannot sign, and
their verification steps pass keyless refusals through unchanged. Each
provider's refusal names a fallback credential type.
- The Google Cloud keyless hint says it covers Cloud services (BigQuery,
Vertex AI), not Google Workspace.
* feat(credentials): keyless Snowflake connections through workload identity federation
A Snowflake connection can now trust Sim's OIDC issuer instead of holding a
programmatic access token. Sim signs a short-lived token (audience
snowflakecomputing.com) for the credential's own random subject; the customer
creates a SERVICE user with WORKLOAD_IDENTITY = (TYPE = OIDC ISSUER SUBJECT).
- Save verifies by minting a token and running the identity statement at the
pinned account host through the guarded egress path; Snowflake's refusals
keep the shared codes (invalid_credentials, site_not_found,
provider_unavailable). Subjects bind to their creator like AWS/Databricks.
- Runtime: the resolver returns authStyle 'snowflake-workload-identity' for a
keyless credential, and the tools and selectors send Bearer WIF.OIDC.<token>
with the WORKLOAD_IDENTITY_FEDERATION token type. authStyle and domain are
authoritative on every Snowflake tool, so a caller can no longer choose the
token type or steer the account host of a saved credential.
- PAT credentials resolve and verify exactly as before.
- Connect dialog offers the keyless service user with the CREATE USER
statement; it falls back to the token dialog where keyless is unavailable.
- Docs: Snowflake connections page with keyless setup, troubleshooting, and
the 60-minute Snowflake key cache on signing-key rotation.
* fix(snowflake): run Cortex Analyst SQL with the resolved credential and reopen keyless reconnects as keyless
Cortex Analyst's "run the SQL" went through a nested snowflake_execute_sql
call carrying the already-resolved token and host. With authStyle and domain
now authoritative, the executor cleared both before the nested call, so it
failed for every credential (and a keyless token would have been sent as a
PAT). The generated SQL now runs as one guarded statement request built from
the parent call's credential-derived host, token, and token type, through the
same requestTarget egress the tool transport uses, with redirects refused.
The Snowflake connect dialog opened every reconnect on the programmatic
access token. The workload-identity prepare call now takes the reconnected
credential and reports whether it is keyless (only to an admin of that
credential in the same workspace), and the dialog opens on that mode.
Docs: the 60-minute wait applies before signing with a new key; removing the
old key needs 10 minutes with keyless Snowflake connections.
* fix(snowflake): cancel Cortex Analyst's generated SQL with the run
The generated SQL used to run as a nested tool call, which inherited the run's
abort signal; running it directly dropped that. postProcess now receives the
executor's effective abort signal as an optional fourth argument (the same
signal the tool's own request used), and Cortex Analyst forwards it to the DNS
check, the guarded fetch, and the response read. Other tools' postProcess
hooks are unchanged.
* feat(credentials): saved GitHub personal access tokens and Bitbucket access tokens
GitHub: a saved personal access token credential (fine-grained or classic),
verified against api.github.com/user with the tools' own headers. GitHub's
workflow block authenticates with an inline token rather than OAuth, so it
follows the token-block pattern: github_v3 is the credential-only successor
of github_v2, which stays exactly as it was, marked legacy and hidden from the
toolbar. Every GitHub tool declares the optional saved-token policy; inline
tokens keep working. The GitHub App installation credential (Search) is a
separate service and is untouched: the Assistant still projects GitHub tools
onto the person's connected GitHub account, and Search policy now follows the
visible GitHub block (github_v3).
Bitbucket: a workspace, project, or repository access token as a second
option next to OAuth (the Linear pattern), verified by listing one repository
of the typed workspace on api.bitbucket.org; the slug is validated so it
cannot steer the path. List Workspaces needs a signed-in user, so it now
refuses a saved access token before any request.
Also: isHostNotFound no longer lets an outer error code mask ENOTFOUND on its
cause.
* fix(credentials): close wave 2a review findings on GitHub and Bitbucket tokens
- The GitHub token service is `github-token`, so it no longer shares an id
with the GitHub sign-in provider: parseProvider and getProviderIdFromServiceId
answer for sign-in exactly as before, and a token-only service is never
marked connected from a sign-in account whose id prefixes it.
- Suggested connect rows offer each integration once and count it connected
when any of its services' OAuth or service-account credentials is saved
(GitHub's Search App and saved tokens share one integration).
- Assistant GitHub calls bind through the connected-account policy the
Assistant projects (the person's github-repositories OAuth account) in the
token resolver too, on both the ordinary and managed paths; workflow runs
and saved workspace tokens are unaffected.
- Bitbucket verification reads one repository (`workspace/repository`), the
request Atlassian documents for workspace, project, and repository access
tokens alike; listing a workspace is not documented for repository tokens.
- prepare-workload-identity test uses the central credentials-access mock.
* feat(credentials): DocuSign JWT Grant credentials next to OAuth
A saved DocuSign credential that authenticates with JWT Grant (an
integration key, an impersonated user ID, the app's RSA private key, and an
environment), offered as a second option beside the existing OAuth
connection, which is unchanged.
The minter signs an RS256 assertion (iss = integration key, sub = user,
aud = the environment's authentication host without a scheme, scope
"signature impersonation"), exchanges it at that host's /oauth/token, then
reads /oauth/userinfo on the same host to bind the pinned account (or the
user's default) and returns its eSignature REST base. Both hosts come only
from the stored environment; a base_uri outside that environment's
docusign.net shape is never trusted with the token. GUIDs and the key are
checked before any request, and tokens are re-minted about 15 minutes
before they expire, as DocuSign advises.
DocuSign tools take the account base as an authoritative credential param,
so a caller can never supply it, and DocuSignClient skips its
deployment-host userinfo lookup when one is bound. OAuth tokens resolve
exactly as before.
Save-time failures map to consent_required (the connect modal shows the
exact consent URL for the key and environment) and account_not_found (a
pinned account the user does not belong to), alongside the shared
invalid_credentials and provider_unavailable codes.
* fix(credentials): close wave 2b review findings on DocuSign JWT Grant
- The DocuSign knowledge connector now honours a JWT Grant credential's
bound account. The resolved token's instanceUrl reaches the connector as
credentialInstanceUrl in the sync context (seeded on every path through
syncContextForToken). The connector re-validates it with the same parser
as DocuSignClient, lists and fetches from that account in the
credential's environment, links envelopes to that environment's web app,
and validates without asking the deployment host. A seeded value of the
wrong shape fails closed. OAuth syncs are unchanged.
- RSA keys under 2048 bits are refused as invalid_credentials with copy
that names the size, instead of jose's raw TypeError.
- A short expires_in no longer makes every call re-mint: the cached
lifetime floors at six minutes while staying a minute under the real
expiry.
- The connect modal shows the consent URL as a link with a copy button,
and account_not_found says "pinned account" only when one was entered.
* feat(credentials): Microsoft Entra app-only credentials for Entra ID, SharePoint, Dataverse, and Dynamics 365
A saved Microsoft app credential (OAuth 2.0 client credentials) as an
additional option next to Microsoft OAuth, which is unchanged. One app
registration serves the four services whose tools run without a signed-in
user; Outlook, OneDrive, Excel, Word, Planner, and Teams never offer it and
token resolution refuses it for them (provider mismatch).
- Modes: client secret; certificate (PS256 client assertion with the
certificate's x5t#S256 thumbprint, aud = the tenant token endpoint, 5-minute
lifetime; key/certificate pairing, RSA size, and expiry checked before any
request); keyless federated credential (a Sim workload-identity token for the
credential's own subject, audience api://AzureADTokenExchange, subject bound
to the saving user, refused if the app also accepts an unheld subject).
- The token resource comes from the tool's service, passed from the
server-validated tool policy: Graph for Entra ID and SharePoint, the stored
environment for Dataverse and Dynamics 365. Any other service is refused.
- The environment URL is stored on the credential (public-cloud Dynamics
hosts, https root only). Dataverse tools take credentialType and instanceUrl
as authoritative params; an app credential's request goes only to its own
environment and a block environment that names another is refused. OAuth
requests keep the block environment exactly as before. Dynamics 365 already
matched instanceUrl against the block environment.
- Save check: a Graph token reading the app's own service principal (no
permission needed), plus Dataverse WhoAmI when an environment is set. Entra
AADSTS codes map to actionable copy; runtime failures keep the shared
invalid_credentials / provider_unavailable split. Tokens cache per
credential, resource, and stored-secret version in an LRU.
- Azure AD Reset password refuses app-only credentials: Graph does not
support application permissions for resetPassword.
- Connect dialog with tenant ID, client ID, environment URL, and the
issuer/audience/subject to paste; docs page with per-mode setup.
* fix(credentials): close wave 3 review findings on Microsoft app credentials
- SharePoint selectors (workspace and organization paths) and knowledge
connectors now pass the service they resolve for (the selector's own
serviceId, the connector's declared auth provider), so a Microsoft app
credential browses SharePoint with a Graph token instead of being refused.
The resolution option is renamed from toolService to service; it is only
ever set from server-side policy.
- AADSTS700211 and 700212 are no longer mapped: Microsoft documents only
70021 and 700213 for federated credential mismatches. Other keyless
refusals still name the mismatch.
- DocuSign minter test mocks carry account_name, and the connector
access-token test narrows its tokens with a guard instead of non-null
assertions.
* feat(credentials): keyless Google Cloud credentials via Workload Identity Federation
A keyless mode of the existing Google service account credential
(google-service-account) for Google Cloud APIs. JSON-key credentials, their
connect flow, and their token minting are unchanged.
- Flow: Sim signs a short-lived token for the credential's own subject with
aud = the customer's provider resource name
(https://iam.googleapis.com/projects/<number>/locations/global/
workloadIdentityPools/<pool>/providers/<provider>), exchanges it at
sts.googleapis.com/v1/token (token-exchange, jwt subject token,
cloud-platform scope, audience //iam.googleapis.com/...), then calls
iamcredentials generateAccessToken for the service account with the tool's
scopes and a 1h lifetime. Impersonation rather than direct federated access:
some Cloud APIs reject federated tokens, and the service account keeps the
same identity and roles a JSON key uses.
- Inputs validated against Google's documented formats before any request:
numeric project number, pool/provider IDs (4-32 [a-z0-9-], no gcp-), and a
user-managed *.iam.gserviceaccount.com email, so nothing can steer the STS
audience or IAM URL. Requests never follow redirects.
- Scope: refuses domain-wide delegation (an impersonated user) and any service
but BigQuery and Vertex AI before reading further or contacting Google, with
a new shared unsupported_use code and copy pointing to a JSON key. Workspace
blocks never offer the mode.
- Save check: STS exchange, impersonation, and tokeninfo (no IAM role or
enabled API needed), plus a probe that a subject no credential holds cannot
impersonate the service account. Subject bound to the saving user with the
signed proof; kept across reconnects.
- STS/IAM failures map to actionable copy (provider settings, issuer
reachability, the exact workloadIdentityUser binding) without Google's
descriptions or any token; runtime keeps the invalid_credentials /
provider_unavailable split. Tokens cache per credential, secret version, and
scopes in an LRU.
- Per-credential audiences: audiences.ts gains google without a fixed
audience; the setup response omits audience for it and reports a keyless
reconnect. Connect dialog shows the issuer, audience, subject, and filled-in
gcloud commands (pool, OIDC provider with attribute condition on the
subject, IAM binding); docs section added.
* fix(credentials): close wave 4 review findings on keyless Google Cloud credentials
- Drop the tokeninfo check: a token from generateAccessToken already proves
the provider accepted Sim's token and the impersonation binding, and
tokeninfo puts a live token in a query string.
- Test that saving fails closed when the stray-subject pin probe hits an STS
outage or an unreachable IAM endpoint.
- Pass --project=<project number> on all three gcloud setup commands, drop
the unused Resource Manager API from the docs, and raise the shared
validation error for an empty scope list.
* fix(credentials): keep Snowflake, Microsoft app, and Google keyless subjects unique
The subject-uniqueness scan from #9866 covered only AWS and Databricks. It now
also scans Snowflake, Microsoft app, and Google service account credentials,
so no two live credentials of an owner hold one keyless subject. Their keyed
secrets that carry no config (a Google JSON key, a Snowflake programmatic
access token) hold no subject and no longer read as unreadable. The three
keyless save paths report a newly bound subject so create checks it.
* fix(credentials): close round-1 CI and review findings on alt auth
- Knowledge connector tests expect the service now passed with Google
service-account token requests; a new test proves a JSON-key mint signs the
same request with or without it.
- Re-record the tool-registry-boundary baseline: the keyless Snowflake,
Microsoft app, and Google modules add 5 modules behind credential-service,
which tipped credit-usage past its allowance on top of staging's drift.
- Docs compatibility baseline: record the new code examples in the Google and
Snowflake service account pages.
- Generate the Microsoft certificate test fixture at run time instead of
committing a PEM key and certificate.
- A Microsoft app credential reconnect opens on keyless only when the stored
credential is federated (the prepare step now reports it), like Snowflake;
new connections still default to keyless.
- TSDoc on the Google project number, pool/provider ID, and service account
email validators.
* fix(credentials): offer keyless Google setup only in a Google Cloud context
Reconnecting a keyless Google service account from a Workspace integration
(Gmail, Drive, ...) offered the keyless form, saving a credential that
integration can never use. The dialog now offers keyless only for a Google
Cloud service (new or reconnect) or on the credential's own page; from a
Workspace integration it explains the credential works only with BigQuery and
Vertex AI and does not save. The chat connect control passes its service so
it gets the same gate.
* test(credentials): match the stable part of the subject-in-use refusal
* feat(search): update GitLab permission CSVs through the API
* fix(search): align GitLab CSV updates with CLI and API policies
* test(cli): cover confirmation for GitLab permission replacement
Select acceptance work from the task graph, separate docs site and platform checks, and preserve complete comparison history for push attribution.
Build docs once and run isolated acceptance groups in parallel after bounded server readiness. Reuse validated content and incremental build inputs with bounded retention.
Validate native source/toolchain fingerprints and restored output integrity, seed trusted branch caches, and balance desktop smoke across four whole-file shards. Bound organization-search diagnostics and reclaim closed-PR merge-ref caches.
Validation: full root tests, all workspace types, lint and 62 audits; real cache invalidation and Git attribution controls; complete hosted docs, integration, organization-search, Electron and packaged smoke coverage; final-head bot reviews.
* feat(docs): rebuild documentation with the Paper design system
* fix(docs): verify nested tabs and fresh-checkout CI setup
* chore(docs): refresh preservation evidence against latest staging
* fix(docs): align shared navigation and controls with Paper
* fix(docs): share active heading across responsive outlines
* fix(docs): track the final section at the end of the page
* fix(docs): preserve sidebar scroll in a persistent layout
* fix(docs): restore live screenshot backgrounds and framing
* fix(docs): finish layout polish and clean implementation references
* fix(docs): align shared dark theme and overlay states
* fix(docs): remove dark borders from platform screenshots
* test(docs): benchmark production navigation and image delivery in CI
* fix(docs): preserve machine content and production reading contracts
* fix(docs): retain readable tabs without JavaScript and verify current staging
* fix(docs): expose root response schemas and generate clean-checkout types
* fix(docs): resolve no-script tabs in the preflight cascade layer
* perf(docs): import only the search schema constructors
* fix(docs): preserve retrieval excerpts and reduce reading overhead
* fix(docs): reuse in-flight intent prefetches during navigation
* docs: record production readiness evidence and release requirements
* docs: clarify optimizer measurement provenance
* docs: preserve latest staging Search assets and compatibility evidence
* fix(docs): polish responsive controls and keep search indexing current
* test(docs): select the visible API example in browser checks
* test(docs): execute native examples against streaming and binary responses
* fix(docs): stream native API responses without buffering
* test(docs): cover review regressions through public interfaces
* fix(docs): preserve accessible examples and gate index publication
* fix(docs): finish accessible controls and cached content validation
* fix(docs): validate integration parents and report partial search failures
* fix(docs): refine navigation and compact sample controls
* fix(docs): isolate synchronous corpus validation from HTTP readers
* fix(docs): restore Paper interaction styling and verify responsive controls
* fix(docs): score each search page once per retrieval source
* fix(docs): attribute benchmark metrics to their source document
---------
Co-authored-by: Waleed Latif <walif6@gmail.com>
Production and staging keep building every affected commit, so a shared-package change that breaks the docs build still fails on staging before main. Other preview branches skip the build unless apps/docs changed since the branch's last successful deployment; a first deployment or a previous SHA outside the shallow clone builds.
* improvement(library): single JSON-LD source, Markdown articles, and IndexNow pings
* improvement(library): link Andrew's author profile and surface the docs history fetch outcome in build logs
* fix(library): gate IndexNow on the ECS cutover, cover unpublished and renamed pages, and give customer stories speakable hooks
* fix(docs): fetch commit history from the repository Vercel names, since its clone has no origin remote
* fix(library): noindex direct Markdown article URLs on self-hosted deployments and diff IndexNow from the last submitted revision
* improvement(seo): fix soft 404s, per-integration freshness, and docs markdown for AI crawlers
* test(seo): crawl the production build for landing SEO regressions
* chore(landing): remove the post and author loading skeletons the slug pages no longer use
* fix(seo): resolve docs slugs through the catalog, keep API pages negotiable, and harden the crawler suite
* fix(docs): carry the landing-page backlink into integration markdown
* test(seo): match the visible date attribute case-insensitively