@huanlin/dsh-plugin-tools-manager 0.2.0

package/lib/gateway.js

@@ -0,0 +1,180 @@
+/**
+ * gateway.ts — host-side HTTP gateway exposing the tool tree + disabled set
+ * to the browser through a self-hosted `/tools-manager/api` route.
+ *
+ * Mirrors the dsh-interpreters / dsh-better-sidebar pattern: `ctx.webServer.
+ * register` claims a prefix route, the handler reads/writes the settings seam
+ * in-process (no wire-layer allowlist gate), and the browser reaches it
+ * through `fetch('/tools-manager/api/<method>')`.
+ *
+ * Route shape:
+ *   POST /tools-manager/api/list
+ *     → { ok: true, value: { plugins: [{ name, tools: [{ name, description, disabled }] }] } }
+ *   POST /tools-manager/api/set  body: { toolName, disabled }
+ *     → { ok: true, value: { plugins: [...] } }   (refreshed full tree)
+ * Errors carry { ok: false, error: { code, message } }.
+ *
+ * @module dsh-tools-manager/gateway
+ */
+import { SETTINGS_NAMESPACE } from './settings.js';
+/** HTTP route prefix owning every tools-manager API request. */
+const API_PREFIX = '/tools-manager/api';
+/**
+ * Register the `/tools-manager/api` HTTP route on the host's web server.
+ *
+ * The route reads the tool tree from the registry and reads/writes the
+ * disabled set through the settings bridge. The settings service is optional:
+ * when absent, `list` still works (degraded to entry-source disabled set) and
+ * `set` returns a clear error.
+ * @param ctx - host context carrying `webServer`.
+ * @param registry - the tool attribution registry.
+ * @param bridge - the settings bridge the route reads through.
+ */
+export function registerHttpGateway(ctx, registry, bridge) {
+    let settings;
+    ctx.inject(['settings'], (sctx) => {
+        settings = sctx.settings;
+        return () => { settings = undefined; };
+    });
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'prefix',
+        path: API_PREFIX,
+        handler: async (req, res) => {
+            if (req.method !== 'POST') {
+                writeJson(res, 405, envelopeError('method-not-allowed', 'POST only'));
+                return;
+            }
+            const pathname = new URL(req.url ?? '/', 'http://dsh.internal').pathname;
+            const method = pathname.startsWith(`${API_PREFIX}/`)
+                ? pathname.slice(`${API_PREFIX}/`.length)
+                : undefined;
+            if (method === undefined || method.includes('/')) {
+                writeJson(res, 404, envelopeError('not-found', 'unknown tools-manager API method'));
+                return;
+            }
+            try {
+                const body = await readJsonBody(req);
+                if (method === 'list') {
+                    const view = buildView(registry, bridge);
+                    writeJson(res, 200, envelopeOk(view));
+                }
+                else if (method === 'set') {
+                    const view = await handleSet(body, settings, registry, bridge);
+                    writeJson(res, 200, envelopeOk(view));
+                }
+                else {
+                    writeJson(res, 404, envelopeError('not-found', `unknown tools-manager API method "${method}"`));
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeJson(res, 500, envelopeError('internal', message));
+            }
+        },
+    }), 'tools-manager: /tools-manager/api routes');
+}
+/**
+ * Handle the `set` method: validate the patch, write the user layer, return
+ * the refreshed tree.
+ * @param body - the parsed JSON body from the request.
+ * @param settings - the live settings service (undefined when unavailable).
+ * @param registry - the tool attribution registry.
+ * @param bridge - the settings bridge for reading the source.
+ * @returns the refreshed tree view.
+ * @throws when the settings service is unavailable or the body is invalid.
+ */
+export async function handleSet(body, settings, registry, bridge) {
+    const patch = extractSetPatch(body);
+    if (settings === undefined) {
+        throw new Error('tools-manager: settings service is unavailable — the disabled set cannot be written');
+    }
+    const current = bridge.source();
+    let nextDisabled;
+    if (patch.disabled === true) {
+        if (!current.disabled.includes(patch.toolName)) {
+            nextDisabled = [...current.disabled, patch.toolName];
+        }
+        else {
+            nextDisabled = [...current.disabled];
+        }
+    }
+    else {
+        nextDisabled = current.disabled.filter(name => name !== patch.toolName);
+    }
+    await settings.update(SETTINGS_NAMESPACE, { disabled: nextDisabled });
+    return buildView(registry, bridge);
+}
+/**
+ * Extract and validate the `set` patch from the request body.
+ *
+ * JSON wire boundary: the body must be `{ toolName: string, disabled: boolean }`.
+ * Unknown keys are dropped; missing or mistyped fields produce a 400-style
+ * error (thrown as an Error, caught by the handler and returned as
+ * `internal`).
+ * @param body - the parsed JSON body.
+ * @returns the normalized patch.
+ * @throws when the body is missing required fields or has wrong types.
+ */
+export function extractSetPatch(body) {
+    if (!isObject(body)) {
+        throw new Error('tools-manager: set body must be a JSON object { toolName, disabled }');
+    }
+    const toolName = Reflect.get(body, 'toolName');
+    const disabled = Reflect.get(body, 'disabled');
+    if (typeof toolName !== 'string' || toolName === '') {
+        throw new Error('tools-manager: set body `toolName` must be a non-empty string');
+    }
+    if (typeof disabled !== 'boolean') {
+        throw new Error('tools-manager: set body `disabled` must be a boolean');
+    }
+    return { toolName, disabled };
+}
+/**
+ * Build the full tree view from the registry + bridge.
+ * @param registry - the tool attribution registry.
+ * @param bridge - the settings bridge (for the disabled set).
+ * @returns the tree view with each tool tagged `disabled`.
+ */
+export function buildView(registry, bridge) {
+    const disabledSet = new Set(bridge.source().disabled);
+    const groups = registry.getTree();
+    return {
+        plugins: groups.map(group => ({
+            name: group.name,
+            tools: group.tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                disabled: disabledSet.has(tool.name),
+            })),
+        })),
+    };
+}
+/** Read and parse a JSON body from a node:http request. */
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    if (text === '')
+        return {};
+    return JSON.parse(text);
+}
+/** Write a JSON response envelope. */
+function writeJson(res, status, body) {
+    const json = JSON.stringify(body);
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(json);
+}
+/** Build a success envelope. */
+function envelopeOk(value) {
+    return { ok: true, value };
+}
+/** Build an error envelope. */
+function envelopeError(code, message) {
+    return { ok: false, error: { code, message } };
+}
+/** Narrow unknown to a non-null object. */
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}

