Skip to main content

Plugin Manifest

Reference for plugin.json: identity, versions, platform compatibility, instance mode and project applications, twenty-four capability tokens, scopes, activation events and event routes, the thirty-four contribution limits, and strict validation.

Updated
Reviewed

Every plugin has a plugin.json at its root. It declares the plugin's identity, which Daintree versions it works with, what it contributes to the UI, and what capabilities it claims to need.

Daintree reads installed manifests at startup and project manifests when their registered project opens or its plugins folder changes. Project contributions register only after trust and staging permit the plugin to load. Contributions declared here populate the command palette, menus, and toolbars immediately, before any plugin code runs. The entry module is only imported when something actually triggers it. See Contribution Points for the shape of each contributes array and Plugin System for how manifests get installed.

Manifest shape

{
  "$schema": "https://raw.githubusercontent.com/daintreehq/daintree/develop/schemas/plugin.schema.json",
  "name": "acme.linear-planner",
  "version": "0.1.0",
  "displayName": "Linear Planner",
  "description": "Plan Linear issues as multi-step agent workflows.",
  "tagline": "Turn Linear issues into agent workflows.",
  "category": "ai",
  "authors": [
    { "name": "Ada Lovelace", "url": "https://ada.example.com", "role": "Maintainer" }
  ],
  "main": "dist/index.js",
  "engines": { "daintree": ">=0.41.0" },
  "worksWith": ["acme.linear"],
  "capabilities": ["fs:project-read", "network:fetch"],
  "scopes": {
    "network": { "allowedUrls": ["https://api.linear.app/graphql"] },
    "fs": { "allowedPaths": ["${project}/docs"] }
  },
  "activationEvents": [],
  "contributes": {
    "commands": [ /* … */ ],
    "panels": [ /* … */ ],
    "views": [ /* … */ ],
    "settings": [ /* … */ ]
  }
}

The $schema line is optional. The scaffold writes it so editors offer completion and inline errors; Daintree accepts the key and never reads it. Project plugins point it at plugin.project.schema.json instead.

Required fields

name: the plugin id

A scoped identifier in publisher.plugin-name form, at most 64 characters, matching:

^[a-z0-9]+(?:-[a-z0-9]+)*\.[a-z0-9]+(?:-[a-z0-9]+)*$

Lowercase only, hyphens rather than underscores, exactly one period separating publisher from plugin name, no spaces. acme.linear-planner and gpriday.cost-management are valid; LinearPlanner, acme/linear, acme.linear.planner, and Acme.LinearPlanner are not.

The publisher segment should identify you: a GitHub handle, company name, or domain prefix. It is what prevents collisions between independently authored plugins. This id is also the namespace every contribution gets: a command declared as plan-from-issue becomes the action acme.linear-planner.plan-from-issue at runtime, and most other contributions are qualified the same way. A project plugin's ids carry its instance as well; write manifest references as publisher.name.id and the host qualifies them. Agent ids are the exception: they register as declared, in one app-wide roster.

The daintree.* namespace is reserved for first-party plugins. A user-installed or project manifest claiming it is rejected. Names are unique per root: an installed plugin that reuses a built-in's name is rejected, as is a second installed plugin with the same name. A project plugin may share its name with an installed app-wide plugin, and both load as separate instances.

version

Must be valid semver: 0.1.0, 1.2.3-beta.1. Anything semver.valid() rejects fails manifest validation outright. For a plugin installed from a URL, Check for update compares the SHA-256 hash of the archive rather than this string; a catalog install is offered a newer version from the catalog. Version it honestly either way: it is what a user sees on the plugin row, what the plugin blocklist matches against, what daintree-plugin package names the archive after, and what decides whether a remote host is offered an update.

Identity and catalog metadata

FieldTypeNotes
displayNamestringHuman-readable name in UI listings. Falls back to name. Never used for runtime lookups.
descriptionstringOne-sentence blurb. Long values are truncated in listings.
taglinestringOne-line value proposition, trimmed and capped at 120 characters. Shown under the name on the plugin row. Distinct from description: the tagline is the hook, the description is the blurb.
authorsarrayUp to 10 attribution entries, rendered as a Contributors block in the detail pane.
worksWitharrayOther plugins this one works with, by manifest id. Disclosure only. See worksWith.
categoryenumforge, ai, workspace, or other. Groups the plugin in the manager's list and catalog.
mainstringPath to the compiled ESM entry, relative to the plugin root. Optional: a plugin with only static contributions (a skill pack, a recipe pack) needs no code at all. An exported activate() must settle within 5 seconds, and host.register* calls work only until it does. A path that escapes the plugin directory is ignored.
mcpNamestringThe short name agents see this plugin's MCP server under. See mcpName.
$schemastringJSON Schema URL for editors. Accepted and ignored by the host.

