dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/types/packages/market-runtime/src/runtime/host/resource-filter-service.d.ts

@@ -0,0 +1,34 @@
+/** One live workspace policy snapshot. Publication follows successful persistence. */
+import type { ResourceFace, ResourceFavoriteWire } from '../../../../market-contracts/src/contracts/resource-window.js';
+import { type SurfaceToggleKey, type SurfaceToggles } from '../../../../market-contracts/src/contracts/surface-toggles.js';
+import { type ResourceFilters } from '../../application/state/workspace-policy.js';
+import type { ResourceFavoriteInput } from '../../../../market-contracts/src/contracts/resource-window.js';
+export interface ResourceFilterHooks {
+    onFiltersChanged(): Promise<void> | void;
+}
+export declare class ResourceFilterService {
+    private readonly dataRoot;
+    private readonly hooks;
+    private filters;
+    private readonly workspace;
+    private tail;
+    constructor(dataRoot: string, workspace: string | undefined, hooks: ResourceFilterHooks);
+    private enqueue;
+    /** Reload shares mutation ordering; an earlier read cannot overwrite a later write. */
+    reload(): Promise<void>;
+    /** Callers receive detached data, never the owner's mutable snapshot. */
+    currentFilters(): ResourceFilters;
+    currentToggles(): SurfaceToggles;
+    allowsSurface(key: SurfaceToggleKey): boolean;
+    allowsEntry(face: ResourceFace, entryId: string): boolean;
+    allows(face: ResourceFace, entryId: string): boolean;
+    offEntriesOf(face: ResourceFace): string[];
+    private mutate;
+    setSurface(key: SurfaceToggleKey, enabled: boolean): Promise<SurfaceToggles>;
+    setEntry(face: ResourceFace, entryId: string, enabled: boolean): Promise<ResourceFilters>;
+    /** One complete commit and one refresh. Failed refresh does not roll back persisted state. */
+    applyFilters(toggles: SurfaceToggles, offEntries: Partial<Record<ResourceFace, string[]>>): Promise<ResourceFilters>;
+    favorites(): Promise<ResourceFavoriteWire[]>;
+    saveFavorite(input: ResourceFavoriteInput): Promise<ResourceFavoriteWire>;
+    deleteFavorite(id: string): Promise<void>;
+}

package/lib/types/packages/market-runtime/src/runtime/host/scoped-contributors.d.ts

@@ -0,0 +1,58 @@
+/** Agent-owned extension registrations; pending targets prepare data, committed policy authorizes effects. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { CatalogPort as Catalog } from '../../catalog-port.js';
+import { type ExtensionSelection } from '../../../../market-contracts/src/contracts/extension-presets.js';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
+import type { ShellSeam } from '../surfaces/dynamic-context.js';
+import { type UserPanelStore } from '../panels/user-panels.js';
+import { type HostTranslate } from './host-locale.js';
+import type { McpMountFactory } from '../../adapter-contracts.js';
+import type { ExtensionMcpTool } from './extension-tool-gates.js';
+import type { MenuRowRegistration } from './menu-row-identities.js';
+export interface ScopedContributorPorts {
+    dataRoot: string;
+    catalog: Catalog;
+    /** Validated selected projections; may read pending selection during registration, never grants execution. */
+    suites?(agent: Agent): Promise<Suite[]>;
+    shell: () => ShellSeam | undefined;
+    allows(agent: Agent, resourceId: string, suiteId?: string): boolean;
+    registrationAllows?(agent: Agent, resourceId: string): boolean;
+    /**
+     * Creates one MCP mount over the context it is given. The composition root
+     * supplies the adapter, so this module never imports a transport package; the
+     * agent-scoped mount and the workspace-pooled host bridge both come from it.
+     */
+    mcpMounts: McpMountFactory;
+    /** Production supplies panels; omission supports a skill-provider-only consumer. */
+    panels?: {
+        commands: UserPanelStore;
+        skills?: UserPanelStore;
+    };
+    t?: HostTranslate;
+    /** Plugin-owned root context for workspace-pooled host-compatibility MCP. */
+    hostContext?: Context;
+}
+export declare class ScopedExtensionContributors {
+    private readonly ports;
+    private readonly mounted;
+    private readonly hostMcp;
+    private readonly hostQueues;
+    constructor(ports: ScopedContributorPorts);
+    private registrationAllows;
+    private registerSkills;
+    private attach;
+    /** Called inside the session maintenance transaction, before its committed record. */
+    reconcile(agent: Agent, selection: ExtensionSelection): Promise<void>;
+    private hostOperation;
+    private reconcileHostMcp;
+    private releaseHostMcp;
+    committed(agent: Agent): void;
+    /** Invalidate cached summaries and run startup hooks only after the session is durably ready. */
+    ready(agent: Agent, source?: string): Promise<void>;
+    invalidateAll(): void;
+    toolOwnership(agent: Agent): ExtensionMcpTool[];
+    registrations(): MenuRowRegistration[];
+    dispose(agent: Agent): Promise<void>;
+    disposeAll(): Promise<void>;
+}

