dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/types/packages/market-bundle/src/application/suite-queries.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Suite presentation queries: one suite's detail, one suite document, and that
+ * document's translation.
+ *
+ * The three reads share one lookup — a source-qualified identity resolved in the
+ * user snapshot, or in one project's when the caller names a workspace — and one
+ * presentation composed over it. They live here rather than on the facade
+ * because the facade composes collaborators and forwards, while these reads
+ * carry the rule themselves: which snapshot answers, what the detail shows, and
+ * how a document's translation is keyed.
+ *
+ * Every dependency arrives as a function on {@link SuiteQueryPorts}. The facade
+ * passes closures, so a caller that replaces one of its own methods (a test
+ * stubbing the localization callbacks or the user snapshot read) is still the
+ * one called here.
+ * @module application/suite-queries
+ */
+import { type CatalogSnapshot } from '../../../market-catalog/src/index.js';
+import type { InstalledEntry } from '../../../market-contracts/src/model/types.js';
+import type { McpMountDiagnostic } from '../../../market-contracts/src/contracts/mcp.js';
+import type { SuiteDetail, SuiteDocumentText, UserPanelKind } from '../../../market-contracts/src/contracts/market.js';
+import type { DocumentTranslation } from '../../../market-contracts/src/contracts/translation.js';
+import type { LocalizeDocument, LocalizeFields } from '../../../market-contracts/src/ports/ports.js';
+/** The reads one suite query needs, each resolved per call. */
+export interface SuiteQueryPorts {
+    /** The user-dimension snapshot this deployment serves. */
+    readUserCatalog(): Promise<CatalogSnapshot>;
+    /** One workspace's project snapshot. */
+    readProjectCatalog(cwd: string): Promise<CatalogSnapshot>;
+    /** Install entry of one suite; undefined while it is not installed. */
+    installed(sourceId: string, suiteId: string): InstalledEntry | undefined;
+    /** Plugin storage root holding per-suite overrides. */
+    dataRoot(): string;
+    /** Live MCP mount diagnostics, as the mount registry last reported them. */
+    mcpDiagnostics(): readonly McpMountDiagnostic[];
+    /** The host locale preference this read resolves once. */
+    localePreference(): string;
+    /** Resolve one entity's translated fields, on the facade's own callback. */
+    translateFields: LocalizeFields;
+    /** Resolve one document body, on the facade's own callback. */
+    translateDocument: LocalizeDocument;
+}
+export declare class SuiteQueries {
+    private readonly ports;
+    constructor(ports: SuiteQueryPorts);
+    /** One suite's full detail for the market detail modal. */
+    suiteDetail(sourceId: string, suiteId: string, projectCwd?: string): Promise<SuiteDetail>;
+    /**
+     * One suite document's authored text for the market detail modal — a skill, a
+     * command, or an agent, all through the one reader.
+     *
+     * The suite comes from the same snapshot {@link suiteDetail} answers from, and
+     * the text is re-read from the checkout the scan found it in: the request
+     * names an identity, never a path, so this route cannot be spent on a file of
+     * a page's choosing.
+     */
+    suiteDocument(sourceId: string, suiteId: string, kind: UserPanelKind, name: string, projectCwd?: string): Promise<SuiteDocumentText>;
+    /**
+     * Translate one suite document for the market detail page.
+     *
+     * The suite comes from the same snapshot {@link suiteDetail} and
+     * {@link suiteDocument} answer from, and the document is re-read from the
+     * checkout the scan found it in: the request names an identity and never
+     * carries text, so this path cannot be spent on content of a page's choosing.
+     *
+     * The translation is keyed exactly as the user panel keys the same file
+     * ({@link pluginResourceId}, on the document's own surface), so one document
+     * is one cache entry however it was opened — whichever surface translated it
+     * first, the other reads it back without paying a provider again.
+     *
+     * Frontmatter is stripped for the reason the panel strips it: a provider
+     * asked to translate YAML answers with YAML that no longer parses. The reader
+     * still sees the authored block above the document, because the row renders
+     * the file and this section renders only its translation.
+     * @param sourceId - the source the suite belongs to.
+     * @param suiteId - the suite's id inside that source.
+     * @param kind - which document surface the name belongs to.
+     * @param name - the document's name inside that surface.
+     * @returns the assembled body and how many chunks are still in flight.
+     */
+    suiteDocumentTranslation(sourceId: string, suiteId: string, kind: UserPanelKind, name: string, projectCwd?: string, retry?: boolean): Promise<DocumentTranslation>;
+    /** The normalized suite a source-qualified identity names, or a miss. */
+    private suiteOf;
+}

