dsh-agent-plugins-market 0.7.0 → 0.7.1

package/lib/types/catalog/plugin-variables.d.ts

@@ -0,0 +1,16 @@
+import type { Suite } from '../model/types.js';
+/** The absolute paths one expansion can supply; an absent entry leaves its variable verbatim. */
+export interface PluginPathContext {
+    /** Suite checkout root: `${PLUGIN_ROOT}` and its dialect aliases. */
+    root?: string;
+    /** Per-suite data directory: `${PLUGIN_DATA}` and its aliases. */
+    data?: string;
+    /** Directory holding the skill file: `${CLAUDE_SKILL_DIR}`. */
+    skillDir?: string;
+    /** Calling session's project directory: `${CLAUDE_PROJECT_DIR}` and its aliases. */
+    projectDir?: string;
+}
+/** The suite root `${PLUGIN_ROOT}` and its dialect aliases resolve to. */
+export declare function pluginRootOf(suite: Pick<Suite, 'manifest' | 'root'>): string | undefined;
+/** Replace every path variable the context can resolve; other text stays exactly as written. */
+export declare function expandPluginPaths(text: string, context: PluginPathContext): string;

package/lib/types/catalog/skills-parse.d.ts

@@ -11,5 +11,18 @@ export interface ParsedSkillFrontmatter {
  *   skill must be dropped from discovery.
  */
 export declare function parseSkillFrontmatter(text: string, expectedName: string | undefined): ParsedSkillFrontmatter | string;
+/**
+ * Rejection for a user skill document the harness's own `dsh-skill-filesystem`
+ * reader would drop from `~/.agents/skills`, or `undefined` when that reader
+ * accepts it.
+ *
+ * The two readers share the directory, so the panel publishes only documents
+ * both accept: a listed entry never becomes a skill that loads in a
+ * market-equipped session alone. The checks mirror the shipped reader rather
+ * than the lenient suite scan — strict YAML, no display-name normalization,
+ * and a `name` the reader compares only against its kebab grammar.
+ * @returns the drop reason, phrased as the reader's own diagnostic.
+ */
+export declare function skillEntryRejection(text: string): string | undefined;
 /** Strip the frontmatter block, returning the instruction body. */
 export declare function stripFrontmatter(text: string): string;

package/lib/types/catalog/source-catalog.d.ts

@@ -1,8 +1,13 @@
 import type { DiscoveredSuite, SourceRef, SuiteDimension } from '../model/types.js';
 /** Discover suites from the selected configured or project checkouts. */
 export declare function discoverSourceList(sources: SourceRef[], dimension: SuiteDimension, dimensionRoot: string): Promise<DiscoveredSuite[]>;
-/** Discover suites plus per-source scan diagnostics for one dimension. */
-export declare function discoverSourceListWithNotes(sources: SourceRef[], dimension: SuiteDimension, dimensionRoot: string, scanProjectLayouts?: boolean): Promise<{
+/**
+ * Discover suites plus per-source scan diagnostics for one dimension.
+ * @param scanProjectLayouts - whether the project's own native Agent directories
+ *   join the scan. Required on purpose: the switch has one owner (the host
+ *   settings document), so a default here would be a second copy of it.
+ */
+export declare function discoverSourceListWithNotes(sources: SourceRef[], dimension: SuiteDimension, dimensionRoot: string, scanProjectLayouts: boolean): Promise<{
     suites: DiscoveredSuite[];
     scanNotes: Record<string, string[]>;
 }>;

package/lib/types/contracts/market.d.ts

@@ -28,6 +28,7 @@ export declare const MARKET_ROUTES: {
     readonly setSurface: "/api/agent-plugins/set-surface";
     readonly mcpOverrides: "/api/agent-plugins/mcp-overrides";
     readonly setMcpOverride: "/api/agent-plugins/set-mcp-override";
+    readonly setMcpServerEnabled: "/api/agent-plugins/set-mcp-server-enabled";
     readonly mcpRetry: "/api/agent-plugins/mcp-retry";
     readonly mcpReauthorize: "/api/agent-plugins/mcp-reauthorize";
     readonly mcpBackend: "/api/agent-plugins/mcp-backend";
@@ -243,6 +244,8 @@ export interface SuiteDetail {
     description: string | null;
     author: string | null;
     keywords: string[];
+    /** Last modification of the suite checkout, as an ISO timestamp; null when it cannot be read. */
+    updatedAt: string | null;
     layout: string;
     dimension: string;
     root: string;
@@ -273,6 +276,7 @@ export interface SkillContent {
 }
 /** A user panel entry (skills / commands / agent personas) over HTTP. */
 export interface UserPanelEntryWire {
+    /** Entry name: the name its document declares, else the file's base name. */
     name: string;
     description: string;
     disabled: boolean;
@@ -284,7 +288,13 @@ export interface UserPanelEntryWire {
     suiteName?: string;
     metadata: Record<string, unknown>;
     path: string;
+    /** The entry file's last modification, as an ISO timestamp. */
+    updatedAt?: string | null;
     content: string;
+    /** Suite checkout root of a plugin-provided file; runtime consumers resolve `${PLUGIN_ROOT}` against it. */
+    suiteRoot?: string;
+    /** The suite's `${PLUGIN_DATA}` directory, for the same runtime resolution. */
+    suiteData?: string;
 }
 /** The user panel surface the market exposes. */
 export type UserPanelKind = 'skills' | 'commands' | 'agents';

package/lib/types/contracts/settings.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Browser-safe settings contract of the market's host settings namespace: the
+ * namespace key, the fields with their defaults, and the one reader that turns
+ * a stored section into resolved values.
+ *
+ * The defaults live here and nowhere else. The namespace schema declares them
+ * to the host, the node half reads them back through {@link resolveMarketSettings},
+ * and the browser half — which cannot import `src/runtime` — reads the same
+ * resolved values off the settings snapshot it is handed. Changing a default is
+ * therefore a one-line edit in this module.
+ *
+ * @module contracts/settings
+ */
+/** Settings namespace this plugin registers; the key the plugin-config tab pairs our card by. */
+export declare const MARKET_SETTINGS_NAMESPACE = "dsh-agent-plugins-market";
+/** The persisted download-region setting: `auto` follows the interface language. */
+export type DownloadRegionSetting = 'auto' | 'global' | 'china';
+/** Every market setting with the value it resolves to when the document says nothing. */
+export interface MarketSettings {
+    /** ON = the built-in MCP bridge with OAuth and SSE; OFF = host client compat mode. */
+    mcpEnhanced: boolean;
+    /** ON = native project Agent layouts (`.claude/`, `.agents/`) take part in discovery. */
+    scanProjectLayouts: boolean;
+    /** Download region for GitHub acquisition. */
+    downloadRegion: DownloadRegionSetting;
+    /** ON = the `report_market_issue` model tool is registered. */
+    feedbackEnabled: boolean;
+    /** ON = every configured source refreshes in the background. */
+    autoUpdateSources: boolean;
+}
+/**
+ * The default of every market setting — the single place one is written.
+ *
+ * These are user-visible behavior: a flip here is a behavior change that ships
+ * with its documentation, not a private implementation detail.
+ */
+export declare const MARKET_SETTINGS_DEFAULTS: MarketSettings;
+/** Every field name the market's settings section carries. */
+export type MarketSettingKey = keyof MarketSettings;
+/**
+ * Narrow an untrusted stored region to a setting; anything else reads as the
+ * declared default.
+ * @param value - the stored `downloadRegion` value.
+ * @param fallback - the value an unrecognized input reads as.
+ */
+export declare function narrowDownloadRegion(value: unknown, fallback?: DownloadRegionSetting): DownloadRegionSetting;
+/**
+ * Resolve a stored settings section the way the host resolves it: each field
+ * takes its stored value when it is one this field accepts, and its declared
+ * default otherwise.
+ *
+ * The host hands the resolved section back on its own, but not every caller has
+ * one — the plugin's own halves read a section they may not have received yet,
+ * and a test hands in a bare literal. Funnelling all of them through this
+ * function is what keeps a second reading of "what does missing mean" from
+ * growing somewhere else.
+ * @param section - the stored (or absent) namespace section, untrusted.
+ */
+export declare function resolveMarketSettings(section: unknown): MarketSettings;

package/lib/types/model/layouts.d.ts

@@ -42,6 +42,10 @@ export declare const MANIFEST_ALIASES: Partial<Record<ManifestKind, readonly str
 /** Equivalent plugin-owned path variables; these never resolve as credentials. */
 export declare const PLUGIN_ROOT_VARIABLES: ReadonlySet<string>;
 export declare const PLUGIN_DATA_VARIABLES: ReadonlySet<string>;
+/** Equivalent session project-directory variables; only a calling session supplies the directory. */
+export declare const PROJECT_DIR_VARIABLES: ReadonlySet<string>;
+/** Claude Code names the directory holding the skill's own file; no dialect alias exists. */
+export declare const SKILL_DIR_VARIABLE = "CLAUDE_SKILL_DIR";
 /** Explicit project document formats and portable surfaces; execution stays in the runtime adapters. */
 export type ProjectMcpFormat = 'mcpServers' | 'zcode' | 'codex';
 export type ProjectHookFormat = 'claude' | 'zcode';
@@ -50,6 +54,11 @@ export interface ProjectLayout {
     label: string;
     subdirs: readonly string[];
     mcpFiles?: readonly string[];
+    /**
+     * Project-root-relative hook documents, read in order. A `settings.json`
+     * layer carries a `hooks` key; a standalone `hooks.json` may instead be the
+     * bare event table, the same file shape a suite ships under `hooks/`.
+     */
     hookFiles?: readonly string[];
     mcpFormat?: ProjectMcpFormat;
     hookFormat?: ProjectHookFormat;
@@ -64,6 +73,7 @@ export declare const PROJECT_LAYOUTS: readonly [{
     readonly dirName: ".agents";
     readonly label: "agents";
     readonly subdirs: readonly ["skills", "agents", "commands"];
+    readonly hookFiles: readonly [".agents/hooks/hooks.json", ".agents/hooks.json"];
 }, {
     readonly dirName: ".codex";
     readonly label: "Codex";

package/lib/types/runtime/agent-role-router.d.ts

@@ -10,6 +10,10 @@ export interface AgentRoleEntry {
     disabled: boolean;
     title?: string;
     rawText?: string;
+    /** Suite checkout root the card's `${PLUGIN_ROOT}` variables resolve to; absent for project-native files. */
+    suiteRoot?: string;
+    /** The suite's `${PLUGIN_DATA}` directory; absent for project-native files. */
+    suiteData?: string;
 }
 /**
  * The executable part of one card. `tools` / `disallowedTools` stay in the file
@@ -83,9 +87,9 @@ export declare function parseAgentRole(text: string): AgentRolePolicy;
  */
 export declare function resolveAgentOptions(policy: AgentRolePolicy, parent: unknown, llm: AgentRoleHost['llm'], signal: AbortSignal, subject: string, diagnose: (message: string) => void): Promise<AgentRoleOptions | undefined>;
 /** Stable summaries; invalid declarations are excluded and transient read failures abort publication. */
-export declare function agentRoleCatalog(entries: AgentRoleEntry[], signal: AbortSignal, diagnose?: (message: string) => void): Promise<SubagentCatalogEntry[]>;
+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): Promise<AgentRolePolicy>;
+export declare function readAgentRole(entry: AgentRoleEntry, projectDir?: string): Promise<AgentRolePolicy>;
 /**
  * Start one role child and return its durable id without waiting for the result.
  * Resume state, steering, and the settlement notice belong to the host's

package/lib/types/runtime/commands-mounts.d.ts

@@ -3,12 +3,13 @@
  * register as dsh slash commands.
  *
  * A CC command is a prompt template the model executes (its body carries
- * `$ARGUMENTS` and execution rules), so the handler maps it onto the
- * harness's follow-up mechanism: the template with `$ARGUMENTS` substituted
- * becomes one durable user-role follow-up message on the receiving agent.
- * Registrations reconcile on every enable/disable/install/uninstall; a
- * broken command file or an unavailable `ctx.commands` is contained per
- * command and reported as a diagnostic.
+ * `$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, SuiteMarkdownResource } from '../model/types.js';
@@ -23,13 +24,20 @@ interface CommandSpec {
     description: string;
     body: string;
     hint?: string;
+    /** Set when the command file belongs to a suite with a plugin root; absent for project-native files. */
+    suiteRoot?: string;
+    /** The suite's `${PLUGIN_DATA}` directory; absent for project-native files. */
+    suiteData?: string;
 }
 export declare class CommandMountRegistry {
     private readonly ctx;
     private readonly t;
+    private readonly dataRoot?;
     private readonly fingerprints;
     private readonly live;
-    constructor(ctx: Context, t?: HostTranslate);
+    constructor(ctx: Context, t?: HostTranslate, dataRoot?: string | undefined);
+    /** 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[]>;
     /** Dispose every registered command; used at plugin teardown. */

package/lib/types/runtime/deadline.d.ts

@@ -1,18 +1,17 @@
-/**
- * Bounded waits for work this plugin cannot cancel.
- *
- * Every wait here is a race against a timer: the caller stops waiting and the
- * underlying work keeps running. That is the only safe shape for a mount and
- * for the change pipeline that drives it — a spawned server process or a
- * browser authorization the user is completing must not be abandoned just
- * because nobody is waiting for it any more.
- *
- * @module runtime/deadline
- */
+/** Identifies this plugin's bounded waits inside a timeout reason. */
+export declare const MARKET_DEADLINE_CODE = "MARKET_DEADLINE";
 /**
  * Resolve `true` once `work` settles, or `false` when `deadlineMs` elapses.
  *
  * A rejection counts as settled: this helper only reports timing, so callers
  * that need the failure attach their own handler to `work`.
+ *
+ * A non-positive wait means "do not wait": the answer is simply whether the
+ * work had already settled. That is deliberately not the host primitive's own
+ * reading of a non-positive timeout, which is "arm no timer at all" — the floor
+ * below keeps the two from collapsing into opposite behaviors.
+ * @param work - the work to wait for; it is never cancelled, only stopped being awaited.
+ * @param deadlineMs - how long to wait, in milliseconds.
+ * @returns whether the work settled before the deadline.
  */
 export declare function settlesWithin(work: Promise<unknown>, deadlineMs: number): Promise<boolean>;

package/lib/types/runtime/dynamic-context.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Claude Code dynamic context injection: `` !`command` `` in a command body or
+ * skill body runs the command and the placeholder becomes its output.
+ *
+ * One pass over the original text recognizes both spellings — the inline
+ * `` !`cmd` `` (only at a line start or after whitespace, matching the authoring
+ * rule) and the multi-line ```` ```! ```` fence — and every command runs
+ * sequentially in the calling session's directory. Outputs are inserted as
+ * plain text and never re-read, so a command cannot emit another placeholder.
+ *
+ * Failure is contained per invocation rather than per placeholder: the caller
+ * aborts the whole invocation with the command's own output, so a model never
+ * reads half-injected text. Exit code 1 counts as a result for the commands
+ * whose benign outcome it is (`grep`, `rg`, `find`, `diff`, `test`, …).
+ *
+ * The shell service is reached structurally: {@link shellSeamOf} resolves it
+ * from any context, and a profile without one keeps the author's literal text.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** How long one injected command may run; the executor caps a larger request. */
+export declare const DYNAMIC_CONTEXT_TIMEOUT_MS = 120000;
+/** The requested forward cap for one injected command's stdout, in bytes. */
+export declare const DYNAMIC_CONTEXT_MAX_OUTPUT_BYTES: number;
+/** The slice of the host shell service this module uses. */
+export interface ShellSeam {
+    resolve(request: {
+        command: string;
+        workdir?: string;
+        timeoutMs?: number;
+        stdoutMaxBytes?: number;
+        signal?: AbortSignal;
+    }): unknown;
+    run(spec: unknown): Promise<ShellOutcome>;
+}
+/** The fields of one shell run this module reads. */
+export interface ShellOutcome {
+    exitCode: number | null;
+    timedOut: boolean;
+    aborted: boolean;
+    stdout: {
+        text: string;
+        truncated: boolean;
+        spillPath?: string;
+    };
+    stderr: {
+        text: string;
+        truncated: boolean;
+        spillPath?: string;
+    };
+}
+/**
+ * Resolve the host shell service from any context, whether or not the reading
+ * fiber injects `shell`.
+ *
+ * Cordis resolves `ctx.shell` by walking the reading fiber's ancestors, so a
+ * scope that does not inject the service throws `cannot get property "shell"
+ * without inject` even when a sibling fiber provides it. `ctx.get` reads the
+ * global service store instead and answers `undefined` in a profile that has
+ * no shell, which is what keeps the seam optional.
+ *
+ * @param ctx - the context the dynamic-context pass runs under.
+ * @returns the shell seam, or `undefined` when the profile provides none.
+ */
+export declare function shellSeamOf(ctx: Context): ShellSeam | undefined;
+export interface DynamicContextOptions {
+    shell: ShellSeam;
+    /** Session directory every injected command runs in. */
+    workdir?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Run every placeholder's command and return the text the model receives.
+ *
+ * @param text - author text whose `${...}` variables and arguments are already resolved.
+ * @param options - the resolved shell seam, session directory and cancellation signal.
+ * @returns the text with each placeholder replaced by its command's output.
+ * @throws when a command fails, times out or is aborted, carrying the command and its output.
+ */
+export declare function injectDynamicContext(text: string, options: DynamicContextOptions): Promise<string>;
+/** Whether this command's exit status is a result rather than a failure. */
+export declare function benignExit(exitCode: number | null, command: string): boolean;

package/lib/types/runtime/host-locale.d.ts

@@ -6,8 +6,26 @@ interface ResolvedLocale {
 }
 /** Resolve the active host language from settings; unknown values default to zh. */
 export declare function bindHostLocale(preference: string | undefined): HostTranslate;
-/** Read `locale.preference` from `$DSH_HOME/settings.yaml` (best effort). */
+/**
+ * Wire the host settings service as the primary locale source, replacing the
+ * `settings.yaml` fallback.
+ * @param read - reads `locale.preference` from the settings service.
+ */
+export declare function setHostLocaleSource(read: () => string | undefined): void;
+/**
+ * The persisted locale preference: the host settings document when the service
+ * is composed, else `$DSH_HOME/settings.yaml` (best effort).
+ */
 export declare function readLocalePreference(): Promise<string | undefined>;
 /** Bind a host translator against the persisted locale preference. */
 export declare function loadHostLocale(): Promise<ResolvedLocale>;
+/**
+ * Read `locale.preference` from the host settings service.
+ *
+ * The locale namespace is registered by the host's own client-locale plugin, so
+ * this reads `undefined` until that plugin mounts — which is why the caller
+ * re-binds when the service arrives rather than capturing the value once.
+ * @param settingsCtx - a context carrying the `settings` service.
+ */
+export declare function readHostLocalePreference(settingsCtx: unknown): string | undefined;
 export {};

package/lib/types/runtime/lsp-mounts.d.ts

@@ -29,6 +29,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import { type LegacyLspSeam } from './profile-seam.js';
+import { type PluginPathContext } from '../catalog/plugin-variables.js';
 import { type Suite } from '../model/types.js';
 export interface LspMountDiagnostic {
     suiteId: string;
@@ -54,6 +55,8 @@ export declare function toLspServerConfig(spec: {
     initializationOptions?: unknown;
     configuration?: unknown;
 }): LspStdioServerConfig;
+/** Resolve author-written paths in one declaration before the host spawns the server. */
+export declare function expandLspServerConfig(config: LspStdioServerConfig, context: PluginPathContext): LspStdioServerConfig;
 /** Minimal structural shape of a dynamically imported host plugin module. */
 interface HostModule {
     default?: unknown;
@@ -87,6 +90,8 @@ export declare class LspMountRegistry {
     private capabilityFailure;
     /** Latest diagnostic per suite id; cleared when its suite mounts or leaves the wanted set. */
     private readonly lastDiagnostics;
+    /** Plugin storage root holding each suite's `${PLUGIN_DATA}` directory; unset leaves the variable verbatim. */
+    private pluginDataRoot?;
     /** Direct (user-configured) server provider; defaults to none. */
     private directProvider;
     private disabledProvider;
@@ -119,6 +124,8 @@ export declare class LspMountRegistry {
     private seamConflictReason;
     /** Dispose the capability seam this registry mounted, once no wanted server needs it. */
     private releaseCapability;
+    /** Install the plugin storage root per-suite data directories resolve against. */
+    setPluginDataRoot(root: string): void;
     /** Install the direct (user-configured) server provider used at reconcile time. */
     setDirectProvider(provider: () => Promise<Record<string, import('../model/types.js').LspServerSpec>>): void;
     setDisabledProvider(provider: () => Promise<Set<string>>): void;

package/lib/types/runtime/mcp-backend.d.ts

@@ -4,8 +4,8 @@
  * 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 a host settings namespace (`dsh-agent-plugins-market`,
- * `mcpEnhanced: boolean`, default true) registered by the plugin's node half:
+ * 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. `readMcpBackend` remains only as the
@@ -16,30 +16,23 @@
 import z from '@deepseek-ai/schemastery';
 /** The MCP mount backend the market uses for suite servers. */
 export type McpBackend = 'builtin' | 'host';
-/** Settings namespace this plugin registers; the key the plugin-config tab pairs our card by. */
-export declare const MCP_SETTINGS_NAMESPACE = "dsh-agent-plugins-market";
-/** Schema of the market settings namespace: the switches this plugin's config card serves. */
+/**
+ * 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.
+ */
 export declare const MarketSettingsSchema: z<Schemastery.ObjectS<{
-    /** ON (default) = the built-in bridge with OAuth and SSE; OFF = host client compat mode. */
     mcpEnhanced: z<boolean, boolean>;
-    /** Read native Agent layouts under the project root; OFF (default) scans configured sources only. */
     scanProjectLayouts: z<boolean, boolean>;
-    /** Download region for GitHub acquisition; `auto` follows the interface language. */
     downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china">;
-    /** ON (default) = the `report_market_issue` model tool is registered; OFF = unregistered. */
     feedbackEnabled: z<boolean, boolean>;
-    /** ON = refresh every configured source in the background; OFF (default) = never. */
     autoUpdateSources: z<boolean, boolean>;
 }>, Schemastery.ObjectT<{
-    /** ON (default) = the built-in bridge with OAuth and SSE; OFF = host client compat mode. */
     mcpEnhanced: z<boolean, boolean>;
-    /** Read native Agent layouts under the project root; OFF (default) scans configured sources only. */
     scanProjectLayouts: z<boolean, boolean>;
-    /** Download region for GitHub acquisition; `auto` follows the interface language. */
     downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china">;
-    /** ON (default) = the `report_market_issue` model tool is registered; OFF = unregistered. */
     feedbackEnabled: z<boolean, boolean>;
-    /** ON = refresh every configured source in the background; OFF (default) = never. */
     autoUpdateSources: z<boolean, boolean>;
 }>>;
 /** Path of the legacy persisted settings file under the plugin data root. */

package/lib/types/runtime/mcp-client/config.d.ts

@@ -12,6 +12,14 @@ import type { ReconnectConfig } from './connection.js';
 import type { McpServerPolicy } from '../../model/types.js';
 /** Default timeout for individual MCP tool calls (ms). */
 export declare const DEFAULT_TOOL_CALL_TIMEOUT_MS = 60000;
+/**
+ * How long one connection attempt may spend initializing (ms). A server that
+ * never answers would otherwise hold its process, transport and browser leg
+ * until the SDK's own 60-second request default expired; a working server
+ * handshakes well under a second, and a genuinely slow one can declare its own
+ * `startupTimeoutMs`.
+ */
+export declare const DEFAULT_STARTUP_TIMEOUT_MS = 10000;
 /** Valid `serverName`, kept below the public tool-name budget. */
 export declare const SERVER_NAME_PATTERN: RegExp;
 /**

package/lib/types/runtime/mcp-client/host-seams.d.ts

@@ -1,55 +1,25 @@
 /**
- * Local ports of the tiny host seams the self-built MCP client needs.
+ * The host seams the self-built MCP client consumes, re-exported from the
+ * packages that own them.
  *
- * The market plugin must stay self-contained at runtime: it cannot import
- * host-internal packages that are not published at compatible versions, and
- * every one of these seams is a small pure function or constant. Each port
- * below is copied verbatim (semantics, not prose) from the harness source at
- * `0.1.1-rc.2` and carries the upstream reference it came from, so a future
- * host change can be re-diffed against `~/workspace/deepseek-harness`.
+ * These are small pure functions and constants, but each one encodes a rule
+ * this plugin must obey rather than a choice it gets to make: which credential
+ * keys the host accepts, how long a timer may be, which environment names never
+ * reach a child process, and which image failures a caller can correct. Reading
+ * them from the host keeps one owner per rule, so a host change reaches this
+ * plugin instead of leaving a copy behind.
  *
- * Anything larger than a handful of lines (the JSON Schema subset validator)
- * lives in its own module.
+ * The OAuth provider and attachment admission reach their services through the
+ * optional `credentials` / `attachments` seams at runtime, so the service types
+ * here stay structural — only the rules are imported.
  *
  * @module runtime/mcp-client/host-seams
  */
-/**
- * The largest delay `setTimeout` accepts without overflowing to a 1ms clamp
- * (2^31 - 1). Shared guard for reconnect and callback timers.
- */
-export declare const MAX_TIMER_DELAY_MS = 2147483647;
-/** `DSH_*` environment namespace owned by the harness. */
-export declare const DSH_ENV_PREFIX: "DSH_";
-/**
- * Credential-shaped environment names are NOT forwarded to MCP server child
- * processes (the harness's own `DEEPSEEK_API_KEY`/secrets must not leak into a
- * spawned server implicitly). Deliberately supplied env entries survive
- * because the config's explicit env merges after the scrub.
- */
-export declare const SENSITIVE_ENV_PATTERN: RegExp;
-/**
- * The ambient parent environment minus credential-shaped names and minus all
- * `DSH_*` names — the canonical base every harness child starts from. `PATH`,
- * `HOME`, locale, and proxy variables survive, so child CLIs run normally;
- * harness identity never leaks implicitly. Both scrubs match case-insensitively:
- * Windows environment names are case-insensitive, so a parent `dsh_*` entry
- * would otherwise survive and read back as `$env:DSH_*` in the child.
- * @returns a fresh environment object safe to hand to a child spawn.
- */
-export declare function scrubbedParentEnv(): Record<string, string>;
-/** A credential record key: `<scope>/<id>` with both segments in the grammar below. */
-declare const credentialKeyBrand: unique symbol;
-export type CredentialKey = string & {
-    readonly [credentialKeyBrand]: true;
-};
-/**
- * Brand a scope and an id as a {@link CredentialKey}.
- * @param scope - the owning plugin's registered name (here: the `mcp-auth` record scope).
- * @param id - the plugin's own addressing unit (here: the folded serverName).
- * @returns the branded key.
- * @throws TypeError when either segment is not a lowercase hyphenated identifier.
- */
-export declare function credentialKey(scope: string, id: string): CredentialKey;
+import type { CredentialKey } from '@deepseek-ai/dsh-credentials';
+import type { SaveImageAttachment } from '@deepseek-ai/dsh-attachment';
+export { MAX_TIMER_DELAY_MS } from '@deepseek-ai/dsh-timeout';
+export { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess';
+export { credentialKey, type CredentialKey } from '@deepseek-ai/dsh-credentials';
 /**
  * Structural mirror of the host `CredentialProvider` record surface the OAuth
  * provider needs. Typed structurally because the store arrives via the
@@ -64,26 +34,12 @@ export interface CredentialRecordStore {
     readRecord(key: CredentialKey): Promise<unknown>;
     modifyRecord(key: CredentialKey, mutate: (current: unknown) => Promise<unknown>): Promise<unknown>;
 }
+export { isImageAdmissionError, type ImageMediaType, type SaveImageAttachment } from '@deepseek-ai/dsh-attachment';
 /**
- * Distinguish caller-correctable image admission failures from storage faults,
- * so an admission refusal projects text diagnostics while a storage fault is
- * reported as such.
- */
-export declare function isImageAdmissionError(error: unknown): boolean;
-/** Raster formats supported by the durable attachment vocabulary. */
-export type ImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
-/** One decoded image handed to the host attachment store. */
-export interface SaveImageAttachment {
-    data: Buffer;
-    mediaType: ImageMediaType;
-}
-/**
- * Structural mirror of the host `AttachmentStore.saveImages` surface. The
- * returned refs are opaque host values that ride inside `ContentBlock`
- * image blocks; typed `unknown` here and narrowed by the model content
- * contract at the projection site.
+ * Structural mirror of the host attachment store surface this plugin writes
+ * through. The service is resolved off the tool host at call time, so its
+ * concrete class is deliberately not imported.
  */
 export interface AttachmentStoreLike {
     saveImages(images: readonly SaveImageAttachment[]): Promise<readonly unknown[]>;
 }
-export {};

package/lib/types/runtime/project-runtime.d.ts

@@ -4,7 +4,7 @@ import type { Catalog } from '../application/catalog.js';
 import type { HostTranslate } from './host-locale.js';
 import type { Suite } from '../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): {
+export declare function mountProjectCommands(ctx: Context, catalog: Catalog, t: HostTranslate, dataRoot?: string): {
     refresh(): Promise<void>;
     dispose(): Promise<void>;
 };
@@ -19,11 +19,18 @@ 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): {
+export declare function mountSuiteInstructions(ctx: Context, catalog: Catalog, dataRoot?: string): {
     refresh(): Promise<void>;
     dispose(): Promise<void>;
 };
-export declare function suiteInstructions(suites: readonly Suite[]): Promise<{
+/** Runtime paths one instruction pass can resolve; a variable without one stays verbatim. */
+export interface SuiteInstructionPaths {
+    /** Plugin storage root holding each suite's `${PLUGIN_DATA}` directory. */
+    dataRoot?: string;
+    /** Directory of the session the instructions are injected into. */
+    projectDir?: string;
+}
+export declare function suiteInstructions(suites: readonly Suite[], paths?: SuiteInstructionPaths): Promise<{
     text: string;
     errors: Array<{
         suiteId: string;

package/lib/types/runtime/reconcile-scheduler.d.ts

@@ -28,7 +28,7 @@ export declare class ReconcileScheduler {
     private requested;
     private pass;
     private readonly pendingCredentialRefs;
-    private credentialFlush;
+    private readonly credentialFlush;
     private readonly releaseCredentialUpdates;
     constructor(ctx: Context, runtime: RuntimeReconciler, host: ReconcileHost);
     /** Reconcile now, joining the pass in flight and remembering one follow-up for it. */