dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/index.js

@@ -1,257 +1,2 @@
-import z from '@deepseek-ai/schemastery';
-import { MarketSettingsFields } from './application/mcp/mcp-backend.js';
-import { Catalog } from './application/catalog.js';
-import { settlesWithin } from './application/deadline.js';
-import { RuntimeReconciler } from './runtime/core/reconciler.js';
-import { ReconcileScheduler } from './runtime/core/reconcile-scheduler.js';
-import { MarketSettingsNamespace } from './runtime/host/settings-namespace.js';
-import { deleteMcpAuthGrant } from './runtime/mcp/mcp-auth-record.js';
-import { inspectToolRegistry, toolsServiceOf } from './runtime/host/tool-registry-observer.js';
-import { migratePluginStorage } from './application/state/storage-migration.js';
-import { mountAgentRoleTool } from './runtime/agents/agent-role-router.js';
-import { projectAgentRoles } from './application/project-agent-roles.js';
-import { mountProjectCommands, mountProjectMcp, mountProjectHooks, mountSuiteInstructions } from './runtime/surfaces/project-runtime.js';
-import { createPanelResources } from './application/panel-resources.js';
-import { resolveAgentsRoot, resolveDataRoot, resolveUserRoot } from './catalog/paths.js';
-import { mountSuiteRoutes } from './routes.js';
-import { SuiteSkillProvider } from './runtime/surfaces/skills-provider.js';
-import { shellSeamOf } from './runtime/surfaces/dynamic-context.js';
-import { loadLspServers } from './application/lsp/lsp-direct-config.js';
-import { loadDisabledLspServers } from './application/lsp/lsp-server-state.js';
-import { bindHostLocale, LOCALE_SETTINGS_ENTRY, readHostLocalePreference, readLocalePreference, setHostLocaleSource } from './runtime/host/host-locale.js';
-import { createUserPanelStores } from './runtime/panels/user-panels.js';
-import { SourceAutoUpdater } from './runtime/core/source-auto-update.js';
-import { UserPanelSkillProvider } from './runtime/panels/user-panels.js';
-import { UserCommandMountRegistry } from './runtime/panels/user-commands.js';
-import { presetSourceRef } from './model/preset-source.js';
-export const name = 'dsh-agent-plugins-market';
-export const inject = ['skills', 'commands'];
-export const Config = z.object({
-    userRoot: z.union([z.string(), z.const(undefined)]),
-    dataRoot: z.union([z.string(), z.const(undefined)]),
-    sources: z.any(),
-    git: z.object({
-        proxy: z.string(),
-        insteadOf: z.dict(z.string(), z.any()),
-        timeoutMs: z.natural(),
-        cloneRetry: z.boolean(),
-        fallbackTarball: z.boolean(),
-        allowHttpArchives: z.boolean()
-    }),
-    mcpEnhanced: MarketSettingsFields.mcpEnhanced.volatile(),
-    scanProjectLayouts: MarketSettingsFields.scanProjectLayouts.volatile(),
-    downloadRegion: MarketSettingsFields.downloadRegion.volatile(),
-    feedbackEnabled: MarketSettingsFields.feedbackEnabled.volatile(),
-    autoUpdateSources: MarketSettingsFields.autoUpdateSources.volatile()
-});
-const undefinedRef = { get: () => undefined };
-export async function apply(ctx, config = { mcpEnhanced: undefinedRef, scanProjectLayouts: undefinedRef, downloadRegion: undefinedRef, feedbackEnabled: undefinedRef, autoUpdateSources: undefinedRef }) {
-    const userRoot = resolveUserRoot(config.userRoot);
-    const dataRoot = resolveDataRoot(config.dataRoot, userRoot);
-    const agentsRoot = resolveAgentsRoot();
-    const migration = await migratePluginStorage(config);
-    if (migration.conflicts.length > 0)
-        throw new Error(`Plugin storage migration conflicts (original files retained): ${migration.conflicts.join(', ')}`);
-    let providerControl;
-    let userPanelControl;
-    // Host runtime copy resolves from the harness `locale.preference` setting.
-    const hostLocale = { t: bindHostLocale(undefined) };
-    const refreshHostLocale = () => {
-        hostLocale.t = bindHostLocale(readLocalePreference());
-        providerControl?.invalidate();
-        userPanelControl?.invalidate();
-    };
-    // The preference is the `locale` entry's live configuration, projected by the
-    // host settings service. Resolve that service through the store from this
-    // entry's own context, and register the wiring as an effect so it lives
-    // exactly as long as this fiber: a context captured from an injection
-    // callback throws `cannot get required service "settings" in inactive
-    // context` once a profile reload disposes that fiber, and the unhandled
-    // rejection ends the host. Re-read once the service lands, because it may
-    // mount after this plugin.
-    ctx.effect(() => setHostLocaleSource(() => readHostLocalePreference(ctx.get('settings'))), 'dsh-agent-plugins-market: host locale source');
-    refreshHostLocale();
-    ctx.inject(['settings'], () => {
-        refreshHostLocale();
-    });
-    // A language switch writes the `locale` entry's form; re-read so the copy the
-    // market renders follows it without a reload.
-    ctx.effect(() => ctx.on('settings/document-updated', (ns) => {
-        if (ns === LOCALE_SETTINGS_ENTRY)
-            refreshHostLocale();
-    }), 'dsh-agent-plugins-market: host locale refresh');
-    const runtime = new RuntimeReconciler(ctx, dataRoot, key => hostLocale.t(key));
-    // User panel stores (skills / commands / agent personas) and their runtime
-    // contributions: one extra skill provider plus one command mount registry.
-    const panels = createUserPanelStores(agentsRoot);
-    const userCommands = new UserCommandMountRegistry(ctx, panels.commands, key => hostLocale.t(key));
-    let disposed = false;
-    let projectCommands;
-    let projectMcp;
-    let projectHooks;
-    let suitePrompts;
-    const scheduler = new ReconcileScheduler(ctx, runtime, {
-        enabledSuites: () => catalog.enabledUserSuites(),
-        publishMcpDiagnostics: diagnostics => {
-            catalog.mcpDiagnostics = diagnostics;
-        }
-    });
-    /** Reconcile the user command mounts and report each failure once. */
-    const reconcileUserCommands = async () => {
-        const diagnostics = await userCommands.reconcile().catch(() => []);
-        for (const reason of diagnostics) {
-            ctx.logger?.warn(`[dsh-agent-plugins-market] user commands: ${reason}`);
-        }
-    };
-    /**
-     * How long the change pipeline holds the queue on one stage. A mount that
-     * stops responding — a stdio server that never finishes its handshake, a
-     * browser authorization nobody completed — delays its own surface only; the
-     * stage keeps running while the pipeline moves on to the next change.
-     */
-    const CHANGE_STAGE_DEADLINE_MS = 20_000;
-    /** Run one pipeline stage, logging its failure or its overrun instead of holding the pipeline. */
-    const runStage = async (stage, work) => {
-        const running = (async () => await work())();
-        void running.catch(error => {
-            ctx.logger?.warn(`[dsh-agent-plugins-market] ${stage} failed: ${error instanceof Error ? error.message : String(error)}`);
-        });
-        if (!(await settlesWithin(running, CHANGE_STAGE_DEADLINE_MS))) {
-            ctx.logger?.warn(`[dsh-agent-plugins-market] ${stage} is still running after ${CHANGE_STAGE_DEADLINE_MS}ms; the change pipeline continues without waiting for it`);
-        }
-    };
-    /**
-     * Catalog change pipeline: invalidate the derived skill and command
-     * surfaces, refresh the project mounts, then reconcile every runtime mount.
-     * `CatalogContext` schedules it in the background, so a stage that overruns
-     * costs freshness, never the mutation that asked for it.
-     */
-    const onChanged = async () => {
-        if (disposed)
-            return;
-        providerControl?.invalidate();
-        userPanelControl?.invalidate();
-        await runStage('project commands', () => projectCommands?.refresh());
-        await runStage('suite instructions', () => suitePrompts?.refresh());
-        await runStage('project MCP and hooks', () => Promise.all([projectMcp?.refresh(), projectHooks?.refresh()]));
-        await runStage('user commands', () => reconcileUserCommands());
-        await runStage('runtime mounts', () => scheduler.request());
-    };
-    // Background source updates: off until the settings switch says otherwise.
-    const autoUpdate = new SourceAutoUpdater(ctx, () => catalog.refreshSource());
-    const settings = new MarketSettingsNamespace(ctx, config, dataRoot, hostLocale, {
-        setScanProjectLayouts: enabled => catalog.setScanProjectLayouts(enabled),
-        refreshMcpMounts: () => {
-            void Promise.all([scheduler.request(), projectMcp?.refresh()]).catch(() => { });
-        },
-        setAutoUpdateSources: enabled => autoUpdate.setEnabled(enabled)
-    });
-    // The credentials store powers the MCP re-authorize action (dropping a grant
-    // record forces the next mount through a fresh browser authorization). Every
-    // port below is read at call time: this plugin's apply may run before the
-    // credentials, tools and settings services provision, and a snapshot taken
-    // here would be permanently undefined even after the service is live.
-    // Read at call time: the tools service provisions after apply() returns.
-    let toolsRegistry = toolsServiceOf(ctx);
-    const ports = {
-        mcpToolSnapshot: () => inspectToolRegistry(toolsRegistry),
-        credentialsStore: {
-            deleteGrantRecord: async (serverName) => {
-                const store = ctx.get?.('credentials');
-                await deleteMcpAuthGrant(store, serverName);
-            }
-        },
-        // Re-authorize must rebuild the live bridge, not just drop the grant: the
-        // registry flags the mount and the following reconcile tears it down and
-        // remounts, so the server's 401 restarts the browser authorization.
-        mcpRemount: (suiteId, serverKey) => runtime.forceMcpRemount(suiteId, serverKey),
-        mcpRemountAll: () => runtime.forceMcpRemountAll(),
-        mcpServerOwner: serverName => runtime.mcpServerOwner(serverName),
-        lspStatusSource: runtime.lsp,
-        mcpBackend: () => settings.backend(),
-        setMcpBackend: backend => settings.setBackend(backend),
-        downloadRegion: () => settings.downloadRegion(),
-        localePreference: () => readLocalePreference() ?? 'zh'
-    };
-    const catalog = new Catalog({ userRoot, dataRoot, agentsRoot, onChanged, ports, ...(config.git === undefined ? {} : { git: config.git }) });
-    await catalog.load();
-    // Configured seeds first, then the record this plugin presets: the market
-    // lists the first-party collection on the first open, and the ordinary
-    // refresh path clones it. Registration performs no network access.
-    await catalog.mergeSources([...(config.sources ?? []), presetSourceRef()]);
-    const resources = createPanelResources(catalog, panels);
-    runtime.setMcpOverridesProvider(async () => catalog.allMcpOverrides(await catalog.enabledUserSuites()));
-    runtime.lsp.setDirectProvider(async () => (await loadLspServers(agentsRoot)).servers);
-    runtime.lsp.setDisabledProvider(() => loadDisabledLspServers(dataRoot));
-    runtime.setMcpBackendProvider(() => catalog.mcpBackend());
-    // The namespace must be registered after the catalog exists: the host
-    // resolves the inject callback synchronously when the settings service is
-    // already mounted, and the registration reads back the project-layout switch.
-    settings.mount();
-    ctx.inject(['tools'], toolsCtx => {
-        toolsRegistry = toolsCtx.tools;
-        // Foreign-namespace guard: a native host MCP client (or another plugin)
-        // owning `mcp__<serverName>__` names makes the mount registry skip its
-        // own server with a clear diagnostic instead of failing mid-registration.
-        runtime.setMcpToolNamesProvider(() => inspectToolRegistry(toolsRegistry).map(tool => tool.name));
-    });
-    void Promise.resolve()
-        .then(async () => {
-        await reconcileUserCommands();
-        await scheduler.request();
-    })
-        .catch(() => { });
-    // The shell seam resolves lazily: the service may land after this plugin, and
-    // a profile without one keeps dynamic-context placeholders literal.
-    const shellSeam = () => shellSeamOf(ctx);
-    ctx.skills.registerProvider(control => {
-        providerControl = control;
-        return new SuiteSkillProvider(catalog, { dataRoot, shell: shellSeam });
-    });
-    // User panel skills ride a second provider so a panel
-    // edit invalidates only its own catalog contribution.
-    ctx.skills.registerProvider(control => {
-        userPanelControl = control;
-        return new UserPanelSkillProvider(panels.skills);
-    });
-    ctx.inject(['tools', 'llm', 'subagents', 'agents'], hostCtx => {
-        hostCtx.effect(() => mountAgentRoleTool(hostCtx, async (parent) => [
-            ...(await resources.agents.list(true)).map(entry => ({ ...entry, title: entry.name, name: entry.id ?? entry.name })),
-            ...(await projectAgentRoles(catalog, parent))
-        ]), 'dsh-agent-plugins-market: agent role routing');
-    });
-    ctx.inject(['agents'], hostCtx => {
-        hostCtx.effect(() => {
-            const mounted = mountProjectCommands(hostCtx, catalog, key => hostLocale.t(key), dataRoot);
-            const mcp = mountProjectMcp(hostCtx, catalog, dataRoot);
-            const hooks = mountProjectHooks(hostCtx, catalog);
-            const prompts = mountSuiteInstructions(hostCtx, catalog, dataRoot);
-            projectCommands = mounted;
-            projectMcp = mcp;
-            projectHooks = hooks;
-            suitePrompts = prompts;
-            return async () => {
-                if (projectCommands === mounted)
-                    projectCommands = undefined;
-                if (projectMcp === mcp)
-                    projectMcp = undefined;
-                if (projectHooks === hooks)
-                    projectHooks = undefined;
-                if (suitePrompts === prompts)
-                    suitePrompts = undefined;
-                await Promise.all([mounted.dispose(), mcp.dispose(), hooks.dispose(), prompts.dispose()]);
-            };
-        }, 'dsh-agent-plugins-market: project command lifecycle');
-    });
-    ctx.inject(['webServer', 'loader'], hostCtx => {
-        hostCtx.effect(() => mountSuiteRoutes(hostCtx, catalog, resources), 'dsh-agent-plugins-market: http routes');
-    });
-    ctx.effect(() => () => {
-        disposed = true;
-        scheduler.dispose();
-        autoUpdate.dispose();
-        settings.dispose();
-        userCommands.disposeAll();
-        void runtime.dispose();
-    }, 'dsh-agent-plugins-market: lifecycle');
-}
+/** Public installation entry; domain ownership lives in private workspace packages. */
+export * from './packages/market-bundle/src/index.js';