package/lib/index.js

@@ -0,0 +1,49 @@
+/**
+ * index.ts — dsh-tools-manager host plugin entry.
+ *
+ * Wires together three halves:
+ *   - `ToolRegistry` attributes each registered tool to its source plugin by
+ *     snapshot-diffing `ctx.tools.schemas()` on every `tools/change`.
+ *   - `installPolicy` installs the two-layer enable/disable gate:
+ *     `system-prompt/assemble` hides disabled tools from the model, and
+ *     `ctx.tools.guard()` denies their execution. Both read the same
+ *     `disabled` set so the two layers can never drift.
+ *   - `registerHttpGateway` exposes `/tools-manager/api/list|set` for the
+ *     browser settings card.
+ *
+ * The disabled set persists through the `tools-manager` settings namespace in
+ * `$DSH_HOME/settings.yaml`; runtime edits update the in-memory set and the
+ * next assembly / guard call reads the fresh value — no restart needed.
+ *
+ * @module @huanlin/dsh-plugin-tools-manager
+ */
+import { registerHttpGateway } from './gateway.js';
+import { installPolicy } from './policy.js';
+import { ToolRegistry } from './registry.js';
+import { installToolsManagerSettings } from './settings.js';
+export { Config, resolveConfig } from './config.js';
+export { registerHttpGateway } from './gateway.js';
+export { installPolicy, filterTools, disabledReason, DISABLED_REASON_PREFIX } from './policy.js';
+export { ToolRegistry, BASELINE_GROUP, UNKNOWN_GROUP } from './registry.js';
+export { SETTINGS_NAMESPACE } from './settings.js';
+export const name = 'tools-manager';
+export const inject = ['tools', 'webServer', 'systemPrompt'];
+/**
+ * Plugin body: build the registry, install the policy, register the HTTP
+ * gateway, and keep the disabled set in sync with settings changes.
+ * @param ctx - host context carrying `tools`, `webServer`, and `systemPrompt`.
+ * @param config - resolved composition config (seed).
+ */
+export function apply(ctx, config = {}) {
+    ctx.logger('tools-manager').info('apply() called, config=', JSON.stringify(config));
+    const bridge = installToolsManagerSettings(ctx, config);
+    const disabledSet = () => new Set(bridge.source().disabled);
+    const registry = new ToolRegistry(ctx);
+    const disposePolicy = installPolicy(ctx, disabledSet);
+    registerHttpGateway(ctx, registry, bridge);
+    ctx.logger('tools-manager').info('registry + policy + gateway installed');
+    ctx.effect(() => () => {
+        disposePolicy();
+        registry.dispose();
+    }, 'tools-manager: cleanup');
+}

