@jini-ai/agent-plugins 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+## Unreleased — lifecycle consumer adoption
+
+- Expose narrow `createAgentPluginActivations(required, optional)` composition without
+  requiring unrelated network, layout or federation ports.
+- Supply raw transport entries to the optional metadata reader, including servers with
+  no declared extension, so hosts can translate legacy fields through the shared validators.
+  Malformed declared extensions still exclude the server before translation.
+- Preserve the original lifecycle validation, integrity, streaming, symlink and durability
+  rationale alongside the canonical implementations; move the URL-install real-HTTP/ZIP
+  integration suite into the package and add paired metadata-translation regression cases.
+
+
+## Unreleased — lifecycle test compilation
+
+- Preserve copied test timeouts and conditional skips through Vitest registration.
+- Match the native process signal mock type, retain assertion-based result narrowing, and allow explicitly unset delivery-mode environment fixtures.
+
+## 0.4.0 — 2026-10-02
+
+### BREAKING
+
+- Generic locking moved to platform/fs/file-lock, lifecycle ports use core primitives, and the product-specific theme plugin was evicted. The neutral ui-ux-design plugin remains bundled.
+- Distribution includes runtime output, release documentation and required assets only. Process records and per-job neutrality checks are no longer part of the package surface.
+
+## Unreleased — canonical lifecycle effects
+
+### BREAKING
+
+- Product-specific theme assets are no longer bundled or exported; products own these assets.
+- Remove the local exclusive lock, lock passthroughs/errors/constants from lifecycle, and filesystem/handle wrapper factory/types. Use platform locks directly.
+- Lifecycle accepts native fs/promises operations and FileHandles. Clocks extend core Clock (`nowMs()`), IDs extend IdGenerator (`newId()`) with random().
+
+### Changed
+
+- Activation explicitly retains 15000ms timeout and 10000ms staleness through the shared lock; polling is now fixed at 10ms and timeout uses core wall-clock elapsed time.
+- Shared ownership checks bind token and inode/device; release preserves failed critical-section errors.
+- Native liveness treats only ESRCH as death; unknown probe failures never authorize stale-owner eviction.
+- Archive-error specification now matches safe generic transport/body causes and redacted URL diagnostics.
+
+
+## Unreleased
+
+- Add the host-injected plugin lifecycle on `./lifecycle`: archive installation, activation and locks, bundled digests and seeding/retirement, trusted files, reference resolution and local ranking.
+- Add typed Agent Plugins 1.0.0 manifest extension readers on `./manifest`, with a required namespace and optional host metadata translation. Inline transport fields cannot supply reviewed read metadata.
+- Add explicit MCP provisioning ports and helpers. Federation stays in the host; this package has no dependency on `@jini-ai/mcp`.
+- Add opt-in native effects (`./lifecycle/node`) and a yauzl adapter (`./lifecycle/yauzl`) with an optional peer, supplied by the host.
+- Preserve existing exports and the package version. Tests and verification are deferred by owner directive.
+
+- Integrate `./manifest`, `./lifecycle`, `./lifecycle/node` and `./lifecycle/yauzl` barrels and runtime metadata; add object structural validators to the root/manifest and an instrumentable node filesystem adapter.
+- Preserve standard object-shaped manifest authors and legacy string authors; remove the malformed optional archive-entry union and module-namespace type.
+- BREAKING (new lifecycle APIs): filesystem and file-handle ports, fetch ports, archive entries/readers, lifecycle error constructors and callbacks now accept required/optional objects. Callers of the unpublished extraction must update their adapters.
+- BREAKING (new lifecycle APIs): optional lifecycle observers/translators, MCP pluginManifest, digest clock overrides and trusted-file query options belong in the second object. Legacy root validator signatures and all existing export names remain available.
+
+- Restore ten real-ZIP lifecycle parity cases using the actual optional yauzl peer and a test-only yazl writer; retain injected-reader tests and add malformed-archive coverage.
+- Redact credentials, query strings and fragments from archive failure diagnostics. Unparseable URLs use a fixed placeholder; transport messages/causes use safe text, body transport errors use `REQUEST_FAILED`, and HTTP reason phrases use standard status labels.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Open Design contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,261 @@
+# `@jini-ai/agent-plugins`
+
+> **Leon, this is you from the past. Do not try to merge `plugins` and `agent-plugins`.**
+
+Support for **Agent Plugins**, an open, vendor-neutral spec (v1.0.0, published 2026-08-06) for
+bundling Agent Skills and MCP servers into one portable directory. Published by a Technical
+Steering Committee with maintainers from Amazon, Cursor, Google, Microsoft, OpenAI, and Vercel.
+Source: https://developers.googleblog.com/agent-plugins-package-your-skills-tools-and-more/
+
+If you are an agent reading this cold: this document is written so you don't need the source
+article to understand the shape of a plugin or what this package provides. `PluginManifest` and
+`McpManifest` (exported from the package root) type every field confirmed against the published
+schemas (`AGENT_PLUGINS_SCHEMA_URL`, `AGENT_PLUGINS_MCP_SCHEMA_URL`), not inferred — both still
+carry an index signature in case a future schema revision adds a field neither type has caught up
+to yet.
+
+**Extracted 2026-08-18** from `@jini-ai/plugins`, where this content used to live nested under a
+`./agent-plugins` subpath. That package now only reserves the unrelated, unimplemented `./host`
+format (Jini's own host-extension plugin system — a different concept entirely, see "Not this
+package" below) — everything Agent-Plugins-shaped moved here, one level up, since there was no
+longer a second format sharing the namespace to disambiguate against.
+
+## The problem this solves
+
+Before this spec, shipping the same skill or MCP server to multiple agent clients meant
+maintaining incompatible copies — every client used a different manifest format and directory
+layout ("fork and drift"). Agent Plugins standardizes the packaging format only; each client still
+decides its own install mechanism, permission model, and sandboxing.
+
+## What a plugin looks like on disk
+
+A plugin is a directory. Example (this package's own bundled plugin, `ui-ux-design/`):
+
+```
+ui-ux-design/
+├── plugin.json                       # manifest — minimally { "$schema": ..., "name": "ui-ux-design" }
+├── mcp.json                          # MCP server declarations (empty here — example only)
+├── skills/
+│   └── <skill-name>/
+│       ├── SKILL.md                  # Agent Skills format: frontmatter (name, description) + body
+│       ├── references/               # optional supporting docs the skill body links out to
+│       ├── examples/                 # optional
+│       └── scripts/                  # optional
+└── com.anthropic.claude-code/        # client extension directory (§8.2) — example only
+    └── hooks/
+        └── hooks.json
+```
+
+`plugin.json` optional fields beyond `$schema`/`name`: `version`, `description`, `author`
+(`{name, email, url}`), `homepage`, `repository`, `license`, `keywords` (string array), and
+`extensions` — an object keyed by reverse-domain client namespace (e.g. `com.example.client`) for
+client-specific data the schema assigns no semantics to.
+
+`mcp.json` declares MCP servers under `mcpServers`, one of three explicit transport shapes — no
+guessing which one a client should assume:
+
+```json
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {
+    "local-validator": {
+      "type": "stdio",
+      "command": "./bin/validator",
+      "args": ["--data", "${PLUGIN_DATA}/validator"],
+      "env": { "CONFIG": "${PLUGIN_ROOT}/config.json" },
+      "cwd": "${PLUGIN_ROOT}"
+    },
+    "deployment-api": {
+      "type": "streamable-http",
+      "url": "https://deploy.example.com/mcp",
+      "headers": { "X-Tenant": "public-tenant" }
+    },
+    "legacy-events": {
+      "type": "sse",
+      "url": "https://legacy.example.com/sse"
+    }
+  }
+}
+```
+
+`ui-ux-design/mcp.json` ships with an empty `mcpServers: {}` — a valid, working
+example of the file's shape, not a real server declaration. Replace it (or delete it — `mcp.json`
+is optional) the moment this plugin actually needs one.
+
+A plugin can also have reverse-domain-namespaced directories at its root — §8.2 of the
+specification: "the extension directory for a namespace is the top-level directory named after
+it," contents entirely client-defined, and clients that don't recognize a namespace simply ignore
+it. The spec's own example is `com.example.client/hooks/hooks.json` — using `example.com` the same
+way an RFC does, since the spec assigns no real namespace to any actual client and publishes no
+namespace registry. `ui-ux-design/com.anthropic.claude-code/hooks/hooks.json`
+follows the same shape with a real client substituted in: `com.anthropic.claude-code` is a
+plausible reverse-DNS guess (Anthropic controls `anthropic.com`; Claude Code is the client this
+whole package was built inside), **not** a confirmed or registered identifier — nothing publishes
+one. Content is illustrative only, per the same "no portable semantics" rule.
+
+Discovery (how a client finds/installs a plugin in the first place) is explicitly out of scope for
+the packaging spec itself — it lives in separate layers (Agentic Resource Discovery, an AI
+Catalog format) that this package does not implement.
+
+## What's in this package
+
+| export | runtime | contents |
+|---|---|---|
+| `.` (root) | universal | `PluginManifest`/`McpManifest` types, `validatePluginManifest({ value })`/`validateMcpManifest({ value })` structural validators (plus compatible `isPluginManifest(value)`/`isMcpManifest(value)` wrappers), and the known path constants (`PLUGIN_MANIFEST_FILENAME`, `PLUGIN_SKILLS_DIRNAME`, `PLUGIN_MCP_MANIFEST_FILENAME`). No filesystem access, no DOM. |
+| `./manifest` | universal | Strict manifest/MCP parsing and typed namespace readers; object structural validators are also re-exported here. |
+| `./lifecycle` | node | Host-injected installation, activation, locks, digests, bundles, trusted files, reference resolution, ranking and MCP provisioning helpers. |
+| `./lifecycle/node` | node | `createNodeAgentPluginEffects({})` opt-in native effects. |
+| `./lifecycle/yauzl` | node | `createYauzlAgentPluginArchiveReader({ yauzl })`; the host supplies the optional peer library. |
+| `./ui-ux-design/*` | — | Raw files of the bundled `ui-ux-design` plugin — static JSON/Markdown, not run through the TS build. |
+
+The universal root handles structural validation. The separate Node lifecycle entry implements
+local archive installation and host-owned activation policy; it does not implement remote catalog discovery.
+
+## Not this package: `@jini-ai/plugins` (`./host`)
+
+`@jini-ai/plugins` is a **different, sibling package** — Jini's own host-extension plugin format
+(manifest + `setup()` + hooks + activation), unrelated to the third-party Agent Plugins spec this
+package supports. Do not confuse the two — "agent plugins" (this package, a
+public spec) and "Jini plugins" (`@jini-ai/plugins`'s `./host`, Jini's own unbuilt format) share
+the word "plugin" and nothing else.
+
+## Bundled plugins
+
+Real, install-ready plugin directories shipped alongside the code — not illustrative examples.
+Each lives at the package root under **its own name** (`ui-ux-design/`).
+Plugins live at the package root rather than inside `src/` because `src/` is the TypeScript
+compile root (`rootDir: "src"`, `include: ["src"]`) — a plugin's skill trees can carry files
+(`.tsx` examples, etc.) that are illustrative content, not package code, and putting them under
+`src/` makes `tsc` try to compile them (measured, on `ui-ux-design`: 207 errors from the three
+`shadcn-ui/examples/*.tsx` files alone). Static content and compiler input are kept in separate
+trees on purpose.
+
+### `ui-ux-design/`
+
+Bundles the AI-Dev-Shop Web Design agent's full skill set (per its `agents/web-design/skills.md`
+persona and the `framework/routing/skills-registry.md` ownership mapping) into one portable plugin:
+
+- `ui-ux-design` — design-foundations (tokens, typography, spacing, breakpoints, component state
+  matrix) *and* first-impression polish, scanning hierarchy, conversion-focused visual signals —
+  one skill, not two. AI-Dev-Shop merged its former separate `ux-design` and `premium-ui` skills
+  into this single `ui-ux-design` skill; this sample tracks that merge instead of carrying the two
+  predecessor skills as stale copies (see git history for the 2026-08-12 consolidation).
+- `interface-design` — repeatable, memory-consistent visual systems for dashboards/admin panels/apps
+- `gstack-design` — manual four-mode workflow (consultation, shotgun, html, review)
+- `frontend-accessibility` — WCAG 2.1 AA checklist
+- `vercel-web-design-guidelines` — Vercel Web Interface Guidelines auditor
+- `shadcn-ui` — shadcn/ui (Radix + Tailwind) component discovery/integration guidance
+- `web-compliance` — legal/compliance checkpoints for public-facing UX flows
+
+Each skill directory is a verbatim copy of the corresponding `AI-Dev-Shop/skills/<name>/` tree —
+copied rather than referenced, because the whole point of a plugin is that it is self-contained and
+portable to a host that has never heard of AI-Dev-Shop. `AI-Dev-Shop/agents/web-design/skills.md`
+itself (the persona that composes these skills into one role) is not bundled — it is ADS-specific
+routing glue, not a portable skill.
+
+Consumers may read bundled raw assets through the public wildcard subpath. Product-specific
+plugin assets are owned and shipped by their product, outside this library.
+
+## Scripts
+
+```bash
+pnpm --filter @jini-ai/agent-plugins build
+pnpm --filter @jini-ai/agent-plugins typecheck
+pnpm --filter @jini-ai/agent-plugins test
+```
+
+The build and typecheck include lifecycle test sources. Copied Node test options are
+translated to Vitest registration, preserving per-test timeouts and platform skip conditions.
+
+## Adding another bundled plugin
+
+1. Create `<plugin-name>/plugin.json` at the package root with at least
+   `{ "$schema": AGENT_PLUGINS_SCHEMA_URL, "name": "<plugin-name>" }`. Do **not** put it under
+   `src/` — see "Bundled plugins" above for why.
+2. Add `<plugin-name>/skills/<skill-name>/SKILL.md` per skill (plus any `references/`,
+   `examples/`, `scripts/` the skill needs).
+3. Register it in `package.json`: an `exports` key `"./<plugin-name>/*": "./<plugin-name>/*"`, a
+   matching `jini.entries` key (the R8 guard requires every export to have one), and a
+   `files` entry.
+4. Add coverage in `src/__tests__/manifest.test.ts` following the `ui-ux-design plugin` block — assert the manifest validates and the expected skill
+   directories exist.
+
+## Lifecycle API and ports
+
+New public callables use `(requiredArgs, optionalArgs)`, with effects supplied as ports.
+Create and retain one lifecycle per host context:
+
+```ts
+import { createAgentPluginLifecycle, createAgentPluginLayout } from '@jini-ai/agent-plugins/lifecycle';
+import { createNodeAgentPluginEffects } from '@jini-ai/agent-plugins/lifecycle/node';
+
+const layout = createAgentPluginLayout({ root: pluginRoot });
+const lifecycle = createAgentPluginLifecycle({
+  ...createNodeAgentPluginEffects({}),
+  layout,
+  productName,
+  extensionNamespace,
+  bundledArchiveMagic,
+  deliveryMode,
+  seededEnabledPluginIds,
+  retiredBundledPlugins,
+  formatPluginToolPointer,
+  mcpProvisioning,
+  outboundGuard,
+  fetch: ({ url }, options) => fetch(url, options),
+}, { onEvent, readServerMetadata });
+
+const downloaded = await lifecycle.fetchAgentPluginArchive({ url }, { signal });
+const installed = await lifecycle.installAgentPlugin({
+  archive: downloaded.archive,
+  expectedSha256: downloaded.sha256,
+  archiveReader,
+  layout,
+  workspaceId,
+});
+```
+
+All names in the example are supplied by the host. There is no default storage root,
+namespace, product name, bundle policy or archive framing. Preserve your existing framing
+when adopting the package. Prefer pinned hashes for remote installations; trust-on-first-use
+is an explicit choice in `installAgentPluginFromUrl`.
+
+Filesystem effects use native `node:fs/promises` signatures and native FileHandles. Inject
+instrumented native effects directly through `filesystem`; `createNodeAgentPluginEffects({})`
+provides the default. Clocks extend core `Clock` with `monotonicMs()` and `sleep({ ms })`;
+IDs extend core `IdGenerator` with `random()`.
+
+Generic locks are imported directly from `@jini-ai/platform/fs/file-lock`. Lifecycle activation
+uses `withFileLock({ lockPath, run }, { timeoutMs: 15000, staleMs: 10000, pollMs: 10, ...effects })`.
+Lock helpers, errors and constants are no longer members/exports of the lifecycle API.
+
+Archive readers implement `entries({ archive })`; file entries expose `openReadStream({})`.
+`createYauzlAgentPluginArchiveReader({ yauzl })` accepts the native library protocol explicitly;
+no peer library is imported by the core. Fetch ports implement `fetch({ url }, requestOptions)`.
+The outbound guard runs before every request and redirect. The host's fetch adapter must
+pin DNS if its security policy requires protection against DNS rebinding.
+
+Public callbacks also receive objects: `pluginIdOf({ item })`, `run({ lock })`,
+`isProcessAlive({ pid })`, `onStaleLockRemoved({ holder })`, `onInactive({ plugin })`
+and `now({})`. Lock ownership checks use `lock.assertHeld({})`. Constructors receive
+named fields, for example `new AgentPluginInstallError({ code, message }, { cause })`.
+`recordBundledAgentPluginDigests` accepts the clock override in its second object;
+`findTrustedPluginPackages` accepts `orderByPluginId` and `onInactive` in its second object.
+
+`parseAgentPluginMcpConfig({ value, extensionNamespace }, { pluginManifest, readServerMetadata })`
+accepts optional namespace metadata separately. Strict parsing preserves standard object
+shaped authors and older string authors. Inline transport fields never become reviewed-read
+metadata. MCP provisioning helpers delegate to the host and notify only after success;
+filesystem installation and federation remain separate operations with host-owned recovery.
+
+The legacy root validators keep their positional shape and behavior. New code can use the
+object-shaped `validatePluginManifest` and `validateMcpManifest` facades. Internal composition
+factories are implementation details and are not package exports.
+
+See [integration-extraction.md](integration-extraction.md) for the reconciliation, source mapping,
+rewire ledger and verification commands. All verification is deferred by owner directive.
+
+For a host that needs only activation, use `createAgentPluginActivations` with
+`createNodeAgentPluginEffects({})` instead of supplying unused network/provisioning
+ports. Retain one returned object for the process lifetime. See `API.md` for the
+object-shaped reads, filters and optional legacy metadata reader.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { AGENT_PLUGINS_MCP_SCHEMA_URL, AGENT_PLUGINS_SCHEMA_URL, PLUGIN_MANIFEST_FILENAME, PLUGIN_MCP_MANIFEST_FILENAME, PLUGIN_SKILLS_DIRNAME, isMcpManifest, isPluginManifest, validatePluginManifest, validateMcpManifest, } from './manifest.js';
+export type { McpManifest, McpServerEntry, PluginManifest, PluginManifestAuthor } from './manifest.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export { AGENT_PLUGINS_MCP_SCHEMA_URL, AGENT_PLUGINS_SCHEMA_URL, PLUGIN_MANIFEST_FILENAME, PLUGIN_MCP_MANIFEST_FILENAME, PLUGIN_SKILLS_DIRNAME, isMcpManifest, isPluginManifest, validatePluginManifest, validateMcpManifest, } from './manifest.js';
+//# sourceMappingURL=index.js.map