DreamLake

Personal agent files, skills and MCP

This unreleased implementation supports multiple personal skills, remote MCP connections, explicitly confirmed MCP tool calls and a unified Slack OAuth connection, with dedicated Skills, MCP servers, Connections, Memory and History pages under My assistant. Native GitHub/Google Drive/S3 adapters remain deferred. User-configured authenticated MCP services can expose those resources; that is not native account OAuth. Slack supports user-authorized web chat tools and persistent, read-only assistant access through private DMs. A real Slack App and deployment are still required; local fake-provider tests are not live acceptance. The legacy fixed-workspace Slack pilot and external MCP adapter retain their existing routes.

Personal assistant and namespace-owned resources

One personal assistant per signed-in user. ensureAgentIdentity(userId) binds the built-in account and private context to the user's personal namespace. Switching resource namespaces does not change that identity. Resource ACLs still apply.

ObjectOwnership and scope
My assistant, Skills, Memory, MCP/Slack connections, private historyThe signed-in user, across workspaces
Custom agents at /:namespace/agentsNamespace-owned reusable definitions: instructions, arguments and a tool allowlist
Resource Connections at /:namespace/connectionsNamespace credentials for Sources/storage, visible only to credential managers
Resources a chat works withSelected namespace, bounded by the user's existing permissions

A custom agent is a resource definition, not another login or assistant identity. Only compatible, validated builtin-v1 definitions can be selected by the web assistant; others require their external runtime. Selecting a supported definition changes instructions and allowed tools. Personal definitions can use personal extensions within their allowlist. Nonpersonal definitions do not receive personal Skills/MCP/Slack extension scopes, even if they name those tools. Personal Memory is loaded by user on every turn, including organization definitions. An organization definition is not a memory-isolated organization assistant.

Management pages

CommandPageBehavior
/go my assistant…/builtin-agentPersonal ownership, management links and tool preferences
/go my skills…/builtin-agent/skillsAdd/import SKILL.md, edit, enable, disable or delete skills
/go my mcp servers…/builtin-agent/mcpRemote MCP servers and access from MCP clients
/go my connections…/builtin-agent/connectionsApp-level connections with capabilities grouped within each app
/go my memory…/builtin-agent/memoryRead up to 50 memories, edit at their version or explicitly forget
/go my history…/builtin-agent/historyRecent conversations, execution state and tool receipts

All six pages use the standalone application frame under the signed-in user's /:personal/builtin-agent/** path and are absent from Settings and the sidebar. The namespace in this URL is an ownership address, not a switch to another assistant. Every page states its personal owner. Nonowner/organization URLs never mount private API consumers; backend checks remain authoritative. Auth changes clear private rows and credential drafts. The reserved application segment is not a legacy project-browser path; account switching goes to Projects.

The existing /agent definition selector and /agents resource route keep their behavior, labeled Custom agents. Existing /connections targets the selected namespace. Chat drafts survive navigation. Unsaved forms are discarded when leaving a management page; opening or closing connection setup preserves visited forms. Credentials are never saved in browser storage. My assistant and existing account Settings read the same tool-access preference.

App connections and MCP

Assistant connections groups capabilities by application. Slack appears once. Connect Slack starts OAuth; its verified account/workspace, reading, sending and ongoing assistant DM access are managed inside that connection. Normal setup has no manual token or link code. The legacy generic extension API can still create manual Slack records for compatibility; the unified page uses OAuth. One Slack identity can bind to only one DreamLake user; switching Slack identities requires disconnecting first. Existing manual-token connections require explicit migration confirmation.

Capability switches restrict the assistant's available tools; they do not reduce the OAuth scopes already granted at Slack. Changing a switch increments the file revision, invalidates pending external actions. Reading/sending switches do not turn off DM assistant access. Disconnect disables local access first, revokes that user's Slack token best effort and removes personal files/action history. If Slack cannot confirm revocation, the page instructs the user to remove access in Slack. Shared bot installation credentials are retained for other connected users.

The MCP servers page manages only remote MCP servers. Its separate disclosure, Use assistant from an MCP client, configures access to DreamLake from another app. To disconnect a client, remove its configuration and revoke its DreamLake bearer through the issuer. Neither Slack controls nor a mixed Slack/MCP provider selector appears here; MCP records and client setup do not appear on Assistant connections. Shared file storage and editor internals do not imply a shared product category.

Old ?tab=channels URLs open the same Slack connection page. Separate Files and Integrations pages remain removed without deleting stored files or backend APIs.