package/lib/types/packages/market-bundle/src/index.d.ts

@@ -0,0 +1,125 @@
+import { type Context, type Volatile } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { DownloadRegionSetting } from '../../market-contracts/src/contracts/settings.js';
+import type { SourceRef } from '../../market-contracts/src/model/types.js';
+export declare const name = "dsh-agent-plugins-market";
+export declare const inject: string[];
+/** Host configuration. */
+/** Host configuration; the five market settings arrive as volatile references the host updates in place. */
+export interface Config {
+    /** User-dimension suite root; defaults to `~/.dsh/agent-plugins` (`$DSH_HOME/agent-plugins`). */
+    userRoot?: string;
+    /** Legacy mutable data root to migrate; writes always use the canonical root/data. */
+    dataRoot?: string;
+    /** Initial repository sources, merged into the persisted state on first load. */
+    sources?: SourceRef[];
+    /**
+     * Git/archive acquisition tuning: `proxy` (http/https proxy URL),
+     * `insteadOf` URL-prefix rewrites (mirror acceleration), `timeoutMs` per
+     * git invocation, `cloneRetry` (default true), `fallbackTarball` (retry a
+     * failed GitHub clone as a codeload tarball download; default false), and
+     * `allowHttpArchives` (permit plain-http archive URLs; default false).
+     */
+    git?: {
+        proxy?: string;
+        insteadOf?: Record<string, string>;
+        timeoutMs?: number;
+        cloneRetry?: boolean;
+        fallbackTarball?: boolean;
+        allowHttpArchives?: boolean;
+    };
+    /** MCP mount backend switch; updated live through the host settings service. */
+    mcpEnhanced: Volatile<boolean | undefined>;
+    /** Project-layout discovery switch; updated live through the host settings service. */
+    scanProjectLayouts: Volatile<boolean | undefined>;
+    /** Download region choice; updated live through the host settings service. */
+    downloadRegion: Volatile<DownloadRegionSetting | undefined>;
+    /** Experience-feedback tool switch; updated live through the host settings service. */
+    feedbackEnabled: Volatile<boolean | undefined>;
+    /** Background source-update switch; updated live through the host settings service. */
+    autoUpdateSources: Volatile<boolean | undefined>;
+    /** UI translation switch; updated live through the host settings service. */
+    translationEnabled: Volatile<boolean | undefined>;
+    /** Agent preset manager switch (experimental); updated live through the host settings service. */
+    agentPresetsEnabled: Volatile<boolean | undefined>;
+}
+/**
+ * Schemastery projection the host loader reads: the seven volatile fields become
+ * the `dsh-agent-plugins-market` settings namespace (the Plugins panel's
+ * configuration page reads it), while the startup fields stay plain.
+ */
+/** The schema's input face: every field optional, exactly what a profile patch may carry. */
+export interface ConfigInput {
+    userRoot?: string | null;
+    dataRoot?: string | null;
+    sources?: unknown;
+    git?: {
+        proxy?: string | null;
+        insteadOf?: Record<string, unknown>;
+        timeoutMs?: number | null;
+        cloneRetry?: boolean | null;
+        fallbackTarball?: boolean | null;
+        allowHttpArchives?: boolean | null;
+    };
+    mcpEnhanced?: boolean | null;
+    scanProjectLayouts?: boolean | null;
+    downloadRegion?: 'auto' | 'global' | 'china' | null;
+    feedbackEnabled?: boolean | null;
+    autoUpdateSources?: boolean | null;
+    translationEnabled?: boolean | null;
+    agentPresetsEnabled?: boolean | null;
+}
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    userRoot: z<string | undefined, string | undefined, "plain">;
+    dataRoot: z<string | undefined, string | undefined, "plain">;
+    sources: z<any, any, "plain">;
+    git: z<Schemastery.ObjectS<NoInfer<{
+        proxy: z<string, string, "plain">;
+        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
+        timeoutMs: z<number, number, "plain">;
+        cloneRetry: z<boolean, boolean, "plain">;
+        fallbackTarball: z<boolean, boolean, "plain">;
+        allowHttpArchives: z<boolean, boolean, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        proxy: z<string, string, "plain">;
+        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
+        timeoutMs: z<number, number, "plain">;
+        cloneRetry: z<boolean, boolean, "plain">;
+        fallbackTarball: z<boolean, boolean, "plain">;
+        allowHttpArchives: z<boolean, boolean, "plain">;
+    }>>, "plain">;
+    mcpEnhanced: z<boolean, boolean, "volatile-defined">;
+    scanProjectLayouts: z<boolean, boolean, "volatile-defined">;
+    downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china", "volatile-defined">;
+    feedbackEnabled: z<boolean, boolean, "volatile-defined">;
+    autoUpdateSources: z<boolean, boolean, "volatile-defined">;
+    translationEnabled: z<boolean, boolean, "volatile">;
+    agentPresetsEnabled: z<boolean, boolean, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    userRoot: z<string | undefined, string | undefined, "plain">;
+    dataRoot: z<string | undefined, string | undefined, "plain">;
+    sources: z<any, any, "plain">;
+    git: z<Schemastery.ObjectS<NoInfer<{
+        proxy: z<string, string, "plain">;
+        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
+        timeoutMs: z<number, number, "plain">;
+        cloneRetry: z<boolean, boolean, "plain">;
+        fallbackTarball: z<boolean, boolean, "plain">;
+        allowHttpArchives: z<boolean, boolean, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        proxy: z<string, string, "plain">;
+        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
+        timeoutMs: z<number, number, "plain">;
+        cloneRetry: z<boolean, boolean, "plain">;
+        fallbackTarball: z<boolean, boolean, "plain">;
+        allowHttpArchives: z<boolean, boolean, "plain">;
+    }>>, "plain">;
+    mcpEnhanced: z<boolean, boolean, "volatile-defined">;
+    scanProjectLayouts: z<boolean, boolean, "volatile-defined">;
+    downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china", "volatile-defined">;
+    feedbackEnabled: z<boolean, boolean, "volatile-defined">;
+    autoUpdateSources: z<boolean, boolean, "volatile-defined">;
+    translationEnabled: z<boolean, boolean, "volatile">;
+    agentPresetsEnabled: z<boolean, boolean, "volatile-defined">;
+}>>, "plain">;
+export declare function apply(ctx: Context, config?: Config): Promise<void>;