authors

Each entry requires name (up to 100 characters) and accepts optional url, email, and a free-form role (up to 50 characters). Unknown keys on an entry are rejected. Because url renders as a clickable button in the detail pane it carries the same discipline as a network scope: https:// only, no embedded credentials, a multi-label public hostname, and no private or loopback hosts.

"authors": [
  { "name": "Ada Lovelace", "url": "https://ada.example.com", "role": "Maintainer" },
  { "name": "Grace Hopper", "email": "grace@example.com" }
]

worksWith

Up to 16 other plugins this one works with, by manifest id (publisher.name), built-ins included, none repeated and never the plugin itself. The Plugin Manager lists them in the detail pane with whether each is installed, turned off, or missing. Nothing is installed, activated, or ordered because of the list, and a missing plugin changes nothing about how this one runs. To call another plugin at runtime, use declared services or dispatch its actions.

"worksWith": ["acme.linear", "daintree.github"]

category

Omit it and Daintree derives one from what you contribute, checking the most identity-defining contribution first: forge providers map to forge; Element Picker providers to workspace; agents, MCP servers, skills, or agent MCP tools to ai; panels or views to workspace; anything else to other. The derivation has a fixed priority, so a plugin that contributes several kinds of thing can land in a group that does not describe it. Declare the category explicitly in that case.

mcpName

Each plugin gets one named MCP server in agent terminals, presented as daintree-<mcpName>. The value is 1 to 16 lowercase letters, digits, or hyphens, starting with a letter or digit, so the full name fits Claude Code's 25-character server key and is a bare TOML key for Codex. docs, runbooks, and decisions are taken by Daintree's own servers. It only matters for a plugin that declares databases or an agentMcp endpoint. Without it, Daintree derives the name from the last segment of name. The base name is the same in every project. When two plugins in a project resolve to the same name, installed plugins keep it before project plugins, then manifest ids in code-point order; the others get an eight-character hash suffix. See Contribution Points for the tools a plugin serves there.

Version compatibility

engines.daintree is a semver range saying which Daintree versions the plugin supports.

"engines": { "daintree": ">=0.41.0" }

The range is advisory. If the running version does not satisfy it, Daintree still loads the plugin and shows a Plugin version mismatch warning once for that plugin version and range: when the app is older than the range it suggests updating Daintree, and when it is newer it suggests checking for a newer plugin. If the field is omitted entirely, Daintree logs a console warning and loads the plugin anyway. An invalid range string is a validation error. The one exception is a project plugin that declares an application: it must declare a range, and it is not loaded at all when the range excludes the running Daintree.

Unknown keys in engines, such as node, are dropped without an error: daintree is its only recognized key.

Warning
A pre-1.0 caret such as ^0.32.0 covers only the 0.32 minor, so every later minor release draws the mismatch warning. The source scaffold uses open-ended ranges (>=0.41.0, or >=0.46.0 for the app template; the 0.1.0 scaffold on npm writes >=0.11.0), and daintree-plugin doctor warns about caret ranges. Set a minimum that actually includes the APIs you use. A permissive range does not prove compatibility.

Remote windows and platforms

Two optional fields describe where a plugin can run. Both matter mainly for remote hosts.

FieldValuesEffect
remote"supported" (the default when omitted) or "unsupported""unsupported" marks a plugin that only works for the person sitting at the machine, such as a view that assumes the window's localhost is the project's machine. It is not activated for a window attached from another machine; that window shows a placeholder instead.
platformsA non-empty, non-repeating subset of "darwin", "linux", "win32"The operating systems the package has a build for. Omit it unless the plugin ships native modules for specific systems. When one machine installs or updates the plugin on another (for example from Settings > Hosts) and the target system is not listed, the install is refused before anything is copied.

Project scope

scope and scopes are different fields. Top-level "scope": "project" declares a repository plugin. It is required under <projectRoot>/.daintree/plugins/ and rejected under installed or builtin roots. Omit it for an app-wide plugin; "global" is not a valid manifest value.

