dsh-agent-plugins-market 0.6.2 → 0.7.1

package/lib/runtime/regions.js

@@ -1,24 +1,5 @@
-/**
- * Download regions for GitHub acquisition, modeled on dshmarket's regions.js:
- * one setting answers "where are you" instead of a row of mirror toggles.
- *
- * The China route proxies github.com clones through a public prefix proxy —
- * `git clone https://gh-proxy.com/https://github.com/owner/repo` — rather
- * than rewriting the hostname, which is what lets one prefix cover clone,
- * fetch, and release downloads without a mapping table per service. Public
- * proxies come and go, so the route carries an environment escape hatch
- * (`DSH_MARKET_GITHUB_PROXY`), and the region itself is a setting the user
- * can flip at any time; sources already cloned keep their proxied origin and
- * follow it on refresh.
- *
- * @module runtime/regions
- */
 /** The China-route GitHub prefix proxy, no trailing slash. */
 const DEFAULT_GITHUB_PROXY = 'https://gh-proxy.com';
-/** Narrow an untrusted stored value to a setting; anything else reads as auto. */
-export function narrowDownloadRegion(value) {
-    return value === 'global' || value === 'china' ? value : 'auto';
-}
 /**
  * Resolve the effective region: an explicit choice wins; `auto` follows the
  * interface language — a Chinese-language user defaults to the China route.

package/lib/runtime/server-config.js

@@ -1,5 +1,6 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { MCP_SCHEMA_ID, validateAgainstSchema, validateMcpJson } from '../catalog/validate.js';
 import { parseLspServers } from '../catalog/lsp-spec.js';
 import { qualifiedSuiteId } from '../catalog/paths.js';
@@ -56,10 +57,11 @@ export async function loadLspOverrides(root) {
 export async function saveLspOverride(root, id, config) {
     const overrides = await loadLspOverrides(root);
     overrides[id] = config;
-    await mkdir(root, { recursive: true });
     const path = join(root, 'lsp-overrides.json');
-    await writeFile(`${path}.tmp`, JSON.stringify(Object.fromEntries(Object.entries(overrides).map(([key, value]) => [key, lspConfig(value)])), null, 2), { mode: 0o600 });
-    await rename(`${path}.tmp`, path);
+    await writeFileAtomic(path, JSON.stringify(Object.fromEntries(Object.entries(overrides).map(([key, value]) => [key, lspConfig(value)])), null, 2), {
+        mode: 0o600,
+        dirMode: 0o700
+    });
 }
 export async function applyLspOverrides(root, suites) {
     const overrides = await loadLspOverrides(root);

package/lib/runtime/settings-namespace.js

@@ -0,0 +1,144 @@
+import { MARKET_SETTINGS_NAMESPACE, resolveMarketSettings } from '../contracts/settings.js';
+import { FEEDBACK_TOOL_NAME, mountFeedbackTool } from './feedback-tool.js';
+import { MarketSettingsSchema, readMcpBackend } from './mcp-backend.js';
+export class MarketSettingsNamespace {
+    ctx;
+    dataRoot;
+    locale;
+    host;
+    scope;
+    watchers = [];
+    feedbackDisposer;
+    /**
+     * The feedback tool's last reported mount state. A settings change that does
+     * not move it (region, backend, project layouts) must not re-log the same
+     * line, and every other state is exactly one line: mounted, skipped by the
+     * switch, or skipped because the host has no tools registry to register on.
+     */
+    feedbackMountState;
+    constructor(ctx, dataRoot, locale, host) {
+        this.ctx = ctx;
+        this.dataRoot = dataRoot;
+        this.locale = locale;
+        this.host = host;
+    }
+    /** Register the namespace; the host resolves it whenever the settings service mounts. */
+    mount() {
+        this.ctx.inject(['settings'], settingsCtx => this.register(settingsCtx));
+    }
+    /** The persisted MCP backend choice; the built-in client until registration lands. */
+    async backend() {
+        return this.settings().mcpEnhanced ? 'builtin' : 'host';
+    }
+    /**
+     * Persist a backend choice.
+     * @throws when the settings service is not mounted.
+     */
+    async setBackend(backend) {
+        if (this.scope === undefined)
+            throw new Error('the settings service is not mounted');
+        await this.scope.update({ mcpEnhanced: backend !== 'host' });
+    }
+    /** The persisted download-region setting. */
+    async downloadRegion() {
+        return this.settings().downloadRegion;
+    }
+    /**
+     * The resolved settings, whether or not the namespace is registered yet.
+     *
+     * Every reader goes through here so "the field is absent" has exactly one
+     * answer — {@link resolveMarketSettings} — instead of each caller inventing
+     * its own fallback for the window before registration lands.
+     */
+    settings() {
+        return resolveMarketSettings(this.scope?.get());
+    }
+    /** Release every watcher and unmount the feedback tool. */
+    dispose() {
+        for (const release of this.watchers.splice(0))
+            release();
+        this.feedbackDisposer?.();
+        this.feedbackDisposer = undefined;
+    }
+    register(settingsCtx) {
+        try {
+            this.ctx.logger?.info?.('[dsh-agent-plugins-market] settings inject resolved — registering namespace');
+            const settings = settingsCtx.settings;
+            const scope = settings.register(MARKET_SETTINGS_NAMESPACE, MarketSettingsSchema);
+            this.scope = scope;
+            this.ctx.logger?.info?.('[dsh-agent-plugins-market] settings namespace registered — plugin-config card will serve');
+            this.syncProjectLayouts();
+            this.watchers.push(scope.watch(() => this.syncProjectLayouts()));
+            this.syncAutoUpdateSources();
+            this.watchers.push(scope.watch(() => this.syncAutoUpdateSources()));
+            // One-time migration from the earlier data-root settings.json choice.
+            void readMcpBackend(this.dataRoot).then(backend => {
+                if (backend === 'host')
+                    void scope.update({ mcpEnhanced: false }).catch(() => { });
+            });
+            let previousBackend = this.settings().mcpEnhanced;
+            this.watchers.push(scope.watch(() => {
+                const backend = this.settings().mcpEnhanced;
+                if (backend === previousBackend)
+                    return;
+                previousBackend = backend;
+                this.host.refreshMcpMounts();
+            }));
+            // The experience-feedback model tool: gated by the namespace's
+            // `feedbackEnabled` field (default on); the switch unregisters it. The
+            // tool mount is doubly contained — its failure must never take the
+            // settings namespace (and with it the config card) down with it. The
+            // mount outcome is logged on every transition so an absent
+            // `report_market_issue` in a session is traceable to its cause.
+            this.syncFeedbackTool();
+            this.watchers.push(scope.watch(() => this.syncFeedbackTool()));
+        }
+        catch (error) {
+            this.ctx.logger?.error?.(`[dsh-agent-plugins-market] settings namespace registration failed — the plugin-config card will be hidden this boot: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
+        }
+    }
+    /** Apply the background source-update switch. */
+    syncAutoUpdateSources() {
+        try {
+            this.host.setAutoUpdateSources(this.settings().autoUpdateSources);
+        }
+        catch (error) {
+            this.ctx.logger?.error?.(`[dsh-agent-plugins-market] background source update switch failed: ${String(error)}`);
+        }
+    }
+    syncProjectLayouts() {
+        void this.host.setScanProjectLayouts(this.settings().scanProjectLayouts).catch(error => {
+            this.ctx.logger?.error?.(`[dsh-agent-plugins-market] project layout reconciliation failed: ${String(error)}`);
+        });
+    }
+    syncFeedbackTool() {
+        try {
+            const wanted = this.settings().feedbackEnabled;
+            if (!wanted) {
+                if (this.feedbackDisposer !== undefined) {
+                    this.feedbackDisposer();
+                    this.feedbackDisposer = undefined;
+                }
+            }
+            else if (this.feedbackDisposer === undefined) {
+                this.feedbackDisposer = mountFeedbackTool(this.ctx, this.dataRoot, (key, params) => this.locale.t(key, params)) ?? undefined;
+            }
+            const state = !wanted ? 'off' : this.feedbackDisposer === undefined ? 'unavailable' : 'mounted';
+            if (state === this.feedbackMountState)
+                return;
+            this.feedbackMountState = state;
+            if (state === 'mounted') {
+                this.ctx.logger?.info?.(`[dsh-agent-plugins-market] ${FEEDBACK_TOOL_NAME} mounted on the host tools registry`);
+            }
+            else if (state === 'off') {
+                this.ctx.logger?.info?.(`[dsh-agent-plugins-market] ${FEEDBACK_TOOL_NAME} not mounted: feedbackEnabled is off`);
+            }
+            else {
+                this.ctx.logger?.warn?.(`[dsh-agent-plugins-market] ${FEEDBACK_TOOL_NAME} not mounted: the host exposes no tools registry`);
+            }
+        }
+        catch (error) {
+            this.ctx.logger?.error?.(`[dsh-agent-plugins-market] feedback tool mount failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
+        }
+    }
+}

