dsh-agent-plugins-market 0.9.0 → 0.9.2

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

@@ -0,0 +1,41 @@
+/** Explicit cross-domain entry surface. Internal modules are not import targets for siblings. */
+export { extensionResourceEnabled } from './application/extension-authorization.js';
+export { exposesIndividualHooks } from './application/extension-hook-selection.js';
+export { USER_HOOKS_SOURCE, USER_HOOKS_SUITE, loadUserHooksSuite } from './application/panels/user-hooks.js';
+export { createPanelResources, pluginResourceId } from './application/panel-resources.js';
+export { readExtensionSuiteDeclarations } from './application/extension-suite-declarations.js';
+export type { ExtensionSuiteCandidate } from './application/extension-suite-selection.js';
+export type { CatalogPort } from './catalog-port.js';
+export type { PanelResourceStore } from './application/panel-resources.js';
+export type { ResourceFilters } from './application/state/resource-filters.js';
+export { RuntimeReconciler } from './runtime/core/reconciler.js';
+export { ReconcileScheduler } from './runtime/core/reconcile-scheduler.js';
+export { SurfaceToggleService } from './runtime/host/surface-toggle-service.js';
+export { inspectToolRegistry, toolsServiceOf } from './runtime/host/tool-registry-observer.js';
+export { mountAgentRoleTool } from './runtime/agents/agent-role-router.js';
+export { mountUnlessAgentTeams } from './runtime/agents/agent-teams-seat.js';
+export { mountTeammateRoleTool } from './runtime/agents/teammate-role-tool.js';
+export { mountTeamCoordination } from './runtime/agents/team-coordination.js';
+export { projectAgentRoles } from './application/project-agent-roles.js';
+export { ExtensionRuntime, extensionWorkspace } from './runtime/host/extension-runtime.js';
+export { attachExtensionToolGates } from './runtime/host/extension-tool-gates.js';
+export type { ExtensionLspProvider, ExtensionMcpTool, ExtensionToolGates } from './runtime/host/extension-tool-gates.js';
+export { ScopedExtensionContributors } from './runtime/host/scoped-contributors.js';
+export { projectExtensionSuites, suiteOwnsResourceId } from './application/extension-suite-selection.js';
+export { ResourceFilterService } from './runtime/host/resource-filter-service.js';
+export { shellSeamOf } from './runtime/surfaces/dynamic-context.js';
+export { HOOK_RUN_DEFAULT_TIMEOUT_SEC, HOOK_RUN_FAILED, HOOK_RUN_MAX_OUTPUT_CHARS, HOOK_RUN_MAX_TIMEOUT_MS, HOOK_RUN_NO_COMMAND, HOOK_RUN_SHELL_UNAVAILABLE, HOOK_RUN_UNKNOWN_DECLARATION, hookRunFailure, hookRunShellOf, hookRunStdin, runHookDryRun } from './runtime/surfaces/hook-dry-run.js';
+export type { HookDryRunOptions, HookRunShell, HookRunShellRequest, HookRunShellResult } from './runtime/surfaces/hook-dry-run.js';
+export { LOCALE_SETTINGS_ENTRY, bindHostLocale, readHostLocalePreference, readLocalePreference, setHostLocaleSource } from './runtime/host/host-locale.js';
+export type { HostLocaleKey, HostTranslate, LocaleSettingsSource } from './runtime/host/host-locale.js';
+export { UserPanelSkillProvider, createUserPanelStores } from './runtime/panels/user-panels.js';
+export { SourceAutoUpdater } from './runtime/core/source-auto-update.js';
+export { collectMenuRowIdentities } from './runtime/host/menu-row-identities.js';
+export type { ExtensionRouteService } from './extension-service.js';
+export { readModelCatalog } from './runtime/host/model-catalog.js';
+export type { McpMountFactory, RuntimeMounts, SharedMcpMountPort } from './adapter-contracts.js';
+export { RetryScheduler, SerialPassQueue } from './runtime/core/mount-lifecycle.js';
+export type { MountPluginHandle, PluginMountContext } from './runtime/core/mount-lifecycle.js';
+export { causeMessages } from './runtime/host/failure-detail.js';
+export { resolveDeclaredCommand } from './runtime/host/shell-path.js';
+export { optionalService } from './runtime/core/context.js';