package/lib/types/packages/market-runtime/src/runtime/host/surface-toggle-service.d.ts

@@ -0,0 +1,10 @@
+/** Legacy surface API over the shared policy owner; no independent state or persistence. */
+import type { SurfaceToggleKey, SurfaceToggles } from '../../../../market-contracts/src/contracts/surface-toggles.js';
+import type { ResourceFilterService } from './resource-filter-service.js';
+export declare class SurfaceToggleService {
+    private readonly owner;
+    constructor(owner: ResourceFilterService);
+    reload(): Promise<void>;
+    currentToggles(): SurfaceToggles;
+    set(key: SurfaceToggleKey, enabled: boolean): Promise<SurfaceToggles>;
+}

package/lib/types/packages/market-runtime/src/runtime/panels/user-commands.d.ts

@@ -0,0 +1,74 @@
+/**
+ * User command mounting: every enabled entry of the user commands panel
+ * registers as a dsh slash command, so user-authored quick replies behave
+ * exactly like suite commands — the body with `$ARGUMENTS` substituted rides
+ * one follow-up message on the receiving agent. A nested entry registers
+ * under its flattened call name (`git/commit` → `git-commit`) while the panel
+ * keeps addressing it by path; when two entries flatten to one call name the
+ * later one takes a numeric suffix (`git-commit-1`) and is reported, because a
+ * second registration of one name is what makes the host's slash menu drop it.
+ * Reconciled on every catalog change, keyed by the entry path.
+ * @module runtime/user-commands
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { HostTranslate } from '../host/host-locale.js';
+import type { UserPanelStore } from './user-panels.js';
+import type { MenuRowRegistration } from '../host/menu-row-identities.js';
+/** Register/unregister user-panel commands to match the panel's enabled entries. */
+export declare class UserCommandMountRegistry {
+    private readonly ctx;
+    private readonly store;
+    private readonly t;
+    private readonly fingerprints;
+    private readonly live;
+    /**
+     * The call names this seat holds, and the entry each one was registered for.
+     *
+     * Occupancy is per layer, which is the unit the host checks: this registry
+     * registers into the global layer, so its names must be unique among
+     * themselves and against every other registration in that layer.
+     */
+    private readonly names;
+    private readonly registeredName;
+    /** The menu row each live registration produces, with the panel id it translates as. */
+    private readonly registered;
+    /** Per-workspace entry filter; an absent provider registers everything wanted. */
+    private entryFilter;
+    private selectionPolicy;
+    private registrationPolicy;
+    private allowDisabled;
+    constructor(ctx: Context, store: UserPanelStore, t: HostTranslate);
+    /**
+     * Install the per-workspace entry filter read at wanted-row time, keyed by
+     * the panel path name the resource window lists (`commands:${entry.name}`).
+     */
+    setEntryFilter(filter: () => {
+        allows(face: 'commands', entryId: string): boolean;
+    }): void;
+    /** Gate reconcile and execution by the original panel path name; unset allows all. */
+    setSelectionPolicy(callback: (name: string) => boolean, registration?: (name: string) => boolean, options?: {
+        allowDisabled?: boolean;
+    }): void;
+    /**
+     * Sync the live registrations with the panel's enabled entries.
+     *
+     * A switched-off commands surface reconciles against no entries at all,
+     * which unregisters whatever is live — skipping the pass would leave the
+     * previous registrations mounted after the switch went off.
+     * @param allow - whether the workspace's commands switch is on.
+     */
+    reconcile(allow?: boolean): Promise<string[]>;
+    /**
+     * Every command this seat currently holds: the call name the menu row carries
+     * and the panel identity that owns its translation.
+     *
+     * The registry is the only place that knows a name allocation suffixed, and a
+     * user entry's panel identity is the entry name the panel lists.
+     * @returns one row per live registration, in registration-key order.
+     */
+    registrations(): MenuRowRegistration[];
+    /** Dispose every registration (plugin teardown). */
+    disposeAll(): void;
+    /** Free the call name one unmounted entry held, so a later claim can reuse it. */
+    private releaseName;
+}

