dsh-agent-plugins-market 0.6.2 → 0.7.1

package/lib/types/catalog/scan-pipeline.d.ts

@@ -20,7 +20,7 @@
  * attempt is recorded on the result, so callers can surface why a source
  * resolved the way it did.
  */
-import type { Suite } from '../model/types.js';
+import type { DiscoveredSuite } from '../model/types.js';
 /** One filter's work context: the checkout and its identity. */
 export interface ScanContext {
     marketplacePath?: string;
@@ -40,7 +40,7 @@ export type ScanAbstentionReason = string;
 /** The outcome of one filter (or the whole chain) for one checkout. */
 export type ScanResolution = {
     kind: 'resolved';
-    suites: Suite[];
+    suites: DiscoveredSuite[];
 } | {
     kind: 'abstain';
     reason: ScanAbstentionReason;
@@ -69,7 +69,7 @@ export interface ScanAttempt {
 /** The full outcome of scanning one checkout. */
 export interface ScanResult {
     marketplacePath?: string;
-    suites: Suite[];
+    suites: DiscoveredSuite[];
     attempts: ScanAttempt[];
     /** Human-readable diagnostics: dropped entries, broken manifests, fallbacks taken. */
     notes: string[];

package/lib/types/catalog/scan-resolvers.d.ts

@@ -1,9 +1,6 @@
-import type { Suite, SuiteComponents, SuiteDimension } from '../model/types.js';
+import type { DiscoveredSuite, SuiteComponents, SuiteDimension } from '../model/types.js';
 import { type MarketplaceEntry } from './manifests.js';
 import type { ScanChain, ScanContext, ScanFilter, ScanResolution, ScanResult } from './scan-pipeline.js';
-export { repoName } from './manifests.js';
-export { listMdFiles, discoverLspEntries, type LspEntry } from './surfaces.js';
-export type { MarketplaceEntry } from './manifests.js';
 export interface SuiteHint extends SuiteComponents {
     layout?: import('../model/layouts.js').ManifestKind;
     name?: string;
@@ -70,13 +67,10 @@ export declare class FlatCollectionsStrategy implements ScanFilter {
 }
 /** The default chain, most specific first with a terminal fallback. */
 export declare function defaultScanFilters(): readonly ScanFilter[];
-/** Discover every suite under one source checkout. */
-export declare function discoverSuitesInSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension, sourceUrl?: string): Promise<Suite[]>;
 /** Scan one checkout through the filter chain with full diagnostics. */
 export declare function scanSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension, sourceUrl?: string): Promise<ScanResult>;
-/** Whether a directory carries any known suite manifest. */
-export declare function hasSuiteManifest(dir: string): Promise<boolean>;
 /** Whether a directory carries skill files in the flat or bundled shape. */
 export declare function hasSkillFiles(dir: string): Promise<boolean>;
 /** Read one suite root into the normalized shape, or undefined when no manifest parses. */
-export declare function readSuite(root: string, sourceId: string, dimension: SuiteDimension, hint: SuiteHint | undefined, notes?: string[]): Promise<Suite | undefined>;
+export declare function readSuite(root: string, sourceId: string, dimension: SuiteDimension, hint: SuiteHint | undefined, notes?: string[]): Promise<DiscoveredSuite | undefined>;
+export {};

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

@@ -5,18 +5,24 @@ export interface ParsedSkillFrontmatter {
     whenToUse?: string;
     invocation: SkillInvocationPolicy;
 }
-/** Kebab-case skill names only, matching the shipped provider's rule. */
-export declare function isSkillName(name: string): boolean;
-/**
- * Normalize a display-style skill name into kebab-case (e.g. "Presentations"
- * → "presentations"), or `undefined` when nothing usable remains.
- */
-export declare function normalizeSkillName(name: string): string | undefined;
 /**
  * Parse skill frontmatter with the shipped provider's fail-closed semantics.
  * @returns the parsed frontmatter, or a rejection string explaining why the
  *   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 { SourceRef, Suite, SuiteDimension } from '../model/types.js';
+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<Suite[]>;
-/** Discover suites plus per-source scan diagnostics for one dimension. */
-export declare function discoverSourceListWithNotes(sources: SourceRef[], dimension: SuiteDimension, dimensionRoot: string, scanProjectLayouts?: boolean): Promise<{
-    suites: Suite[];
+export declare function discoverSourceList(sources: SourceRef[], dimension: SuiteDimension, dimensionRoot: string): Promise<DiscoveredSuite[]>;
+/**
+ * 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/catalog/suite-scanner.d.ts

@@ -4,13 +4,15 @@
  * The actual discovery lives in the strategy chain (`scan-pipeline.ts` +
  * `scan-resolvers.ts`); this module is the compatibility facade that keeps
  * the historical imports (`discoverSuitesInSource`, `repoName`,
- * `listMdFiles`, `LspEntry`) stable for callers and tests.
+ * `listMdFiles`) stable for callers and tests.
  */
-import type { Suite, SuiteDimension } from '../model/types.js';
-export { repoName, listMdFiles, discoverLspEntries, scanSource, canonicalGitUrl, resolveMarketplaceEntry, defaultScanFilters, MarketplaceStrategy, RootedStrategy, FlatCollectionsStrategy } from './scan-resolvers.js';
-export type { MarketplaceEntry, EntryResolution, EntryHandler, SuiteHint } from './scan-resolvers.js';
-export type { LspEntry } from './surfaces.js';
+import type { DiscoveredSuite, SuiteDimension } from '../model/types.js';
+export { repoName } from './manifests.js';
+export { listMdFiles, discoverLspEntries } from './surfaces.js';
+export { scanSource, canonicalGitUrl, resolveMarketplaceEntry, defaultScanFilters, MarketplaceStrategy, RootedStrategy, FlatCollectionsStrategy } from './scan-resolvers.js';
+export type { MarketplaceEntry } from './manifests.js';
+export type { EntryResolution, EntryHandler, SuiteHint } from './scan-resolvers.js';
 export { runScanChain } from './scan-pipeline.js';
 export type { ScanContext, ScanFilter, ScanChain, ScanResolution, ScanAttempt, ScanResult } from './scan-pipeline.js';
 /** Discover every suite under one source checkout. */
-export declare function discoverSuitesInSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension, sourceUrl?: string): Promise<Suite[]>;
+export declare function discoverSuitesInSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension, sourceUrl?: string): Promise<DiscoveredSuite[]>;

package/lib/types/catalog/validate.d.ts

@@ -32,5 +32,3 @@ export declare function validateMcpJson(pluginRoot: string, raw: unknown, option
 export declare function expandPlaceholders(value: string, pluginRoot: string, pluginData: string, env?: NodeJS.ProcessEnv): string;
 /** Resolve an expanded plugin-relative cwd to an absolute path. */
 export declare function resolveCwd(value: string, pluginRoot: string, pluginData: string): string;
-/** Whether one absolute path equals or lies under another absolute path. */
-export declare function isWithin(root: string, candidate: string): boolean;

package/lib/types/contracts/lsp-status.d.ts

@@ -50,4 +50,39 @@ export interface LspStatusPayload {
     };
     /** True when the host lacks the LSP packages, so every declaration is blocked. */
     hostMissing: boolean;
+    /**
+     * A profile layer that still registers the seam this plugin owns, present
+     * only while a `seam-conflict` is actually being reported. Releases before
+     * the plugin provisioned LSP itself told users to add such a layer by hand,
+     * so an upgrade can land here and the panel offers to remove it.
+     */
+    legacySeam?: LspLegacySeam;
+}
+/** One profile layer that must be removed before this plugin can own the LSP seam. */
+export interface LspLegacySeam {
+    /** Profile name, as passed to `dsh --profile`. */
+    profile: string;
+    /** Absolute path of the profile's patch file. */
+    patchPath: string;
+    /** The conflicting `insert` rows, as `id` plus package name. */
+    rows: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Other profiles carrying a legacy layer, which this action does not touch. */
+    otherProfiles: string[];
+    /** Whether the host must restart before the removal takes effect. */
+    restartRequired: boolean;
+    /** Human-readable summary of the layer, used in the panel copy. */
+    summary: string;
+}
+/** The outcome of removing one profile's legacy LSP layer. */
+export interface LspLegacySeamMigration {
+    profile: string;
+    /** Absolute path of the patch file that was edited. */
+    patchPath: string;
+    /** Where the pre-edit content was kept. */
+    backupPath: string;
+    /** True when the host must restart before the removal takes effect. */
+    restartRequired: boolean;
 }

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

@@ -9,6 +9,7 @@ export declare const MARKET_ROUTES: {
     readonly lspStatus: "/api/agent-plugins/lsp-status";
     readonly lspServers: "/api/agent-plugins/lsp-servers";
     readonly addLspServer: "/api/agent-plugins/lsp-servers/add";
+    readonly migrateLspSeam: "/api/agent-plugins/lsp-servers/migrate-seam";
     readonly serverConfig: "/api/agent-plugins/server-config";
     readonly saveServerConfig: "/api/agent-plugins/server-config/save";
     readonly progress: "/api/agent-plugins/progress";
@@ -27,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";
@@ -71,7 +73,7 @@ export declare function userPanelRoute(kind: UserPanelKind): string;
 /** Build one user-panel mutation route URL (all POSTs). */
 export declare function userPanelMutationRoute(kind: UserPanelKind, mutation: UserPanelMutation, name?: string): string;
 /** The MCP mount backend state reported to the settings page. */
-export interface McpBackendPayload {
+export type McpBackendInfo = {
     backend: 'builtin' | 'host';
     /** Whether the host `dsh-mcp-client` resolves from the plugin context. */
     hostClient: {
@@ -83,7 +85,7 @@ export interface McpBackendPayload {
         setting: 'auto' | 'global' | 'china';
         effective: 'global' | 'china';
     };
-}
+};
 /** One unmanaged `.sources/` checkout the user can adopt as a source. */
 export interface UnmanagedSource {
     id: string;
@@ -242,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;
@@ -272,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;
@@ -283,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/mcp-status.d.ts

@@ -35,6 +35,10 @@ export interface McpStatusEntry {
     advertisedTools?: boolean;
     /** Whether a failed server will be retried automatically. */
     retryable?: boolean;
+    /** A remote server whose suite declares no `auth` block: the bridge still
+     *  runs the OAuth flow when the server answers 401, which the redacted
+     *  configuration alone cannot show. */
+    oauthDefault?: boolean;
 }
 /** The MCP status response returned by the host. */
 export interface McpStatusPayload {

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/model/types.d.ts

@@ -26,8 +26,20 @@ export interface SourceRef {
     /** The checkout pre-existed (manually cloned or adopted); never deleted on source removal. */
     adopted?: boolean;
 }
+/**
+ * Archive URL suffixes with the payload kind each names, longest suffix first
+ * so `.tar.gz` wins over `.tar`. Source-kind inference, source-id derivation,
+ * and archive extraction all read this one table.
+ */
+export declare const ARCHIVE_SUFFIXES: readonly [readonly [".tar.gz", "targz"], readonly [".tgz", "targz"], readonly [".zip", "zip"], readonly [".tar", "tar"]];
+/** Payload kind of an archive source. */
+export type ArchiveFormat = (typeof ARCHIVE_SUFFIXES)[number][1];
+/** Classify an archive URL by extension; undefined when unsupported. */
+export declare function archiveFormatOf(url: string): ArchiveFormat | undefined;
 /** Whether a URL points at a downloadable archive. */
 export declare function isArchiveUrl(url: string): boolean;
+/** Drop a trailing archive suffix (`plugin-0.1.zip` → `plugin-0.1`); other values pass through. */
+export declare function stripArchiveSuffix(value: string): string;
 /**
  * Effective acquisition kind of a source: the explicit `kind` wins, the
  * legacy `local` flag maps to `'local'`, archive-shaped URLs infer
@@ -163,8 +175,13 @@ export interface LspSuiteConfig {
 }
 /** Install dimension of a suite. */
 export type SuiteDimension = 'user' | 'project';
-/** One discovered suite with runtime-relevant fields resolved. */
-export interface Suite {
+/**
+ * One suite as scanning produced it, with runtime-relevant fields resolved:
+ * no install entry has been merged in, so there is no lock commit, install
+ * timestamp, or effective surface set — except where the layout describes the
+ * set itself (project-native). Runtime consumers take {@link Suite}.
+ */
+export interface DiscoveredSuite {
     resources?: {
         commands: SuiteMarkdownResource[];
         agents: SuiteMarkdownResource[];
@@ -184,7 +201,7 @@ export interface Suite {
     surfaces: SuiteSurfaceCounts;
     dimension: SuiteDimension;
     enabled: boolean;
-    /** Effective per-surface enablement (overrides merged over enabled defaults). */
+    /** Effective per-surface enablement, declared only by a self-describing layout. */
     activeSurfaces?: Record<SuiteSurfaceKey, boolean>;
     lockCommit?: string;
     installedAt?: string;
@@ -196,6 +213,15 @@ export interface Suite {
     /** Surface diagnostics on a surviving suite; invalid declared manifests are rejected before discovery returns a suite. */
     errors: string[];
 }
+/**
+ * A suite with its install state applied: the shape `CatalogContext.project()`
+ * returns and every runtime consumer takes. The effective surface set is
+ * always present, so no consumer has to interpret its absence.
+ */
+export interface Suite extends DiscoveredSuite {
+    /** Effective per-surface enablement (overrides merged over enabled defaults). */
+    activeSurfaces: Record<SuiteSurfaceKey, boolean>;
+}
 export interface ProjectHooks {
     projectRoot: string;
     events: Record<string, Array<{
@@ -229,5 +255,3 @@ export interface SuiteState {
     sources: SourceRef[];
     installed: Record<string, InstalledEntry>;
 }
-/** Browser-safe market records are shared from the transport contracts. */
-export type { OverviewPayload, SourceOverview, SuiteOverviewCard } from '../contracts/market.js';

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

@@ -0,0 +1,6 @@
+/** Internal IDs stay opaque to callers; only colliding resource names need qualification. */
+export declare function namedAgentRoles<T extends {
+    name: string;
+}>(entries: readonly T[]): Array<T & {
+    callName: string;
+}>;

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

@@ -1,10 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type SubagentCatalogEntry } from './subagent-catalog.js';
 import { type HostTranslate } from './host-locale.js';
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-export declare const AGENT_ROLE_TOOL_NAME = "subagents_run";
+export declare const AGENT_ROLE_TOOL_NAME = "subagent_run";
 /** Panel identity is preserved so identically named cards from different suites remain addressable. */
 export interface AgentRoleEntry {
     name: string;
@@ -13,7 +10,15 @@ 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
+ * and are preserved by the editors, but they are not applied.
+ */
 export interface AgentRolePolicy {
     content: string;
     model?: string;
@@ -21,75 +26,77 @@ export interface AgentRolePolicy {
     reasoningEffort?: string;
     title?: string;
     description?: string;
-    tools?: string[];
-    disallowedTools?: string[];
     disabled: boolean;
 }
-/** Strict YAML parsing prevents malformed routing/restriction metadata from silently inheriting wider privileges. */
-export declare function parseAgentRole(text: string): AgentRolePolicy;
-interface ModelCatalog {
-    listProviders(): {
-        id: string;
-    }[];
-    listModels(provider: string): Promise<{
-        id: string;
-    }[]>;
-    resolveCallConfig(config: {
-        provider: string;
-        model: string;
-        reasoningEffort?: string;
-    }, signal?: AbortSignal): Promise<unknown>;
-}
-/** Bare ids must resolve uniquely; Claude aliases are accepted only if actually advertised by a DSH provider. */
-export declare function resolveAgentModel(policy: AgentRolePolicy, catalog: ModelCatalog): Promise<{
+/** Child LLM options this plugin sends; never carries inherited parent values. */
+export interface AgentRoleOptions {
     provider?: string;
     model?: string;
-}>;
-export interface AgentRoleRequest {
-    label: string;
+    reasoningEffort?: string;
+}
+/** What the host `ctx.subagents` seam receives for one role delegation. */
+export interface AgentRoleDelegation {
     prompt: {
         type: 'text';
         text: string;
     }[];
     parent: unknown;
-    signal: AbortSignal;
     maxDepth: number;
-    agentOptions: {
-        provider?: string;
-        model?: string;
-        reasoningEffort?: string;
-    };
     persona: string;
-    toolFilter?: {
-        allow?: string[];
-        deny?: string[];
-    };
+    agentOptions?: AgentRoleOptions;
 }
 export interface AgentRoleHost {
     tools: {
         register(definition: unknown): () => void;
     };
-    llm: ModelCatalog;
+    llm: {
+        resolveCallConfig(config: {
+            provider: string;
+            model: string;
+            reasoningEffort?: string;
+        }, signal?: AbortSignal): Promise<unknown>;
+    };
     subagents: {
-        start(provider: string, request: AgentRoleRequest): Promise<{
-            id: string;
-            result: Promise<{
-                stopReason: string;
-                output: JsonValue[];
-            }>;
-            dispose(): void | Promise<void>;
+        startContinuable(spec: {
+            provider: string;
+            label: string;
+            request: AgentRoleDelegation;
+            signal: AbortSignal;
+        }): Promise<{
+            childId: string;
+            messageId: string;
         }>;
     };
 }
-/** Read the same declaration for catalog summaries and execution, including inline resources. */
-export declare function readAgentRole(entry: AgentRoleEntry): Promise<AgentRolePolicy>;
+/** Strict YAML parsing prevents malformed routing metadata from silently inheriting wider privileges. */
+export declare function parseAgentRole(text: string): AgentRolePolicy;
+/**
+ * Resolve the child LLM options one card may contribute.
+ *
+ * A card route is advisory. Only an exact `provider` plus `model` pair is
+ * applied, and only when the live LLM runtime accepts it; every other
+ * declaration — a bare id, a Claude alias, a lone `provider`, an unsupported
+ * effort — degrades to inheriting the parent route and reports a diagnostic.
+ * @param policy - the card's parsed routing metadata.
+ * @param parent - the calling Agent whose route an unusable declaration falls back to.
+ * @param llm - live LLM runtime owning provider, model and effort validation.
+ * @param signal - tool-call cancellation signal.
+ * @param subject - role name used in diagnostics.
+ * @param diagnose - diagnostic sink; degradation is reported, never silent.
+ * @returns the options to send, or undefined for pure inheritance.
+ */
+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[]>;
-/** Resolve fresh panel state and raw Markdown on every call, including after edits, disabling and uninstall. */
-export declare function executeAgentRole(host: AgentRoleHost, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, name: string, prompt: string, parent: unknown, signal: AbortSignal): Promise<{
-    runId: string;
-    output: JsonValue[];
+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>;
+/**
+ * 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
+ * continuation manager; this executor owns only role resolution.
+ */
+export declare function executeAgentRole(host: AgentRoleHost, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, agentName: string, prompt: string, parent: unknown, signal: AbortSignal, diagnose?: (message: string) => void): Promise<{
+    subagentId: string;
 }>;
 /** Mount once after tools, llm and subagents are available; the returned disposer belongs to the plugin lifecycle. */
 export declare function mountAgentRoleTool(ctx: Context, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, t?: HostTranslate): () => void;
-export {};

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

@@ -0,0 +1,17 @@
+/** 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>;