Relation to resource Connections

Namespace Connections manages workspace Source/storage credentials with its existing manager-only visibility, OAuth lifecycle and Source reference constraints. The assistant already uses the signed-in user's DreamLake resource permissions, limited to the tools and changes allowed in chat and applicable definition allowlists. No additional assistant connection is needed for already-accessible DreamLake resources. This does not imply every CLI operation is available as an assistant tool or expose stored namespace credentials. Assistant connections adds capabilities specifically for the personal assistant; it does not grant additional DreamLake resource access. App authorization is separate from DreamLake sign-in: connecting GitHub or Slack does not create, switch, or merge DreamLake accounts. Sign in to the intended DreamLake account first, then connect the external app from that account. The two surfaces link to one another with explicit purpose and scope, and reuse UIKit patterns without merging their underlying records or authorization.

New personal entries default to disabled. Skill instructions cannot grant permissions or run uploaded code. Replacing an MCP endpoint replaces its credential; clearing a saved bearer requires explicit confirmation.

File authority and layout

Skill/MCP content and their index are files, not database document bodies. The owner-only logical file space reuses the existing agent identity and private context binding. It is not an ordinary Source: current Source ACLs include Project and sharing authority and do not provide a restricted owner-only type. This feature neither creates a normal Source catalog entry nor changes Source ACLs. The existing context project remains subject to its existing catalog visibility.

agent.json
AGENT.md                              # existing instruction-file reference, if present
skills/<name>-<id>/skill.json
skills/<name>-<id>/SKILL.md
mcp/<name>-<id>.json
slack/<name>-<id>.json
operations.json                       # current operation metadata projection
operations/<id>.json                  # exact proposal and current result projection

agent.json is authoritative for enabled/state/revision and the current immutable snapshot references. Skill/MCP logical JSON views combine that index with content snapshots, and are read-only projections, not a second editable source. Every skill has its own SKILL.md. Memory has not migrated: no placeholder memory files are created or represented as writable.

Physical objects use a server-resolved agent-home/<serviceAccount.id>/ prefix, separate from project object keys and agent-context/. No Node rows are created for virtual home files, so ordinary project search/read/archive tools cannot address them and project transfer snapshots do not copy the prefix. The existing AGENT.md file is referenced through its existing authorized reader, not moved.

Read requests only look up an existing private context. Only an explicit Add may provision the existing agent account/project. Every lookup verifies active User, personal namespace, unrevoked caller-owned account, and the context project's current private visibility, creator and agent metadata. Deletion/transfer or a revoked identity fails closed. Account-deletion integration is still absent; purgeUserExtensions is the trusted cleanup hook for all home object versions and credentials. Call it before removing the service-account row, or supply its captured account IDs. Project deletion/transfer revokes access but does not automatically reclaim home objects; this lifecycle integration remains pending.

Concurrency and cleanup

Each write uploads immutable content, verifies its size/hash and presence, then changes the index using the exact ETag and S3 conditional writes. Only index- referenced snapshots are visible. Same-revision or index CAS conflicts return 409; an old write is not silently replayed. The same CAS enforces 32 skills, 16 MCP and one newly saved native Slack connection. The parser still accepts up to eight legacy Slack records so owners can inspect and remove them. No records are deleted automatically. More than one enabled legacy Slack connection fails discovery/execution with agent_slack_multiple_enabled; the model catalog excludes those Slack records while other skills/MCP keep working. Disable/delete still work. A second create returns agent_slack_already_connected; Legacy records can be edited; OAuth-managed records must use the Slack connection lifecycle. This is a product constraint, not a Slack platform limit. A skill body is at most 32 KiB UTF-8; config snapshots are at most 8 KiB and the index at most 64 KiB. Names are unique within each extension kind and use 1–64 lowercase ASCII letters/digits/ hyphens, starting with a letter or digit. Descriptions are at most 300 characters.

The S3 adapter tests If-None-Match: * and an incorrect If-Match before accepting mutations; a backend that ignores conditions is refused. Deployment must verify its actual bucket/IAM behavior. The application never edits IAM; operators must configure the file-storage permissions before enabling extensions.

Deletion first CASes the item to disabled/deleting, then removes all credential rows and content snapshot versions/delete markers, and finally removes the index entry. A cleanup failure keeps a deleting entry so the owner can retry; it cannot be enabled, read or discovered and still occupies quota. Index-version metadata follows the bucket's retention policy until whole-home cleanup; deletion does not claim erasure from conversation replies, audit metadata or independent backups.