package/lib/policy.js

@@ -0,0 +1,81 @@
+/**
+ * policy.ts — global tool enable/disable, two layers consistent.
+ *
+ * One `disabled: Set<string>` drives both seams so the model-visible schema
+ * and the execution gate can never drift:
+ *
+ *   | Layer            | Seam                          | Effect |
+ *   |------------------|-------------------------------|--------|
+ *   | Hidden (model)   | `system-prompt/assemble`      | Filter `assembly.tools`, return transformed assembly |
+ *   | Denied (execute) | `ctx.tools.guard()` (plain)   | Return a denial reason for disabled tools |
+ *
+ * `restrict()` is intentionally NOT used: it requires a scoped ctx and cannot
+ * express a process-global filter. `guard()` is monotonic and applies to
+ * every agent's calls; `system-prompt/assemble` is a waterfall that can
+ * transform `assembly.tools` and delegate the rest to downstream listeners.
+ *
+ * @module dsh-tools-manager/policy
+ */
+/** Canonical denial reason returned by the guard for a disabled tool. */
+export const DISABLED_REASON_PREFIX = 'tool is disabled by tools-manager:';
+/**
+ * Build the canonical denial reason string for a disabled tool.
+ * @param toolName - the disabled tool's name.
+ * @returns the reason handed to {@link ToolGuard}.
+ */
+export function disabledReason(toolName) {
+    return `${DISABLED_REASON_PREFIX} ${JSON.stringify(toolName)}`;
+}
+/**
+ * Install the two-layer enable/disable policy.
+ *
+ * Both layers read the same `disabled` thunk so they stay consistent across
+ * settings changes without any extra notification wiring: the host entry
+ * swaps the thunk's backing store in place when settings commit, and the
+ * next assembly / guard call reads the fresh value.
+ * @param ctx - host context carrying `tools` and `systemPrompt`.
+ * @param disabled - a thunk returning the current disabled-name set.
+ * @returns the disposer that removes both layers.
+ */
+export function installPolicy(ctx, disabled) {
+    // Filter the FINAL assembly.tools (after delegating to downstream listeners)
+    // so the disabled set is honoured regardless of listener ordering. The
+    // waterfall's `next()` returns the assembly handed back by later listeners;
+    // we filter that result and return the transformed copy.
+    const disposeAssemble = ctx.on('system-prompt/assemble', async (_assembly, _context, next) => {
+        const result = await next();
+        const set = disabled();
+        if (set.size === 0)
+            return result;
+        const filteredTools = result.tools.filter(tool => !set.has(tool.name));
+        if (filteredTools.length === result.tools.length)
+            return result;
+        return { ...result, tools: filteredTools };
+    });
+    const guard = (exec) => {
+        const set = disabled();
+        if (set.size === 0)
+            return undefined;
+        if (set.has(exec.name))
+            return disabledReason(exec.name);
+        return undefined;
+    };
+    const disposeGuard = ctx.tools.guard(guard);
+    return () => {
+        disposeAssemble();
+        disposeGuard();
+    };
+}
+/**
+ * Pure helper: filter a tool schema list by a disabled-name set.
+ * Exported for unit tests so the filter logic can be exercised without
+ * spinning up a cordis context.
+ * @param tools - the input tool schemas.
+ * @param disabled - the disabled-name set.
+ * @returns the input list with disabled tools removed.
+ */
+export function filterTools(tools, disabled) {
+    if (disabled.size === 0)
+        return [...tools];
+    return tools.filter(tool => !disabled.has(tool.name));
+}

package/lib/registry.js

