dsh-agent-plugins-market 0.6.2 → 0.7.0

package/lib/runtime/agent-role-router.js

@@ -4,7 +4,13 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import { parse as parseYaml } from 'yaml';
 import { mountSubagentCatalog } from './subagent-catalog.js';
 import { bindHostLocale } from './host-locale.js';
-export const AGENT_ROLE_TOOL_NAME = 'subagents_run';
+import { namedAgentRoles } from './agent-role-names.js';
+export const AGENT_ROLE_TOOL_NAME = 'subagent_run';
+/**
+ * Absolute delegation-depth cap applied to every role child. The host default is
+ * the same value; keeping it explicit preserves the shipped recursion budget.
+ */
+const MAX_AGENT_ROLE_DEPTH = 3;
 function optionalText(value, key) {
     if (value === undefined)
         return undefined;
@@ -12,19 +18,7 @@ function optionalText(value, key) {
         throw new Error(`agent metadata ${key} must be a non-empty string`);
     return value.trim();
 }
-function toolList(value, key) {
-    if (value === undefined)
-        return undefined;
-    const entries = typeof value === 'string' ? value.split(',') : Array.isArray(value) ? value : [value];
-    return [
-        ...new Set(entries.map(entry => {
-            if (typeof entry !== 'string' || !/^[\w.:-]+$/.test(entry.trim()))
-                throw new Error(`agent metadata ${key} must contain tool names (comma-separated or a YAML array)`);
-            return entry.trim();
-        }))
-    ];
-}
-/** Strict YAML parsing prevents malformed routing/restriction metadata from silently inheriting wider privileges. */
+/** Strict YAML parsing prevents malformed routing metadata from silently inheriting wider privileges. */
 export function parseAgentRole(text) {
     const match = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(text);
     if (match === null) {
@@ -32,7 +26,11 @@ export function parseAgentRole(text) {
             throw new Error('agent frontmatter is not closed');
         return { content: text, disabled: false };
     }
-    const parsed = parseYaml(match[1]);
+    // A matched block always carries its body; the check keeps the type honest.
+    const frontmatter = match[1];
+    if (frontmatter === undefined)
+        throw new Error('agent frontmatter is not closed');
+    const parsed = parseYaml(frontmatter);
     if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
         throw new Error('agent frontmatter must be a YAML object');
     const metadata = parsed;
@@ -56,43 +54,63 @@ export function parseAgentRole(text) {
         ...(provider === undefined ? {} : { provider }),
         ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
         ...(title === undefined ? {} : { title }),
-        ...(description === undefined ? {} : { description }),
-        ...(metadata.tools === undefined ? {} : { tools: toolList(metadata.tools, 'tools') }),
-        ...(metadata.disallowedTools === undefined ? {} : { disallowedTools: toolList(metadata.disallowedTools, 'disallowedTools') })
+        ...(description === undefined ? {} : { description })
     };
 }
-/** Bare ids must resolve uniquely; Claude aliases are accepted only if actually advertised by a DSH provider. */
-export async function resolveAgentModel(policy, catalog) {
-    if (policy.model === undefined)
-        return policy.provider === undefined ? {} : { provider: policy.provider };
-    const providers = catalog.listProviders();
-    if (policy.provider !== undefined) {
-        if (!providers.some(provider => provider.id === policy.provider))
-            throw new Error(`agent model provider "${policy.provider}" is not registered`);
-        return { provider: policy.provider, model: policy.model };
+function parentRouteOf(parent) {
+    const agent = parent;
+    return agent?.session?.requestHeader?.()?.config ?? agent?.options ?? {};
+}
+/**
+ * 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 async function resolveAgentOptions(policy, parent, llm, signal, subject, diagnose) {
+    // One value, so a half-specified route can never be forwarded downstream.
+    const requested = policy.provider === undefined || policy.model === undefined ? undefined : { provider: policy.provider, model: policy.model };
+    if (requested === undefined && (policy.provider !== undefined || policy.model !== undefined)) {
+        const declared = [policy.provider, policy.model].filter(value => value !== undefined).join('/');
+        diagnose(`agent "${subject}": route "${declared}" needs an exact provider and model pair; it is ignored and the child inherits the parent route`);
     }
-    const qualified = providers.filter(provider => policy.model.startsWith(`${provider.id}/`)).sort((a, b) => b.id.length - a.id.length)[0];
-    if (qualified !== undefined) {
-        const model = policy.model.slice(qualified.id.length + 1);
-        if (model === '')
-            throw new Error('agent model id must not be empty');
-        return { provider: qualified.id, model };
+    const effort = policy.reasoningEffort;
+    if (effort === undefined && requested === undefined)
+        return undefined;
+    const inherited = parentRouteOf(parent);
+    const provider = requested?.provider ?? inherited.provider;
+    const model = requested?.model ?? inherited.model;
+    if (provider === undefined || model === undefined) {
+        /* v8 ignore next 3 -- an effective route is always known once a parent Agent ran a request. */
+        if (effort !== undefined)
+            diagnose(`agent "${subject}": reasoning effort "${effort}" has no effective route to validate against; it is ignored`);
+        return undefined;
     }
-    const matches = (await Promise.all(providers.map(async (provider) => {
-        try {
-            return (await catalog.listModels(provider.id)).some(model => model.id === policy.model) ? provider.id : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }))).filter((provider) => provider !== undefined);
-    if (matches.length !== 1)
-        throw new Error(`agent model "${policy.model}" ${matches.length === 0 ? 'is not advertised' : 'is ambiguous'}; configure provider and model explicitly`);
-    return { provider: matches[0], model: policy.model };
-}
-/** Read the same declaration for catalog summaries and execution, including inline resources. */
-export async function readAgentRole(entry) {
-    return parseAgentRole(entry.rawText ?? (await readFile(entry.path, 'utf8')));
+    const routeChanged = provider !== inherited.provider || model !== inherited.model;
+    const effectiveEffort = effort ?? (routeChanged ? undefined : inherited.reasoningEffort);
+    try {
+        await llm.resolveCallConfig({ provider, model, ...(effectiveEffort === undefined ? {} : { reasoningEffort: effectiveEffort }) }, signal);
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        diagnose(`agent "${subject}": route ${provider}/${model} is unusable (${String(error)}); it is ignored and the child inherits the parent route`);
+        return undefined;
+    }
+    // Cancellation raised during the adapter lookup must not create a child.
+    signal.throwIfAborted();
+    return {
+        ...(requested ?? {}),
+        ...(effort === undefined ? {} : { reasoningEffort: effort })
+    };
 }
 /** Stable summaries; invalid declarations are excluded and transient read failures abort publication. */
 export async function agentRoleCatalog(entries, signal, diagnose = () => { }) {
@@ -100,7 +118,7 @@ export async function agentRoleCatalog(entries, signal, diagnose = () => { }) {
     const counts = new Map();
     for (const entry of entries)
         counts.set(entry.name, (counts.get(entry.name) ?? 0) + 1);
-    for (const entry of entries) {
+    for (const entry of namedAgentRoles(entries)) {
         signal.throwIfAborted();
         if (entry.disabled)
             continue;
@@ -128,86 +146,82 @@ export async function agentRoleCatalog(entries, signal, diagnose = () => { }) {
         if (policy.disabled)
             continue;
         const description = (policy.description ?? entry.description).replaceAll(/\s+/g, ' ').trim();
+        // Advertise a route only when the executor would apply it.
+        const exact = policy.provider !== undefined && policy.model !== undefined;
         summaries.push({
-            name: entry.name,
-            title: policy.title ?? entry.title ?? entry.name,
+            name: entry.callName,
+            roleId: entry.name,
+            title: policy.title ?? entry.title ?? entry.callName,
             description: description.length <= 500 ? description : `${description.slice(0, 497)}...`,
-            ...(policy.provider === undefined ? {} : { provider: policy.provider }),
-            ...(policy.model === undefined ? {} : { model: policy.model }),
+            ...(exact ? { provider: policy.provider, model: policy.model } : {}),
             ...(policy.reasoningEffort === undefined ? {} : { reasoningEffort: policy.reasoningEffort })
         });
     }
     signal.throwIfAborted();
     return summaries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
-/** Resolve fresh panel state and raw Markdown on every call, including after edits, disabling and uninstall. */
-export async function executeAgentRole(host, listRoles, name, prompt, parent, signal) {
+/** Read the same declaration for catalog summaries and execution, including inline resources. */
+export async function readAgentRole(entry) {
+    return parseAgentRole(entry.rawText ?? (await readFile(entry.path, 'utf8')));
+}
+/**
+ * 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 async function executeAgentRole(host, listRoles, agentName, prompt, parent, signal, diagnose = () => { }) {
     if (parent === undefined)
-        throw new Error('subagents_run requires a calling agent');
+        throw new Error('subagent_run requires a calling agent');
     if (prompt.trim() === '')
-        throw new Error('subagents_run requires a non-empty prompt');
+        throw new Error('subagent_run requires a non-empty prompt');
     signal.throwIfAborted();
-    const entries = (await listRoles(parent)).filter(entry => entry.name === name);
-    if (entries.length !== 1)
-        throw new Error(`agent role "${name}" is unavailable or ambiguous`);
-    const entry = entries[0];
+    const [entry, ...duplicates] = namedAgentRoles(await listRoles(parent)).filter(candidate => candidate.callName === agentName);
+    if (entry === undefined || duplicates.length > 0)
+        throw new Error(`agent "${agentName}" is unavailable or ambiguous`);
     if (entry.disabled)
-        throw new Error(`agent role "${name}" is disabled`);
+        throw new Error(`agent "${agentName}" is disabled`);
     const policy = await readAgentRole(entry);
     if (policy.disabled)
-        throw new Error(`agent role "${name}" is disabled`);
-    const agentOptions = { ...(await resolveAgentModel(policy, host.llm)), ...(policy.reasoningEffort === undefined ? {} : { reasoningEffort: policy.reasoningEffort }) };
-    const parentAgent = parent;
-    const parentOptions = parentAgent.session?.requestHeader?.()?.config ?? parentAgent.options ?? {};
-    const provider = agentOptions.provider ?? parentOptions.provider;
-    const model = agentOptions.model ?? parentOptions.model;
-    if (provider === undefined || model === undefined)
-        throw new Error('subagents_run requires an effective provider and model');
-    const routeChanged = provider !== parentOptions.provider || model !== parentOptions.model;
-    const reasoningEffort = agentOptions.reasoningEffort ?? (routeChanged ? undefined : parentOptions.reasoningEffort);
-    await host.llm.resolveCallConfig({ provider, model, ...(reasoningEffort === undefined ? {} : { reasoningEffort }) }, signal);
+        throw new Error(`agent "${agentName}" is disabled`);
+    const agentOptions = await resolveAgentOptions(policy, parent, host.llm, signal, agentName, diagnose);
     signal.throwIfAborted();
-    const run = await host.subagents.start('spawn', {
-        label: name,
-        prompt: [{ type: 'text', text: prompt }],
-        parent,
-        signal,
-        maxDepth: 3,
-        agentOptions,
-        persona: policy.content,
-        ...(policy.tools === undefined && policy.disallowedTools === undefined
-            ? {}
-            : {
-                toolFilter: {
-                    ...(policy.tools === undefined ? {} : { allow: policy.tools }),
-                    ...(policy.disallowedTools === undefined ? {} : { deny: policy.disallowedTools })
-                }
-            })
+    const started = await host.subagents.startContinuable({
+        provider: 'spawn',
+        label: agentName,
+        request: {
+            prompt: [{ type: 'text', text: prompt }],
+            parent,
+            maxDepth: MAX_AGENT_ROLE_DEPTH,
+            persona: policy.content,
+            ...(agentOptions === undefined ? {} : { agentOptions })
+        },
+        signal
     });
-    try {
-        const result = await run.result;
-        if (result.stopReason !== 'completed')
-            throw new Error(`agent role "${name}" stopped: ${result.stopReason}; partial output: ${JSON.stringify(result.output)}`);
-        return { runId: run.id, output: result.output };
-    }
-    finally {
-        await run.dispose();
-    }
+    return { subagentId: started.childId };
 }
 /** Mount once after tools, llm and subagents are available; the returned disposer belongs to the plugin lifecycle. */
 export function mountAgentRoleTool(ctx, listRoles, t = bindHostLocale(undefined)) {
     const host = ctx;
     const tool = defineTool({
         name: AGENT_ROLE_TOOL_NAME,
-        description: 'Delegate a self-contained task to a role from the current subagent catalog and wait for its result. The child starts without the parent conversation. Its saved provider, model, reasoning effort, persona and tool restrictions are applied automatically.',
+        description: 'Delegate a self-contained task to a role from the current subagent catalog. The child starts without the parent conversation and runs ' +
+            'in the background: this returns a durable subagent id immediately. When the run settles the runtime sends you a notice carrying its ' +
+            "outcome and closing message, and send_message steers the child while it runs. The role's saved persona and model settings are applied automatically.",
         parameters: {
-            role: { type: 'string', required: true, description: 'Exact role ID from the current subagent catalog.' },
+            agent: { type: 'string', required: true, description: 'Exact callable role name from the current subagent catalog.' },
             prompt: { type: 'string', required: true, description: 'Complete task and context for the isolated child.' }
         },
-        output: { schema: { type: 'json' }, render: (_args, result) => [{ type: 'text', text: JSON.stringify(result) }] },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { subagentId: { type: 'string', required: true } }
+            },
+            render: (_args, value) => [{ type: 'text', text: `started subagent ${value.subagentId}` }]
+        },
         isConcurrencySafe: () => true,
         async execute(args, exec) {
-            return executeAgentRole(host, listRoles, args.role, args.prompt, exec.agent, exec.signal);
+            return executeAgentRole(host, listRoles, args.agent, args.prompt, exec.agent, exec.signal, message => ctx.logger?.warn(message));
         }
     });
     const disposeTool = host.tools.register(tool);

package/lib/runtime/commands-mounts.js

@@ -19,7 +19,7 @@ export class CommandMountRegistry {
         const diagnostics = [];
         const wanted = new Map();
         for (const suite of enabledSuites) {
-            const specs = suite.activeSurfaces?.commands === false ? [] : await readCommands(suite.root, suite.resources?.commands);
+            const specs = suite.activeSurfaces.commands === false ? [] : await readCommands(suite.root, suite.resources?.commands);
             for (const spec of specs) {
                 // The registry key is source-qualified: bare suite ids are unique per
                 // source only, so two sources' same-named suites would collide.
@@ -58,9 +58,12 @@ export class CommandMountRegistry {
                     ...(spec.hint === undefined ? {} : { input: { hint: spec.hint } }),
                     handler: invocation => {
                         const agent = invocation.agent;
-                        const text = [this.t('commandForwardTitle', { command: spec.name, suite: spec.suiteId }), '', spec.body.replaceAll('$ARGUMENTS', invocation.rawInput.trim())].join('\n');
+                        // The template rides the agent verbatim: a decorator line naming
+                        // this plugin or the suite would be text the command author never
+                        // wrote, and the follow-up's `source` already records provenance.
+                        const text = spec.body.replaceAll('$ARGUMENTS', invocation.rawInput.trim());
                         agent.followup({ content: [{ type: 'text', text }], source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' } });
-                        return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name, suite: spec.suiteId }) };
+                        return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name }) };
                     }
                 });
                 this.live.set(key, disposer);
@@ -111,11 +114,11 @@ export async function readCommands(root, resources) {
     return specs;
 }
 function commandMeta(text) {
-    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
-    if (match === null)
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text)?.[1];
+    if (frontmatter === undefined)
         return undefined;
     try {
-        const raw = parseYaml(match[1]);
+        const raw = parseYaml(frontmatter);
         if (typeof raw !== 'object' || raw === null)
             return undefined;
         const record = raw;

package/lib/runtime/deadline.js

@@ -0,0 +1,28 @@
+/**
+ * Bounded waits for work this plugin cannot cancel.
+ *
+ * Every wait here is a race against a timer: the caller stops waiting and the
+ * underlying work keeps running. That is the only safe shape for a mount and
+ * for the change pipeline that drives it — a spawned server process or a
+ * browser authorization the user is completing must not be abandoned just
+ * because nobody is waiting for it any more.
+ *
+ * @module runtime/deadline
+ */
+/**
+ * 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`.
+ */
+export function settlesWithin(work, deadlineMs) {
+    return new Promise(resolve => {
+        const timer = setTimeout(() => resolve(false), deadlineMs);
+        timer.unref?.();
+        const settle = () => {
+            clearTimeout(timer);
+            resolve(true);
+        };
+        void work.then(settle, settle);
+    });
+}

package/lib/runtime/feedback-tool.js

@@ -5,18 +5,26 @@
  * default true), the model can call `report_market_issue` when it concludes a
  * problem it is looking at is caused by dsh-agent-plugins-market — a failed
  * install, a misdetected source, a market UI defect the user just described.
- * The tool files a GitHub issue on the plugin repository through the GitHub
- * REST API, or falls back to appending a local JSONL record under the plugin
- * data root when no repository host context is available.
+ *
+ * Filing happens in three steps, most preferred first: the `gh` CLI when it is
+ * installed and authenticated, the GitHub REST API when the process carries a
+ * `GITHUB_TOKEN` / `GH_TOKEN`, and otherwise nothing is filed — the caller
+ * gets the complete issue text plus a prefilled "new issue" URL that is opened
+ * in the browser and handed back to the user to submit.
  *
  * The tool is deliberately narrow: the title/body must describe the problem,
- * submissions are rate-limited, and the setting switch unregisters the tool
- * on the next reconcile pass.
+ * real submissions are rate-limited, and the setting switch unregisters the
+ * tool on the next reconcile pass.
  * @module runtime/feedback-tool
  */
-import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { defineTool } from '@deepseek-ai/dsh-tools';
+import { platformBrowserOpener } from './mcp-client/oauth.js';
+const execFileAsync = promisify(execFile);
 /** The GitHub repository experience feedback files issues against. */
 export const FEEDBACK_REPO_OWNER = 'Sivan757';
 export const FEEDBACK_REPO_NAME = 'dsh-agent-plugins-market';
@@ -24,12 +32,19 @@ export const FEEDBACK_REPO_NAME = 'dsh-agent-plugins-market';
 export const FEEDBACK_LABEL = 'agent-feedback';
 /** Minimum milliseconds between two accepted submissions (burst guard). */
 const SUBMIT_COOLDOWN_MS = 60_000;
+/** Timeout for one `gh issue create` invocation. */
+const GH_TIMEOUT_MS = 30_000;
+/** The public "new issue" page for one report, prefilled with title and body. */
+export function newIssueUrl(title, body) {
+    const query = new URLSearchParams({ title, body, labels: FEEDBACK_LABEL });
+    return `https://github.com/${FEEDBACK_REPO_OWNER}/${FEEDBACK_REPO_NAME}/issues/new?${query.toString()}`;
+}
 /**
- * Submit one experience report. Tries the GitHub issue API first (works when
- * the deployment carries a GITHUB_TOKEN / GH_TOKEN with repo scope), then
- * falls back to the local JSONL spool under `<dataRoot>/feedback/`.
+ * Submit one experience report through `gh`, then the REST API, then a
+ * prefilled issue page the user submits themselves. Only a real submission
+ * advances the burst cooldown.
  */
-export async function submitFeedback(dataRoot, report, now = Date.now()) {
+export async function submitFeedback(dataRoot, report, now = Date.now(), ports = {}) {
     const title = report.title.trim();
     if (title === '')
         return { ok: false, reason: 'title is required' };
@@ -38,6 +53,18 @@ export async function submitFeedback(dataRoot, report, now = Date.now()) {
     if (now - lastAt < SUBMIT_COOLDOWN_MS) {
         return { ok: false, reason: 'a feedback report was submitted less than a minute ago; wait and try again' };
     }
+    const ghIssue = ports.ghIssue ?? createIssueWithGh;
+    let ghFailure;
+    try {
+        const url = await ghIssue(title, body);
+        if (url !== undefined) {
+            await stampSubmitAt(dataRoot, now);
+            return { ok: true, location: url };
+        }
+    }
+    catch (error) {
+        ghFailure = error instanceof Error ? error.message : String(error);
+    }
     const token = process.env['GITHUB_TOKEN'] ?? process.env['GH_TOKEN'];
     if (token !== undefined && token !== '') {
         try {
@@ -46,22 +73,40 @@ export async function submitFeedback(dataRoot, report, now = Date.now()) {
             return { ok: true, location: url };
         }
         catch (error) {
-            // Network or auth failure: fall through to the local spool so the
-            // report is never lost, and say so in the outcome.
-            const local = await spoolLocally(dataRoot, title, body);
-            await stampSubmitAt(dataRoot, now);
-            return {
-                ok: true,
-                location: local,
-                reason: `GitHub issue failed (${error instanceof Error ? error.message : String(error)}); saved locally instead`
-            };
+            ghFailure ??= error instanceof Error ? error.message : String(error);
         }
     }
-    const local = await spoolLocally(dataRoot, title, body);
-    await stampSubmitAt(dataRoot, now);
-    return { ok: true, location: local };
+    const url = newIssueUrl(title, body);
+    let opened = true;
+    try {
+        await (ports.openPage ?? openInBrowser)(url);
+    }
+    catch {
+        // A headless host has no browser to open; the link in `location` still works.
+        opened = false;
+    }
+    const detail = ghFailure === undefined ? 'nothing could file the issue automatically' : `filing failed (${ghFailure})`;
+    return {
+        ok: true,
+        location: url,
+        issueText: `${title}\n\n${body}`,
+        reason: opened ? `${detail}; the prefilled issue page was opened — submit it in the browser` : `${detail}; open the issue page at the returned location to submit it`
+    };
+}
+/** Open one URL in the platform browser; a failure is the caller's to report. */
+async function openInBrowser(url) {
+    await platformBrowserOpener(new URL(url), 'feedback', () => { });
+}
+/**
+ * File the issue with the `gh` CLI. Undefined means gh is absent, not
+ * authenticated, or otherwise unable to create the issue — never a thrown
+ * failure, so the caller can fall through to the REST API.
+ */
+async function createIssueWithGh(title, body) {
+    const { stdout } = await execFileAsync('gh', ['issue', 'create', '--repo', `${FEEDBACK_REPO_OWNER}/${FEEDBACK_REPO_NAME}`, '--title', title, '--body', body, '--label', FEEDBACK_LABEL], { timeout: GH_TIMEOUT_MS });
+    return /https:\/\/\S+/.exec(stdout)?.[0];
 }
-/** POST one issue; returns its html_url. */
+/** POST one issue through the REST API; returns its html_url. */
 async function createIssue(token, title, body) {
     const response = await fetch(`https://api.github.com/repos/${FEEDBACK_REPO_OWNER}/${FEEDBACK_REPO_NAME}/issues`, {
         method: 'POST',
@@ -84,25 +129,26 @@ async function createIssue(token, title, body) {
         throw new Error('GitHub API returned no issue URL');
     return payload.html_url;
 }
+/**
+ * Render one tool argument as text. Arguments arrive as untrusted values, so
+ * `String` keeps the coercion the report has always applied for anything the
+ * declared `type: 'string'` schema does not already cover.
+ */
+function textOf(value) {
+    return String(value);
+}
 /** Render the model's structured report into a deterministic issue body. */
 export function renderFeedbackBody(report) {
     const lines = ['## Experience feedback', '', `**Problem:** ${report.description.trim()}`, ''];
-    if (report.expected?.trim() !== undefined && report.expected.trim() !== '')
-        lines.push(`**Expected:** ${report.expected.trim()}`, '');
-    if (report.actual?.trim() !== undefined && report.actual.trim() !== '')
-        lines.push(`**Actual:** ${report.actual.trim()}`, '');
+    const expected = report.expected?.trim();
+    const actual = report.actual?.trim();
+    if (expected !== undefined && expected !== '')
+        lines.push(`**Expected:** ${expected}`, '');
+    if (actual !== undefined && actual !== '')
+        lines.push(`**Actual:** ${actual}`, '');
     lines.push('---', `Filed automatically by the dsh-agent-plugins-market \`${FEEDBACK_TOOL_NAME}\` tool.`);
     return lines.join('\n');
 }
-/** Append one report to the local spool; returns the spool file path. */
-async function spoolLocally(dataRoot, title, body) {
-    const dir = join(dataRoot, 'feedback');
-    await mkdir(dir, { recursive: true });
-    const file = join(dir, 'reports.jsonl');
-    const record = JSON.stringify({ at: new Date().toISOString(), title, body });
-    await appendFile(file, `${record}\n`, 'utf8');
-    return file;
-}
 /** The last accepted submission's timestamp; 0 when the stamp file is absent. */
 async function readLastSubmitAt(dataRoot) {
     try {
@@ -115,11 +161,9 @@ async function readLastSubmitAt(dataRoot) {
     }
 }
 async function stampSubmitAt(dataRoot, now) {
-    const dir = join(dataRoot, 'feedback');
-    await mkdir(dir, { recursive: true });
     // Overwrite, not append: an appending stamp concatenates timestamps and
     // parseInt on the merged digits disables the cooldown permanently.
-    await writeFile(join(dir, 'last-submit-at'), String(now), 'utf8');
+    await writeFileAtomic(join(dataRoot, 'feedback', 'last-submit-at'), String(now), { mode: 0o600, dirMode: 0o700 });
 }
 export const FEEDBACK_TOOL_NAME = 'report_market_issue';
 const FEEDBACK_DESCRIPTION = 'File an experience-feedback issue for dsh-agent-plugins-market (the DeepSeek Harness agent plugin market). ' +
@@ -127,8 +171,14 @@ const FEEDBACK_DESCRIPTION = 'File an experience-feedback issue for dsh-agent-pl
     'stuck install/uninstall, a market source that will not scan, wrong market UI behavior, or a runtime injection ' +
     'defect the user attributes to a market suite. Do not call it for problems in other plugins, in the harness, ' +
     "or in the user's own repositories. Compose a specific title; describe what happened, what was expected, and " +
-    'the exact error text when one appeared.';
-/** Register the feedback tool; returns the disposer. Undefined when the host has no tools service. */
+    'the exact error text when one appeared. When the result carries `issueText`, the issue was not filed for you: ' +
+    'show the human that text and the `location` link so they can submit it on GitHub.';
+/**
+ * Register the feedback tool; returns the disposer. Undefined when the host has
+ * no tools service to register on — the caller turns that into a mount-path
+ * diagnostic instead of an error, since the setting can simply have no effect
+ * on this host.
+ */
 export function mountFeedbackTool(hostCtx, dataRoot, t) {
     const host = hostCtx;
     if (typeof host.tools?.register !== 'function')
@@ -152,6 +202,7 @@ export function mountFeedbackTool(hostCtx, dataRoot, t) {
                 properties: {
                     ok: { type: 'boolean', required: true },
                     location: { type: 'string' },
+                    issueText: { type: 'string' },
                     reason: { type: 'string' }
                 }
             },
@@ -160,8 +211,8 @@ export function mountFeedbackTool(hostCtx, dataRoot, t) {
         async execute(args) {
             const input = args;
             const report = {
-                title: String(input['title'] ?? ''),
-                description: String(input['description'] ?? ''),
+                title: textOf(input['title'] ?? ''),
+                description: textOf(input['description'] ?? ''),
                 ...(typeof input['expected'] === 'string' ? { expected: input['expected'] } : {}),
                 ...(typeof input['actual'] === 'string' ? { actual: input['actual'] } : {})
             };

package/lib/runtime/hooks-mounts.js

@@ -10,29 +10,29 @@
  * on every enable/disable/install/uninstall; a missing bridge package, a
  * broken hook file, or a mount failure is contained per suite.
  */
-import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { tmpdir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
+import { SerialPassQueue } from './mount-lifecycle.js';
 import { qualifiedSuiteId } from '../catalog/paths.js';
 export class HooksMountRegistry {
     ctx;
     live = new Map();
     fingerprints = new Map();
     temporary = new Map();
-    queue = Promise.resolve();
+    passes = new SerialPassQueue();
     constructor(ctx) {
         this.ctx = ctx;
     }
     /** Mount/unmount one bridge per suite to match the enabled suites exactly. */
-    async reconcile(enabledSuites) {
-        const run = this.queue.then(() => this.reconcileNow(enabledSuites));
-        this.queue = run.then(() => { }, () => { });
-        return run;
+    reconcile(enabledSuites) {
+        return this.passes.run(() => this.reconcileNow(enabledSuites));
     }
     async reconcileNow(enabledSuites) {
         const diagnostics = [];
-        const active = enabledSuites.filter(suite => suite.activeSurfaces?.hooks !== false && (suite.resources === undefined || suite.hooks !== undefined));
+        const active = enabledSuites.filter(suite => suite.activeSurfaces.hooks !== false && (suite.resources === undefined || suite.hooks !== undefined));
         // Keys are the qualified suite id: bare ids are unique per source only.
         const wanted = new Set(active.map(suite => qualifiedSuiteId(suite.sourceId, suite.id)));
         for (const [suiteId, handle] of [...this.live]) {
@@ -68,12 +68,10 @@ export class HooksMountRegistry {
     }
     /** Dispose every live bridge; used at plugin teardown. */
     async disposeAll() {
-        const run = this.queue.then(async () => {
+        await this.passes.run(async () => {
             for (const [suiteId, handle] of [...this.live])
                 await this.unmount(suiteId, handle);
         });
-        this.queue = run.catch(() => { });
-        await run;
     }
     async mount(key, suite, content, fingerprint, originalPath) {
         let bridge;
@@ -93,7 +91,7 @@ export class HooksMountRegistry {
             if (configPath === undefined) {
                 temporary = await mkdtemp(join(tmpdir(), 'dsh-project-hooks-'));
                 configPath = join(temporary, 'hooks.json');
-                await writeFile(configPath, content, { mode: 0o600 });
+                await writeFileAtomic(configPath, content, { mode: 0o600 });
             }
             handle = mountCtx.plugin(bridge, {
                 configPath,