Project scope makes contributes.surfaces, "project" databases, and file editor paths available, and every other contribution it permits reaches only the owning project. It rejects menuItems, agents, processTools, mcpServers, and themes, each of which lands in an app-wide registry with no way to keep the contribution inside one project. An mcpServers entry is allowed when an agentMcp endpoint's source bridges it, because the endpoint's grants are bound to the project. It also rejects forgeProviders (their synchronous methods cannot cross the plugin worker), cloudProviders (a repository must never add something that creates machines on the user's account), projectTemplates (offered before any project exists), and canopyViews (Canopy belongs to no project). The per-point table is under Scope availability; see also Project-level Plugins.

A setting has its own scope: user, project, or local. This selects persistence and does not change plugin origin. A panel's scope (worktree or project) is different again. scopes.fs, scopes.network, and scopes.socket describe capability reach.

instanceMode

"instanceMode": "project" opts an installed package into running as one independently bound instance per project instead of one app-wide singleton. The package is installed once; each project enables it separately and gets its own instance, with its own settings, storage, databases, connections, and contributions, pinned to that project rather than to whichever one is focused. Closing, disabling, or reloading one project leaves the others loaded.

It is accepted only from the user plugins root and cannot be combined with scope. It takes the same contribution restrictions as "scope": "project", and in exchange may declare "project" databases. The features only a repository plugin has (surface claims, file editor paths and default: true, and application) still require "scope": "project". Absent means singleton, so every existing manifest behaves as before. An update cannot switch an installed package between the two modes: uninstall it first.

application

A project plugin can name itself its project's application, so the project opens as a purpose-built tool rather than as Daintree with an extra panel. The block implements nothing: it names the application and points at parts the same manifest already contributes.

"application": {
  "name": "Budget",
  "iconId": "wallet",
  "destination": "home",
  "sidebarViewId": "accounts",
  "settingsViewId": "preferences",
  "welcomeTour": { "id": "welcome", "version": 1 },
  "firstWorkflow": "record-transaction",
  "requiredTools": ["ledger"]
}
  • name (up to 64 characters) and destination ("home", which needs a surfaces.projectHome claim, or "grid") are required. arrangement: "beside-grid" opens a Home destination beside the grid.
  • sidebarViewId, settingsViewId, welcomeTour, firstWorkflow, and requiredTools each name a sidebar view, settings view, plugin tour (one with no panelKind), command of kind "command", or agent MCP endpoint the manifest declares. presentation suggests presentation levels, and navigation declares the sections the application's views navigate between.
  • It is available only with "scope": "project" and requires engines.daintree. At most one plugin in a project may declare one; a second makes the application unavailable rather than picking a winner. The user's own choices about Home and presentation always outrank its defaults.
  • While it is active, its welcome tour is offered once per project on each machine (raising welcomeTour.version offers it again), then its first workflow as a button. Nothing in this flow starts an agent, a recipe, or an install on its own.

Capabilities

The field is capabilities. The strict permissions enum this replaced is no longer accepted under that name.

The model is disclosure-first with host-side policy effects. There is no Node sandbox, so declaring nothing does not stop a plugin from doing anything, but the tokens are not merely advisory either. They are shown to the user in the detail pane, they drive danger classification on every action the plugin registers, they gate the matching host APIs, and they cap the consent tier a plugin-hosted MCP server's tools can reach. Declare honestly: this is the part of the manifest users judge you by.

TokenIntentHigh-risk
fs:project-readRead files in the current project worktree.
fs:project-writeModify files in the current project worktree. Required for a "project" database.Yes
fs:user-data-readRead from ~/.daintree/ or elsewhere in your home directory.
fs:user-data-writeWrite to ~/.daintree/ or elsewhere in your home directory.Yes
network:fetchMake outbound HTTP requests.
agent:invokeSend prompts to agents from plugin code.Yes
agent:readObserve agent state: lifecycle phase, and session cost and tokens on completion.
agent:registerRegister a launchable agent CLI as a selectable agent.Yes
agent:inputSend text to an agent terminal.Yes
agent:launch-presetLaunch an agent on one of the user's presets through agent.launch. Each preset asks once on first use, and the grant ends when the preset changes.Yes
terminal:readRead a terminal's current screen as plain text. Separate from agent:read because a screen routinely shows tokens and environment dumps, so first use asks for consent.
git:readRead git state: branches, status, log.
git:writeMake git changes: commits, branches.Yes
clipboard:readRead the system clipboard.
clipboard:writeWrite text or PNG images to the system clipboard.
shell:execSpawn subprocesses through the managed host.process surface.Yes
socket:connectConnect to local Unix-domain sockets or Windows named pipes, such as the Docker socket. Disclosure only.
mcp:exposeServe contributes.agentMcp tools to agents running in terminals. Required by that contribution; each endpoint stays off until the user enables it for a project.
project:dispatchName a target project when dispatching an action. Declaring it enables nothing on its own: the user must also turn on Allow project targeting for the plugin.
host:dispatchList the remote hosts this machine drives and run built-in actions in one. Installed app-wide plugins only, and it enables nothing until the user turns on Allow host targeting for the plugin.
panel:focus-readObserve which kind of panel has focus: the kind, whether it is an agent, and its worktree id, never a panel's id, title, URL, or content. Disclosure only.
notification:osShow an operating-system notification from host.notify. Enables nothing until the user turns on Allow OS notifications for the plugin.
artifact:storeHold large files in the host's artifact cache through host.artifacts: import, download, upload, or play one in a view, with the bytes kept in the main process.
preview:inspectRead the DOM and runtime of a previewed page through a contributed Element Picker provider. Required to declare one; it gates nothing else.

The eight marked high-risk raise every action the plugin registers to effectiveDanger: "confirm", regardless of what the action declared, unless a command's requires (below) leaves them out. The host may only raise, never lower. Read-only and trivially reversible tokens are excluded on purpose: promoting on those would over-confirm and train people to dismiss the dialog. socket:connect is excluded for a different reason: the host has no interception point for node:net, so elevating on a token it cannot enforce would buy friction without buying safety. project:dispatch and host:dispatch change where a dispatch lands, not which actions a plugin can reach, so they are not high-risk either.

A command can narrow which capabilities that derivation consults with its requires field, so one shell:exec command does not put a confirmation on your "open the panel" command. Several host APIs enforce declarations, including managed process, filesystem, Git, clipboard, system, terminal, and agent APIs. These are gates on supported host calls, not on arbitrary Node code. The full contract, including the compound-capability lattice, first-use consent, and the explicit non-guarantees, is on Trust & Capabilities.

Scopes

scopes is an optional top-level object that declares what a capability actually intends to reach. Its three buckets carry different runtime weight, and the page is explicit about which is which because pretending otherwise would be the same mistake the old permissions model made.

"scopes": {
  "network": { "allowedUrls": ["https://api.acme.com/v1"] },
  "fs":      { "allowedPaths": ["${project}/src", "/Users/me/.acme/data"] },
  "socket":  { "allowedPaths": ["/var/run/docker.sock"] }
}
BucketAcceptsRuntime weight
network.allowedUrlshttps:// URLs on multi-label public hostnames. Wildcards, embedded credentials, single-label intranet hosts, and private, loopback, or link-local targets are rejected at parse time.Live, and enforced for artifacts. A non-empty allowlist takes network:fetch out of the compound-capability rules, based on the declared target intent, and host.artifacts downloads and uploads must target a listed URL, with each download redirect checked. It does not block the plugin's own network requests.
fs.allowedPathsAbsolute paths, or the dynamic tokens ${project} and ${worktree} with an optional /sub/path suffix. Relative paths, .. segments, globs, and unknown tokens are rejected.Enforced for the host API. Every path argument to host.fs.*, host.system.openPath and showItemInFolder, and host.documents.renderPdf, and the worktree root of every host.git.* call, is realpath-resolved and contained to a declared root; traversal and symlink escapes reject with a PATH_NOT_ALLOWED: prefix. It does not seal raw node:fs.
socket.allowedPathsAbsolute Unix-domain socket paths and Windows named pipes (\\.\pipe\name). Both forms parse on every platform so a cross-platform manifest validates everywhere.Purely advisory. Nothing enforces it. It exists so the Permissions tab can say "connects to /var/run/docker.sock" instead of showing a bare token.

The host includes an implicit per-instance data root under ~/.daintree/plugin-data/; matching filesystem capabilities still apply. A project plugin, or an installed package's per-project instance, with no fs.allowedPaths defaults to its bound project root as well. Declaring that list replaces the project-root default. An app-wide installed plugin has no implicit project root. Each root has a class that decides which capability a call needs: the data root is user-data class, ${project} and ${worktree} entries are project class, and a literal path is user-data class under the home directory and project class elsewhere. Most projects live under the home directory, so reach one with a token rather than a literal path if you want the fs:project-* pair to apply. A misspelled bucket (networking rather than network) is a manifest error, not a silently dropped field.

Activation events

Plugins are lazy by default. Omit activationEvents, or pass an empty array, and Daintree defers importing main and calling activate() until one of the plugin's contributions is first used: a command dispatched, a provider asked for an answer (a declarative search provider answers without it), a panel view opened or a settings or sidebar view mounted, a view calling one of the plugin's channels, or an agent reaching the plugin's own MCP tools. Installing, updating, re-enabling, or dev-linking an app-wide plugin activates it at once.

The only recognized value is "onStartupFinished", which opts the plugin into eager activation once the app has finished starting. List it only when the plugin genuinely has to run at boot.

"activationEvents": ["onStartupFinished"]

Either way, contributions are registered eagerly from the manifest. A lazy plugin's commands, panels, and keybindings are all present before a line of its code has run: activation governs the import and the activate() call, nothing else. Twenty manifest-declared commands cost zero activation time.

A plugin that only needs to react when something happens should declare event routes rather than activate at startup to subscribe.

Event routes

eventRoutes names events that wake the plugin and run one of its own commands. The host listens on the plugin's behalf: when the event happens it activates the plugin if needed and runs the command with the event's payload. A route is not a live subscription, so a plugin that reacts only through routes can still be idled out and is woken again by its next event.

"eventRoutes": [
  { "event": "agentWaiting", "command": "onAgentWaiting" },
  { "event": "worktreeAdded", "command": "onWorktreeChange" },
  { "event": "worktreeRemoved", "command": "onWorktreeChange" }
]
EventFires whenNeeds
agentWaitingAn agent moves into waiting.agent:read
worktreeAddedThe worktree set gains a worktree.
worktreeRemovedThe worktree set loses a worktree.
projectForegroundA project comes to the foreground.

command is the bare id of a contributes.commands entry in the same manifest, not an imperatively registered action, and not one declared "danger": "confirm", since nobody is there to confirm it. Each event may be routed once. Wakes are best effort: nothing is replayed at load, bursts coalesce, a transition that reverses before its wake runs cancels it, and a failed wake is not retried. The command's argument type is PluginEventRouteWake in the SDK.

contributes

Thirty-four optional arrays plus four objects: surfaces, account, services, and assistantKnowledge. All are optional. An omitted array defaults to empty; account, connections, and assistantKnowledge stay absent when omitted. Each array has an upper bound, generous relative to any real plugin: most caps exist to reject adversarial manifests that would otherwise exhaust the registration loops, not to constrain you. A few are small on purpose, because each entry takes a place in a list the user shares with every other plugin.

KeyMaxKeyMax
commands200views50
keybindings200panels50
menuItems200skills50
contextMenus200agents50
settings200fileDecorationProviders50
toolbarButtons100recipes50
processTools100promptTemplates50
mcpServers20forgeProviders20
elementPickerProviders20launchEntries20
layouts20terminalLinks20
themes20databases16
contextProviders10fileEditors10
tours10projectTemplates10
worktreeSetupSteps10setup10
cloudProviders8connections8
searchProviders5canopyViews5
agentMcp1worktreeDeleteNotes1

The objects are bounded by their shape: surfaces has four fixed keys (emptyCanvas, projectHome, worktreeCreate, defaultLayout), and services holds two lists of at most 16. The authors array at the top level is capped at 10 and worksWith at 16. Inside a panel, menu takes at most five entries and toolbar at most three. See Contribution Points for each one.

Deprecated aliases

Two keys were renamed in the 1.0 freeze:

DeprecatedStable
experimental_viewsviews
experimental_mcpServersmcpServers

An old manifest still parses and runs identically: the deprecated key is normalized to its canonical name before validation, and the plugin service logs a one-time deprecation warning naming the replacement. If both keys are present, the canonical one wins and the deprecated one is stripped. daintree-plugin validate reports the rename as a warning. Rename them; the aliases may be removed in a future major.

Validation

The manifest is validated by Zod at load time, and validation is strict: unknown keys at the top level and unknown keys inside contributes are rejected rather than ignored. A typo cannot silently drop a contribution. Failures surface as a user-visible error naming the schema path that failed; an unknown top-level key also gets a "did you mean" suggestion when it resembles a real field. daintree-plugin validate runs the same schema locally before you package.

Beyond per-field shape, a cross-field pass rejects references that would dangle and produce a contribution that silently never fires. These are the errors that catch real mistakes:

RuleWhy it is an error rather than a runtime no-op
A panel view (location: "panel") whose id matches no panels entry.A view renders into a panel of the same id. Without one it could never be shown.
More than one location: "settings" view, or a settings, sidebar, or file editor view sharing its id with a panel.A plugin has one custom settings section, and a shared id would attach the view to the panel instead.
A sidebar view without a name, or a sidebar-only or settings-only field on another kind of view.The switcher lists a sidebar view by name, and anywhere else the field would be silently ignored.
A toolbar button that is not exactly one of a popover, an action (with an optional menu), or a non-empty menu alone; a launch entry or layout entry without exactly one target; or a command, panel, or recipe target outside your own plugin.The button or row would do nothing, or dispatch on another plugin's behalf.
A forgeProviders entry whose settingsScopeRef or viewRefs name nothing declared.The reference resolves to nothing and the wiring quietly does not happen.
A ${settings:id} token in an MCP server's command, args, or env naming an undeclared setting, or a malformed token.The supervisor substitutes only declared ids, so an unknown one resolves to an empty string and the value vanishes at spawn.
An actionId on a toolbar button, menu item, keybinding, or context menu that resolves to nothing.The contribution paints a button or binding that does nothing when invoked. Built-in ids closed to plugin dispatch are rejected too, as is an id in another plugin's namespace, and an id in your own namespace that matches no declared command, when you declared any.
A panel menu or toolbar entry naming anything other than one of your own actions, or the same action twice.Panel entries are dispatched with { panelId }, which no built-in action takes.
Duplicate id values within one contribution array.The registry is keyed on the bare id, so the second entry would silently first-lose at load.
contributes.agents without the agent:register capability, contributes.agentMcp without mcp:expose, elementPickerProviders without preview:inspect, or an account or non-empty connections without network:fetch.Each is a real side effect; the capability is what surfaces it to the user.
An event route naming an undeclared command, a "confirm" command, or the same event twice.The wake would have nothing to run, or nobody to confirm it.
A plugin agent id, or a processTools command, that collides with a built-in, or the same process-tool command declared twice.Built-ins always win at runtime, so the plugin's entry would register a detection that never fires.
A "project" database in a manifest without "scope": "project" (or "instanceMode": "project") or without fs:project-write, or a path on a "local" database. A declared query the host cannot serve safely.A project database is a file in the repository, so it needs a project to resolve against and the write capability that discloses it.
A slot-backed fileEditors entry outside a built-in plugin, or file editor paths or default: true outside a project plugin.A slot resolves out of the app's own bundle, and paths are relative to the project the plugin belongs to.
A settings field of type: "enum" with no options, a min greater than its max, extensions on any type other than file, or a default on a secret.Each would render a field that cannot be filled in correctly, a filter that does nothing, or a credential committed in plugin.json.
A surfaces slot's viewId that names no view, a settings, sidebar, or file editor view, or a PTY-backed panel, or a defaultLayout that names no layout. The same checks apply to a toolbar popover's and a Canopy view's viewId.The surface cannot render its declared component, but would still hold the slot.
A panel declaring hasPty: true with dockable: false or with toolbar entries.A PTY-backed kind renders as a terminal, which is always dockable and uses the terminal's header.
A tour whose panelKind names no panel this plugin declares.A panel tour opens from its own panel's menu.
A contribution group the plugin's scope does not allow, such as menuItems under "scope": "project" or a surface claim without it.The contribution would reach projects it should not, or have no project to belong to. See Project scope.

The retired previewTools and guestAdapters keys are now unknown keys: a manifest that still declares either is rejected from every origin. A few rules are only known when the plugin loads, so a manifest that passes daintree-plugin validate can still have a contribution refused there: a command id that collides with a built-in action is skipped and reported, and the rest of the plugin loads.

Tip
The commonest validation failures are the dull ones: a name missing its period, uppercase in the id, an engines.daintree that is not a valid range, a capability token that is not in the list above, and contribute written for contributes. Run daintree-plugin validate before you package and none of them reach a user.

For exact fields and generated editor schemas, use the authoritative Zod schema and its cross-field validators, the installed-plugin JSON Schema, or the project-plugin JSON Schema. The CLI also prints them with daintree-plugin schema, schema --project, and schema --out <file>. All links point to the November 20, 2026 revision this page was checked against.