@jini-ai/admin 0.3.9 → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+## 0.4.0 — 2026-10-02
+
+### BREAKING
+
+- Shell copy is host-neutral and public APIs use object argument contracts; theme/process handoffs are archived.
+- 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
+
+- Fix strict compilation of entity tables and integration/session test fixtures
+  with explicit row, deferred-promise and tuple types. Runtime behavior and test
+  assertions are unchanged.
+
+- Replace the removed connector integration import guidance with host-owned connector ports. Keep the allowed React agentic helpers in their original package.
+
+- Adopt shared kernel contracts and preserve the module rationale in neutral documentation.
+
+
+- Complete object-argument calls in Sidebar, RowMenu and ConfirmDialog, preserving
+  preferences, routing, tone precedence, selection and agent handle behavior.
+- Merge every per-request `HeadersInit` form through `Headers`, with case-insensitive
+  overrides and no input mutation. Clarify host-owned route factories, restore
+  ceremony inputs and the need for a host restore capability before offering media undo.
+- Add caller and header regression tests; execution is deferred by owner directive.
+
+- Restore the HTTP transport's 60-second deadline with a `timeoutMs` override and
+  caller-signal precedence. Restore typed network/timeout and unparseable-5xx
+  failures with neutral API messages; inject page-unload detection through the host.
+- Expose success response headers through `request`'s optional `onOk({ response })`
+  observer, preserving JSON return values for ETag / If-Match route adapters.
+- Honor `defaultPanelId` in dashboard navigation and agent-page maps while keeping
+  the conventional dashboard-root default. Clear local authentication after failed
+  logout so a session-error retry cannot restore the old principal.
+- Add regression tests for these audit fixes; execution is deferred by owner directive.
+
+- Add a manifest-driven AdminShell with injected session/navigation ports, host API
+  and workspace scope, feature contributions and persistent assistant-pane slots.
+- Add a query-preserving shell navigation adapter and generalized shell regression
+  tests. Barrel/subpath wiring and verification remain coordinator follow-ups.
+
+### Admin extraction integration
+
+- Wire `./react/shell`, `./react/entities`, and `./browser/shell-navigation` with
+  browser runtime metadata, and expose their APIs through the existing barrels.
+  Export the framework-free shell contracts from the core and ports barrels.
+- Add generic entity index, list, detail and create/edit screens over the entity
+  port, with injected translation/navigation and AdminShell route contributions.
+- BREAKING: Admin helpers, error constructors, client/transport factories, browser
+  navigation and converted service-port methods now take required and optional
+  argument objects. Fetch, browser and preference persistence dependencies are
+  injected ports. Pass `{}` for input-free and optional-only service-port methods,
+  and update custom route factories and injected component hooks.
+- Integration verification is pending. The active Sidebar/RowMenu and entity/menu
+  port owners must finish their remaining convention changes before release.
+- BREAKING: Embed marker helpers take `{ el }`; the React editor adapts these
+  object APIs to the upstream editor callback contracts without changing markers.

package/README.md

@@ -17,8 +17,10 @@ not in your bundle.
 |---|---|---|
 | `@jini-ai/admin/core` | contracts, panel registry, route matching, transport, ports | nothing |
 | `@jini-ai/admin/browser` | `window`-bound navigation, link interception | a DOM |
-| `@jini-ai/admin/server` | Composio integration: catalog, OAuth, tool execution | Node.js |
-| `@jini-ai/admin/react` | Presentational primitives (`Sidebar`, `DataTable`, `RowMenu`, `ConfirmButton`, `ConfirmDialog`, `InteractiveHtmlEditor`) and hooks; `<AdminShell>` and panels are not built yet | React (optional peer) |
+| `@jini-ai/admin/react` | Primitives, hooks, shell and entity screens | React and React DOM (optional peers) |
+| `@jini-ai/admin/react/shell` | Session gate, panel rendering and persistent assistant slot | React and injected session/navigation |
+| `@jini-ai/admin/react/entities` | Schema-driven index, list, detail and create/edit screens | React and injected registry/translation/navigation |
+| `@jini-ai/admin/browser/shell-navigation` | Query-preserving History API adapter for the shell | Injected browser window/document/location |
 
 `/core` is the layer a panel author codes against: no React, no DOM, no I/O. That boundary is
 enforced at runtime — this package's vitest config runs `src/core/**` without a jsdom environment,