package/lib/types/{runtime → packages/market-runtime/src/runtime}/agents/agent-role-router.d.ts

@@ -3,6 +3,10 @@ import { type SubagentCatalogEntry } from './subagent-catalog.js';
 import { parseAgentRole, type AgentRoleEntry, type AgentRolePolicy } from '../../application/agent-roles.js';
 export { parseAgentRole };
 export type { AgentRoleEntry, AgentRolePolicy };
+/** A declaration that has been through the call-name pass, so it answers exactly one callable name. */
+export type NamedAgentRole = AgentRoleEntry & {
+    callName: string;
+};
 export declare const AGENT_ROLE_TOOL_NAME = "subagent_role";
 /** Child LLM options this plugin sends; never carries inherited parent values. */
 export interface AgentRoleOptions {
@@ -68,22 +72,22 @@ export interface AgentRoleRun {
     }>;
     dispose(): Promise<void>;
 }
-/** One tracked background role job as the host `jobs` registry sees it. */
-export interface AgentRoleJob {
-    cancel(reason?: string): void;
-    done: Promise<{
-        status: string;
-        detail?: string;
-    }>;
-}
-/** The host `jobs` registry seam, reached through `ctx.get('jobs')`. */
-export interface AgentRoleJobs {
-    start(spec: {
-        kind: string;
-        label: string;
-        owner?: unknown;
-        run(): AgentRoleJob;
-    }): string;
+/**
+ * The calling Agent as this plugin reads it: the route it would use and the
+ * working directory its session carries. One shape covers both reads, so no
+ * call site casts the parent for itself. The parent stays opaque to the host
+ * call, which receives the Agent itself and derives identity from it.
+ */
+export interface AgentRoleParent {
+    options?: AgentRoleOptions;
+    session?: {
+        requestHeader?(): {
+            config?: AgentRoleOptions;
+        } | undefined;
+        header?: {
+            cwd?: unknown;
+        };
+    };
 }
 /**
  * Resolve the child LLM options for one role call.
@@ -109,25 +113,40 @@ export declare function resolveAgentOptions(policy: AgentRolePolicy, requested:
 export declare function agentRoleCatalog(entries: AgentRoleEntry[], signal: AbortSignal, diagnose?: (message: string) => void, projectDir?: string): Promise<SubagentCatalogEntry[]>;
 /** Read the same declaration for catalog summaries and execution, including inline resources. */
 export declare function readAgentRole(entry: AgentRoleEntry, projectDir?: string): Promise<AgentRolePolicy>;
+/** The calling session's directory, which is what a card's `${CLAUDE_PROJECT_DIR}` names. */
+export declare function sessionCwd(parent: unknown): string | undefined;
+/** Resolve one current, enabled role for either host delegation surface. */
+export declare function resolveRolePolicy(listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, agentName: string, parent: unknown): Promise<{
+    entry: NamedAgentRole;
+    policy: AgentRolePolicy;
+}>;
 /**
- * How one role call reaches a child, mirroring the host's own delegation tool.
+ * Prove the role this call resolved is still a current, enabled role.
  *
- * `continuable` is the default: the host establishes a durable child and this
- * returns its id immediately, leaving resume state, steering and the settlement
- * notice to the continuation manager. `foreground` starts a one-shot run and
- * returns its report as this call's result, for a caller that needs the answer
- * before its next action. `background` starts the same one-shot run as a tracked
- * job, so the caller collects it later with `job_output` and can stop it with
- * `job_kill` instead of holding the turn open.
+ * Route validation awaits the live LLM runtime, and a global disable or a
+ * session selection change can land while that await is in flight. A child
+ * created from a role the current catalog no longer authorizes would run
+ * instructions that were already revoked, so the catalog is re-read
+ * immediately before the spawn and compared by the stable role id parsed from
+ * the declaration, never by the display or call name: a role renamed underneath
+ * this call cannot be mistaken for the one it resolved.
+ * @param listRoles - the same parent-scoped catalog reader the call resolved from.
+ * @param resolved - the entry this call resolved before its asynchronous work began.
+ * @param parent - the calling agent, so a session-scoped catalog is re-read for that same session.
+ * @throws when the role is gone, disabled, ambiguous, or no longer answers its call name.
  */
-export type AgentRoleRunMode = 'continuable' | 'background' | 'foreground';
+export declare function requireCurrentRole(listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, resolved: NamedAgentRole, parent: unknown): Promise<void>;
+/**
+ * How one role call reaches a child, carrying the host delegation tool's own
+ * two-value semantics: `continuable` is the default, and only an explicit
+ * `false` asks for a `foreground` run. A call that passes `true` keeps the
+ * default, so one rule covers this tool and the host's `subagent` alike.
+ */
+export type AgentRoleRunMode = 'continuable' | 'foreground';
 /** One role call's outcome, discriminated so the tool can render each channel. */
 export type AgentRoleResult = {
     kind: 'continuable';
     subagentId: string;
-} | {
-    kind: 'background';
-    jobId: string;
 } | {
     kind: 'foreground';
     runId: string;
@@ -137,9 +156,8 @@ export type AgentRoleResult = {
  * Run one role child through the requested channel.
  * @param host - the exact live seams this executor owns: tools, llm and subagents.
  * @param mode - which channel the call asked for.
- * @param jobs - the host jobs registry; only the `background` channel needs it.
  */
-export declare function executeAgentRole(host: AgentRoleHost, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, agentName: string, prompt: string, parent: unknown, requestedRoute: AgentRoleOptions, mode: AgentRoleRunMode, signal: AbortSignal, diagnose?: (message: string) => void, jobs?: AgentRoleJobs): Promise<AgentRoleResult>;
+export declare function executeAgentRole(host: AgentRoleHost, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, agentName: string, prompt: string, parent: unknown, requestedRoute: AgentRoleOptions, mode: AgentRoleRunMode, signal: AbortSignal, diagnose?: (message: string) => void): Promise<AgentRoleResult>;
 /**
  * Mount once after tools, llm and subagents are available; the returned disposer belongs to the plugin lifecycle.
  *
@@ -148,4 +166,21 @@ export declare function executeAgentRole(host: AgentRoleHost, listRoles: (parent
  * re-published whenever roles change, so guidance kept out of the catalog is
  * sent once and stays readable through compaction.
  */
-export declare function mountAgentRoleTool(ctx: Context, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>): () => void;
+/**
+ * One observation of the parent-scoped role source.
+ *
+ * The complete flag is the discovery contract the host skill registry uses: a
+ * reader that could not enumerate every source reports an incomplete
+ * observation, and the catalog publisher never replaces a published list from
+ * one, because a failed read is not evidence that its roles were removed. A
+ * bare entry list is the older protocol and means the read completed.
+ */
+export interface AgentRoleSnapshot {
+    entries: AgentRoleEntry[];
+    complete: boolean;
+}
+/** A role reader answers with entries directly or with an explicit snapshot. */
+export type AgentRoleObservation = AgentRoleEntry[] | AgentRoleSnapshot;
+/** Normalize one observation; a bare list means the read completed. */
+export declare function roleSnapshot(observation: AgentRoleObservation): AgentRoleSnapshot;
+export declare function mountAgentRoleTool(ctx: Context, listRoles: (parent?: unknown) => Promise<AgentRoleObservation>): () => void;

package/lib/types/packages/market-runtime/src/runtime/agents/agent-teams-seat.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Which delegation surface a deployment runs.
+ *
+ * Team messaging addresses Team members, not standalone children created through
+ * `ctx.subagents`. Deployments can expose both creation paths. Host tool
+ * activation belongs to the local DSH profile, not this plugin.
+ *
+ * Two delegation surfaces in one session therefore compete for the same work
+ * and disagree about how to name a child. This module keeps one of them: the
+ * standalone role surface stays mounted only while Agent Teams is absent.
+ * Team deployments mount the role-aware teammate entry through a separate inject.
+ * @module runtime/agents/agent-teams-seat
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Whether this context's deployment activated Agent Teams.
+ *
+ * Presence of the service is the signal rather than a tool lookup: the service
+ * is what the Team tools are installed from, so a deployment cannot run them
+ * without it, and it is readable from any scope through `ctx.get`.
+ * @param ctx - any host context; the read tolerates strict mode and absence.
+ * @returns true when Agent Teams owns delegation in this deployment.
+ */
+export declare function agentTeamsActive(ctx: unknown): boolean;
+/**
+ * Keep one model-facing surface mounted only while Agent Teams is absent.
+ *
+ * Presence can change after this plugin mounts: the deployment loads its
+ * bundles independently, so the Team service may register from a sibling fiber
+ * at any point in the boot. The registration event re-evaluates the seat, so a
+ * surface that was already published is withdrawn rather than left to compete.
+ *
+ * Withdrawal removes the tool and its catalog listener. Guidance already
+ * delivered earlier in a session is part of that session's history and stays
+ * there. The Team catalog publishes replacement guidance when its enhanced
+ * entry is ready; neither registration rewrites earlier session history.
+ * @param ctx - host context carrying the tools registry and the event bus.
+ * @param mount - mounts the surface and returns its disposer.
+ * @returns the disposer that unsubscribes and withdraws a mounted surface.
+ */
+export declare function mountUnlessAgentTeams(ctx: Context, mount: () => () => void): () => void;

package/lib/types/{runtime → packages/market-runtime/src/runtime}/agents/subagent-catalog.d.ts

@@ -16,6 +16,10 @@ export interface SubagentCatalogSource {
     form: 'catalog';
     update?: true;
     entries: readonly SubagentCatalogEntry[];
+    /** Omitted on historical standalone catalogs. */
+    tool?: 'spawn_teammate_role';
+    /** Fingerprint of the model-facing guidance, independent of the role entries. */
+    guidanceHash?: string;
 }
 declare module '@deepseek-ai/dsh-llm' {
     interface MessageSourceMap {
@@ -47,10 +51,31 @@ export type CatalogStepListener = (payload: {
     agent: CatalogAgent;
     signal: AbortSignal;
 }, next: () => Promise<CatalogStepDecision>) => Promise<CatalogStepDecision>;
-/** Register after the exact tool definition; teardown removes guidance before execution. */
+/**
+ * One observation of the roles a session can delegate to.
+ *
+ * The complete flag is the discovery contract the host skill registry already
+ * uses: an observation that could not read every source carries no authority to
+ * replace the published list, because a failed read is not evidence that its
+ * roles were removed. Only a complete observation may publish, including a
+ * complete observation that is genuinely empty.
+ */
+export interface SubagentCatalogSnapshot {
+    entries: readonly SubagentCatalogEntry[];
+    complete: boolean;
+}
+/** A snapshot, or a bare entry list, which the protocol treats as complete. */
+export type SubagentCatalogObservation = SubagentCatalogEntry[] | SubagentCatalogSnapshot;
+/**
+ * Register after the exact tool definition; teardown removes guidance before execution.
+ *
+ * The snapshot callback follows the host skill registry's provider protocol: it may
+ * return the entries directly (meaning a complete read) or an explicit snapshot
+ * whose `complete` flag reports whether every source answered.
+ */
 export declare function mountSubagentCatalog(ctx: Context, tool: {
     name: string;
-}, snapshot: (agent: CatalogAgent, signal: AbortSignal) => Promise<SubagentCatalogEntry[]>): () => void;
+}, snapshot: (agent: CatalogAgent, signal: AbortSignal) => Promise<SubagentCatalogObservation>, mode?: 'subagent_role' | 'spawn_teammate_role'): () => void;
 /**
  * Model-facing catalog text: the delegation triggers, then the role list, then
  * the same guidance on first publication and on every update, so a replacement
@@ -64,3 +89,10 @@ export declare function mountSubagentCatalog(ctx: Context, tool: {
  * tell the model which model each role runs on without changing what it does.
  */
 export declare function renderCatalogText(entries: readonly SubagentCatalogEntry[], update: boolean): string;
+/**
+ * Discovery only: which roles exist and which entry point takes a given call.
+ * Authorization, briefing, coordination and shared-task practice stay with the
+ * host policy and the Team coordination section, so this text never restates
+ * them and never argues for a role on model grounds.
+ */
+export declare function renderTeamRoleCatalogText(entries: readonly SubagentCatalogEntry[]): string;

package/lib/types/packages/market-runtime/src/runtime/agents/team-coordination.d.ts

@@ -0,0 +1,8 @@
+/** Role-aware Team workflow, independent of whether any specialty roles are installed. */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Resolve the current Agent from each assembly, not from a retained parent scope.
+ * Native and role-created members share this section; missing/stale/non-Team scopes
+ * render nothing. Cordis owns registration cleanup through the returned disposer.
+ */
+export declare function mountTeamCoordination(ctx: Context): () => void;

package/lib/types/packages/market-runtime/src/runtime/agents/teammate-role-runtime.d.ts

@@ -0,0 +1,74 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type Agent } from '@deepseek-ai/dsh-agent';
+import { z } from 'zod';
+export declare const TEAM_ROLE_SOURCE = "teammate-role-binding";
+declare const snapshotSchema: z.ZodObject<{
+    roleId: z.ZodString;
+    persona: z.ZodString;
+    route: z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        reasoningEffort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const bindingSchema: z.ZodObject<{
+    roleId: z.ZodString;
+    persona: z.ZodString;
+    route: z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        reasoningEffort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    version: z.ZodLiteral<1>;
+    childId: z.ZodString;
+}, z.core.$strict>;
+export type TeammateRoleSnapshot = z.infer<typeof snapshotSchema>;
+type Binding = z.infer<typeof bindingSchema>;
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        /** The known user/message envelope keeps this plugin-owned creation snapshot replayable. */
+        'teammate-role-binding': {
+            kind: 'teammate-role-binding';
+            form: 'context';
+            binding: Binding;
+        };
+    }
+}
+export interface RoleTeammateRequest {
+    name: string;
+    description: string;
+    prompt: string;
+    /** Model-facing role name from the catalog, so the member reads a role rather than its encoded id. */
+    agent?: string;
+}
+export interface RoleTeammateResult {
+    target: string;
+    roleId: string;
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+/** Creation and replay keep role data out of task text and never mutate the Lead's route. */
+export declare class TeammateRoleRuntime {
+    private readonly ctx;
+    private readonly teams;
+    private readonly subagents;
+    private readonly pending;
+    private readonly stop;
+    private readonly registrations;
+    private readonly compositions;
+    private readonly creations;
+    private readonly initializing;
+    private disposal?;
+    constructor(ctx: Context);
+    /** Reattach immutable role snapshots after a plugin reload, before exposing its creation tool. */
+    restore(): Promise<void>;
+    /** Resolve after native Team admission; use the returned target with native Team management tools. */
+    spawn(parent: Agent, request: RoleTeammateRequest, snapshot: TeammateRoleSnapshot, signal: AbortSignal): Promise<RoleTeammateResult>;
+    private initialize;
+    private initializeOnce;
+    /** Stop owned role work before removing its scoped configuration; native Team records stay authoritative. */
+    dispose(): Promise<void>;
+    private finishDisposal;
+}
+export {};

package/lib/types/packages/market-runtime/src/runtime/agents/teammate-role-tool.d.ts

@@ -0,0 +1,6 @@
+/** Role-aware creation is an additional Team entry point, not another member manager. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type AgentRoleObservation } from './agent-role-router.js';
+export declare const TEAMMATE_ROLE_TOOL_NAME = "spawn_teammate_role";
+/** Install the enhanced tool after its replay listener is ready; teardown drains owned role creations. */
+export declare function mountTeammateRoleTool(ctx: Context, listRoles: (parent?: unknown) => Promise<AgentRoleObservation>): Promise<() => Promise<void>>;

package/lib/types/{runtime → packages/market-runtime/src/runtime}/core/reconcile-scheduler.d.ts

@@ -10,13 +10,16 @@
  * @module runtime/reconcile-scheduler
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { Suite } from '../../model/types.js';
-import type { McpMountDiagnostic } from '../mcp/mcp-mounts.js';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
+import type { ExtensionSuiteCandidate } from '../../application/extension-suite-selection.js';
+import type { McpMountDiagnostic } from '../../../../market-contracts/src/contracts/mcp.js';
 import type { RuntimeReconciler } from './reconciler.js';
 /** The catalog surface one reconcile pass reads from and publishes to. */
 export interface ReconcileHost {
     /** Enabled user-dimension suites to reconcile. */
     enabledSuites(): Promise<Suite[]>;
+    /** Full validated installed declarations, including ordinary disabled resources. */
+    declarations?(): Promise<ExtensionSuiteCandidate[]>;
     /** Publish the pass's MCP mount diagnostics for the status surface. */
     publishMcpDiagnostics(diagnostics: McpMountDiagnostic[]): void;
 }

package/lib/types/packages/market-runtime/src/runtime/core/reconciler.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Runtime reconciliation for enabled suites.
+ *
+ * One catalog snapshot is fanned out to the existing MCP, command, hook, and
+ * LSP mount adapters. The adapters remain separate because their host surfaces
+ * and failure semantics differ; this module owns ordering, containment, and
+ * disposal only.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { McpBackend, McpMountDiagnostic } from '../../../../market-contracts/src/contracts/mcp.js';
+import type { LspMountDiagnostic } from '../../../../market-contracts/src/contracts/lsp.js';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
+import { type CommandMountDiagnostic } from '../surfaces/commands-mounts.js';
+import type { MenuRowRegistration } from '../host/menu-row-identities.js';
+import { type HooksMountDiagnostic } from '../surfaces/hooks-mounts.js';
+import { type ExtensionSuiteCandidate } from '../../application/extension-suite-selection.js';
+import { type HostTranslate } from '../host/host-locale.js';
+import type { LspMountPort, McpOverridesPort, RuntimeMounts } from '../../adapter-contracts.js';
+/**
+ * The per-surface mount gates one reconcile pass reads.
+ *
+ * A switched-off surface is gated here rather than by filtering the suite
+ * snapshot: the reconciler owns both the MCP and the LSP mount branch, so
+ * dropping suites from the shared list would unmount a sibling surface's
+ * mounts along with it. Gating each branch instead keeps the two orthogonal —
+ * an off MCP mount reconciles to zero servers while the same suites keep their
+ * language servers.
+ */
+export interface RuntimeSurfaceGates {
+    /** Whether the named surface may mount on this pass. */
+    allows(surface: RuntimeSurfaceKey): boolean;
+}
+/**
+ * The toggle keys the reconciler's own mount branches answer to.
+ *
+ * Hooks have no per-workspace switch, so that branch stays ungated; skills and
+ * agents mount through their own providers and the market through its routes.
+ */
+export type RuntimeSurfaceKey = 'commands' | 'mcp' | 'lsp';
+/** Diagnostics returned by one runtime reconciliation pass. */
+export interface RuntimeDiagnostics {
+    mcp: McpMountDiagnostic[];
+    commands: CommandMountDiagnostic[];
+    hooks: HooksMountDiagnostic[];
+    lsp: LspMountDiagnostic[];
+    errors: Array<{
+        surface: 'mcp' | 'commands' | 'hooks' | 'lsp';
+        reason: string;
+    }>;
+}
+export interface SessionDemandReceipt {
+    /** Publish staged identities after durability; never throws, and revoked receipts are no-ops. */
+    commit(): void;
+    rollback(): Promise<void>;
+}
+export declare class RuntimeReconciler {
+    private readonly mcp;
+    private readonly commands;
+    private readonly hooks;
+    private readonly lspRegistry;
+    private readonly queues;
+    private gates;
+    private disposed;
+    private agentScopedContributors;
+    private authority;
+    private authorityEpoch;
+    private globalSuites;
+    private readonly committed;
+    private readonly staged;
+    private sharedQueue;
+    private demandedMcp;
+    private demandedLsp;
+    private overridesProvider;
+    private disposal?;
+    private readonly warn;
+    /**
+     * @param ctx - the context every mount registers through.
+     * @param dataRoot - the plugin data root the mount adapters store under.
+     * @param mounts - the transport adapters this coordinator drives. The
+     * composition root builds them, so no transport package is imported here.
+     * @param t - host translator for the command registry's own diagnostics.
+     */
+    constructor(ctx: Context, dataRoot: string, mounts: RuntimeMounts, t?: HostTranslate);
+    /** Transfer commands and hooks to per-agent registries; call before the first reconcile. */
+    setAgentScopedContributors(): void;
+    /** Exact live MCP definitions and their owning extension resources. */
+    mcpToolOwnership(): import('../host/extension-tool-gates.js').ExtensionMcpTool[];
+    /** The LSP mount registry, consumed by the LSP status surface. */
+    get lsp(): LspMountPort;
+    /** The suite commands the global layer currently holds, for the slash menu's row faces. */
+    commandRegistrations(): MenuRowRegistration[];
+    /** Install the per-workspace entry filter on the MCP mount registry. */
+    setMcpEntryFilter(filter: () => {
+        allows(face: 'mcp', entryId: string): boolean;
+    }): void;
+    /** Install the per-workspace entry filter on the command mount registry. */
+    setCommandsEntryFilter(filter: () => {
+        allows(face: 'commands', entryId: string): boolean;
+    }): void;
+    /**
+     * Install the per-workspace surface gates, read on every pass.
+     *
+     * Set after construction because the toggle service is built later in
+     * composition; until then every surface mounts, which is the all-on default.
+     */
+    setSurfaceGates(gates: RuntimeSurfaceGates): void;
+    /** Install the per-suite MCP overrides provider used at mount time. */
+    setMcpOverridesProvider(provider: () => Promise<Map<string, McpOverridesPort>>): void;
+    /** Install the live tool-name provider used for foreign-namespace mount guards. */
+    setMcpToolNamesProvider(provider: () => string[]): void;
+    /** Install the backend provider deciding which MCP client mounts each server. */
+    setMcpBackendProvider(provider: () => Promise<McpBackend>): void;
+    /** Whether the current MCP snapshot uses one credential reference. */
+    usesCredential(ref: string): boolean;
+    /** Flag one MCP mount for an explicit rebuild on the next reconcile. */
+    forceMcpRemount(suiteId: string, serverKey: string): void;
+    /** Flag every live MCP mount for a rebuild on the next reconcile. */
+    forceMcpRemountAll(): void;
+    /** The mount key owning one derived serverName; undefined when not mounted here. */
+    mcpServerOwner(serverName: string): {
+        suiteId: string;
+        serverKey: string;
+    } | undefined;
+    /** Publish fresh immutable authority without mounting or waiting behind network work. */
+    setCatalogAuthority(candidates: readonly ExtensionSuiteCandidate[], global: readonly Suite[]): void;
+    /** Update full validated authority and the ordinary global base in one shared-service pass. */
+    refreshCatalog(candidates: readonly ExtensionSuiteCandidate[], global: readonly Suite[]): Promise<RuntimeDiagnostics>;
+    /** Legacy enabled-only refresh never replaces full authority or session demand. */
+    reconcile(global: readonly Suite[]): Promise<RuntimeDiagnostics>;
+    private reconcileSnapshot;
+    private surface;
+    private enqueue;
+    /** Stage only identities; configuration always comes from current validated authority. */
+    stageSessionDemand(owner: object, requested: readonly Suite[], directLspIds?: readonly string[]): Promise<SessionDemandReceipt>;
+    releaseSessionDemand(owner: object): Promise<void>;
+    private project;
+    private reconcileShared;
+    private assertMounted;
+    /** Stop receipt admission before draining shared and independently queued local work. */
+    dispose(): Promise<void>;
+}