@@ -0,0 +1,314 @@
+/**
+ * registry.ts — tool-to-plugin attribution registry.
+ *
+ * ## Attribution challenge
+ *
+ * dsh-tools' `ctx.tools.schemas()` returns only `{ name, description,
+ * parameters }` — there is **no source-plugin field**. The `ToolRuntime`
+ * internally tracks which scope (fiber) registered each tool via
+ * `ScopedLayers`, but that mapping is private and scope keys are opaque
+ * objects, not plugin names.
+ *
+ * ## Approach (zero source-code modification)
+ *
+ * Two mechanisms work together:
+ *
+ * 1. **`internal/plugin` + `internal/status`** — tracks which plugin is
+ *    currently loading (fiber created → `apply()` running → ACTIVE). The
+ *    pending-stack top is the best attribution candidate for any tool
+ *    registered during that window.
+ *
+ * 2. **`tools/change` diff** — on every registry mutation, the registry
+ *    diffs `ctx.tools.schemas()` against its last snapshot; new tools are
+ *    attributed to the current pending-stack top (or {@link UNKNOWN_GROUP}
+ *    when no plugin is pending).
+ *
+ * 3. **`ctx.registry.values()`** — enumerates all loaded plugin runtimes
+ *    (name + fibers), so we can list known plugin names in the tree even
+ *    when we cannot attribute specific tools to them.
+ *
+ * `ctx.tools.register` is deliberately NOT wrapped: the Cordis traceable
+ * proxy rebinds `this.ctx` to each caller's context on every property
+ * access, which is how `scopeOf(this.ctx)` routes a registration to the
+ * correct scope layer. Monkey-patching the method (e.g. `.bind(proxy)`)
+ * pins `this.ctx` to this plugin's unscoped context, collapsing every
+ * scoped registration onto the global layer and producing "already
+ * registered" collisions when agent presets mount their tool rows.
+ *
+ * ## Known limitations
+ *
+ * - **Baseline tools**: tools registered before this plugin loaded cannot be
+ *   attributed to their source plugin — their `internal/plugin` event fired
+ *   before we subscribed. They fall to {@link BASELINE_GROUP}.
+ * - **Async registration**: a plugin that registers tools after `apply()`
+ *   returns (e.g. in a `setTimeout` or async callback) may have already left
+ *   the pending stack — those tools fall to {@link UNKNOWN_GROUP}.
+ * - **Concurrent loads**: the most recently created pending fiber wins.
+ *
+ * @module dsh-tools-manager/registry
+ */
+/** Group name for tools registered before this plugin loaded. */
+export const BASELINE_GROUP = '(baseline)';
+/** Group name for tools whose source plugin could not be determined. */
+export const UNKNOWN_GROUP = '(unknown)';
+/**
+ * Fiber lifecycle states (cordis `FiberState` const enum, erased at compile
+ * time). Matched numerically: 0 PENDING, 1 LOADING, 2 ACTIVE, 3 FAILED,
+ * 4 DISPOSED, 5 UNLOADING.
+ */
+const STATE_ACTIVE = 2;
+const STATE_FAILED = 3;
+const STATE_DISPOSED = 4;
+/**
+ * The tool-to-plugin attribution registry.
+ *
+ * Construction is an effect: it registers `internal/plugin`,
+ * `internal/status`, and `tools/change` listeners on the supplied context.
+ * All listeners are fibre-scoped effects and auto-clean on unload.
+ */
+export class ToolRegistry {
+    ctx;
+    /** pluginName → tools (preserves registration order). */
+    byPlugin = new Map();
+    /** toolName → pluginName (reverse index for fast removal). */
+    toolToPlugin = new Map();
+    /** Last schemas() snapshot (name → entry), used for removal detection. */
+    lastSnapshot = new Map();
+    /** Stack of plugin names whose fibres are still loading (not yet ACTIVE/FAILED/DISPOSED). */
+    pendingPlugins = [];
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.snapshotBaseline();
+        ctx.on('internal/plugin', (fiber) => this.onPluginEvent(fiber));
+        ctx.on('internal/status', (fiber) => this.onStatusEvent(fiber));
+        ctx.on('tools/change', () => this.reconcile());
+    }
+    /**
+     * The plugin currently in its `apply()` (pending-stack top), or undefined.
+     * @returns the name of the most recently created loading plugin.
+     */
+    currentLoadingPlugin() {
+        return this.pendingPlugins.length > 0
+            ? this.pendingPlugins[this.pendingPlugins.length - 1]
+            : undefined;
+    }
+    /**
+     * Take the initial schemas() snapshot and attribute every visible tool to
+     * {@link BASELINE_GROUP}. Also enumerate loaded plugins via ctx.registry
+     * so their names appear as empty groups in the tree (informational).
+     */
+    snapshotBaseline() {
+        const schemas = this.readSchemas();
+        const map = new Map();
+        const entries = [];
+        for (const s of schemas) {
+            const entry = { name: s.name, description: s.description, parameters: s.parameters };
+            map.set(s.name, entry);
+            entries.push(entry);
+            this.toolToPlugin.set(s.name, BASELINE_GROUP);
+        }
+        this.lastSnapshot = map;
+        if (entries.length > 0)
+            this.byPlugin.set(BASELINE_GROUP, entries);
+        // Enumerate loaded plugins so their names appear as groups (even if empty).
+        this.enumerateLoadedPlugins();
+    }
+    /**
+     * Enumerate all loaded plugin runtimes via `ctx.registry.values()` and
+     * register their names as (possibly empty) groups in the tree. This gives
+     * the user visibility into all loaded plugins, even when we cannot
+     * attribute specific tools to them.
+     */
+    enumerateLoadedPlugins() {
+        const registry = this.ctx.registry;
+        if (registry === undefined || typeof registry.values !== 'function')
+            return;
+        try {
+            for (const runtime of registry.values()) {
+                const name = runtime.name;
+                if (name === undefined || name === 'root')
+                    continue;
+                // Check if any fiber of this runtime is still active.
+                const hasActive = runtime.fibers.some(f => f.uid !== null && f.state !== STATE_DISPOSED);
+                if (!hasActive)
+                    continue;
+                // Register as an empty group if not already present.
+                if (!this.byPlugin.has(name)) {
+                    this.byPlugin.set(name, []);
+                }
+            }
+        }
+        catch {
+            // Registry enumeration is best-effort; failures are non-fatal.
+        }
+    }
+    /**
+     * `internal/plugin` fires on fibre creation (uid just assigned) and on
+     * disposal (uid cleared). Creation pushes the name onto the pending stack;
+     * disposal is also handled by `internal/status` (DISPOSED), so this path
+     * only guards against a missing status event.
+     */
+    onPluginEvent(fiber) {
+        if (fiber.uid !== null) {
+            // Created: push onto pending stack (deduped — a restart fires creation
+            // again before the old DISPOSED clears).
+            if (!this.pendingPlugins.includes(fiber.name)) {
+                this.pendingPlugins.push(fiber.name);
+            }
+            // Register as an empty group so it appears in the tree immediately.
+            if (!this.byPlugin.has(fiber.name) && fiber.name !== 'root') {
+                this.byPlugin.set(fiber.name, []);
+            }
+        }
+        else {
+            this.removeFromPending(fiber.name);
+        }
+    }
+    /**
+     * `internal/status` fires on every state transition. When a fibre reaches
+     * ACTIVE, FAILED, or DISPOSED it is no longer "pending" — its apply() has
+     * finished (or thrown) and tools registered during apply() have already
+     * fired their `tools/change`.
+     */
+    onStatusEvent(fiber) {
+        if (fiber.state === STATE_ACTIVE || fiber.state === STATE_FAILED || fiber.state === STATE_DISPOSED) {
+            this.removeFromPending(fiber.name);
+        }
+        // On DISPOSED, also drop the plugin's group from the tree — its tools
+        // auto-unregister via effect cleanup, so the next tools/change reconcile
+        // will remove them, but the empty group lingers unless we clear it here.
+        if (fiber.state === STATE_DISPOSED) {
+            this.byPlugin.delete(fiber.name);
+        }
+        // On ACTIVE, re-enumerate plugins to catch any that loaded while we
+        // were processing.
+        if (fiber.state === STATE_ACTIVE) {
+            this.enumerateLoadedPlugins();
+        }
+    }
+    /** Remove a plugin name from the pending stack (preserves order of the rest). */
+    removeFromPending(name) {
+        if (this.pendingPlugins.length === 0)
+            return;
+        this.pendingPlugins = this.pendingPlugins.filter(n => n !== name);
+    }
+    /**
+     * Diff the current `ctx.tools.schemas()` against the last snapshot and
+     * update the attribution map.
+     *
+     * New tools → attributed via pending attribution (from register wrapper)
+     *   or pending-stack top, or {@link UNKNOWN_GROUP}.
+     * Removed tools → deleted from the map and from their plugin group.
+     * Existing tools → description / parameters refreshed in place.
+     */
+    reconcile() {
+        const schemas = this.readSchemas();
+        const current = new Map();
+        for (const s of schemas) {
+            current.set(s.name, { name: s.name, description: s.description, parameters: s.parameters });
+        }
+        // Added or changed tools.
+        for (const [name, entry] of current) {
+            const prev = this.lastSnapshot.get(name);
+            if (prev === undefined) {
+                this.attributeNew(name, entry);
+            }
+            else {
+                this.refreshExisting(name, entry);
+            }
+        }
+        // Removed tools.
+        for (const [name] of this.lastSnapshot) {
+            if (!current.has(name)) {
+                this.removeTool(name);
+            }
+        }
+        this.lastSnapshot = current;
+    }
+    /** Attribute a newly registered tool using pending attribution or pending-stack top. */
+    attributeNew(name, entry) {
+        // Attribute to the plugin currently in its apply() (pending-stack top),
+        // or UNKNOWN_GROUP when no plugin is pending.
+        const owner = this.currentLoadingPlugin() ?? UNKNOWN_GROUP;
+        // If the tool was previously attributed (e.g. re-registered after a
+        // dispose/reload), remove it from its old group first.
+        const prevOwner = this.toolToPlugin.get(name);
+        if (prevOwner !== undefined && prevOwner !== owner) {
+            this.removeToolFromGroup(name, prevOwner);
+        }
+        const list = this.byPlugin.get(owner) ?? [];
+        list.push(entry);
+        this.byPlugin.set(owner, list);
+        this.toolToPlugin.set(name, owner);
+    }
+    /** Refresh an existing tool's description/parameters in its current group. */
+    refreshExisting(name, entry) {
+        const owner = this.toolToPlugin.get(name);
+        if (owner === undefined) {
+            // Previously unseen but in the snapshot — attribute now.
+            this.attributeNew(name, entry);
+            return;
+        }
+        const list = this.byPlugin.get(owner);
+        if (list === undefined)
+            return;
+        const idx = list.findIndex(e => e.name === name);
+        if (idx >= 0) {
+            list[idx] = entry;
+        }
+        else {
+            list.push(entry);
+        }
+    }
+    /** Remove a tool from the attribution map and its plugin group. */
+    removeTool(name) {
+        const owner = this.toolToPlugin.get(name);
+        if (owner === undefined)
+            return;
+        this.removeToolFromGroup(name, owner);
+        this.toolToPlugin.delete(name);
+    }
+    /** Remove a tool from one specific plugin group (helper). */
+    removeToolFromGroup(name, owner) {
+        const list = this.byPlugin.get(owner);
+        if (list === undefined)
+            return;
+        const idx = list.findIndex(e => e.name === name);
+        if (idx >= 0)
+            list.splice(idx, 1);
+        // Don't delete empty groups — they may represent loaded plugins with
+        // no tools yet (from enumerateLoadedPlugins / internal/plugin).
+    }
+    /** Read `ctx.tools.schemas()` and narrow to the fields we use. */
+    readSchemas() {
+        const schemas = this.ctx.tools.schemas();
+        return Array.isArray(schemas) ? schemas : [];
+    }
+    /**
+     * The attribution tree: one entry per plugin group, in insertion order,
+     * each carrying its tools in registration order.
+     * @returns a snapshot of the current tree.
+     */
+    getTree() {
+        return [...this.byPlugin.entries()].map(([name, tools]) => ({
+            name,
+            tools: tools.map(t => ({ ...t })),
+        }));
+    }
+    /**
+     * The set of disabled tool names (delegated to {@link ToolPolicy} via the
+     * host entry). Exposed for the gateway to tag each tool row with its
+     * disabled state.
+     */
+    isDisabled(name, disabled) {
+        return disabled.has(name);
+    }
+    /**
+     * No-op disposal hook. All listeners are registered through `ctx.on()`
+     * (fibre-scoped effects) and auto-clean on unload; there is no manually
+     * installed wrapper to restore.
+     */
+    dispose() {
+        // intentionally empty — listeners are fibre-scoped effects.
+    }
+}