@@ -60,10 +62,10 @@ Three properties carry decisions worth not re-deriving:
 ```ts
 import { resolvePanels, buildNav, buildAgentPageMap, matchRoute } from '@jini-ai/admin/core';
 
-const mounted   = resolvePanels(ALL_PANELS, { capabilities: wiredPorts, permissions: me.permissions });
-const nav       = buildNav(mounted);
-const agentPages = buildAgentPageMap(mounted);   // pass the RESOLVED set, never the raw one
-const route     = matchRoute('/users/u1', mounted);
+const mounted   = resolvePanels({ panels: ALL_PANELS }, { capabilities: wiredPorts, permissions: me.permissions });
+const nav       = buildNav({ panels: mounted });
+const agentPages = buildAgentPageMap({ panels: mounted });   // pass the RESOLVED set, never the raw one
+const route     = matchRoute({ routePath: '/users/u1', panels: mounted });
 // -> { panelId: 'users', view: 'user-detail', params: { userId: 'u1' }, query }
 ```
 
@@ -71,31 +73,28 @@ Route matching is registry-driven: a panel declares its own detail routes and th
 generic. Unregistered paths return `panelId: null` so the shell can fall through to the dashboard,
 matching the ported behaviour — a typo should look like a bad URL, not an empty screen.
 
-## Adding your own routes alongside the shipped ones
+## Adding host routes
 
-Every route group is `(transport) => port`. Jini's and yours are the same shape, so they compose
-into one client with one auth policy, one error class, and one place to add retries or tracing:
+Route groups are host-owned factories taking `({ transport })`. The package ships
+contracts and an HTTP transport; it does not ship identity or media route factories.
 
 ```ts
 import { createAdminClient, createHttpTransport } from '@jini-ai/admin/core';
 
-const transport = createHttpTransport({ baseUrl: '/api/admin/v1' });
-
-const client = createAdminClient(transport, {
-  identity: createIdentityRoutes,   // shipped by @jini-ai/admin
-  media:    createMediaRoutes,      // shipped by @jini-ai/admin
-  posts:    createHostPostRoutes,   // yours, same signature
-  widgets:  createHostWidgetRoutes, // yours
+const transport = createHttpTransport({
+  baseUrl: '/api/admin/v1',
+  fetch: ({ url }, init) => fetch(url, init),
 });
-
-await client.identity.listUsers();
-await client.posts.list();
-await client.transport.request('/one-off');   // escape hatch for un-wrapped routes
+const createStatusRoutes = ({ transport }) => ({
+  read: ({}) => transport.request({ path: '/status' }),
+});
+const client = createAdminClient({ transport, groups: { status: createStatusRoutes } });
+await client.status.read({});
+await client.transport.request({ path: '/one-off' });
 ```
 
-`AdminTransport` is an interface rather than a bare function so a host can supply a non-HTTP
-implementation — an in-process direct dispatch for a multi-instance runner, or a fixture-returning
-fake in tests — without any route group knowing.
+`AdminTransport` also supports non-HTTP adapters. Hosts bind authentication,
+workspace scope and error handling at that boundary.
 
 ## Errors
 
@@ -111,14 +110,13 @@ the server. A bug here can only show or hide a control; it cannot grant or block
 operation, because every mutation must be independently re-checked server-side. Do not import
 these into server code.
 
-## Composio integration has moved
+## Connector integrations
 
-`@jini-ai/admin/server` no longer exists. Composio started as its own standalone package
-(`@jini-ai/composio`), was folded into this package as `./server` on 2026-08-01, and has since
-moved back out — now `@jini-ai/integrations/composio`, one of two subpaths (alongside
-`@jini-ai/integrations/media-providers`) under the single `@jini-ai/integrations` package
-(`packages/integrations/`). See that package's own `README.md` and `src/composio/source-map.md`
-for full provenance. Import it directly rather than through `@jini-ai/admin`.
+`@jini-ai/admin/server` no longer exists. The former embedded connector backend
+was extracted and subsequently removed by the owner. Hosts supply connector data
+and authorization through the UI ports; there is no built-in connector vendor
+adapter to import. See `@jini-ai/integrations` for the supported webhook and
+media-provider capabilities.
 
 ## Before writing a panel: check `@jini-ai/ui-core` first
 
@@ -131,11 +129,47 @@ Panels that reuse `ui-core` take the dependency in `/react/panels/*`. **`/core`
 zero-dependency** — otherwise every consumer of the contracts layer pulls in 6,000+ lines of
 unrelated domain features to get a type.
 