package/lib/types/{runtime/host → packages/market-bundle/src/platform}/settings-namespace.d.ts

@@ -2,21 +2,23 @@
  * The market settings the host carries in this plugin's own config: the loader
  * projects the entry's `Config` schema into the `dsh-agent-plugins-market`
  * settings namespace, so the Plugins panel's configuration page reads and
- * writes these five switches, and the host updates the volatile references in
+ * writes these seven fields, and the host updates the volatile references in
  * place on every change (emitting `loader/volatile-update`).
  *
  * Every consumer reads through {@link MarketSettingsNamespace.settings} so
  * "the field is absent" has exactly one answer —
  * {@link resolveMarketSettings} — instead of each caller inventing its own
- * fallback for the window before the host applies its first value.
+ * fallback for the window before the host applies its first value. That reader
+ * also takes the interface language, because one field's default follows it
+ * rather than a constant.
  *
  * @module runtime/settings-namespace
  */
 import type { Context } from '@deepseek-ai/cordis';
-import { type DownloadRegionSetting } from '../../contracts/settings.js';
-import type { HostTranslate } from './host-locale.js';
-import type { McpBackend } from '../../contracts/mcp.js';
-/** The five volatile references the entry's config carries for this namespace. */
+import { type DownloadRegionSetting } from '../../../market-contracts/src/contracts/settings.js';
+import type { HostTranslate } from '../../../market-runtime/src/index.js';
+import type { McpBackend } from '../../../market-contracts/src/contracts/mcp.js';
+/** The seven volatile references the entry's config carries for this namespace. */
 export interface MarketSettingRefs {
     mcpEnhanced: {
         get(): boolean | undefined;
@@ -33,6 +35,12 @@ export interface MarketSettingRefs {
     autoUpdateSources: {
         get(): boolean | undefined;
     };
+    translationEnabled: {
+        get(): boolean | undefined;
+    };
+    agentPresetsEnabled: {
+        get(): boolean | undefined;
+    };
 }
 /** Runtime reactions the namespace drives. */
 export interface SettingsNamespaceHost {
@@ -42,13 +50,21 @@ export interface SettingsNamespaceHost {
     refreshMcpMounts(): void;
     /** Arm or disarm the background source updater. */
     setAutoUpdateSources(enabled: boolean): void;
+    /** Stop queued work on disable; restore failed work eligibility on enable, without clearing cached results. */
+    syncTranslationEnabled(): void;
 }
 export declare class MarketSettingsNamespace {
     private readonly ctx;
-    private readonly refs;
     private readonly dataRoot;
     private readonly locale;
     private readonly host;
+    /**
+     * The host interface language, read per call. It is a reader rather than a
+     * captured string because a language switch must move the translation
+     * default without rebuilding this namespace.
+     */
+    private readonly localePreference;
+    private readonly refs;
     private readonly watchers;
     private feedbackDisposer;
     /**
@@ -60,13 +76,20 @@ export declare class MarketSettingsNamespace {
     private feedbackMountState;
     constructor(ctx: Context, refs: MarketSettingRefs, dataRoot: string, locale: {
         t: HostTranslate;
-    }, host: SettingsNamespaceHost);
+    }, host: SettingsNamespaceHost, 
+    /**
+     * The host interface language, read per call. It is a reader rather than a
+     * captured string because a language switch must move the translation
+     * default without rebuilding this namespace.
+     */
+    localePreference: () => string);
     /** Subscribe the runtime reactions to live settings updates. */
     mount(): void;
     /** Release every watcher and unmount the feedback tool. */
     dispose(): void;
     /**
-     * The resolved settings, from the volatile references the host updates in place.
+     * The resolved settings, from the volatile references the host updates in
+     * place and the interface language they resolve over.
      */
     private settings;
     /** The persisted MCP backend choice; the built-in client until the host applies a value. */
@@ -79,6 +102,18 @@ export declare class MarketSettingsNamespace {
     setBackend(backend: McpBackend): Promise<void>;
     /** The persisted download-region setting. */
     downloadRegion(): Promise<DownloadRegionSetting>;
+    /**
+     * Read the live translation switch: the stored preference while the user has
+     * one, the interface language's default otherwise.
+     */
+    translationEnabled(): boolean;
+    /**
+     * Notify the translation owner on either effective preference edge. Unrelated
+     * writes do not reset failures or disturb cached results.
+     * @param previous - whether translation was on at the last look.
+     * @returns whether it is on now, for the next comparison.
+     */
+    private syncTranslationProviders;
     /** Apply the background source-update switch. */
     private syncAutoUpdateSources;
     private syncProjectLayouts;

package/lib/types/{application/mcp/mcp-backend.d.ts → packages/market-bundle/src/platform/settings-schema.d.ts}

@@ -1,25 +1,16 @@
-/**
- * MCP backend selection: whether suite MCP servers mount through the
- * market's self-built bridge (default — stdio, Streamable HTTP with OAuth,
- * and legacy SSE) or through the host's `@deepseek-ai/dsh-mcp-client`
- * (compatibility mode: no OAuth, no SSE, but the host-native implementation).
- *
- * The choice is the `mcpEnhanced` field of the market's host settings
- * namespace (see `contracts/settings.ts`) registered by the plugin's node half:
- * the registration is what makes the host 插件配置 tab serve our card, the
- * client card binds it for state, and the node half watches it to remount
- * servers when the switch flips.
- *
- * @module application/mcp-backend
- */
 import z from '@deepseek-ai/schemastery';
-import type { McpBackend } from '../../contracts/mcp.js';
-export type { McpBackend };
 /**
  * Schema of the market settings namespace: the switches this plugin's config
  * card serves, with the defaults declared to the host. The values themselves
  * belong to {@link MARKET_SETTINGS_DEFAULTS}; this schema states them, it does
  * not own them.
+ *
+ * `translationEnabled` deliberately declares no default. Its default follows
+ * the interface language, and a declared default would be materialized into the
+ * live config reference, where "the user never set this" and "the user turned it
+ * off" would both read `false` — the distinction the derivation rests on. With
+ * the field absent, the reference answers `undefined` until the user writes it,
+ * and {@link resolveMarketSettings} fills the language's own default in.
  */
 export declare const MarketSettingsFields: {
     readonly mcpEnhanced: z<boolean, boolean, "defined">;
@@ -27,6 +18,8 @@ export declare const MarketSettingsFields: {
     readonly downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china", "defined">;
     readonly feedbackEnabled: z<boolean, boolean, "defined">;
     readonly autoUpdateSources: z<boolean, boolean, "defined">;
+    readonly translationEnabled: z<boolean, boolean, "plain">;
+    readonly agentPresetsEnabled: z<boolean, boolean, "defined">;
 };
 export declare const MarketSettingsSchema: z<Schemastery.ObjectS<NoInfer<{
     readonly mcpEnhanced: z<boolean, boolean, "defined">;
@@ -34,22 +27,14 @@ export declare const MarketSettingsSchema: z<Schemastery.ObjectS<NoInfer<{
     readonly downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china", "defined">;
     readonly feedbackEnabled: z<boolean, boolean, "defined">;
     readonly autoUpdateSources: z<boolean, boolean, "defined">;
+    readonly translationEnabled: z<boolean, boolean, "plain">;
+    readonly agentPresetsEnabled: z<boolean, boolean, "defined">;
 }>>, Schemastery.ObjectT<NoInfer<{
     readonly mcpEnhanced: z<boolean, boolean, "defined">;
     readonly scanProjectLayouts: z<boolean, boolean, "defined">;
     readonly downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china", "defined">;
     readonly feedbackEnabled: z<boolean, boolean, "defined">;
     readonly autoUpdateSources: z<boolean, boolean, "defined">;
+    readonly translationEnabled: z<boolean, boolean, "plain">;
+    readonly agentPresetsEnabled: z<boolean, boolean, "defined">;
 }>>, "plain">;
-/** What the host client probe reports: resolvability plus its version. */
-export interface HostMcpClientProbe {
-    available: boolean;
-    version?: string;
-}
-/**
- * Probe whether the host's `dsh-mcp-client` is resolvable from this plugin's
- * module context, and at which version. Best effort: any failure reads as
- * "unavailable", which the mount path surfaces as a per-server diagnostic
- * when the host backend is selected.
- */
-export declare function probeHostMcpClient(): Promise<HostMcpClientProbe>;

package/lib/types/packages/market-bundle/src/routes-extension-presets.d.ts

@@ -0,0 +1,15 @@
+/** Session-addressed extension APIs. Workspace authority comes from the live Agent, never request paths. */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ExtensionRouteService } from '../../market-runtime/src/index.js';
+export type { ExtensionRouteService } from '../../market-runtime/src/index.js';
+interface WebHost {
+    webServer: {
+        register(route: {
+            kind: 'exact';
+            path: string;
+            handler(request: IncomingMessage, response: ServerResponse): Promise<void>;
+        }): () => void;
+    };
+}
+/** Mount only after session initialization has an enforcement gate. */
+export declare function mountExtensionPresetRoutes(host: WebHost, service: ExtensionRouteService): () => void;

package/lib/types/packages/market-bundle/src/routes-resources.d.ts

@@ -0,0 +1,17 @@
+import type { ResourceFace } from '../../market-contracts/src/contracts/resource-window.js';
+import { type ResourceInventoryDeps } from './application/resource-inventory.js';
+/** What the window routes need from the composition root. */
+export interface ResourceRouteDeps extends ResourceInventoryDeps {
+    /** Flip one entry; the service persists and reconciles. */
+    setEntry(face: ResourceFace, entryId: string, enabled: boolean): Promise<unknown>;
+    /** Apply one favorite's complete snapshot (six switches plus entry filters). */
+    applyFavorite(id: string): Promise<void>;
+    /** Save the current workspace state as one named favorite; returns its id. */
+    saveFavorite(name: string): Promise<string>;
+    /** Drop one favorite by id. */
+    deleteFavorite(id: string): Promise<void>;
+    /** Reset this workspace to the installed default: no entry filters, every surface switch on. */
+    resetWorkspace(): Promise<void>;
+}
+/** Mount the resource-window routes; returns the disposer releasing them all. */
+export declare function mountResourceRoutes(hostCtx: unknown, deps: ResourceRouteDeps): () => void;

package/lib/types/packages/market-bundle/src/routes.d.ts

@@ -0,0 +1,32 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { MarketService } from '../../market-contracts/src/ports/queries.js';
+import type { PanelResourceStore } from '../../market-runtime/src/index.js';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ProjectExtensionReader } from './application/extension-project.js';
+export interface WebServerService {
+    register(route: {
+        kind: 'exact' | 'prefix';
+        path: string;
+        handler: (request: IncomingMessage, response: ServerResponse) => void | Promise<void>;
+    }): () => void;
+}
+/** The live-session lookup a read route uses to answer for one session's workspace. */
+export interface SuiteRouteSessionResolver {
+    /** The live agent for one session id; undefined when no such live session exists. */
+    agent(sessionId: string): Agent | undefined;
+    /**
+     * That agent's project reader. The transport cannot build one itself: it holds
+     * the panel stores but not the panel sources or the full catalog they are read
+     * over. Omitted means session-scoped reads stay unavailable, never global.
+     */
+    project?(agent: Agent): ProjectExtensionReader;
+}
+/** Mount every route; returns the disposer releasing them all. */
+export declare function mountSuiteRoutes(hostCtx: unknown, manager: MarketService, panels?: {
+    skills: PanelResourceStore;
+    commands: PanelResourceStore;
+    agents: PanelResourceStore;
+}, surfaceToggles?: {
+    currentToggles(): import('../../market-contracts/src/contracts/surface-toggles.js').SurfaceToggles;
+    set(key: import('../../market-contracts/src/contracts/surface-toggles.js').SurfaceToggleKey, enabled: boolean): Promise<unknown>;
+}, session?: SuiteRouteSessionResolver): () => void;

package/lib/types/packages/market-bundle/src/runtime-adapters.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The composition root's mount adapters for the runtime coordinator.
+ *
+ * The runtime package drives MCP and LSP through structural ports; this module
+ * is the one place that knows which registries implement them, so the concrete
+ * transport packages stay out of the runtime's import graph. Construction here
+ * mirrors what the coordinator used to do itself: the same constructor
+ * arguments, and the plugin data root still set by the coordinator.
+ *
+ * @module runtime-adapters
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { McpMountFactory, RuntimeMounts, SharedMcpMountPort } from '../../market-runtime/src/index.js';
+/**
+ * Build the shared-service MCP adapter over one context.
+ *
+ * The mount registry stays the sole owner of its transport state: this wrapper
+ * only adds the mount proof, which needs the registry's own server-name
+ * derivation, and forwards every other call unchanged.
+ * @param ctx - the context the registry mounts through.
+ * @param dataRoot - the plugin data root the registry stores overrides under.
+ * @returns the MCP adapter the coordinator drives.
+ */
+export declare function createSharedMcpMount(ctx: Context, dataRoot: string): SharedMcpMountPort;
+/**
+ * Create one MCP mount for an agent-scoped contributor.
+ *
+ * The contributor mounts into contexts it does not own, so it takes the factory
+ * and calls it per context; the adapter is the same object the coordinator
+ * drives, which keeps one registry implementation behind both seams.
+ * @param ctx - the context the mount registers into.
+ * @param dataRoot - the plugin data root the mount stores overrides under.
+ * @returns the MCP mount for that context.
+ */
+export declare const createMcpMount: McpMountFactory;
+/**
+ * Build both mount adapters one reconciler drives.
+ * @param ctx - the context the registries mount through.
+ * @param dataRoot - the plugin data root the MCP registry stores overrides under.
+ * @returns the MCP and LSP adapters for that reconciler.
+ */
+export declare function createRuntimeMounts(ctx: Context, dataRoot: string): RuntimeMounts;

package/lib/types/packages/market-bundle/src/session-extension.d.ts

@@ -0,0 +1,62 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ExtensionHookRunInput, ExtensionHooksOverview } from '../../market-contracts/src/contracts/extension-presets.js';
+import type { Suite } from '../../market-contracts/src/model/types.js';
+import { ScopedExtensionContributors, projectAgentRoles, type ExtensionSuiteCandidate, type RuntimeReconciler, type HostTranslate, type createUserPanelStores, type createPanelResources } from '../../market-runtime/src/index.js';
+import type { Catalog } from './application/catalog.js';
+import type { SuiteRouteSessionResolver } from './routes.js';
+interface SessionExtensionOptions {
+    ctx: Context;
+    dataRoot: string;
+    agentsRoot: string;
+    runtime: RuntimeReconciler;
+    hostLocale: {
+        t: HostTranslate;
+    };
+}
+interface SessionExtensionSources {
+    catalog: Catalog;
+    panels: ReturnType<typeof createUserPanelStores>;
+    resources: ReturnType<typeof createPanelResources>;
+    readUserDeclarations: () => Promise<ExtensionSuiteCandidate[]>;
+}
+interface SessionExtensions {
+    mount(sources: SessionExtensionSources): void;
+    invalidate(invalidateDefaultSkills: () => void): void;
+    refresh(): Promise<void> | undefined;
+    commandRegistrations(): ReturnType<ScopedExtensionContributors['registrations']>;
+    roles: (parent?: unknown) => Promise<{
+        entries: Awaited<ReturnType<typeof projectAgentRoles>>;
+        complete: boolean;
+    }>;
+    session(): SuiteRouteSessionResolver | undefined;
+}
+/** The catalog reads the settings Hooks page needs. */
+type HooksOverviewCatalog = Pick<Catalog, 'enabledUserSuites' | 'overview' | 'mcpStatus' | 'lspStatus'>;
+export declare function readHooksOverview(catalog: HooksOverviewCatalog): Promise<ExtensionHooksOverview>;
+/** One dry run's resolved declaration: the command the catalog published, or the stable code that names why none resolved. */
+export type HookDeclarationResolution = {
+    command: string;
+    timeoutSec?: number;
+    suite: Suite;
+} | {
+    error: string;
+};
+/**
+ * Resolve one dry run's declaration from the same rows the Hooks overview
+ * publishes.
+ *
+ * The caller passes the suites to search, so a session's project hooks join
+ * user and installed rows without changing how identity is built. The command
+ * comes from the scanned declaration; the request carries identity only.
+ * @param catalog - the catalog status reads the overview uses.
+ * @param suites - the suites whose hook rows the lookup may match.
+ * @param input - the declaration address from the client.
+ * @returns the resolved command with its suite, or a stable error code.
+ */
+export declare function resolveHookDeclaration(catalog: HooksOverviewCatalog, suites: readonly Suite[], input: ExtensionHookRunInput): Promise<HookDeclarationResolution>;
+/**
+ * Create the stable readers before catalog initialization. Mount only after its sources are loaded.
+ * Call mount once. Host injection owns start and disposal; construction registers nothing.
+ */
+export declare function createSessionExtensions({ ctx, dataRoot, runtime, hostLocale }: SessionExtensionOptions): SessionExtensions;
+export {};

package/lib/types/{application → packages/market-catalog/src/application}/catalog-context.d.ts

@@ -1,6 +1,6 @@
-import type { GitOptions } from '../catalog/git.js';
-import { type DiscoveredSuite, type InstalledEntry, type Suite, type SuiteDimension, type SuiteState } from '../model/types.js';
-import type { CatalogPortsOverride } from './ports.js';
+import type { GitOptions } from '../scanning/git.js';
+import { type DiscoveredSuite, type InstalledEntry, type Suite, type SuiteDimension, type SuiteState } from '../../../market-contracts/src/model/types.js';
+import type { CatalogPortsOverride } from '../../../market-contracts/src/ports/ports.js';
 import { SnapshotCache, type SnapshotHost } from './snapshot-cache.js';
 /**
  * Git network tuning, plumbed from the host config to every remote-touching
@@ -40,6 +40,12 @@ export interface CatalogOptions {
      * staleness regressions need no real sleeps.
      */
     userSnapshotTtlMs?: number;
+    /**
+     * Clock seam for every TTL and window the snapshot cache keeps. Defaults to
+     * `Date.now`; a test injects a hand-driven clock so freshness, the scan
+     * cache, and the keep-warm window are asserted instead of waited for.
+     */
+    now?: () => number;
 }
 /** Key of one install entry in the persisted `installed` record. */
 export declare function installKey(sourceId: string, suiteId: string): string;
@@ -71,6 +77,8 @@ export declare class CatalogContext implements SnapshotHost {
     readonly git: CatalogGitOptions;
     /** Discovery scans and dimension snapshots derived from {@link state}. */
     readonly snapshots: SnapshotCache;
+    /** The clock every TTL and window in this context is measured against. */
+    readonly now: () => number;
     private readonly onChanged;
     constructor(options: CatalogOptions);
     get state(): SuiteState;

package/lib/types/{application → packages/market-catalog/src/application}/install-store.d.ts

@@ -1,4 +1,4 @@
-import { type SourceRef, type SuiteSurfaceKey } from '../model/types.js';
+import { type SourceRef, type SuiteSurfaceKey } from '../../../market-contracts/src/model/types.js';
 import { type CatalogContext } from './catalog-context.js';
 import { type SourceStore } from './source-store.js';
 export declare class InstallStore {

package/lib/types/{application → packages/market-catalog/src/application}/regions.d.ts

@@ -13,7 +13,7 @@
  *
  * @module application/regions
  */
-import type { DownloadRegionSetting } from '../contracts/settings.js';
+import type { DownloadRegionSetting } from '../../../market-contracts/src/contracts/settings.js';
 /** The route downloads actually take. */
 export type EffectiveRegion = 'global' | 'china';
 /**