package/lib/{application → packages/market-bundle/src/application}/catalog.js

@@ -9,18 +9,19 @@
  * MCP, LSP). The facade composes them and forwards, so a caller never has to
  * know which collaborator owns a given invariant.
  */
-import { qualifiedSuiteId } from '../catalog/paths.js';
-import { loadUserMcpSuite } from './mcp/mcp-direct-config.js';
-import { loadSuiteOverrides } from './mcp/mcp-overrides.js';
-import { loadUserHooksSuite } from './panels/user-hooks.js';
-import { applyLspOverrides } from './server-config.js';
-import { buildSuiteDetail, readSkillContent } from './details.js';
-import { CatalogContext } from './catalog-context.js';
-import { InstallStore } from './install-store.js';
-import { LspService } from './lsp-service.js';
-import { McpService } from './mcp-service.js';
-import { resolveCatalogPorts } from './ports.js';
-import { SourceStore, codeloadTarballUrl } from './source-store.js';
+import { qualifiedSuiteId } from '../../../market-catalog/src/index.js';
+import { loadUserMcpSuite } from '../../../market-mcp/src/index.js';
+import { loadUserHooksSuite } from '../../../market-runtime/src/index.js';
+import { applyLspOverrides } from '../../../market-lsp/src/index.js';
+import { SuiteQueries } from './suite-queries.js';
+import { CatalogContext } from '../../../market-catalog/src/index.js';
+import { TranslationService } from '../../../market-translation/src/index.js';
+import { InstallStore } from '../../../market-catalog/src/index.js';
+import { LspService } from '../../../market-lsp/src/index.js';
+import { McpService } from '../../../market-mcp/src/index.js';
+import { resolveCatalogPorts } from '../../../market-contracts/src/ports/ports.js';
+import { SourceStore, codeloadTarballUrl } from '../../../market-catalog/src/index.js';
+import { readExtensionSuiteDeclarations } from '../../../market-runtime/src/index.js';
 export class Catalog {
     context;
     ports;
@@ -29,14 +30,38 @@ export class Catalog {
     installs;
     mcp;
     lsp;
+    translation;
+    suiteQueries;
     constructor(options) {
         this.context = new CatalogContext(options);
         this.ports = resolveCatalogPorts(options.ports);
         this.snapshots = this.context.snapshots;
         this.sourceStore = new SourceStore(this.context, this.ports);
         this.installs = new InstallStore(this.context, this.sourceStore);
-        this.mcp = new McpService(this.context, this.ports, this.sourceStore);
-        this.lsp = new LspService(this.context, this.ports);
+        // The status builders resolve translations through this callback rather
+        // than reaching into the service, so the panel surfaces stay independent
+        // of how the catalog stores them.
+        const localizeFields = (surface, id, fields, locale) => this.translateFields(surface, id, fields, locale);
+        this.mcp = new McpService(this.context, this.ports, this.sourceStore, localizeFields);
+        this.lsp = new LspService(this.context, this.ports, localizeFields);
+        this.translation = new TranslationService({
+            dataRoot: this.context.dataRoot,
+            providers: this.ports.translationProviders ?? [],
+            ...(this.ports.translationEnabled === undefined ? {} : { enabled: this.ports.translationEnabled }),
+            providerIdentity: this.ports.translationProviderIdentity ?? (() => 'none')
+        });
+        // Every dependency is a closure over this instance, so a caller that replaces
+        // one of these methods still decides what the query sees.
+        this.suiteQueries = new SuiteQueries({
+            readUserCatalog: () => this.readUserCatalog(),
+            readProjectCatalog: cwd => this.readProjectCatalog(cwd),
+            installed: (sourceId, suiteId) => this.context.installed(sourceId, suiteId),
+            dataRoot: () => this.context.dataRoot,
+            mcpDiagnostics: () => this.mcp.diagnostics,
+            localePreference: () => this.ports.localePreference(),
+            translateFields: (surface, id, fields, locale) => this.translateFields(surface, id, fields, locale),
+            translateDocument: (surface, id, text, locale, retry) => this.translateDocument(surface, id, text, locale, retry)
+        });
     }
     /** Latest MCP mount diagnostics (suiteId -> reasons), fed by host reconcile. */
     get mcpDiagnostics() {
@@ -53,6 +78,32 @@ export class Catalog {
     get dataRoot() {
         return this.context.dataRoot;
     }
+    /** The shared Agent layout root the direct user declarations (hooks, MCP) are read from. */
+    get agentsRoot() {
+        return this.context.agentsRoot;
+    }
+    /**
+     * The host locale preference the panels render in.
+     *
+     * A read that walks many rows resolves it once and passes the value to every
+     * {@link translateFields} call: the host answers the preference by projecting
+     * every profile entry's live configuration, so reading it per row made a
+     * panel's latency scale with its row count instead of its work.
+     */
+    get localePreference() {
+        return this.ports.localePreference();
+    }
+    /**
+     * The clock this catalog's caches age against.
+     *
+     * The panel row cache is derived from the same files the snapshot cache
+     * walks, so it measures its maximum age on the same timeline: a test that
+     * drives the catalog's injected clock drives both, and a deployment gets the
+     * one process clock.
+     */
+    now() {
+        return this.context.now();
+    }
     get sources() {
         return this.context.state.sources;
     }
@@ -67,6 +118,42 @@ export class Catalog {
     /** Load persisted user state once at plugin activation. */
     async load() {
         await this.context.load();
+        // Cached translations load alongside the catalog so the first overview
+        // answers from cache instead of re-asking a provider.
+        await this.translation.load();
+    }
+    /** Release the localizer's and the snapshot cache's timers; in-flight work still persists. */
+    dispose() {
+        this.translation.dispose();
+        this.snapshots.dispose();
+    }
+    /**
+     * Drop every cached translation, in memory and on disk.
+     *
+     * Translation is lazy, so this is the whole of the reset: nothing is queued
+     * here, and the next panel read repopulates the cache from scratch. The
+     * in-memory copy is emptied too, or the same process would keep serving text
+     * the file no longer holds.
+     * @returns fulfillment once the cache is empty.
+     */
+    async clearTranslations() {
+        await this.translation.clear();
+    }
+    /** Apply the current display preference to pending translation work. */
+    syncTranslationEnabled() {
+        this.translation.onEnabledChanged();
+    }
+    /**
+     * Wait for queued translations to finish.
+     *
+     * Nothing on the request path calls this — the panel renders upstream text
+     * and re-reads. It exists so a test can observe the settled state instead of
+     * polling.
+     * @param deadlineMs - maximum wait; omitted waits for the queue alone.
+     * @returns whether the queue drained before the deadline.
+     */
+    async settleDescriptions(deadlineMs) {
+        return this.translation.settle(deadlineMs);
     }
     /** Append config-seeded sources missing from user state and persist them. */
     async mergeSources(sources) {
@@ -92,6 +179,11 @@ export class Catalog {
     async readUserCatalog() {
         return this.snapshots.readUserCatalog();
     }
+    /** Installed local user declarations, including globally disabled suites; never changes global runtime discovery. */
+    async installedSuiteDeclarations() {
+        const snapshot = await this.readUserCatalog();
+        return readExtensionSuiteDeclarations(snapshot.suites.filter(suite => this.context.installed(suite.sourceId, suite.id) !== undefined));
+    }
     /** Read one coherent project-dimension snapshot for a workspace cwd. */
     async readProjectCatalog(cwd) {
         return this.snapshots.readProjectCatalog(cwd);
@@ -113,12 +205,25 @@ export class Catalog {
         const direct = [...(Object.keys(mcp.mcp.servers).length === 0 ? [] : [mcp]), ...(hooks.surfaces.hooks === 0 ? [] : [hooks])];
         return applyLspOverrides(this.context.dataRoot, direct.length === 0 ? suites : [...suites, ...direct]);
     }
-    /** The full market overview from one user snapshot. */
+    /**
+     * The full market overview from one user snapshot.
+     *
+     * The description is localized on the way out: a suite whose text is already
+     * Chinese (or already bilingual) is served as authored, and every other
+     * description is translated in the background. The read itself never waits on
+     * a provider call — a suite with no cached translation carries its original
+     * text plus a translated field only once one lands, and the panel re-reads
+     * while anything reports itself pending.
+     */
     async overview() {
         const snapshot = await this.readUserCatalog();
         const sourceRows = await this.sourceStore.overviewRows(snapshot);
+        const locale = this.ports.localePreference();
+        let translationPending = 0;
         const cards = snapshot.suites.map(suite => {
             const isInstalled = this.isInstalled(suite.sourceId, suite.id);
+            const localized = this.translateFields('market', qualifiedSuiteId(suite.sourceId, suite.id), { name: suite.manifest.name, description: suite.manifest.description }, locale);
+            translationPending += localized.pending;
             return {
                 sourceId: suite.sourceId,
                 suiteId: suite.id,
@@ -134,7 +239,8 @@ export class Catalog {
                 dimension: suite.dimension,
                 layout: suite.manifest.layout,
                 errors: suite.errors,
-                mcpErrors: this.mcp.diagnostics.filter(diagnostic => diagnostic.suiteId === suite.id).map(diagnostic => `${diagnostic.serverKey}: ${diagnostic.reason}`)
+                mcpErrors: this.mcp.diagnostics.filter(diagnostic => diagnostic.suiteId === suite.id).map(diagnostic => `${diagnostic.serverKey}: ${diagnostic.reason}`),
+                ...localized.fields
             };
         });
         return {
@@ -146,25 +252,71 @@ export class Catalog {
                 enabled: cards.filter(card => card.enabled).length
             },
             roots: { user: this.context.userRoot, data: this.context.dataRoot },
-            unmanaged: await this.sourceStore.unmanaged()
+            unmanaged: await this.sourceStore.unmanaged(),
+            ...(translationPending === 0 ? {} : { translationPending })
         };
     }
-    /** One suite's full detail for the market detail modal. */
-    async suiteDetail(sourceId, suiteId) {
-        const snapshot = await this.readUserCatalog();
-        const suite = snapshot.suites.find(entry => entry.sourceId === sourceId && entry.id === suiteId);
-        if (suite === undefined)
-            throw new Error(`suite "${suiteId}" not found in source "${sourceId}"`);
-        const suiteKey = qualifiedSuiteId(sourceId, suiteId);
-        return buildSuiteDetail(suite, this.context.installed(sourceId, suiteId), this.mcp.diagnostics, await loadSuiteOverrides(this.context.dataRoot, suiteKey));
-    }
-    /** One skill's full SKILL.md text for the market detail modal. */
-    async skillContent(sourceId, suiteId, skillName) {
-        const snapshot = await this.readUserCatalog();
-        const suite = snapshot.suites.find(entry => entry.sourceId === sourceId && entry.id === suiteId);
-        if (suite === undefined)
-            throw new Error(`suite "${suiteId}" not found in source "${sourceId}"`);
-        return readSkillContent(suite, skillName);
+    /** One entity's translated description, pending count included. {@link TranslationService.translateFields} owns the rule. */
+    translateFields(surface, id, fields, locale) {
+        return this.translation.translateFields(surface, id, fields, locale);
+    }
+    /** One authored text translated chunk by chunk. {@link TranslationService.translateDocument} owns the rule for bodies. */
+    translateDocument(surface, id, text, locale, retry = false) {
+        return this.translation.translateDocument(surface, id, text, locale, retry);
+    }
+    /**
+     * The localized face of every `/` menu row this plugin owns.
+     *
+     * The rows come from the runtime registries (through
+     * {@link CatalogPorts.menuRowIdentities}) because only they know the call name
+     * a command actually got; the text comes from the shared translation service,
+     * because the panel reads it through the same translation cache. Resolution
+     * is a cache read and never a provider call: a row whose text is not cached
+     * yet answers without a face, and the panel read that follows queues it.
+     *
+     * A field is emitted only when the translation differs from the authored
+     * text. The menu shows the call name beside the label, so a name that
+     * translated to itself would only duplicate the alias.
+     * @returns one wire row per owned menu row, without rows carrying no translation.
+     */
+    async menuRowFaces() {
+        // No chain, no translations: every cache key is folded with the chain's
+        // identity, so a deployment with no provider has nothing cached to serve.
+        // Skipping it also skips the panel reads behind the rows, which walk every
+        // suite's resources.
+        if ((this.ports.translationProviders ?? []).length === 0)
+            return [];
+        // The switch mirrors the client's: while it is off the `/` menu is not
+        // wrapped at all and renders the host's own rows, so walking the panels for
+        // faces nothing would display only spends the reads. The panels themselves
+        // still render what is already cached — the switch gates new work there.
+        if (this.ports.translationEnabled?.() === false)
+            return [];
+        // One preference read for the whole menu: the host answers it by projecting
+        // every profile entry's live configuration, so resolving it per row made
+        // opening the menu scale with the row count.
+        const locale = this.ports.localePreference();
+        const faces = [];
+        for (const row of await this.ports.menuRowIdentities()) {
+            const { fields } = this.translateFields(row.source, row.id, { description: row.authoredDescription }, locale);
+            const description = row.authoredDescription === undefined || fields.translatedDescription === row.authoredDescription ? undefined : fields.translatedDescription;
+            if (description === undefined)
+                continue;
+            faces.push({ source: row.source, name: row.name, description });
+        }
+        return faces;
+    }
+    /** One suite's full detail. {@link SuiteQueries.suiteDetail} owns the composition. */
+    async suiteDetail(sourceId, suiteId, projectCwd) {
+        return this.suiteQueries.suiteDetail(sourceId, suiteId, projectCwd);
+    }
+    /** One suite document's authored text. {@link SuiteQueries.suiteDocument} owns the read. */
+    async suiteDocument(sourceId, suiteId, kind, name, projectCwd) {
+        return this.suiteQueries.suiteDocument(sourceId, suiteId, kind, name, projectCwd);
+    }
+    /** One suite document's translation. {@link SuiteQueries.suiteDocumentTranslation} owns the keying. */
+    async suiteDocumentTranslation(sourceId, suiteId, kind, name, retry = false, projectCwd) {
+        return this.suiteQueries.suiteDocumentTranslation(sourceId, suiteId, kind, name, projectCwd, retry);
     }
     // ---- Source acquisition and CRUD ----
     /** Add a source and acquire it immediately (clone, download, or in-place). */
@@ -190,6 +342,9 @@ export class Catalog {
     /** Refresh one source checkout, or every source when sourceId is omitted. */
     async refreshSource(sourceId) {
         await this.sourceStore.refresh(sourceId);
+        // No warm-up here: a refresh runs from the background updater too, and
+        // translating then would make the layer eager again. The next panel read
+        // discovers the new text and queues it.
     }
     /** Progress snapshot for the progress route. */
     sourceProgress() {
@@ -229,17 +384,28 @@ export class Catalog {
     async mcpStatus() {
         return this.mcp.status();
     }
-    /** Persist a user-owned MCP service and reconcile its bridge mount. */
-    async addMcpServer(name, server) {
-        await this.mcp.addServer(name, server);
+    /** Validate and persist a user-owned MCP service with optional policy before reconciling its mount. */
+    async addMcpServer(name, server, policy) {
+        await this.mcp.addServer(name, server, policy);
     }
-    /** Read effective service configuration without exposing credential literals. */
-    async serverConfig(kind, id) {
-        return this.mcp.serverConfig(kind, id);
+    /**
+     * Read a service without credential literals, or an unsaved template when
+     * `create` is true. The two transports have separate owners, so this facade
+     * only routes the request to the module that owns the declaration.
+     */
+    async serverConfig(kind, id, create = false) {
+        return kind === 'mcp' ? this.mcp.serverConfig(id, create) : this.lsp.serverConfig(id, create);
     }
-    /** Validate a complete replacement before writing; plugin checkouts remain untouched. */
+    /**
+     * Validate a complete replacement before writing; plugin checkouts remain
+     * untouched. The MCP half also carries the editing policy, which the LSP
+     * document has no seat for.
+     */
     async saveServerConfig(kind, id, config, policy) {
-        await this.mcp.saveServerConfig(kind, id, config, policy);
+        if (kind === 'mcp')
+            await this.mcp.saveServerConfig(id, config, policy);
+        else
+            await this.lsp.saveServerConfig(id, config);
     }
     /** One suite's persisted MCP overrides, addressed by qualified suite id. */
     async mcpOverrides(sourceId, suiteId) {