After a successful mutation, cleanup runs with a separate hard 1.5-second budget and never turns a committed write into a failure. Enabled-only updates reuse their snapshot; other updates immediately attempt to retire the old snapshot. Unreferenced snapshots and credentials older than ten minutes are reclaimed, in small batches, on a later successful owner mutation. If cleanup fails and no further mutation occurs, old unreferenced content can remain until explicit whole-home cleanup. Active references are preserved regardless of pending credential state. An ambiguous index-write outcome never immediately deletes its candidate credential: the write may already have committed. Future reference-based cleanup handles it. Missing/corrupt content fails explicitly, without falling back to an older version.

Credentials and MCP

Only authentication material uses AgentMcpCredential: opaque ID, owner, extension ID, credential version, sealed value, pending/expiry/creation metadata. It holds no skill body, description, index or general MCP configuration. Its single owner/extension index is nonunique. Expiry is not a TTL that could remove an indexed credential after a crash.

The full endpoint, including its potentially sensitive path, and bearer are sealed together with agent.mcp-credential. The payload must match owner, extension, credential reference and version when opened. File views and DTOs show only origin/host and an opaque reference. A nonempty bearer is 16–4096 valid token characters. Production requires the existing database ValueProtector/keyring; missing protection never falls back to plaintext. Keyring changes require process restart.

MCP uses the pinned official SDK 1.32.2 over public HTTPS 443 Streamable HTTP. Credentials, IP literals, query/fragment and localhost are refused in the endpoint; DNS is pinned and all answers must be public. Redirects, OAuth discovery, unsolicited GET push/recovery, stdio commands, sampling, roots and elicitation are unavailable. Server requests cannot execute client actions.

Discovery supports JSON/SSE, a 30-second total deadline, 1 MiB response bytes, 64 KiB SSE lines, 256 event boundaries, four pages, 40 tools, 12 KiB/schema, schema depth 12 and a 36 KiB result envelope. Remote metadata strings are bounded, control/format characters removed, and credential/endpoint echoes redacted. Results are untrusted metadata with executable: false, never dynamic tool registrations. UI and agent share one discovery/user/process; agent calls are limited to two per turn. This is not a distributed provider quota. The same process gate covers confirmed MCP and Slack execution.

APIs and agent integration

BUILTIN_AGENT_EXTENSIONS_ENABLED=true enables the routes and personal turn integration; it defaults off. The built-in agent's existing team admission still applies. Production needs its existing project-file S3 bucket plus conditional- write, bucket-versioning and version-deletion permissions, and secure encryption configuration for MCP. Skills do not need a credential encryption key.