-## Status
+## API arguments and integration status
+
+Public helpers and factories take a required argument object and an optional
+options object. Pass `{}` before optional-only arguments. React props and native
+framework callbacks retain their framework contracts.
+
+```ts
+hasPermission({ permissions, permission: 'records.read' });
+adminHref({ routePath: '/records' }, { base: '/console' });
+new AdminApiError({ message: 'Unavailable', status: 503 }, { code: 'unavailable' });
+createAdminShellNavigation({ location: window.location, window, document });
+```
+
+The shell requires `apiBase`, `workspace`, `adminBase`, `defaultPanelId`,
+`railStorageKey`, title, labels, session/navigation ports, panels and slots. A host
+supplies every product value. Its session port exposes `read(context)`,
+`logout(context)` and `onUnauthenticated({ ...context, onUnauthenticated })`.
+
+Entity screens consume the existing entity port through `EntityRegistryPort` and
+require translation and navigation ports. `createEntityPanel({ adminBase,
+panelId, navigate, registry, translate }, options)` returns an `AdminShellPanel`.
+It contributes list, create, detail and edit routes; agent reachability is opt-in.
+Its translation port takes `{ key }`, and `navigate` takes `{ routePath }`.
+
+The HTML editor's direct marker helpers take `{ el }`; its React component adapts
+those calls to the upstream editor callbacks. Marker bytes and labels are unchanged.
+
+The export map and barrels include all these slices. The package typecheck includes
+test sources and passes after the upstream agentic and UI declarations are rebuilt.
+Runtime tests and packing remain deferred under the owner's execution directive. Active owners
+must still update Sidebar/RowMenu callers and the entity/menu port APIs before the
+package can be released. The integration handoff records the remaining changes.
+
+## Kernel contracts
+
+Admin editor and menu contracts document host integration without repository-specific paths.
+`RedirectMatchType` retains `regex` because callers can submit that rejected request shape;
+its presence does not imply matcher support. Hosts must verify support before offering it.
+
+## Agent-addressable React controls
 
-Slice 1: `/core` (75 tests) and `/browser` (no test files). `/server` (Composio, folded in
-2026-08-01, moved back out to `@jini-ai/integrations/composio`) no longer exists in this package.
-`/react` has real content — presentational primitives and hooks (147 tests) — but no `<AdminShell>`
-or panels yet. `src/core/ports/` now specifies 16 ports (`identity`, `menus`, `integrations`,
-`workspace`, `redirects`, `analytics`, `settings`, `forms`, `seo`, `database`, `members`,
-`recovery`, `auth`, `media`, `plugins`, `comments`), not just `AdminIdentityPort`.
+React controls keep importing `agentHandle` and `buildAgentListHandles` from
+`@jini-ai/agentic`; this is an allowed UI-to-agentic layer dependency. The helpers
+have not moved and consumers continue to use their original exports.

package/dist/agent-plugins/adapters/http.d.ts

@@ -0,0 +1,7 @@
+import type { AgentPluginsApiPort, AgentPluginsTransportPort } from '../ports.js';
+/** Existing workspace routes. Auth, JSON serialization and response decoding belong to transport. */
+export declare function createHttpAgentPluginsApi({ transport, workspacePath }: {
+    transport: AgentPluginsTransportPort;
+    workspacePath: string;
+}, _optional?: {}): AgentPluginsApiPort;
+//# sourceMappingURL=http.d.ts.map

package/dist/agent-plugins/adapters/http.js

@@ -0,0 +1,15 @@
+import { agentPluginSummary, agentPluginFilesSnapshot } from '../rules.js';
+/** Existing workspace routes. Auth, JSON serialization and response decoding belong to transport. */
+export function createHttpAgentPluginsApi({ transport, workspacePath }, _optional = {}) {
+    const base = `${workspacePath.replace(/\/$/, '')}/agent-plugins`;
+    function request(suffix, method, options, body) {
+        options.signal?.throwIfAborted();
+        return transport.request({ path: `${base}${suffix}`, method, ...(body === undefined ? {} : { body }) }, options);
+    }
+    return {
+        async list(_required, options = {}) { const r = await request('', 'GET', options); return Object.freeze(r.agentPlugins.map(row => agentPluginSummary({ row }))); },
+        async setEnabled({ pluginId, enabled }, options = {}) { const r = await request(`/${encodeURIComponent(pluginId)}`, 'PATCH', options, { enabled }); return agentPluginSummary({ row: r.agentPlugin }); },
+        async files({ pluginId }, options = {}) { const r = await request(`/${encodeURIComponent(pluginId)}/files`, 'GET', options); return agentPluginFilesSnapshot({ listing: r }); },
+    };
+}
+//# sourceMappingURL=http.js.map

package/dist/agent-plugins/adapters/memory.d.ts

