dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/{application → packages/market-runtime/src/application}/panels/user-store.js

@@ -14,10 +14,11 @@
  * @module application/user-store
  */
 import { readdir, readFile, rmdir, rm, stat } from 'node:fs/promises';
+import { isAbsentPath } from '../fs-probe.js';
 import { dirname, join } from 'node:path';
 import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { parseDocument, stringify } from 'yaml';
-import { parseSkillFrontmatter, stripFrontmatter } from '../../catalog/skills-parse.js';
+import { parseSkillFrontmatter, stripFrontmatter } from '../../../../market-catalog/src/index.js';
 /** Where user panel entries persist: `<agentsRoot>/<kind>/`. */
 export function userEntryDir(agentsRoot, kind) {
     return join(agentsRoot, kind);
@@ -44,15 +45,48 @@ export const SKILL_ENTRY_SHAPES = ['skill-directory', 'file'];
 export function entryDocumentPath(dir, name, shape) {
     return shape === 'skill-directory' ? join(dir, name, SKILL_ENTRY_FILE) : join(dir, `${name}.md`);
 }
+/**
+ * Whether one panel directory may be listed, answered structurally rather than
+ * from a listing failure.
+ *
+ * A path is either an existing directory, absent (a user who authored nothing
+ * has not broken anything), or something that can never hold entries. Only the
+ * first is listed; the second is a valid empty panel; the third is a broken
+ * configuration. Confirming the shape before listing keeps that decision
+ * independent of the code a `readdir` failure happens to carry.
+ * @param dir - the panel directory.
+ * @param strict - whether a broken configuration is an error or an empty read.
+ * @returns `true` when the directory is confirmed and may be listed.
+ */
+async function confirmDirectory(dir, strict) {
+    let info;
+    try {
+        info = await stat(dir);
+    }
+    catch (error) {
+        // A directory is absent only when its ancestors stay searchable: a platform
+        // can report ENOENT for a child of a file, which is an unreadable panel.
+        if (await isAbsentPath(dir))
+            return false;
+        if (strict)
+            throw error;
+        return false;
+    }
+    if (info.isDirectory())
+        return true;
+    if (strict)
+        throw Object.assign(new Error(`ENOTDIR: not a directory, scandir '${dir}'`), { code: 'ENOTDIR' });
+    return false;
+}
 /** Whether a path is a regular file; strict runtime snapshots propagate real I/O failures. */
 async function isFile(file, strict) {
     try {
         return (await stat(file)).isFile();
     }
     catch (error) {
-        if (strict && error.code !== 'ENOENT')
-            throw error;
-        return false;
+        if (!strict || (await isAbsentPath(file)))
+            return false;
+        throw error;
     }
 }
 /**
@@ -83,14 +117,18 @@ export async function listEntryDocuments(dir, strict = false, shapes = ['file'],
         await collectNestedEntryDocuments(dir, '', shapes, strict, found);
         return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
     }
+    if (!(await confirmDirectory(dir, strict)))
+        return [];
     let entries;
     try {
         entries = await readdir(dir);
     }
     catch (error) {
-        if (strict && error.code !== 'ENOENT')
-            throw error;
-        return [];
+        // Only a structurally confirmed absence is tolerated: the directory can be
+        // removed between the confirmation and the listing.
+        if (!strict || (await isAbsentPath(dir)))
+            return [];
+        throw error;
     }
     for (const entry of entries.sort()) {
         const name = entry.endsWith('.md') ? entry.slice(0, -3) : shapes.includes('skill-directory') ? entry : undefined;
@@ -114,14 +152,16 @@ export async function listEntryDocuments(dir, strict = false, shapes = ['file'],
  * `/` separators and no trailing slash.
  */
 async function collectNestedEntryDocuments(dir, prefix, shapes, strict, found) {
+    if (!(await confirmDirectory(dir, strict)))
+        return;
     let entries;
     try {
         entries = await readdir(dir, { withFileTypes: true });
     }
     catch (error) {
-        if (strict && error.code !== 'ENOENT')
-            throw error;
-        return;
+        if (!strict || (await isAbsentPath(dir)))
+            return;
+        throw error;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         if (entry.isSymbolicLink() || entry.name.startsWith('.') || entry.name === 'node_modules')
@@ -171,9 +211,9 @@ export async function readEntryDocument(document, strict = false) {
         text = await readFile(document.file, 'utf8');
     }
     catch (error) {
-        if (strict && error.code !== 'ENOENT')
-            throw error;
-        return undefined;
+        if (!strict || (await isAbsentPath(document.file)))
+            return undefined;
+        throw error;
     }
     let meta;
     try {

package/lib/{application → packages/market-runtime/src/application}/project-agent-roles.js

@@ -1,23 +1,26 @@
 /** Resolve read-only project roles from the calling session, never from tool-supplied paths. */
-import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
-import { pluginRootOf } from '../catalog/plugin-variables.js';
-import { suiteDataDir } from '../catalog/paths.js';
+import { defaultMarkdownResources, resourceText } from '../../../market-catalog/src/index.js';
+import { pluginRootOf } from '../../../market-catalog/src/index.js';
+import { suiteDataDir } from '../../../market-catalog/src/index.js';
 import { parseAgentRole } from './agent-roles.js';
-export async function projectAgentRoles(catalog, parent) {
+import { isAbsentPath } from './fs-probe.js';
+export async function projectAgentRoles(catalog, parent, options = {}) {
     const cwd = parent?.session?.header?.cwd;
     if (typeof cwd !== 'string' || cwd === '')
         return [];
-    const snapshot = await catalog.readProjectCatalog(cwd);
+    const suites = options.suites ? await options.suites() : (await catalog.readProjectCatalog(cwd)).enabledSuites;
     const entries = [];
-    for (const suite of snapshot.enabledSuites) {
+    for (const suite of suites) {
         if (suite.activeSurfaces.agents === false)
             continue;
         const suiteRoot = pluginRootOf(suite);
         const suiteData = suiteRoot === undefined ? undefined : suiteDataDir(catalog.dataRoot, suite.sourceId, suite.id);
-        for (const resource of suite.resources?.agents ?? (await defaultMarkdownResources(suite.root, 'agents'))) {
+        for (const resource of suite.resources?.agents ?? (options.suites ? [] : await defaultMarkdownResources(suite.root, 'agents'))) {
             const path = resource.file;
-            const rawText = await resourceText(resource).catch(error => {
-                if (error.code !== 'ENOENT')
+            const rawText = await resourceText(options.suites && resource.file !== suite.manifest.path ? { name: resource.name, file: resource.file } : resource).catch(async (error) => {
+                // A vanished document is an ordinary removal; any other failure must not
+                // silently drop a project role from the catalog.
+                if (!(await isAbsentPath(path)))
                     throw error;
                 return undefined;
             });
@@ -25,7 +28,7 @@ export async function projectAgentRoles(catalog, parent) {
                 continue;
             try {
                 const policy = parseAgentRole(rawText);
-                entries.push({
+                const entry = {
                     name: JSON.stringify([suite.sourceId, suite.id, 'agents', resource.name]),
                     path,
                     rawText,
@@ -34,7 +37,13 @@ export async function projectAgentRoles(catalog, parent) {
                     disabled: policy.disabled,
                     ...(suiteRoot === undefined ? {} : { suiteRoot }),
                     ...(suiteData === undefined ? {} : { suiteData })
-                });
+                };
+                if (options.selected) {
+                    if (!options.selected(entry))
+                        continue;
+                    entry.selectionEnabled = true;
+                }
+                entries.push(entry);
             }
             catch {
                 // Malformed routing metadata cannot authorize a project role.

package/lib/packages/market-runtime/src/application/state/extension-presets.js

@@ -0,0 +1,144 @@
+/** Workspace-owned extension presets. Reads do not cache; writers serialize across local host processes. */
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, normalize } from 'node:path';
+import { withFileLock } from '@deepseek-ai/dsh-atomic-write';
+import { writeJsonDocument } from '../../../../market-catalog/src/index.js';
+import { parseExtensionIds, parseExtensionName, stripConfigurationParentIds } from '../../../../market-contracts/src/contracts/extension-presets.js';
+export class ExtensionPresetError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ExtensionPresetError';
+    }
+}
+function workspaceKey(workspace) {
+    if (!isAbsolute(workspace))
+        throw new Error('extension presets require an absolute workspace');
+    return normalize(workspace);
+}
+/** The workspace path is validated and hashed; names and clipboard data never determine a path. */
+export function extensionPresetLibraryPath(dataRoot, workspace) {
+    return join(dataRoot, 'extension-presets', createHash('sha256').update(workspaceKey(workspace)).digest('hex') + '.json');
+}
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new ExtensionPresetError('preset-state-invalid', 'invalid extension preset state');
+    return value;
+}
+function revision(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0 || value === Number.MAX_SAFE_INTEGER) {
+        throw new ExtensionPresetError('preset-state-invalid', 'invalid extension preset revision');
+    }
+    return value;
+}
+function parsePreset(value) {
+    const row = record(value);
+    if (typeof row.id !== 'string' || row.id === '' || row.id.length > 128 || row.revision === 0) {
+        throw new ExtensionPresetError('preset-state-invalid', 'invalid extension preset identity');
+    }
+    return { id: row.id, revision: revision(row.revision), name: parseExtensionName(row.name), enabledIds: parseExtensionIds(row.enabledIds) };
+}
+function parseLibrary(value, workspace) {
+    if (value === undefined)
+        return { revision: 0, defaultPresetId: null, presets: [] };
+    const document = record(value);
+    if (document.version !== 1 || document.workspace !== workspaceKey(workspace) || !Array.isArray(document.presets) || document.presets.length > 256) {
+        throw new ExtensionPresetError('preset-state-invalid', 'invalid workspace extension preset library');
+    }
+    const presets = document.presets.map(parsePreset);
+    if (new Set(presets.map(preset => preset.id)).size !== presets.length || new Set(presets.map(preset => preset.name)).size !== presets.length) {
+        throw new ExtensionPresetError('preset-state-invalid', 'duplicate extension preset identity or name');
+    }
+    const defaultId = document.defaultPresetId;
+    if (defaultId !== null && (typeof defaultId !== 'string' || !presets.some(preset => preset.id === defaultId))) {
+        throw new ExtensionPresetError('preset-state-invalid', 'extension default refers to a missing preset');
+    }
+    return { revision: revision(document.revision), defaultPresetId: defaultId, presets };
+}
+export class ExtensionPresetStore {
+    dataRoot;
+    constructor(dataRoot) {
+        this.dataRoot = dataRoot;
+    }
+    /** Read current disk state; corruption and access failures reject rather than erasing saved choices. */
+    async read(workspace) {
+        let text;
+        try {
+            text = await readFile(extensionPresetLibraryPath(this.dataRoot, workspace), 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return parseLibrary(undefined, workspace);
+            throw error;
+        }
+        try {
+            return parseLibrary(JSON.parse(text), workspace);
+        }
+        catch {
+            throw new ExtensionPresetError('preset-state-invalid', 'invalid workspace extension preset library');
+        }
+    }
+    /** Create a named preset at the caller's observed library revision; configuration parents never persist. */
+    create(workspace, expectedRevision, input) {
+        const parsed = { name: parseExtensionName(input.name), enabledIds: stripConfigurationParentIds(parseExtensionIds(input.enabledIds)) };
+        return this.mutate(workspace, expectedRevision, library => {
+            if (library.presets.length >= 256)
+                throw new Error('workspace extension preset limit reached');
+            this.assertName(library, parsed.name);
+            library.presets.push({ ...parsed, id: randomUUID(), revision: 1 });
+        });
+    }
+    /** Replace one preset and advance its revision; existing session snapshots are not touched. */
+    update(workspace, expectedRevision, id, input) {
+        const parsed = { name: parseExtensionName(input.name), enabledIds: stripConfigurationParentIds(parseExtensionIds(input.enabledIds)) };
+        return this.mutate(workspace, expectedRevision, library => {
+            const preset = this.requirePreset(library, id);
+            this.assertName(library, parsed.name, id);
+            Object.assign(preset, parsed, { revision: revision(preset.revision) + 1 });
+        });
+    }
+    /** Choose only the default for future sessions. Null captures global choices for new sessions. */
+    setDefault(workspace, expectedRevision, id) {
+        return this.mutate(workspace, expectedRevision, library => {
+            if (id !== null)
+                this.requirePreset(library, id);
+            library.defaultPresetId = id;
+        });
+    }
+    /** Delete a preset and clear its default pointer atomically; sessions retain their copies. */
+    delete(workspace, expectedRevision, id) {
+        return this.mutate(workspace, expectedRevision, library => {
+            this.requirePreset(library, id);
+            library.presets = library.presets.filter(preset => preset.id !== id);
+            if (library.defaultPresetId === id)
+                library.defaultPresetId = null;
+        });
+    }
+    requirePreset(library, id) {
+        const preset = library.presets.find(preset => preset.id === id);
+        if (preset === undefined)
+            throw new ExtensionPresetError('preset-not-found', 'extension preset no longer exists');
+        return preset;
+    }
+    assertName(library, name, exceptId) {
+        if (library.presets.some(preset => preset.name === name && preset.id !== exceptId)) {
+            throw new ExtensionPresetError('preset-name-conflict', 'an extension preset with this name already exists');
+        }
+    }
+    async mutate(workspace, expectedRevision, change) {
+        revision(expectedRevision);
+        const path = extensionPresetLibraryPath(this.dataRoot, workspace);
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        return withFileLock(path, async () => {
+            const library = await this.read(workspace);
+            if (library.revision !== expectedRevision)
+                throw new ExtensionPresetError('preset-conflict', 'extension presets changed; reload before saving');
+            change(library);
+            library.revision++;
+            await writeJsonDocument(path, { version: 1, workspace: workspaceKey(workspace), ...library });
+            return library;
+        });
+    }
+}

package/lib/packages/market-runtime/src/application/state/resource-favorites.js

@@ -0,0 +1,90 @@
+/**
+ * Persisted cross-project resource favorites under the plugin data root.
+ *
+ * One global file (`resource-favorites.json`): a favorite is this user's
+ * complete switch snapshot — six surface switches plus the per-entry filters —
+ * captured once and applicable in any workspace. It is deliberately not
+ * per-workspace state: the whole point is replaying one setup in another
+ * project, and the entry ids it stores are workspace-independent (suite and
+ * server identities, never absolute paths).
+ *
+ * @module application/state/resource-favorites
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { withFileLock } from '@deepseek-ai/dsh-atomic-write';
+import { readJsonFile, writeJsonDocument } from '../../../../market-catalog/src/index.js';
+import { resolveFavoriteInput } from '../../../../market-contracts/src/contracts/resource-window.js';
+/** The favorites file lives at the data root, beside the surface-toggles directory. */
+export function resourceFavoritesPath(dataRoot) {
+    return join(dataRoot, 'resource-favorites.json');
+}
+/** Parse one untrusted favorite wire record; malformed rows drop out. */
+function resolveFavorite(row) {
+    const input = resolveFavoriteInput(row);
+    if (input === undefined)
+        return undefined;
+    if (typeof row !== 'object' || row === null)
+        return undefined;
+    const record = row;
+    const id = typeof record.id === 'string' && record.id !== '' ? record.id : undefined;
+    const createdAt = typeof record.createdAt === 'string' && record.createdAt !== '' ? record.createdAt : new Date(0).toISOString();
+    if (id === undefined)
+        return undefined;
+    return { id, name: input.name, createdAt, surfaces: input.surfaces, offEntries: input.offEntries };
+}
+/** Load the global favorite list; absent or malformed means none. */
+export async function loadResourceFavorites(dataRoot) {
+    const value = await readJsonFile(resourceFavoritesPath(dataRoot));
+    if (typeof value !== 'object' || value === null)
+        return [];
+    const record = value;
+    if (!Array.isArray(record.favorites))
+        return [];
+    return record.favorites.flatMap(row => {
+        const favorite = resolveFavorite(row);
+        return favorite === undefined ? [] : [favorite];
+    });
+}
+/**
+ * Apply one mutation to the committed list and persist it as one transaction.
+ *
+ * The whole read-modify-write runs under the published host file lock, so two
+ * operations can never each read the document before either writes it: the
+ * second one re-reads what the first committed and applies its own change on
+ * top. Readers stay lock-free — the atomic rename is what makes that safe — and
+ * a failed operation releases the lock through the helper's own teardown.
+ * @param dataRoot - the plugin's own storage root.
+ * @param mutate - pure change applied to the freshly read list.
+ * @returns the list as committed.
+ */
+async function mutateFavorites(dataRoot, mutate) {
+    const path = resourceFavoritesPath(dataRoot);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    return withFileLock(path, async () => {
+        const next = mutate(await loadResourceFavorites(dataRoot));
+        const document = { version: 1, favorites: next };
+        await writeJsonDocument(path, document);
+        return next;
+    });
+}
+/** Append one favorite and return the stored row. */
+export async function saveResourceFavorite(dataRoot, input) {
+    // Capture the caller's values before any await: the stored row is the snapshot
+    // the call was made with, whatever the caller does to its own object after.
+    const captured = structuredClone(input);
+    const favorite = {
+        id: randomUUID(),
+        name: captured.name,
+        createdAt: new Date().toISOString(),
+        surfaces: captured.surfaces,
+        offEntries: captured.offEntries
+    };
+    await mutateFavorites(dataRoot, favorites => [...favorites, favorite]);
+    return favorite;
+}
+/** Drop one favorite by id; a missing id is a no-op. */
+export async function deleteResourceFavorite(dataRoot, id) {
+    await mutateFavorites(dataRoot, favorites => favorites.filter(favorite => favorite.id !== id));
+}

package/lib/packages/market-runtime/src/application/state/resource-filters.js

@@ -0,0 +1,2 @@
+/** Compatibility entry for workspace policy storage. The document has one mutation owner. */
+export { allFiltersOn, loadResourceFilters, saveResourceFilters, resolveOffEntries } from './workspace-policy.js';

package/lib/packages/market-runtime/src/application/state/surface-toggles.js

@@ -0,0 +1,10 @@
+import { loadResourceFilters, mutateResourceFilters } from './workspace-policy.js';
+export { surfaceTogglesPath } from './workspace-policy.js';
+export async function loadSurfaceToggles(dataRoot, workspace) {
+    return (await loadResourceFilters(dataRoot, workspace)).toggles;
+}
+/** Replace surface choices while preserving the latest committed entry choices. */
+export async function saveSurfaceToggles(dataRoot, workspace, toggles) {
+    const captured = structuredClone(toggles);
+    await mutateResourceFilters(dataRoot, workspace, current => ({ ...current, toggles: captured }));
+}

package/lib/packages/market-runtime/src/application/state/workspace-policy.js

@@ -0,0 +1,56 @@
+/** One persisted workspace policy and its atomic read-modify-write operation. */
+import { createHash } from 'node:crypto';
+import { mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { withFileLock } from '@deepseek-ai/dsh-atomic-write';
+import { readJsonFile, writeJsonDocument } from '../../../../market-catalog/src/index.js';
+import { ALL_SURFACES_ON, resolveSurfaceToggles, SURFACE_TOGGLE_KEYS } from '../../../../market-contracts/src/contracts/surface-toggles.js';
+export function allFiltersOn() {
+    return { toggles: { ...ALL_SURFACES_ON }, offEntries: {} };
+}
+/** Preserve the existing workspace hash and file location. */
+export function surfaceTogglesPath(dataRoot, workspace) {
+    const key = createHash('sha256').update(workspace).digest('hex').slice(0, 24);
+    return join(dataRoot, 'surface-toggles', key + '.json');
+}
+export function resolveOffEntries(value) {
+    if (typeof value !== 'object' || value === null)
+        return {};
+    const record = value;
+    const out = {};
+    for (const face of SURFACE_TOGGLE_KEYS) {
+        const raw = record[face];
+        if (!Array.isArray(raw))
+            continue;
+        const ids = raw.filter((id) => typeof id === 'string' && id !== '');
+        if (ids.length > 0)
+            out[face] = ids;
+    }
+    return out;
+}
+/** v1 and v2 share field names. Invalid JSON and access failures still reject. */
+export async function loadResourceFilters(dataRoot, workspace) {
+    const value = await readJsonFile(surfaceTogglesPath(dataRoot, workspace));
+    if (value === undefined)
+        return allFiltersOn();
+    const record = (typeof value === 'object' && value !== null ? value : {});
+    return { toggles: resolveSurfaceToggles(record.toggles), offEntries: resolveOffEntries(record.entries) };
+}
+/**
+ * Re-read under the published host file lock, persist once, then return the committed snapshot.
+ * The mutation stays synchronous; no runtime refresh or caller callback runs under the file lock.
+ */
+export async function mutateResourceFilters(dataRoot, workspace, mutate) {
+    const path = surfaceTogglesPath(dataRoot, workspace);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    return withFileLock(path, async () => {
+        const next = mutate(await loadResourceFilters(dataRoot, workspace));
+        await writeJsonDocument(path, { version: 2, workspace, toggles: next.toggles, entries: next.offEntries });
+        return next;
+    });
+}
+/** Replace both policy sections as one transaction. */
+export async function saveResourceFilters(dataRoot, workspace, filters) {
+    const captured = structuredClone(filters);
+    await mutateResourceFilters(dataRoot, workspace, () => captured);
+}

package/lib/packages/market-runtime/src/catalog-port.js

@@ -0,0 +1 @@
+export {};

package/lib/packages/market-runtime/src/extension-service.js

@@ -0,0 +1 @@
+export {};

package/lib/packages/market-runtime/src/index.js

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