In addition to existing object read/write/delete access, the runtime role needs s3:GetBucketVersioning on the configured project-file bucket, s3:ListBucketVersions restricted with s3:prefix to agent-home/*, and s3:DeleteObjectVersion on that bucket's agent-home/* objects. Keep these permissions separate from resource-connection credentials and launch authority. Verify the first real extension or OAuth connection save: token exchange and a healthy API alone do not prove that the file-store preflight can succeed.

RouteContract
GET /agent/capabilitiesRead-only negotiation, personalExtensions boolean; no provisioning
GET /agent/extensionsCurrent owner index summaries; no skill bodies
POST /agent/extensionsCreate kind/name/description/enabled plus skill content or MCP endpoint/bearer
GET /agent/extensions/:idDetail; skill content, no MCP endpoint or token
PATCH /agent/extensions/:idRequired revision; endpoint/bearer replaced together
DELETE /agent/extensions/:id?revision=NBegin or resume confirmed content deletion
POST /agent/extensions/:id/discoverRequired revision; enabled personal MCP or Slack
GET /agent/extensions/operations?conversationId=...Owner operation list; optional owned conversation filter
POST /agent/extensions/operationsManual proposal with connectionId/revision/tool/arguments, no dispatch
POST /agent/extensions/operations/:id/decisionExact previewHash plus confirm/reject/acknowledge; explicit owner decision; see bearer boundary below
GET /agent/extensions/filesCurrent logical paths, no object keys
GET /agent/extensions/files?path=...Text/hash for an exact indexed logical file; not path concatenation

The registry offers dreamlake_personal_extensions_list, dreamlake_personal_skill_read, dreamlake_mcp_discover, dreamlake_mcp_call and dreamlake_external_operation_get. Web turns with personalExtensions: 1, no nonpersonal definition, and enabled entries receive independent extensions:read and, for MCP, mcp:discover and external:read scopes. Proposing additionally requires the existing toolsWrite: 1 capability (Allow tool changes), which grants external:propose only when an enabled personal connector is available. Official bundle skills:read remains separate. Scope loading is a fresh best-effort 1.5-second index read; failure omits extensions and lets the chat continue. Each actual tool call rechecks current owner, rollout, personal home ownership, current-turn scopes, enabled state and revision. Agent-definition allowlists still apply. No credential/configuration mutation or operation-confirmation plugin is added.

The browser negotiates GET /agent/capabilities once per mounted authenticated identity. A 404 or failed check omits the new capability so a new web client still chats with an older server whose schema rejects unknown fields. A stale positive followed by rejection is surfaced, never retried as another chat send. Deploy the server before the web app. The flag is evaluated on every request, never persisted on a session. Existing inbound Slack/MCP adapters omit it and acquire no personal extension scopes, even when resuming a web-created session. This opt-in is not proof of a physical browser: an authorized bearer holder can send the same flag.

Receipts retain IDs/revisions and small summaries, not raw skill/discovery bodies. Tool bodies are transient model inputs; an assistant can quote their content in its saved reply, so these are not a promise of total data erasure.

Confirmed external calls

dreamlake_mcp_call saves a proposal only. Every external call, including reads, requires a separate human confirmation in this milestone. The chat shows connection origin, exact tool/arguments, expiration and result. JSON previews escape invisible and bidirectional controls; long parameters scroll without truncation. Confirm submits the displayed immutable proposal digest. It preserves the composer draft. The immutable proposal includes the trusted originating acting namespace and the personal destination connection, both shown on the confirmation card. Older proposals show that their resource scope was not recorded. Users can explicitly approve sending organization data to a personal app. This is an intentional cross-scope disclosure: external results remain untrusted, while ordinary org resource-write tools can still be available if the user selected Full access. No organization-wide connector policy or DLP gate is claimed by this implementation.

After completion, Continue with result explicitly asks the agent to read that operation in the same conversation. Management displays discovered tools without a manual JSON execution form. The existing manual-proposal API remains owner-only; manual proposals are not model-readable.

Decision requests require a bearer, exact configured DREAMLAKE_WEB_ORIGIN Origin, JSON and x-dreamlake-external-action: decision. Missing origin configuration fails closed. The trusted in-process agent API refuses all extension mutations and binds an internal marker that the decision route rejects; clearing attribution does not bypass this boundary. General CORS reflection is not an approval allowlist. This protects the standard built-in agent API channel; Origin/custom headers are not proof of a physical human click. A non-browser process holding the same user bearer (including a separately delegated runner with that credential) can forge those headers. The confirmation flow is not a sandbox against such a process.

The private operations.json index is at most 64 KiB and holds at most 20 entries. Bodies are immutable files under operations/<id>/<uuid>.json, at most 32 KiB, with hash/length references in the index. At most six pending proposals exist; the model can propose at most three per turn. Pending proposals expire after 15 minutes. CAS commits pending → executing before dispatch, with a unique execution token. A CAS timeout or conflict never grants permission to send. Repeated confirmations return saved status without sending again. The caller connection closing does not cancel receipt recording. An expired executing entry is healed to uncertain on read after its 35-second deadline plus 5-second grace; a late finisher cannot overwrite that outcome. Final receipt CAS conflicts permit up to three local retries, never another remote call.

States are pending, executing, succeeded, failed, uncertain, rejected, expired and acknowledged. Unknown effects are never automatically retried. Acknowledge unknown outcome makes an uncertain receipt eligible for eviction; it does not undo the effect or authorize replay. Old terminal records can be evicted to admit new proposals. Credential replacement, disable/delete, changed schema, wrong owner and wrong conversation are checked before dispatch; already-dispatched requests cannot be recalled by revoking a connection.

MCP preflight reads a bounded fresh catalog in the execution session, compares a canonical raw-input-schema digest and validates unchanged arguments. It rejects required task-based tools and schemas containing references, regex, formats or unsupported validation keywords. The interpreted subset supports types, object properties/required/additionalProperties, arrays/items, enum/const, anyOf/oneOf and numeric/string/container bounds. It permits at most 128 schema nodes and 32 enum values, with depth 12; arguments are plain JSON objects up to 8 KiB. No schema code is compiled, external references fetched or defaults/coercions applied. Sanitized catalog metadata is not the execution schema. Tools whose schema changes under sanitization cannot be proposed. SDK generic requests avoid compilation of untrusted outputSchema. No tool is dynamically registered as an official tool.

Results are untrusted text/structured data bounded to 16 KiB, with explicit truncation. Media and resource URLs are not fetched. Network/transport failures after dispatch and MCP isError yield uncertain; they are not safe-retry signals. Receipts store IDs/digests/lengths, not raw arguments or results. The private body files intentionally retain parameters/results for review. Deleting a connector revokes first, then removes its operation entries and all body versions. Reference- based orphan cleanup is bounded to five files and 1.5 seconds after successful changes; without later changes, leftovers may remain until explicit home cleanup. The existing account-delete hook gap and bucket/backup retention caveats still apply.

Slack connector

The unreleased OAuth implementation connects with a configured Slack App. Connect Slack opens Slack's authorization screen and returns to the same user's Assistant connections page. OAuth state expires in ten minutes. A trusted-origin top-level form handoff sets an HttpOnly, SameSite=Lax callback cookie. Callback checks that browser binding and claims the exchange once; authenticated finish requires the original DreamLake owner and unchanged connection revision. No token or client secret is returned to the browser, saved in browser storage or placed in redirect URLs. An ambiguous exchange is not retried automatically.

Personal capability/identity configuration remains in the private agent-home snapshot. The user token uses the existing purpose-bound encrypted credential store. AgentSlackInstallation holds one encrypted bot token per App/workspace; AgentSlackIdentity provides durable unique routing from App/workspace/Slack user to the owning personal connection. These are installation and identity indexes, not replacements for file-backed personal configuration. Pending reservations expire after ten minutes and reconcile only against a matching committed file. Reconnect keeps the active binding while reserving separate pending fields; a failed file update preserves the previous connection. User revocation tombstones also cover callbacks that have not committed yet.

Use assistant in Slack persists until the user turns it off, disconnects or revokes access. Connect explains that accessible DreamLake resources may be included in answers sent to the user's private Slack DM; successful OAuth with versioned consent enables that capability. Existing one-hour M1 connections require explicit Enable Slack assistant consent and are not silently upgraded. Reading/sending Slack messages remain independent switches. Signing out of DreamLake, switching web accounts, or restarting the backend does not revoke this grant. Send disconnect in the DM to turn off assistant access while keeping the app connection.

The private connection file stores a versioned read-only grant ID and creation time, with no expiry and no human bearer. The worker reconstructs authorization from current file settings, identity routing, installation state, account activity and pilot access on every request and before private delivery. Each queued message and reply is bound to its grant ID. Disabling, re-enabling or reconnecting invalidates older queued work. Revocation/uninstall events block subsequent execution and private delivery; resource handlers continue to enforce their current ACLs.

Execution uses bounded in-process chat streaming. Single-use, exact-request tickets exist only inside the server process and authenticate only the chat entry or approved read APIs. No general user JWT is minted. Each tool rechecks the delegation; mutation capabilities, custom agent definitions, browser actions and external-action tools are unavailable. Old M1 logout calls cannot revoke a durable grant. Conversation context has a 30-day idle retention; this does not expire assistant access. Existing per-user message limits, turn timeouts and service availability still apply. There is no channel participation or background proactive messaging. Event IDs deduplicate retries; ambiguous Slack sends are not blindly replayed. The legacy fixed-workspace bot retains its separate configuration and short-lived grant behavior, not another connection card.

The fixed native API endpoint remains https://slack.com/api/. OAuth connects a user token for web chat reading/sending and the App's shared bot installation for DM replies. Web chat tools still require per-turn opt-in and per-call review. Slack DM requests do not inherit personal Skills/MCP/external-action tools.

Fixed operations are auth.test, conversations.list, users.list, conversations.history, conversations.replies, conversations.open and chat.postMessage. Directory pages retain at most 20 minimal entries; history and thread pages at most 15 messages. Continue using the explicit returned cursor; there is no eager polling, pagination loop or automatic rate-limit retry. Required scopes depend on token and conversation types: channel/DM read/history scopes, users:read, chat:write, and im:write for opening a DM. Provider refusals remain visible without asking for broader privileges automatically. See Slack's history, thread and message contracts.

Sending requires an explicit C/G/D conversation ID and at most 4,000 text characters; optional thread timestamps are validated. Open a DM for an explicit user ID first, then send to its returned D ID as a separate confirmed action. The preview does not resolve channel/user names or check external sharing; inspect directory results first. Messages use plain-text mode with Markdown/unfurls disabled. Explicit Slack mention syntax may still notify people. Read methods use URL-encoded POST arguments; write methods use JSON, with tokens only in the Authorization header. Slack known definite ok:false refusal codes, 401/403 and 429 are definite refusals; unknown/fatal/internal provider errors and unknown transport, parse or 5xx outcomes after dispatch are uncertain. All I/O uses the fixed host, pinned public DNS, a dedicated dispatcher, strict byte/time bounds and no redirects.

Slack App setup

This is a deployment prerequisite, not something each end user configures. App registration alone does not establish deployment readiness or live OAuth/DM acceptance for this draft.

  1. In Slack Apps, create a new App from the repository's dreamlake-server/src/slack-connection/app-manifest.json. Use a dedicated App for this OAuth path rather than overwriting an existing fixed-workspace pilot. The manifest targets https://api.dreamlake.ai; replace both URLs for an approved preview environment.
  2. The OAuth redirect must exactly match {DREAMLAKE_API_ORIGIN}/agent/connections/slack/oauth/callback. The signed Events API URL is {DREAMLAKE_API_ORIGIN}/agent/connections/slack/events. Enable the App Home messages tab. Subscribe to message.im, app_uninstalled, and tokens_revoked. The manifest contains the required scopes. Keep token rotation, organization-wide installation and Socket Mode disabled; this implementation rejects rotating/enterprise tokens rather than silently losing refresh capability.
  3. Put the App ID, Client ID, Client Secret and Signing Secret into the backend's existing secret configuration as SLACK_APP_ID, SLACK_CLIENT_ID, SLACK_CLIENT_SECRET, and SLACK_SIGNING_SECRET. Never place secrets in frontend VITE_* variables, Notes, PRs or chat. Set exact trusted DREAMLAKE_API_ORIGIN and DREAMLAKE_WEB_ORIGIN. Existing JWT, Redis, protected-value keyring and agent-home storage prerequisites still apply. This path does not require a manually configured SLACK_BOT_TOKEN, SLACK_TEAM_ID or SLACK_BOT_USER_ID.
  4. Before enabling BUILTIN_AGENT_SLACK_OAUTH_ENABLED=true, use the Schema indexes workflow on reviewed main, with scope builtin-agent: inspect the read-only plan, then apply that exact plan hash. The scope includes the Slack installation and identity indexes; it never drops indexes or applies unrelated schema changes. Startup verifies the unique App/workspace installation and App/workspace/user identity indexes before serving writes. Keep BUILTIN_AGENT_EXTENSIONS_ENABLED=true and the existing pilot access gate. Backend registration and event URL verification must be ready before enabling Connect for users. App creation can start without event subscriptions; save/verify the event URL after the approved backend release is reachable, then complete the manifest configuration.
  5. For users outside the development workspace, complete Slack's distribution configuration and any workspace administrator approvals. Test with a disposable account/workspace: Connect, correct identity display, read a permitted conversation, explicitly confirm one test message, verify persistent DM access beyond one hour and a backend restart, turn it off/on, disconnect, and uninstall/revoke while a reply is queued. Verify web sign-out does not revoke it and old queued work cannot be delivered after re-enabling. Check the second user's connection remains valid when the first disconnects. These are live acceptance steps, not evidence supplied by local fake-provider tests.

The disabled feature reports Slack Connect is not available yet; it never falls back to a manual token form. If enabled with incomplete secrets or missing indexes, server startup fails. See Slack's OAuth installation, manifest and token revocation event references.

Local acceptance and limits

AGENT_EXTENSIONS_TEST_MONGO_URI and AGENT_HOME_TEST_S3_ENDPOINT explicitly name credential-free loopback fixtures for pnpm exec tsx scripts/verify-agent-extensions.ts. The script creates a random database and S3 bucket, enables versioning, verifies real file CAS/quota/ownership and credential-only persistence, then deletes its own objects, versions, database and bucket. It never uses ambient DATABASE_URL or AWS credentials. Its S3 credentials are synthetic fixture values.

Temporary-directory tests cover torn writes, corruption, stale revision, cleanup failure/retry, candidate preservation and orphan reclamation. Protocol tests use synthetic MCP responses. Browser previews also use synthetic account data. These local checks do not verify a third-party OAuth account, a production bucket, Slack messages or production deployment.

Primary protocols: MCP transports, MCP authorization, S3 conditional writes, and version deletion.