@@ -0,0 +1,8 @@
+import type { AgentPluginsApiPort } from '../ports.js';
+import type { AgentPluginSummary, AgentPluginFiles } from '../models.js';
+/** Presentation backend only. No lifecycle install, trust, activation-file or MCP rules copied. */
+export declare function createMemoryAgentPluginsApi({ plugins, files }: {
+    plugins?: readonly AgentPluginSummary[];
+    files?: Readonly<Record<string, AgentPluginFiles>>;
+}, _optional?: {}): AgentPluginsApiPort;
+//# sourceMappingURL=memory.d.ts.map

package/dist/agent-plugins/adapters/memory.js

@@ -0,0 +1,25 @@
+import { agentPluginSummary, agentPluginFilesSnapshot } from '../rules.js';
+/** Presentation backend only. No lifecycle install, trust, activation-file or MCP rules copied. */
+export function createMemoryAgentPluginsApi({ plugins = [], files = {} }, _optional = {}) {
+    const rows = new Map(plugins.map(row => [row.pluginId, agentPluginSummary({ row })]));
+    const listings = new Map(Object.entries(files).map(([id, listing]) => [id, agentPluginFilesSnapshot({ listing })]));
+    function notFound() { throw Object.assign(new Error('Agent plugin not found'), { code: 'AGENT_PLUGIN_NOT_FOUND' }); }
+    return {
+        async list(_required, options = {}) { options.signal?.throwIfAborted(); return Object.freeze([...rows.values()]); },
+        async setEnabled({ pluginId, enabled }, options = {}) {
+            options.signal?.throwIfAborted();
+            if (typeof enabled !== 'boolean')
+                throw Object.assign(new Error('Invalid activation'), { code: 'VALIDATION_ERROR' });
+            const row = rows.get(pluginId);
+            if (!row)
+                return notFound();
+            const updated = agentPluginSummary({ row: { ...row, enabled } });
+            rows.set(pluginId, updated);
+            return updated;
+        },
+        async files({ pluginId }, options = {}) { options.signal?.throwIfAborted(); if (!rows.has(pluginId))
+            return notFound(); const listing = listings.get(pluginId); if (!listing)
+            return agentPluginFilesSnapshot({ listing: { pluginId, files: [], truncated: false, limits: { maxFiles: 200, maxEntries: 2000, maxFileBytes: 524288, maxTotalBytes: 4194304 } } }); return listing; },
+    };
+}
+//# sourceMappingURL=memory.js.map

package/dist/agent-plugins/agent-plugins.module.d.ts