package/lib/runtime/skills-provider.js

@@ -7,24 +7,29 @@
  * `.agents/skills` (200) but beat custom (300); user suites (450) lose to
  * the user's own `~/.dsh/skills` (400) and beat `~/.agents/skills` (500).
  *
- * Bodies are rewritten on load: `${CLAUDE_PLUGIN_ROOT}` (which Claude Code
- * authors write into skill prose) is substituted with the suite root, and the
- * resource base points at the skill directory, so CC-authored skills work
- * verbatim under the harness.
+ * Bodies are rewritten on load: the path variables Claude Code authors write
+ * into skill prose (`${CLAUDE_PLUGIN_ROOT}`, `${CLAUDE_PLUGIN_DATA}`,
+ * `${CLAUDE_PROJECT_DIR}`, `${CLAUDE_SKILL_DIR}`) are substituted, `` !`cmd` ``
+ * dynamic-context placeholders run, and the resource base points at the skill
+ * directory, so CC-authored skills work verbatim under the harness.
  */
 import { readFile } from 'node:fs/promises';
 import { parseSkillFrontmatter, stripFrontmatter } from '../catalog/skills-parse.js';
 import { parseFrontmatterRecord } from './user-store.js';
-import { PLUGIN_ROOT_VARIABLES } from '../model/layouts.js';
+import { expandPluginPaths, pluginRootOf } from '../catalog/plugin-variables.js';
+import { suiteDataDir } from '../catalog/paths.js';
+import { injectDynamicContext } from './dynamic-context.js';
 export const SUITE_PROJECT_SOURCE = 'agent-plugin-project';
 export const SUITE_USER_SOURCE = 'agent-plugin-user';
 const PROJECT_RANK = 250;
 const USER_RANK = 450;
 export class SuiteSkillProvider {
     manager;
+    options;
     name = 'agent-plugin';
-    constructor(manager) {
+    constructor(manager, options = {}) {
         this.manager = manager;
+        this.options = options;
     }
     async list(options) {
         const located = await this.locate(options.cwd);
@@ -42,7 +47,7 @@ export class SuiteSkillProvider {
         }
         return unique.map(entry => this.candidateFor(entry));
     }
-    async get(candidate, _options) {
+    async get(candidate, options) {
         const locator = candidate.locator;
         let text;
         try {
@@ -61,9 +66,21 @@ export class SuiteSkillProvider {
         const parsed = parseSkillFrontmatter(text, candidate.name);
         if (typeof parsed === 'string')
             return undefined;
-        const content = [stripFrontmatter(text), ...(locator.skillInstructions === undefined ? [] : [locator.skillInstructions])]
-            .join('\n\n')
-            .replace(/\$\{([A-Z_]+)\}/g, (match, name) => (PLUGIN_ROOT_VARIABLES.has(name) ? locator.suiteRoot : match));
+        const authored = [stripFrontmatter(text), ...(locator.skillInstructions === undefined ? [] : [locator.skillInstructions])].join('\n\n');
+        const withPaths = expandPluginPaths(authored, {
+            ...(locator.suiteRoot === undefined ? {} : { root: locator.suiteRoot }),
+            ...(locator.data === undefined ? {} : { data: locator.data }),
+            skillDir: locator.directory,
+            ...(options.cwd === undefined ? {} : { projectDir: options.cwd })
+        });
+        const shell = this.options.shell?.();
+        const content = shell === undefined
+            ? withPaths
+            : await injectDynamicContext(withPaths, {
+                shell,
+                ...(options.cwd === undefined ? {} : { workdir: options.cwd }),
+                ...(options.signal === undefined ? {} : { signal: options.signal })
+            });
         return {
             name: parsed.name,
             description: candidate.description,
@@ -79,7 +96,9 @@ export class SuiteSkillProvider {
     candidateFor(entry) {
         return {
             name: entry.skill.name,
-            description: `[${entry.suite.manifest.name}] ${entry.skill.description}`,
+            // The author's description verbatim — the harness renders it into the
+            // model's skill catalog, where a suite-name prefix is our packaging.
+            description: entry.skill.description,
             ...(entry.skill.whenToUse === undefined ? {} : { whenToUse: entry.skill.whenToUse }),
             invocation: entry.skill.invocation,
             source: entry.source,
@@ -90,7 +109,12 @@ export class SuiteSkillProvider {
                 ...(entry.suite.manifest.skillInstructions === undefined ? {} : { skillInstructions: entry.suite.manifest.skillInstructions }),
                 file: entry.skill.file,
                 directory: entry.skill.directory,
-                suiteRoot: entry.suite.root
+                ...(pluginRootOf(entry.suite) === undefined
+                    ? {}
+                    : {
+                        suiteRoot: entry.suite.root,
+                        ...(this.options.dataRoot === undefined ? {} : { data: suiteDataDir(this.options.dataRoot, entry.suite.sourceId, entry.suite.id) })
+                    })
             },
             path: entry.skill.file,
             resourceBase: { kind: 'directory', path: entry.skill.directory }
@@ -100,7 +124,7 @@ export class SuiteSkillProvider {
         const located = [];
         const userSuites = await this.manager.enabledUserSuites();
         for (const suite of userSuites) {
-            for (const skill of suite.activeSurfaces?.skills === false ? [] : suite.skills) {
+            for (const skill of suite.activeSurfaces.skills === false ? [] : suite.skills) {
                 try {
                     if (parseFrontmatterRecord(await readFile(skill.file, 'utf8')).disabled === true)
                         continue;
@@ -120,7 +144,7 @@ export class SuiteSkillProvider {
         const snapshot = await this.manager.readProjectCatalog(cwd);
         const located = [];
         for (const suite of snapshot.enabledSuites) {
-            for (const skill of suite.activeSurfaces?.skills === false ? [] : suite.skills) {
+            for (const skill of suite.activeSurfaces.skills === false ? [] : suite.skills) {
                 try {
                     if (parseFrontmatterRecord(await readFile(skill.file, 'utf8')).disabled === true)
                         continue;

package/lib/runtime/source-auto-update.js

@@ -0,0 +1,66 @@
+/**
+ * Optional background refresh of every configured market source.
+ *
+ * The `autoUpdateSources` setting (default off) turns this on from the
+ * plugin-config card. While enabled the updater runs one refresh pass every
+ * {@link AUTO_UPDATE_INTERVAL_MS} and then waits again; the first pass runs a
+ * full interval after the switch flips, so enabling the feature never starts
+ * network traffic as a surprise. A pass that is still running when the next
+ * tick arrives is skipped rather than queued. The repetition rides the fiber's
+ * timer seat, so it dies with this plugin.
+ * @module runtime/source-auto-update
+ */
+import { repeat } from './timer-seat.js';
+/** How often the background updater refreshes every source. */
+export const AUTO_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1000;
+export class SourceAutoUpdater {
+    ctx;
+    refresh;
+    intervalMs;
+    stop;
+    inFlight = false;
+    constructor(ctx, refresh, intervalMs = AUTO_UPDATE_INTERVAL_MS) {
+        this.ctx = ctx;
+        this.refresh = refresh;
+        this.intervalMs = intervalMs;
+    }
+    /** Whether a refresh timer is currently armed. */
+    get enabled() {
+        return this.stop !== undefined;
+    }
+    /** Arm or disarm the interval; repeated calls with the same state do nothing. */
+    setEnabled(enabled) {
+        if (enabled === this.enabled)
+            return;
+        if (!enabled) {
+            this.stop?.();
+            this.stop = undefined;
+            this.ctx.logger?.info?.('[dsh-agent-plugins-market] background source updates off');
+            return;
+        }
+        this.stop = repeat(this.ctx, () => void this.run(), this.intervalMs);
+        this.ctx.logger?.info?.(`[dsh-agent-plugins-market] background source updates on: every ${Math.round(this.intervalMs / 60_000)} minutes`);
+    }
+    /** Disarm the interval; an in-flight pass finishes on its own. */
+    dispose() {
+        this.stop?.();
+        this.stop = undefined;
+    }
+    async run() {
+        if (this.inFlight) {
+            this.ctx.logger?.warn?.('[dsh-agent-plugins-market] background source update skipped: the previous pass is still running');
+            return;
+        }
+        this.inFlight = true;
+        try {
+            await this.refresh();
+            this.ctx.logger?.info?.('[dsh-agent-plugins-market] background source update finished');
+        }
+        catch (error) {
+            this.ctx.logger?.warn?.(`[dsh-agent-plugins-market] background source update failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+}

package/lib/{model/state.js → runtime/state-store.js}

@@ -2,13 +2,14 @@
  * Persisted suite state: configured sources and per-suite install entries.
  *
  * State is a plain JSON file at `<dimensionRoot>/state.json`. The host is the
- * only writer (through manager actions and the HTTP routes); the manager
- * re-reads the file whenever a mutation races, keeping the on-disk copy
- * authoritative like the market profile state this pattern follows.
+ * only writer (through catalog actions and the HTTP routes), and it re-reads
+ * the file whenever a mutation races, keeping the on-disk copy authoritative
+ * like the market profile state this pattern follows. The record shapes live
+ * in `src/model/types.ts`; only the reading and writing live here.
  */
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { SUITE_SURFACE_KEYS } from './types.js';
+import { readFile } from 'node:fs/promises';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+import { SUITE_SURFACE_KEYS } from '../model/types.js';
 export const EMPTY_STATE = { version: 1, sources: [], installed: {} };
 /** Parse persisted state; unreadable or wrong-version files yield a contained empty state. */
 export async function loadState(statePath) {
@@ -86,10 +87,7 @@ function parseSurfaceOverrides(raw) {
     }
     return hasAny ? { surfaces: overrides } : {};
 }
-/** Persist state atomically through a sibling-temp rename. */
+/** Persist state atomically through the harness's atomic-write helper. */
 export async function saveState(statePath, state) {
-    await mkdir(dirname(statePath), { recursive: true });
-    const temp = `${statePath}.${process.pid}.tmp`;
-    await writeFile(temp, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
-    await rename(temp, statePath);
+    await writeFileAtomic(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600, dirMode: 0o700 });
 }

package/lib/runtime/storage-migration.js

@@ -1,8 +1,9 @@
 /** Consolidate plugin-owned storage before stores, routes, or providers are exposed. */
 import { constants } from 'node:fs';
-import { copyFile, lstat, mkdir, readdir, readFile, rename, rmdir, unlink, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { expandHome, resolveDataRoot, resolveDshHome, resolveUserRoot } from '../catalog/paths.js';
+import { copyFile, lstat, mkdir, readdir, readFile, rmdir, unlink } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+import { expandHome, isWithin, resolveAgentsRoot, resolveDataRoot, resolveDshHome, resolveUserRoot } from '../catalog/paths.js';
 async function info(path) {
     try {
         return await lstat(path);
@@ -54,20 +55,24 @@ export async function mergeStorageTree(from, to, result) {
     }
     await unlink(from);
 }
-function contains(parent, child) {
-    const path = relative(parent, child);
-    return path === '' || (!path.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) && path !== '..' && !isAbsolute(path));
-}
+/** The three hand-authored resource kinds the market panel owns. */
+const PANEL_KINDS = ['skills', 'commands', 'agents'];
 /**
- * Migrate former root overrides and data/user panels into the canonical root.
- * Unknown files in override directories remain untouched. Conflicts remain at
- * the old path and are returned to block activation; reruns are safe.
+ * Migrate former root overrides, data-root panels, and hand-authored
+ * resources into their canonical homes: plugin state under the user/data
+ * roots, and user content under the shared Agent layout root. Unknown files in
+ * override directories remain untouched. Conflicts remain at the old path and
+ * are returned to block activation; reruns are safe.
  */
 export async function migratePluginStorage(config = {}) {
     const userRoot = resolveUserRoot();
     const dataRoot = resolveDataRoot();
+    const agentsRoot = resolveAgentsRoot();
     const result = { conflicts: [] };
-    for (const path of [resolveDshHome(), userRoot, dataRoot, join(userRoot, 'user'), join(userRoot, '.sources')]) {
+    if (isWithin(userRoot, agentsRoot) || isWithin(agentsRoot, userRoot) || isWithin(dataRoot, agentsRoot) || isWithin(agentsRoot, dataRoot)) {
+        throw new Error('The Agent layout root overlaps canonical plugin storage');
+    }
+    for (const path of [resolveDshHome(), userRoot, dataRoot, agentsRoot, join(userRoot, 'user'), join(userRoot, '.sources')]) {
         if ((await info(path))?.isSymbolicLink() === true)
             throw new Error(`Plugin storage cannot use a symbolic-link directory: ${path}`);
     }
@@ -78,7 +83,7 @@ export async function migratePluginStorage(config = {}) {
             throw new Error(`Plugin storage migration cannot traverse a symbolic-link root: ${path}`);
     }
     if (legacyUserRoot !== userRoot) {
-        if (contains(legacyUserRoot, userRoot) || contains(userRoot, legacyUserRoot))
+        if (isWithin(legacyUserRoot, userRoot) || isWithin(userRoot, legacyUserRoot))
             throw new Error('Legacy userRoot overlaps canonical plugin storage');
         const legacySources = join(legacyUserRoot, '.sources');
         const sourceInfo = await info(legacySources);
@@ -123,13 +128,27 @@ export async function migratePluginStorage(config = {}) {
     for (const legacy of new Set([legacyDataRoot, join(resolveDshHome(), 'agent-plugins-data')])) {
         if (legacy === dataRoot)
             continue;
-        if (contains(legacy, dataRoot) || contains(dataRoot, legacy))
+        if (isWithin(legacy, dataRoot) || isWithin(dataRoot, legacy))
             throw new Error('Legacy dataRoot overlaps canonical plugin data storage');
         for (const entry of ['data', 'overrides', 'user', 'settings.json', 'lsp-servers.json', 'feedback']) {
             await mergeStorageTree(join(legacy, entry), join(dataRoot, entry), result);
         }
     }
-    await mergeStorageTree(join(dataRoot, 'user'), join(userRoot, 'user'), result);
+    // Hand-authored resources moved out of plugin storage into the shared Agent
+    // layout root; every former `<root>/user/<kind>` layout maps onto `<kind>`.
+    // Each source is moved straight to its final location so a conflict is
+    // reported at the file the user actually has, not at a hop along the way.
+    for (const kind of PANEL_KINDS) {
+        await mergeStorageTree(join(dataRoot, 'user', kind), join(agentsRoot, kind), result);
+        await mergeStorageTree(join(userRoot, 'user', kind), join(agentsRoot, kind), result);
+    }
+    // Drop the emptied former panel directories; rmdir refuses a non-empty one,
+    // so files retained by a conflict (or an unrecognized kind) keep their home.
+    await rmdir(join(dataRoot, 'user')).catch(() => { });
+    await rmdir(join(userRoot, 'user')).catch(() => { });
+    // Hand-written service declarations moved from data files to Agent-layout files.
+    await mergeStorageTree(join(dataRoot, 'mcp-servers.json'), join(agentsRoot, 'mcp.json'), result);
+    await mergeStorageTree(join(dataRoot, 'lsp-servers.json'), join(agentsRoot, 'lsp.json'), result);
     return result;
 }
 /** Retain all state fields while rebasing adopted checkouts moved with a root. */
@@ -145,15 +164,13 @@ async function relocateManagedSourceUrls(userRoot, legacyUserRoot) {
         if (typeof source !== 'object' || source === null || !('local' in source) || source.local !== true || !('url' in source) || typeof source.url !== 'string')
             continue;
         const oldCheckout = join(legacyUserRoot, '.sources');
-        if (!contains(oldCheckout, resolve(expandHome(source.url))))
+        if (!isWithin(oldCheckout, resolve(expandHome(source.url))))
             continue;
         source.url = join(userRoot, '.sources', relative(oldCheckout, resolve(expandHome(source.url))));
         changed = true;
     }
     if (changed) {
-        const temp = `${path}.migration-${process.pid}.tmp`;
-        await writeFile(temp, `${JSON.stringify(state, null, 2)}\n`, { flag: 'wx' });
-        await rename(temp, path);
+        await writeFileAtomic(path, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600, dirMode: 0o700 });
     }
 }
 async function collectUnsupportedEntries(path, conflicts) {

package/lib/runtime/subagent-catalog.js

@@ -51,8 +51,8 @@ function escapeText(value) {
 }
 function renderCatalog(entries, update, t) {
     const lines = entries.map(entry => {
-        const route = [entry.provider, entry.model].filter(value => value !== undefined).join('/') || t('subagentCatalogInherit');
-        return `<subagent id="${escapeText(entry.name)}" name="${escapeText(entry.title)}" model="${escapeText(route)}" reasoning_effort="${escapeText(entry.reasoningEffort ?? t('subagentCatalogDefaultEffort'))}">${escapeText(entry.description)}</subagent>`;
+        const config = [entry.provider, entry.model, entry.reasoningEffort].filter(value => value !== undefined).map(escapeText);
+        return `- ${escapeText(entry.name)}: ${escapeText(entry.description)}${config.length === 0 ? '' : ` (${config.join(' / ')})`}`;
     });
     return createUserMessage({
         content: [
@@ -74,7 +74,7 @@ function renderCatalog(entries, update, t) {
 }
 function digestEntries(entries) {
     return createHash('sha256')
-        .update(entries.map(entry => JSON.stringify([entry.name, entry.title, entry.description, entry.provider, entry.model, entry.reasoningEffort])).join('\n'))
+        .update(entries.map(entry => JSON.stringify([entry.name, entry.roleId, entry.title, entry.description, entry.provider, entry.model, entry.reasoningEffort])).join('\n'))
         .digest('hex');
 }
 /** Resumed and forked seeds may carry unvalidated source fields; ignore unreadable catalogs. */
@@ -88,10 +88,11 @@ function readEntries(source) {
         const entry = raw;
         if (typeof entry.name !== 'string' || entry.name === '' || typeof entry.title !== 'string' || typeof entry.description !== 'string')
             return undefined;
-        if (['provider', 'model', 'reasoningEffort'].some(key => entry[key] !== undefined && (typeof entry[key] !== 'string' || entry[key] === '')))
+        if (['roleId', 'provider', 'model', 'reasoningEffort'].some(key => entry[key] !== undefined && (typeof entry[key] !== 'string' || entry[key] === '')))
             return undefined;
         entries.push({
             name: entry.name,
+            ...(entry.roleId === undefined ? {} : { roleId: entry.roleId }),
             title: entry.title,
             description: entry.description,
             ...(entry.provider === undefined ? {} : { provider: entry.provider }),

package/lib/runtime/timer-seat.js

@@ -0,0 +1,80 @@
+function seatOf(ctx) {
+    const seat = ctx.get('timer');
+    if (seat === undefined)
+        return undefined;
+    return typeof seat.interval === 'function' && typeof seat.timeout === 'function' && typeof seat.debounce === 'function' ? seat : undefined;
+}
+/**
+ * Repeat `callback` every `delayMs` until the returned disposer runs or the
+ * fiber disposes.
+ * @param ctx - the owning plugin context.
+ * @param callback - the repeating work.
+ * @param delayMs - the period.
+ * @returns the disposer that stops the repetition.
+ */
+export function repeat(ctx, callback, delayMs) {
+    const seat = seatOf(ctx);
+    if (seat !== undefined)
+        return seat.interval(callback, delayMs);
+    const timer = setInterval(callback, delayMs);
+    timer.unref?.();
+    return () => {
+        clearInterval(timer);
+    };
+}
+/**
+ * Run `callback` once after `delayMs`, unless the returned disposer runs first
+ * or the fiber disposes.
+ * @param ctx - the owning plugin context.
+ * @param callback - the deferred work.
+ * @param delayMs - the delay.
+ * @returns the disposer that cancels the pending run.
+ */
+export function defer(ctx, callback, delayMs) {
+    const seat = seatOf(ctx);
+    if (seat !== undefined)
+        return seat.timeout(callback, delayMs);
+    const timer = setTimeout(callback, delayMs);
+    timer.unref?.();
+    return () => {
+        clearTimeout(timer);
+    };
+}
+/**
+ * Collapse a burst of calls into one run of `callback`, `delayMs` after the
+ * last call, until the trigger is disposed or the fiber disposes.
+ * @param ctx - the owning plugin context.
+ * @param callback - the coalesced work.
+ * @param delayMs - the quiet period.
+ * @returns the trigger to call per event and to dispose at teardown.
+ */
+export function coalesce(ctx, callback, delayMs) {
+    const seat = seatOf(ctx);
+    if (seat !== undefined) {
+        const debounced = seat.debounce(callback, delayMs);
+        // The seat returns the debounced function itself, carrying its own
+        // disposer; capture that disposer before this wrapper replaces the field.
+        const stopSeat = debounced.dispose;
+        const trigger = debounced;
+        trigger.dispose = () => {
+            stopSeat?.call(debounced);
+        };
+        return trigger;
+    }
+    let timer;
+    const trigger = (() => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            callback();
+        }, delayMs);
+        timer.unref?.();
+    });
+    trigger.dispose = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = undefined;
+    };
+    return trigger;
+}