package/lib/types/{runtime → packages/market-runtime/src/runtime}/panels/user-panels.d.ts

@@ -142,14 +142,20 @@ export declare function createUserPanelStores(agentsRoot: string): {
  * command grammar (`_` allowed).
  */
 export declare function isUserSkillEntryName(name: string): boolean;
+export interface UserPanelSkillProviderOptions {
+    /** Session-local choice. Valid unselected entries remain non-invocable shadows; absent preserves global switches. */
+    enabled?: (entry: UserPanelEntry) => boolean;
+}
 /**
  * Skill provider over user skills only. Agent definitions belong to the
  * subagent catalog and never become skill candidates or slash entries.
  */
 export declare class UserPanelSkillProvider implements SkillProvider {
     private readonly skills;
+    private readonly options;
     readonly name = "user-panel";
-    constructor(skills: UserPanelStore);
+    constructor(skills: UserPanelStore, options?: UserPanelSkillProviderOptions);
+    private invocation;
     list(_options: SkillLookupOptions): Promise<SkillCandidate[]>;
     get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
     /**

package/lib/types/packages/market-runtime/src/runtime/surfaces/commands-mounts.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Claude Code command compatibility: `commands/*.md` of enabled suites
+ * register as dsh slash commands.
+ *
+ * A CC command is a prompt template the model executes (its body carries
+ * `$ARGUMENTS`, path variables and `` !`cmd` `` dynamic-context placeholders),
+ * so the handler maps it onto the harness's follow-up mechanism: the template
+ * with those placeholders resolved becomes one durable user-role follow-up
+ * message on the receiving agent. Registrations reconcile on every
+ * enable/disable/install/uninstall; a broken command file, a failed injected
+ * command, or an unavailable `ctx.commands` is contained per command and
+ * reported as a diagnostic.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
+export { readCommands } from '../../application/command-resources.js';
+import { type HostTranslate } from '../host/host-locale.js';
+import type { MenuRowRegistration } from '../host/menu-row-identities.js';
+export interface CommandMountDiagnostic {
+    suiteId: string;
+    command: string;
+    reason: string;
+}
+export declare class CommandMountRegistry {
+    private readonly ctx;
+    private readonly t;
+    private readonly dataRoot?;
+    private readonly fingerprints;
+    private readonly live;
+    /**
+     * The call names this seat holds, and the keys they were registered under.
+     *
+     * Occupancy is per layer, which is the unit the host checks: this registry
+     * instance registers into one layer (an agent's scope on the project path,
+     * the global layer on the user path), and a sibling registry in another
+     * layer neither sees nor is seen by these names.
+     */
+    private readonly names;
+    private readonly registeredName;
+    /** The menu row each live registration produces, with the panel id it translates as. */
+    private readonly registered;
+    /** Per-workspace entry filter; an absent provider registers everything wanted. */
+    private entryFilter;
+    private selectionPolicy;
+    private registrationPolicy;
+    private allowDisabled;
+    constructor(ctx: Context, t?: HostTranslate, dataRoot?: string | undefined);
+    /**
+     * Install the per-workspace entry filter read at wanted-row time. A filtered
+     * command never becomes wanted, which unregisters it through the ordinary
+     * reconcile pass — the same path a removed command file takes.
+     */
+    setEntryFilter(filter: () => {
+        allows(face: 'commands', entryId: string): boolean;
+    }): void;
+    /**
+     * Gate reconcile and execution by owning suite and authored resource name,
+     * before call-name flattening or collision allocation. Unset allows all.
+     */
+    setSelectionPolicy(callback: (suite: Suite, commandName: string) => boolean, registration?: (suite: Suite, commandName: string) => boolean, options?: {
+        allowDisabled?: boolean;
+    }): void;
+    /** The live shell seam, when the profile has one; dynamic context stays literal without it. */
+    private shell;
+    /** Register/unregister suite commands to match the enabled suites exactly. */
+    reconcile(enabledSuites: Suite[]): Promise<CommandMountDiagnostic[]>;
+    /**
+     * Every command this layer currently holds: the call name the menu row
+     * carries and the panel identity that owns its translation.
+     *
+     * Two files of one suite can flatten to the same call name, so the
+     * registration key (not the name) is what tells those rows apart; each one
+     * keeps its own resource name and therefore its own translation id.
+     * @returns one row per live registration, in registration-key order.
+     */
+    registrations(): MenuRowRegistration[];
+    /** Dispose every registered command; used at plugin teardown. */
+    disposeAll(): void;
+    /** Free the call name one unmounted key held, so a later claim can reuse it. */
+    private releaseName;
+}

package/lib/types/packages/market-runtime/src/runtime/surfaces/extension-hooks.d.ts

@@ -0,0 +1,59 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
+import { type HooksMountDiagnostic } from './hooks-mounts.js';
+type Source = 'startup' | 'resume';
+/**
+ * Own one live Agent's hooks. Supply a live context injected with shell and
+ * sessionProjections, plus a synchronous live authorization check. Reconcile before
+ * awaiting start; agent/created is deliberately not observed. Dispose before the
+ * Agent or its context tears down. Each command rechecks authorization.
+ * Subagent events use the exact parent carrier, but identify the child on stdin.
+ * Like the host bridge, input rewrites, systemMessage and run-level halt are not
+ * applied; SubagentStop is observation-only. Unknown remote child cwd is empty.
+ * Every command receives its suite's path variables in the process environment,
+ * the same values its command string expands to.
+ */
+export declare class ExtensionHooks {
+    private readonly ctx;
+    private readonly agent;
+    private readonly isSuiteAllowed;
+    /**
+     * Live check for one hook's own identity: the event and its declaration index,
+     * the same position the session inventory published a row for. Absent keeps the
+     * parent-suite contract, which is what a suite with no individual row requires.
+     */
+    private readonly isHookAllowed?;
+    /** Plugin storage root; supplies the suite's data directory to hook processes. */
+    private readonly dataRoot?;
+    private selected;
+    private pending;
+    private readonly runs;
+    private readonly listeners;
+    private readonly children;
+    private startup?;
+    private closing?;
+    private disposed;
+    private revision;
+    private handler;
+    constructor(ctx: Context, agent: Agent, isSuiteAllowed: (suite: Suite) => boolean, 
+    /**
+     * Live check for one hook's own identity: the event and its declaration index,
+     * the same position the session inventory published a row for. Absent keeps the
+     * parent-suite contract, which is what a suite with no individual row requires.
+     */
+    isHookAllowed?: ((suite: Suite, event: string, index: number) => boolean) | undefined, 
+    /** Plugin storage root; supplies the suite's data directory to hook processes. */
+    dataRoot?: string | undefined);
+    /** Replace selection; malformed suites are dropped with diagnostics. Does not replay startup. */
+    reconcile(suites: readonly Suite[]): Promise<HooksMountDiagnostic[]>;
+    /** Run SessionStart once, after already-submitted reconciliation, and await its context injection. */
+    start(source: Source, signal?: AbortSignal): Promise<void>;
+    /** Stop admission, unregister listeners, abort and await owned runs. Repeated calls share completion. */
+    dispose(): Promise<void>;
+    private observeSubagent;
+    private track;
+    private lastTurn;
+    private runPoint;
+}
+export {};

package/lib/types/packages/market-runtime/src/runtime/surfaces/hook-dry-run.d.ts

@@ -0,0 +1,91 @@
+import type { ExtensionHookRunResult } from '../../../../market-contracts/src/contracts/extension-presets.js';
+/** Per-stream cap, in characters, on the output one result carries. */
+export declare const HOOK_RUN_MAX_OUTPUT_CHARS = 32768;
+/** Timeout applied when the declaration carries none. */
+export declare const HOOK_RUN_DEFAULT_TIMEOUT_SEC = 30;
+/** Hard ceiling on any dry run, whatever the declaration asks for. */
+export declare const HOOK_RUN_MAX_TIMEOUT_MS = 60000;
+/** A resolved declaration that named no runnable hook. */
+export declare const HOOK_RUN_UNKNOWN_DECLARATION = "hook-run-unknown-declaration";
+/** A matched declaration that carries no command (a rejected declaration exists only as a diagnostic). */
+export declare const HOOK_RUN_NO_COMMAND = "hook-run-no-command";
+/** No shell executor is mounted in this profile. */
+export declare const HOOK_RUN_SHELL_UNAVAILABLE = "hook-run-shell-unavailable";
+/** The executor rejected the run before it produced an outcome. */
+export declare const HOOK_RUN_FAILED = "hook-run-failed";
+/** The slice of the host shell executor this module uses. */
+export interface HookRunShellRequest {
+    command: string;
+    workdir?: string;
+    timeoutMs?: number;
+    stdin?: string;
+    env?: Record<string, string>;
+    stdoutMaxBytes?: number;
+}
+/** The fields of one shell run this module reads. */
+export interface HookRunShellResult {
+    exitCode: number | null;
+    timedOut: boolean;
+    aborted: boolean;
+    stdout: {
+        text: string;
+        truncated: boolean;
+    };
+    stderr: {
+        text: string;
+        truncated: boolean;
+    };
+}
+/** The host shell executor, reached structurally so a missing service stays optional. */
+export interface HookRunShell {
+    resolve(request: HookRunShellRequest): unknown;
+    execute(spec: unknown): Promise<{
+        result(): Promise<HookRunShellResult>;
+    }>;
+}
+/**
+ * Narrow a resolved shell seam to the executor surface, or answer undefined.
+ *
+ * The seam is read without injecting shell, so its value is untyped at the
+ * boundary. A service that only exposes the legacy run shape is not an
+ * executor and is reported as unavailable rather than run against.
+ * @param value - the service resolved from the context, if any.
+ * @returns the executor surface, or undefined when no executor is mounted.
+ */
+export declare function hookRunShellOf(value: unknown): HookRunShell | undefined;
+/**
+ * The synthetic stdin payload one dry run writes.
+ *
+ * It carries the same event name the declaration fired under and the directory
+ * the command runs in, so a script that reads stdin sees a coherent event,
+ * plus dry_run: true so it can refuse to act for real.
+ * @param event - the declared event the hook belongs to.
+ * @param cwd - the directory the command runs in.
+ * @returns the JSON payload, newline terminated.
+ */
+export declare function hookRunStdin(event: string, cwd: string): string;
+/** One result that reports a failure without running anything. */
+export declare function hookRunFailure(code: string): ExtensionHookRunResult;
+/** How one resolved declaration runs. */
+export interface HookDryRunOptions {
+    /** The event the declaration belongs to. */
+    event: string;
+    /** The declaration's own timeout in seconds; absent uses the module default. */
+    timeoutSec?: number;
+    /** The suite's path variables as process environment. */
+    env?: Record<string, string>;
+}
+/**
+ * Run one resolved command in the home directory under a bounded timeout.
+ *
+ * The timeout is the declaration's own, defaulted to HOOK_RUN_DEFAULT_TIMEOUT_SEC
+ * and capped at HOOK_RUN_MAX_TIMEOUT_MS; the command's cwd is the home
+ * directory whatever the caller passes elsewhere. Both streams are capped
+ * independently, and an executor rejection becomes a result, so the request
+ * never fails with a thrown error.
+ * @param shell - the resolved host shell executor.
+ * @param command - the declaration's own command text.
+ * @param options - the event, declared timeout, and suite environment.
+ * @returns the bounded result of the run.
+ */
+export declare function runHookDryRun(shell: HookRunShell, command: string, options: HookDryRunOptions): Promise<ExtensionHookRunResult>;

package/lib/types/{runtime → packages/market-runtime/src/runtime}/surfaces/hooks-mounts.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '@deepseek-ai/cordis';
-import type { Suite } from '../../model/types.js';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
 export interface HooksMountDiagnostic {
     suiteId: string;
     reason: string;

package/lib/types/{runtime → packages/market-runtime/src/runtime}/surfaces/project-runtime.d.ts

@@ -1,15 +1,16 @@
 /** Native project effects are owned by the receiving agent's scoped host context. */
 import type { Context } from '@deepseek-ai/cordis';
-import type { Catalog } from '../../application/catalog.js';
+import type { CatalogPort as Catalog } from '../../catalog-port.js';
 import type { HostTranslate } from '../host/host-locale.js';
-import type { Suite } from '../../model/types.js';
+import type { McpMountFactory } from '../../adapter-contracts.js';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
 /** Mount under existing and newly created agents; the caller owns refresh and teardown. */
-export declare function mountProjectCommands(ctx: Context, catalog: Catalog, t: HostTranslate, dataRoot?: string): {
+export declare function mountProjectCommands(ctx: Context, catalog: Catalog, t: HostTranslate, dataRoot?: string, allows?: () => boolean): {
     refresh(): Promise<void>;
     dispose(): Promise<void>;
 };
 /** MCP uses a separate injected child so network startup cannot delay local commands. */
-export declare function mountProjectMcp(ctx: Context, catalog: Catalog, dataRoot: string): {
+export declare function mountProjectMcp(ctx: Context, catalog: Catalog, dataRoot: string, mcpMounts: McpMountFactory, allows?: () => boolean): {
     refresh(): Promise<void>;
     dispose(): Promise<void>;
 };
@@ -19,7 +20,9 @@ export declare function mountProjectHooks(ctx: Context, catalog: Catalog): {
     dispose(): Promise<void>;
 };
 /** Kimi's startup skill and system-prompt declarations use the existing scoped prompt service. */
-export declare function mountSuiteInstructions(ctx: Context, catalog: Catalog, dataRoot?: string): {
+export declare function mountSuiteInstructions(ctx: Context, catalog: Catalog, dataRoot?: string, 
+/** Whether one user-dimension suite may contribute instructions; absent allows all. */
+suiteAllowed?: (suite: Suite) => boolean): {
     refresh(): Promise<void>;
     dispose(): Promise<void>;
 };

package/lib/types/packages/market-runtime/src/runtime/surfaces/skills-provider.d.ts

@@ -0,0 +1,71 @@
+import type { SkillCandidate, SkillDefinition, SkillLookupOptions, SkillProvider } from '@deepseek-ai/dsh-skill';
+import type { CatalogPort as Catalog } from '../../catalog-port.js';
+import type { Suite, SuiteSkill } from '../../../../market-contracts/src/model/types.js';
+import { type ShellSeam } from './dynamic-context.js';
+export declare const SUITE_PROJECT_SOURCE = "agent-plugin-project";
+export declare const SUITE_USER_SOURCE = "agent-plugin-user";
+/** Runtime inputs the provider cannot read off one suite. */
+export interface SuiteSkillProviderOptions {
+    /** Plugin storage root holding each suite's data directory. */
+    dataRoot?: string;
+    /** Resolves the live shell seam; absent keeps dynamic-context placeholders literal. */
+    shell?: () => ShellSeam | undefined;
+    /** Validated session-selected clones; supplied readers replace global discovery rather than augmenting it. */
+    suites?: (cwd?: string) => Promise<Suite[]>;
+    /** Explicit live session grant for an ordinary disabled entry; validation and both selection guards still apply. */
+    overrideDisabled?: (suite: Suite, skill: SuiteSkill) => boolean;
+    /** Whether a user or project suite may contribute skills; checked live on list and get. */
+    suiteAllowed?: (suite: Suite) => boolean;
+    /** Per-entry policy, applied before name deduplication and checked live on get; absent allows all. */
+    entryAllowed?: (suite: Suite, skill: SuiteSkill) => boolean;
+}
+export declare class SuiteSkillProvider implements SkillProvider {
+    private readonly manager;
+    private readonly options;
+    readonly name = "agent-plugin";
+    constructor(manager: Catalog, options?: SuiteSkillProviderOptions);
+    list(options: SkillLookupOptions): Promise<SkillCandidate[]>;
+    /** With policy callbacks, only owned candidates from list are loadable; denied or ownerless candidates return undefined. */
+    get(candidate: SkillCandidate, options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
+    private candidateFor;
+    private hasPolicy;
+    private entryAllowed;
+    private locatorAllowed;
+    private canOverrideDisabled;
+    private locate;
+}
+/**
+ * A skill provider that answers nothing while the workspace's skills switch is
+ * off.
+ *
+ * The wrapper is generic over the provider it guards, so both contributors to
+ * the skills surface — installed suites and the user's own panel entries —
+ * answer the one switch. Only the two data-carrying methods observe it and the
+ * wrapped provider keeps its own name, so the provider seat survives a toggle
+ * without re-registering.
+ */
+export declare class ToggledSkillProvider implements SkillProvider {
+    private readonly inner;
+    private readonly allows;
+    constructor(inner: SkillProvider, allows: () => boolean);
+    get name(): string;
+    list(options: Parameters<SkillProvider['list']>[0]): ReturnType<SkillProvider['list']>;
+    get(...args: Parameters<SkillProvider['get']>): ReturnType<SkillProvider['get']>;
+}
+/**
+ * A skill provider that drops the entries this workspace filtered off, while
+ * the surface switch itself keeps flowing through {@link ToggledSkillProvider}.
+ *
+ * The filter answers by the resource-window entry id (`skills:${name}`), which
+ * is the candidate name the harness would surface, so window and provider
+ * agree on what one row names. Both list and get check the live filter, so a
+ * cached candidate cannot bypass a later denial.
+ */
+export declare class EntryFilteredSkillProvider implements SkillProvider {
+    private readonly inner;
+    private readonly allowsEntry;
+    constructor(inner: SkillProvider, allowsEntry: (entryId: string) => boolean);
+    get name(): string;
+    list(options: Parameters<SkillProvider['list']>[0]): ReturnType<SkillProvider['list']>;
+    get(...args: Parameters<SkillProvider['get']>): ReturnType<SkillProvider['get']>;
+}

package/lib/types/packages/market-translation/src/application/state/translation-cache.d.ts

@@ -0,0 +1,56 @@
+import type { TranslationProviderId } from '../../../../market-contracts/src/contracts/translation.js';
+import type { TranslationUnit } from '../translation/unit.js';
+/** One cached translation, stored under its own key. */
+export interface TranslationRecord {
+    /** The translated text exactly as the provider returned it. */
+    text: string;
+    /** The provider that produced this text, for operator inspection. */
+    provider: TranslationProviderId;
+    /** Epoch milliseconds of the successful call, for operator inspection. */
+    at: number;
+}
+/**
+ * The cache file inside the plugin data root.
+ * @param dataRoot - the plugin's own storage root, never the project directory.
+ * @returns the absolute path of the translation cache.
+ */
+export declare function translationCachePath(dataRoot: string): string;
+/**
+ * One cache key: target locale, the unit's identity and text, and the provider
+ * chain's identity.
+ *
+ * Every part is joined with a NUL so no id containing the separator can alias
+ * another unit's entry, and the digest keeps the key bounded regardless of how
+ * long an upstream description is. The provider identity is part of the key on
+ * purpose: a deployment that changes engines must not serve the old engine's
+ * text as if the new one had produced it.
+ * @param unit - the field being translated.
+ * @param locale - the target locale id.
+ * @param providerIdentity - stable identity of the provider chain in use.
+ * @returns a stable key for the persisted entry.
+ */
+export declare function translationKey(unit: TranslationUnit, locale: string, providerIdentity: string): string;
+/**
+ * Read the live cache. A missing, unreadable, or malformed file yields an empty
+ * cache: the panel always renders, it just has nothing translated yet.
+ * @param dataRoot - the plugin's own storage root.
+ * @returns the cached translations keyed by {@link translationKey}.
+ */
+export declare function loadTranslationCache(dataRoot: string): Promise<Record<string, TranslationRecord>>;
+/**
+ * Delete the whole cache file.
+ *
+ * A missing file is the desired end state, not a failure, so the removal is
+ * tolerant. The caller re-reads through {@link loadTranslationCache} to confirm.
+ * @param dataRoot - the plugin's own storage root.
+ */
+export declare function clearTranslationCache(dataRoot: string): Promise<void>;
+/**
+ * Replace the whole cache document.
+ *
+ * Writes go through the shared atomic writer, so a crash mid-write leaves the
+ * previous cache readable rather than a truncated file.
+ * @param dataRoot - the plugin's own storage root.
+ * @param entries - the complete entry set to persist.
+ */
+export declare function saveTranslationCache(dataRoot: string, entries: Record<string, TranslationRecord>): Promise<void>;

package/lib/types/packages/market-translation/src/application/translation/chain.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The ordered provider chain: one batch in, the first provider that answers wins.
+ *
+ * Providers run in the order the composition root hands them over, which is the
+ * market's own quality order — the keyless public endpoints first, the user's
+ * model last. A provider that fails is remembered for the rest of the process:
+ * an unreachable endpoint then costs one timeout per session rather than one
+ * per batch, which matters because a blocked network does not refuse the
+ * connection, it holds it open until the timeout fires.
+ * @module application/translation/chain
+ */
+import type { TranslationProvider, TranslationProviderId } from '../../../../market-contracts/src/contracts/translation.js';
+/** The provider contract lives in the shared contracts; re-exported so chain consumers keep one import. */
+export type { TranslationProvider };
+/**
+ * Per-provider timeout, in chain order.
+ *
+ * Google is first and shortest because a blocked network makes it hang rather
+ * than fail: the whole session should pay that wait at most once. The model
+ * gets the longest budget because a generation legitimately takes seconds.
+ */
+export declare const PROVIDER_TIMEOUT_MS: Record<TranslationProviderId, number>;
+/** Clear the circuit breaker. Tests call this between cases. */
+export declare function resetCircuitBreaker(): void;
+/** Whether a provider has been taken out of the chain by an earlier failure. */
+export declare function isTripped(id: TranslationProviderId): boolean;
+/**
+ * Run one batch through the chain.
+ *
+ * Every provider failure — a throw, a timeout, a short result — takes that
+ * provider out of the chain and moves on to the next. The caller's own
+ * cancellation is not a provider failure: it rethrows immediately and leaves
+ * the breaker untouched, so a panel that closed does not disable a provider for
+ * the rest of the session. Deadline and caller cancellation settle independently
+ * of provider cooperation. A late provider result cannot replace the chosen result.
+ * @param providers - the ordered chain, best first.
+ * @param texts - the batch, already masked.
+ * @param locale - target locale id.
+ * @param signal - caller cancellation, merged with the per-provider deadline.
+ * @param canContinue - live work gate checked before hops and after each result; false cancels without tripping a provider.
+ * @returns the translated batch and the provider that produced it.
+ * @throws when every provider is unavailable, tripped, or fails.
+ */
+export declare function runChain(providers: readonly TranslationProvider[], texts: readonly string[], locale: string, signal?: AbortSignal, canContinue?: () => boolean): Promise<{
+    texts: string[];
+    provider: TranslationProviderId;
+}>;