@@ -0,0 +1,51 @@
+export declare const agentPluginsModule: {
+    readonly id: "agent-plugins";
+    readonly requires: {
+        readonly agentPluginsApi: import("../core/module/token.js").AdminPortToken<import("./ports.js").AgentPluginsApiPort, "admin.agent-plugins.api">;
+    };
+    readonly messages: {
+        readonly title: "Agent Plugins";
+        readonly installed: "Installed";
+        readonly downloaded: "Downloaded";
+        readonly marketplace: "Marketplace";
+        readonly description: "Portable packages installed for this workspace.";
+        readonly denied: "Permission denied";
+        readonly loading: "Loading Agent Plugins…";
+        readonly empty: "No Agent Plugins are installed in this workspace.";
+        readonly loadError: "Failed to load agent plugins";
+        readonly actionError: "Failed to update agent plugin";
+        readonly fileError: "Failed to load package files";
+        readonly filesLoading: "Loading package files…";
+        readonly filesEmpty: "No files to show for this plugin.";
+        readonly filesTruncated: "Some files are not listed: this package is larger than the viewer’s limits.";
+        readonly installedLede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt.";
+        readonly downloadedLede: "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
+        readonly uninstallUnavailable: "Uninstall is unavailable in this view. Package removal is managed by the host.";
+        readonly marketplaceTitle: "Nothing to browse yet";
+        readonly marketplaceDescription: "Marketplace is planned for a future release. This view does not fetch, install, or list marketplace packages yet.";
+        readonly marketplaceHint: "Until then, the Downloaded tab lists the packages available in this workspace.";
+    };
+    readonly pages: {
+        readonly agentPlugins: {
+            readonly path: "/agent-plugins";
+            readonly label: "Agent Plugins";
+            readonly permissions: readonly ["admin.plugins.read"];
+            readonly nav: {
+                readonly group: "operations";
+                readonly icon: "package";
+            };
+            readonly tabs: {
+                readonly installed: {
+                    readonly label: "Installed";
+                };
+                readonly downloaded: {
+                    readonly label: "Downloaded";
+                };
+                readonly marketplace: {
+                    readonly label: "Marketplace";
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=agent-plugins.module.d.ts.map

package/dist/agent-plugins/agent-plugins.module.js

@@ -0,0 +1,6 @@
+import { defineAdminModule } from '../core/module/index.js';
+import { agentPluginsApiToken } from './ports.js';
+import { agentPluginsMessagesEn as m } from './messages.en.js';
+import { AGENT_PLUGINS_READ } from './rules.js';
+export const agentPluginsModule = defineAdminModule({ id: 'agent-plugins', requires: { agentPluginsApi: agentPluginsApiToken }, messages: m, pages: { agentPlugins: { path: '/agent-plugins', label: m.title, permissions: [AGENT_PLUGINS_READ], nav: { group: 'operations', icon: 'package' }, tabs: { installed: { label: m.installed }, downloaded: { label: m.downloaded }, marketplace: { label: m.marketplace } } } } });
+//# sourceMappingURL=agent-plugins.module.js.map

package/dist/agent-plugins/conformance/agent-plugins-api.conformance.d.ts

@@ -0,0 +1,12 @@
+import type { AgentPluginsApiPort } from '../ports.js';
+export interface AgentPluginsConformanceResult {
+    readonly name: string;
+    readonly passed: boolean;
+}
+/** Run in an isolated workspace fixture with two installed ids and readable files for pluginId. */
+export declare function runAgentPluginsApiConformance({ create, pluginId, otherPluginId }: {
+    create: (required: Record<string, never>, optional?: Record<string, never>) => AgentPluginsApiPort | Promise<AgentPluginsApiPort>;
+    pluginId: string;
+    otherPluginId: string;
+}, _optional?: {}): Promise<readonly AgentPluginsConformanceResult[]>;
+//# sourceMappingURL=agent-plugins-api.conformance.d.ts.map

package/dist/agent-plugins/conformance/agent-plugins-api.conformance.js

@@ -0,0 +1,47 @@
+/** Run in an isolated workspace fixture with two installed ids and readable files for pluginId. */
+export async function runAgentPluginsApiConformance({ create, pluginId, otherPluginId }, _optional = {}) {
+    const api = await create({}), results = [];
+    const check = (condition) => { if (!condition)
+        throw new Error('Contract violation'); };
+    async function test(name, run) { try {
+        await run();
+        results.push({ name, passed: true });
+    }
+    catch {
+        results.push({ name, passed: false });
+    } }
+    const initial = await api.list({}), first = initial.find(p => p.pluginId === pluginId), other = initial.find(p => p.pluginId === otherPluginId);
+    if (!first || !other || pluginId === otherPluginId)
+        throw new Error('Conformance needs two distinct installed plugin ids');
+    const expectRejection = async (run) => { let rejected = false; try {
+        await run();
+    }
+    catch {
+        rejected = true;
+    } check(rejected); };
+    try {
+        await test('lists installed packages independent of activation', () => { check(initial.length >= 2 && new Set(initial.map(p => p.pluginId)).size === initial.length); });
+        await test('list snapshots are immutable', () => { check(Object.isFrozen(initial) && Object.isFrozen(first) && Object.isFrozen(first.skills) && Object.isFrozen(first.keywords) && Object.isFrozen(first.mcpServerIds)); });
+        await test('activation replies with the single updated row', async () => { const row = await api.setEnabled({ pluginId, enabled: !first.enabled }); check(row.pluginId === pluginId && row.enabled === !first.enabled && row.description === first.description); });
+        await test('accepted activation is visible on reload', async () => { check((await api.list({})).find(p => p.pluginId === pluginId)?.enabled === !first.enabled); });
+        await test('old snapshot retains its original enabled value', () => { check(initial.find(p => p.pluginId === pluginId)?.enabled === first.enabled); });
+        await test('unrelated row is unchanged', async () => { check(JSON.stringify((await api.list({})).find(p => p.pluginId === otherPluginId)) === JSON.stringify(other)); });
+        await test('repeated assignment is idempotent', async () => { check((await api.setEnabled({ pluginId, enabled: !first.enabled })).enabled === !first.enabled); });
+        await test('disabled package remains inspectable', async () => { await api.setEnabled({ pluginId, enabled: false }); const listing = await api.files({ pluginId }); check(listing.pluginId === pluginId && listing.files.length > 0); });
+        await test('file metadata includes omission and bounds', async () => { const listing = await api.files({ pluginId }); check(typeof listing.truncated === 'boolean' && listing.limits.maxFiles > 0 && listing.files.every(f => typeof f.relativePath === 'string' && f.sizeBytes >= 0 && (f.content === null || typeof f.content === 'string'))); });
+        await test('file snapshots are immutable', async () => { const listing = await api.files({ pluginId }); check(Object.isFrozen(listing) && Object.isFrozen(listing.files) && Object.isFrozen(listing.limits) && listing.files.every(f => Object.isFrozen(f))); });
+        await test('missing activation rejects', async () => { await expectRejection(() => api.setEnabled({ pluginId: '__missing__', enabled: true })); });
+        await test('missing inspector rejects', async () => { await expectRejection(() => api.files({ pluginId: '__missing__' })); });
+        await test('nonboolean activation rejects without mutation', async () => { const before = (await api.list({})).find(p => p.pluginId === pluginId)?.enabled; await expectRejection(() => api.setEnabled({ pluginId, enabled: 'false' })); check((await api.list({})).find(p => p.pluginId === pluginId)?.enabled === before); });
+        const abort = new AbortController();
+        abort.abort();
+        await test('aborted list rejects', async () => { await expectRejection(() => api.list({}, { signal: abort.signal })); });
+        await test('aborted files reject', async () => { await expectRejection(() => api.files({ pluginId }, { signal: abort.signal })); });
+        await test('aborted write leaves activation intact', async () => { const before = (await api.list({})).find(p => p.pluginId === pluginId)?.enabled; await expectRejection(() => api.setEnabled({ pluginId, enabled: !before }, { signal: abort.signal })); check((await api.list({})).find(p => p.pluginId === pluginId)?.enabled === before); });
+    }
+    finally {
+        await api.setEnabled({ pluginId, enabled: first.enabled });
+    }
+    return Object.freeze(results.map(r => Object.freeze(r)));
+}
+//# sourceMappingURL=agent-plugins-api.conformance.js.map

package/dist/agent-plugins/controllers/agent-plugin-files.controller.d.ts

@@ -0,0 +1,20 @@
+import type { AgentPluginsApiPort } from '../ports.js';
+import type { AgentPluginFilesState } from '../models.js';
+export declare function createAgentPluginFilesController({ api, permissions }: {
+    api: AgentPluginsApiPort;
+    permissions?: readonly string[];
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<AgentPluginFilesState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    open({ pluginId }: {
+        pluginId: string;
+    }, _optional?: {}): Promise<void>;
+    select({ path }: {
+        path: string;
+    }, _optional?: {}): void;
+    close(_required: Record<string, never>, _optional?: {}): void;
+    dispose(_required?: Record<string, never>, _optional?: {}): void;
+};
+//# sourceMappingURL=agent-plugin-files.controller.d.ts.map

package/dist/agent-plugins/controllers/agent-plugin-files.controller.js

@@ -0,0 +1,43 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { agentPluginFilesSnapshot, selectAgentPluginFile, AGENT_PLUGINS_READ } from '../rules.js';
+import { agentPluginsMessagesEn as m } from '../messages.en.js';
+export function createAgentPluginFilesController({ api, permissions = [] }, _optional = {}) {
+    const store = createControllerStore({ initial: { pluginId: null, listing: null, loading: false, error: null, selectedPath: '' } });
+    let generation = 0, pending = null;
+    function cancel() { generation++; pending?.abort(); pending = null; }
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe,
+        async open({ pluginId }, _optional = {}) {
+            if (store.signal.aborted || !permissions.includes(AGENT_PLUGINS_READ))
+                return;
+            cancel();
+            const ticket = generation, abort = new AbortController();
+            pending = abort;
+            store.set({ patch: { pluginId, listing: null, loading: true, error: null, selectedPath: '' } });
+            try {
+                const result = await api.files({ pluginId }, { signal: abort.signal });
+                if (ticket !== generation || store.signal.aborted)
+                    return;
+                if (result.pluginId !== pluginId)
+                    throw new Error('Invalid files response');
+                const listing = agentPluginFilesSnapshot({ listing: result });
+                store.set({ patch: { listing, selectedPath: selectAgentPluginFile({ files: listing.files, path: '' })?.relativePath ?? '' } });
+            }
+            catch {
+                if (ticket === generation)
+                    store.set({ patch: { error: m.fileError } });
+            }
+            finally {
+                if (ticket === generation) {
+                    pending = null;
+                    store.set({ patch: { loading: false } });
+                }
+            }
+        },
+        select({ path }, _optional = {}) { if (store.signal.aborted)
+            return; store.set({ patch: { selectedPath: selectAgentPluginFile({ files: store.getSnapshot().listing?.files ?? [], path })?.relativePath ?? '' } }); },
+        close(_required, _optional = {}) { cancel(); store.set({ patch: { pluginId: null, listing: null, loading: false, error: null, selectedPath: '' } }); },
+        dispose(_required = {}, _optional = {}) { cancel(); store.set({ patch: { pluginId: null, listing: null, selectedPath: '' } }); store.dispose(); },
+    };
+}
+//# sourceMappingURL=agent-plugin-files.controller.js.map

package/dist/agent-plugins/controllers/agent-plugins.controller.d.ts

@@ -0,0 +1,25 @@
+import type { AgentPluginsApiPort } from '../ports.js';
+import type { AgentPluginsState, AgentPluginActivationInput, AgentPluginDisableRequest } from '../models.js';
+export declare function createAgentPluginsController({ api, permissions }: {
+    api: AgentPluginsApiPort;
+    permissions?: readonly string[];
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<AgentPluginsState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    load: (_required: Record<string, never>, _optional?: {}) => Promise<void>;
+    setEnabled: (input: AgentPluginActivationInput, _optional?: {}) => Promise<boolean>;
+    requestDisable(input: AgentPluginDisableRequest, _optional?: {}): void;
+    cancelDisable(_required: Record<string, never>, _optional?: {}): void;
+    confirmDisable(_required: Record<string, never>, _optional?: {}): Promise<boolean>;
+    toggleExpanded({ pluginId }: {
+        pluginId: string;
+    }, _optional?: {}): void;
+    inspect({ pluginId }: {
+        pluginId: string;
+    }, _optional?: {}): void;
+    closeInspector(_required: Record<string, never>, _optional?: {}): void;
+    dispose(_required?: Record<string, never>, _optional?: {}): void;
+};
+//# sourceMappingURL=agent-plugins.controller.d.ts.map

package/dist/agent-plugins/controllers/agent-plugins.controller.js

@@ -0,0 +1,91 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { agentPluginSummary, AGENT_PLUGINS_READ, AGENT_PLUGINS_WRITE } from '../rules.js';
+import { agentPluginsMessagesEn as m } from '../messages.en.js';
+export function createAgentPluginsController({ api, permissions = [] }, _optional = {}) {
+    const grants = new Set(permissions);
+    const store = createControllerStore({ initial: { plugins: null, loading: false, error: null, actionError: null, busyIds: [], expandedIds: [], pendingDisable: null, inspectedId: null } });
+    let generation = 0, revision = 0;
+    const canRead = () => !store.signal.aborted && grants.has(AGENT_PLUGINS_READ);
+    const canWrite = () => canRead() && grants.has(AGENT_PLUGINS_WRITE);
+    const rowFor = (id) => store.getSnapshot().plugins?.find(p => p.pluginId === id);
+    async function load(_required, _optional = {}) {
+        if (!canRead())
+            return;
+        const ticket = ++generation, version = revision;
+        store.set({ patch: { loading: true, error: null } });
+        try {
+            const plugins = await api.list({}, { signal: store.signal });
+            // Older reads cannot overwrite accepted writes; each updated row replaces itself once.
+            if (ticket !== generation || store.signal.aborted)
+                return;
+            if (version === revision) {
+                const rows = Object.freeze(plugins.map(row => agentPluginSummary({ row })));
+                const state = store.getSnapshot();
+                store.set({ patch: { plugins: rows, inspectedId: rows.some(p => p.pluginId === state.inspectedId) ? state.inspectedId : null, pendingDisable: rows.some(p => p.pluginId === state.pendingDisable?.pluginId && p.enabled) ? state.pendingDisable : null, expandedIds: state.expandedIds.filter(id => rows.some(p => p.pluginId === id)) } });
+            }
+        }
+        catch {
+            if (ticket === generation)
+                store.set({ patch: { error: m.loadError } });
+        }
+        finally {
+            if (ticket === generation)
+                store.set({ patch: { loading: false } });
+        }
+    }
+    async function setEnabled(input, _optional = {}) {
+        const row = rowFor(input.pluginId), state = store.getSnapshot();
+        if (!canWrite() || !row || row.enabled === input.enabled || state.busyIds.includes(input.pluginId))
+            return false;
+        store.set({ patch: { busyIds: [...state.busyIds, input.pluginId], actionError: null } });
+        try {
+            const updated = await api.setEnabled(input, { signal: store.signal });
+            if (store.signal.aborted)
+                return false;
+            if (updated.pluginId !== input.pluginId)
+                throw new Error('Invalid activation response');
+            revision++;
+            // No optimistic flip: independent rows always splice into the newest snapshot.
+            const current = store.getSnapshot();
+            store.set({ patch: { plugins: Object.freeze((current.plugins ?? []).map(p => p.pluginId === updated.pluginId ? agentPluginSummary({ row: updated }) : p)) } });
+            return true;
+        }
+        catch {
+            store.set({ patch: { actionError: m.actionError } });
+            return false;
+        }
+        finally {
+            store.set({ patch: { busyIds: store.getSnapshot().busyIds.filter(id => id !== input.pluginId) } });
+        }
+    }
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, setEnabled,
+        requestDisable(input, _optional = {}) {
+            if (canWrite() && !store.getSnapshot().pendingDisable && rowFor(input.pluginId)?.enabled && !store.getSnapshot().busyIds.includes(input.pluginId))
+                store.set({ patch: { pendingDisable: { ...input } } });
+        },
+        cancelDisable(_required, _optional = {}) { const p = store.getSnapshot().pendingDisable; if (!p || store.getSnapshot().busyIds.includes(p.pluginId))
+            return; store.set({ patch: { pendingDisable: null } }); },
+        async confirmDisable(_required, _optional = {}) {
+            const pending = store.getSnapshot().pendingDisable;
+            if (!pending || !canWrite() || !rowFor(pending.pluginId)?.enabled) {
+                store.set({ patch: { pendingDisable: null } });
+                return false;
+            }
+            if (store.getSnapshot().busyIds.includes(pending.pluginId))
+                return false;
+            // Explicit false, never invert a stale plugin object captured when the dialog opened.
+            const accepted = await setEnabled({ pluginId: pending.pluginId, enabled: false });
+            if (accepted)
+                store.set({ patch: { pendingDisable: null } });
+            return accepted;
+        },
+        toggleExpanded({ pluginId }, _optional = {}) { if (!canRead() || !rowFor(pluginId))
+            return; const ids = store.getSnapshot().expandedIds; store.set({ patch: { expandedIds: ids.includes(pluginId) ? ids.filter(id => id !== pluginId) : [...ids, pluginId] } }); },
+        inspect({ pluginId }, _optional = {}) { if (canRead() && rowFor(pluginId))
+            store.set({ patch: { inspectedId: pluginId } }); },
+        closeInspector(_required, _optional = {}) { store.set({ patch: { inspectedId: null } }); },
+        dispose(_required = {}, _optional = {}) { generation++; store.set({ patch: { pendingDisable: null, inspectedId: null, busyIds: [] } }); store.dispose(); },
+    };
+}
+//# sourceMappingURL=agent-plugins.controller.js.map

package/dist/agent-plugins/index.d.ts

@@ -0,0 +1,9 @@
+export * from './models.js';
+export * from './ports.js';
+export * from './rules.js';
+export * from './package-file-tree.js';
+export * from './messages.en.js';
+export * from './agent-plugins.module.js';
+export * from './controllers/agent-plugins.controller.js';
+export * from './controllers/agent-plugin-files.controller.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/agent-plugins/index.js

@@ -0,0 +1,9 @@
+export * from './models.js';
+export * from './ports.js';
+export * from './rules.js';
+export * from './package-file-tree.js';
+export * from './messages.en.js';
+export * from './agent-plugins.module.js';
+export * from './controllers/agent-plugins.controller.js';
+export * from './controllers/agent-plugin-files.controller.js';
+//# sourceMappingURL=index.js.map

package/dist/agent-plugins/messages.en.d.ts

@@ -0,0 +1,23 @@
+export declare const agentPluginsMessagesEn: {
+    readonly title: "Agent Plugins";
+    readonly installed: "Installed";
+    readonly downloaded: "Downloaded";
+    readonly marketplace: "Marketplace";
+    readonly description: "Portable packages installed for this workspace.";
+    readonly denied: "Permission denied";
+    readonly loading: "Loading Agent Plugins…";
+    readonly empty: "No Agent Plugins are installed in this workspace.";
+    readonly loadError: "Failed to load agent plugins";
+    readonly actionError: "Failed to update agent plugin";
+    readonly fileError: "Failed to load package files";
+    readonly filesLoading: "Loading package files…";
+    readonly filesEmpty: "No files to show for this plugin.";
+    readonly filesTruncated: "Some files are not listed: this package is larger than the viewer’s limits.";
+    readonly installedLede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt.";
+    readonly downloadedLede: "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
+    readonly uninstallUnavailable: "Uninstall is unavailable in this view. Package removal is managed by the host.";
+    readonly marketplaceTitle: "Nothing to browse yet";
+    readonly marketplaceDescription: "Marketplace is planned for a future release. This view does not fetch, install, or list marketplace packages yet.";
+    readonly marketplaceHint: "Until then, the Downloaded tab lists the packages available in this workspace.";
+};
+//# sourceMappingURL=messages.en.d.ts.map