@agentrhq/webcmd 0.2.3 → 0.2.4

package/cli-manifest.json

@@ -16873,16 +16873,25 @@
   {
     "site": "practo",
     "name": "login",
-    "description": "Open Practo login for manual sign-in",
+    "description": "Open Practo login and wait until the browser session is authenticated",
     "access": "write",
     "domain": "www.practo.com",
     "strategy": "cookie",
     "browser": true,
-    "args": [],
+    "args": [
+      {
+        "name": "timeout",
+        "type": "int",
+        "default": 300,
+        "required": false,
+        "help": "Maximum seconds to wait for the user to finish login"
+      }
+    ],
     "columns": [
       "status",
+      "logged_in",
       "site",
-      "message"
+      "name"
     ],
     "type": "js",
     "modulePath": "practo/login.js",

package/clis/practo/login.js

@@ -1,21 +1,48 @@
+import { AuthRequiredError, TimeoutError } from '@agentrhq/webcmd/errors';
 import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { PRACTO } from './utils.js';
+import { PRACTO, probeIdentity } from './utils.js';
+
+const DEFAULT_TIMEOUT_SECONDS = 300;
+
+function isAuthRequired(error) {
+  return error instanceof AuthRequiredError;
+}
 
 cli({
   site: 'practo',
   name: 'login',
   access: 'write',
-  description: 'Open Practo login for manual sign-in',
+  description: 'Open Practo login and wait until the browser session is authenticated',
   domain: 'www.practo.com',
   strategy: Strategy.COOKIE,
   browser: true,
   navigateBefore: false,
   defaultWindowMode: 'foreground',
   siteSession: 'persistent',
-  args: [],
-  columns: ['status', 'site', 'message'],
-  func: async (page) => {
-    await page.goto(`${PRACTO}/login`);
-    return [{ status: 'opened', site: 'practo', message: 'Finish login in the browser, then run `webcmd practo whoami`.' }];
+  args: [
+    { name: 'timeout', type: 'int', default: DEFAULT_TIMEOUT_SECONDS, help: 'Maximum seconds to wait for the user to finish login' },
+  ],
+  columns: ['status', 'logged_in', 'site', 'name'],
+  func: async (page, kwargs) => {
+    try {
+      const rows = await probeIdentity(page);
+      return [{ status: 'already_logged_in', ...rows[0] }];
+    } catch (error) {
+      if (!isAuthRequired(error)) throw error;
+    }
+
+    await page.goto(`${PRACTO}/login`, { waitUntil: 'none', settleMs: 1500 });
+    const timeout = Number(kwargs.timeout ?? DEFAULT_TIMEOUT_SECONDS);
+    const deadline = Date.now() + timeout * 1000;
+    while (Date.now() < deadline) {
+      await page.wait(2);
+      try {
+        const rows = await probeIdentity(page);
+        return [{ status: 'login_complete', ...rows[0] }];
+      } catch (error) {
+        if (!isAuthRequired(error)) throw error;
+      }
+    }
+    throw new TimeoutError('practo login', timeout, 'Complete Practo login in the browser, then retry.');
   },
 });

package/clis/practo/practo.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { ArgumentError } from '@agentrhq/webcmd/errors';
 import { getRegistry } from '@agentrhq/webcmd/registry';
 import './appointment.js';
@@ -124,6 +124,24 @@ describe('practo command registry', () => {
     expect(cancel.args.find((arg) => arg.name === 'confirm')?.type).toBe('boolean');
   });
 
+  it('waits for manual login to complete', async () => {
+    const login = getRegistry().get('practo/login');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ __error: 'HTTP 401', status: 401 })
+        .mockResolvedValueOnce({ name: 'Ada' }),
+    };
+
+    await expect(login.func(page, { timeout: 1 })).resolves.toEqual([{
+      status: 'login_complete',
+      logged_in: true,
+      site: 'practo',
+      name: 'Ada',
+    }]);
+  });
+
   it('refuses real booking without --confirm true', async () => {
     const book = getRegistry().get('practo/book-confirm');
     await expect(book.func({}, { practice_doctor_id: '859054', time: '2026-07-10 10:30:00' })).rejects.toThrow(ArgumentError);

package/dist/src/browser/daemon-lifecycle.d.ts

@@ -23,8 +23,10 @@ export declare function waitForDaemonStatus(timeoutMs: number): Promise<DaemonSt
 export declare const daemonLifecycleHooks: {
     requestDaemonShutdown: typeof requestDaemonShutdown;
     spawnDaemonProcess: typeof spawnDaemonProcess;
+    signalDaemonProcessTree: typeof signalDaemonProcessTree;
     waitForDaemonStop: typeof waitForDaemonStop;
 };
+export declare function signalDaemonProcessTree(pid: number, signal: NodeJS.Signals): boolean;
 export declare function restartDaemon(opts?: {
     stopTimeoutMs?: number;
     startTimeoutMs?: number;

package/dist/src/browser/daemon-lifecycle.js

@@ -53,8 +53,31 @@ export async function waitForDaemonStatus(timeoutMs) {
 export const daemonLifecycleHooks = {
     requestDaemonShutdown,
     spawnDaemonProcess,
+    signalDaemonProcessTree,
     waitForDaemonStop,
 };
+export function signalDaemonProcessTree(pid, signal) {
+    let signaled = false;
+    if (process.platform !== 'win32') {
+        try {
+            process.kill(-pid, signal);
+            signaled = true;
+        }
+        catch {
+            // Fall back to the daemon PID below.
+        }
+    }
+    if (!signaled) {
+        try {
+            process.kill(pid, signal);
+            signaled = true;
+        }
+        catch {
+            // The process may have already exited; the caller polls the daemon port.
+        }
+    }
+    return signaled;
+}
 export async function restartDaemon(opts = {}) {
     const previousStatus = await fetchDaemonStatus();
     let stopped = previousStatus === null;
@@ -91,13 +114,12 @@ export async function ensureBrowserBridgeReady(opts = {}) {
         if (!portReleased) {
             const stalePid = health.status?.pid;
             if (typeof stalePid === 'number' && Number.isInteger(stalePid) && stalePid > 0) {
-                try {
-                    process.kill(stalePid, 'SIGKILL');
-                }
-                catch {
-                    // EPERM / ESRCH are both resolved by polling the fixed daemon port.
+                daemonLifecycleHooks.signalDaemonProcessTree(stalePid, 'SIGTERM');
+                portReleased = await daemonLifecycleHooks.waitForDaemonStop(1000);
+                if (!portReleased) {
+                    daemonLifecycleHooks.signalDaemonProcessTree(stalePid, 'SIGKILL');
+                    portReleased = await daemonLifecycleHooks.waitForDaemonStop(2000);
                 }
-                portReleased = await daemonLifecycleHooks.waitForDaemonStop(2000);
             }
         }
         if (!portReleased) {

package/dist/src/browser/runtime/local-cloak/session-manager.d.ts

@@ -3,6 +3,7 @@ import { launchPersistentContext as cloakLaunchPersistentContext } from 'cloakbr
 import type { BrowserSurface, SiteSessionMode } from '../../protocol.js';
 import { CloakNetworkCapture } from './network.js';
 export type LaunchPersistentContext = typeof cloakLaunchPersistentContext;
+export type RecoverLockedProfile = (userDataDir: string) => Promise<boolean>;
 export interface SessionKeyInput {
     profileId?: string;
     session?: string;
@@ -33,13 +34,16 @@ export interface CloakTabInfo {
 export interface CloakSessionManagerOptions {
     baseDir?: string;
     launchPersistentContext?: LaunchPersistentContext;
+    recoverLockedProfile?: RecoverLockedProfile;
 }
 export declare function resolveLeaseKey(input: SessionKeyInput): string;
 export declare class CloakSessionManager {
     private readonly opts;
     readonly networkCapture: CloakNetworkCapture;
     private readonly launchPersistentContext;
+    private readonly recoverLockedProfile;
     private readonly profiles;
+    private readonly profileLaunches;
     constructor(opts?: CloakSessionManagerOptions);
     profileStatuses(): {
         contextId: string;
@@ -72,6 +76,7 @@ export declare class CloakSessionManager {
     release(input: SessionKeyInput): Promise<void>;
     shutdown(): Promise<void>;
     private getProfileRuntime;
+    private launchProfileRuntime;
     private openEntries;
     private findEntryByPageId;
     private refreshIdleTimer;

package/dist/src/browser/runtime/local-cloak/session-manager.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { execFile } from 'node:child_process';
 import { launchPersistentContext as cloakLaunchPersistentContext } from 'cloakbrowser';
 import { normalizeProfileId, resolveCloakProfileDir } from './profiles.js';
 import { CloakNetworkCapture } from './network.js';
@@ -17,10 +18,13 @@ export class CloakSessionManager {
     opts;
     networkCapture = new CloakNetworkCapture();
     launchPersistentContext;
+    recoverLockedProfile;
     profiles = new Map();
+    profileLaunches = new Map();
     constructor(opts = {}) {
         this.opts = opts;
         this.launchPersistentContext = opts.launchPersistentContext ?? cloakLaunchPersistentContext;
+        this.recoverLockedProfile = opts.recoverLockedProfile ?? recoverLockedCloakProfile;
     }
     profileStatuses() {
         return [...this.profiles.entries()].map(([contextId, runtime]) => ({
@@ -235,13 +239,35 @@ export class CloakSessionManager {
         const existing = this.profiles.get(profileId);
         if (existing)
             return existing;
+        const pending = this.profileLaunches.get(profileId);
+        if (pending)
+            return pending;
+        const launch = this.launchProfileRuntime(profileId);
+        this.profileLaunches.set(profileId, launch);
+        try {
+            return await launch;
+        }
+        finally {
+            this.profileLaunches.delete(profileId);
+        }
+    }
+    async launchProfileRuntime(profileId) {
         const userDataDir = resolveCloakProfileDir(profileId, { baseDir: this.opts.baseDir });
         fs.mkdirSync(userDataDir, { recursive: true });
-        const context = await this.launchPersistentContext({
+        const launchOptions = {
             userDataDir,
             headless: false,
             humanize: true,
-        });
+        };
+        let context;
+        try {
+            context = await this.launchPersistentContext(launchOptions);
+        }
+        catch (err) {
+            if (!isProfileAlreadyInUseError(err) || !(await this.recoverLockedProfile(userDataDir)))
+                throw err;
+            context = await this.launchPersistentContext(launchOptions);
+        }
         const runtime = { context, pages: new Map(), lastSeenAt: Date.now() };
         this.profiles.set(profileId, runtime);
         return runtime;
@@ -291,3 +317,91 @@ function requireSession(session) {
         throw new Error('Browser session is required.');
     return normalized;
 }
+function isProfileAlreadyInUseError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes('Opening in existing browser session')
+        || message.includes('Failed to create a ProcessSingleton for your profile directory');
+}
+async function recoverLockedCloakProfile(userDataDir) {
+    if (process.platform === 'win32')
+        return false;
+    const initial = await findCloakProfileProcesses(userDataDir);
+    if (initial.length === 0)
+        return false;
+    signalPids(initial, 'SIGTERM');
+    if (await waitForProfileProcessesToExit(userDataDir, 2500))
+        return true;
+    signalPids(await findCloakProfileProcesses(userDataDir), 'SIGKILL');
+    return waitForProfileProcessesToExit(userDataDir, 1500);
+}
+async function waitForProfileProcessesToExit(userDataDir, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if ((await findCloakProfileProcesses(userDataDir)).length === 0)
+            return true;
+    }
+    return (await findCloakProfileProcesses(userDataDir)).length === 0;
+}
+function signalPids(pids, signal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Already exited or not signalable; the follow-up poll decides recovery.
+        }
+    }
+}
+async function findCloakProfileProcesses(userDataDir) {
+    const profileDirs = profileDirAliases(userDataDir);
+    const stdout = await psOutput();
+    const pids = [];
+    for (const line of stdout.split('\n')) {
+        const match = line.match(/^\s*(\d+)\s+(.+)$/);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const command = match[2];
+        if (!Number.isInteger(pid) || pid === process.pid)
+            continue;
+        if (!isCloakBrowserCommand(command))
+            continue;
+        if (!commandUsesProfileDir(command, profileDirs))
+            continue;
+        pids.push(pid);
+    }
+    return [...new Set(pids)];
+}
+function commandUsesProfileDir(command, profileDirs) {
+    for (const dir of profileDirs) {
+        const marker = `--user-data-dir=${dir}`;
+        const index = command.indexOf(marker);
+        if (index < 0)
+            continue;
+        const next = command[index + marker.length];
+        if (next === undefined || /\s/.test(next))
+            return true;
+    }
+    return false;
+}
+function profileDirAliases(userDataDir) {
+    const aliases = new Set([userDataDir]);
+    try {
+        aliases.add(fs.realpathSync.native(userDataDir));
+    }
+    catch {
+        // The launch path is still useful even if realpath cannot resolve it.
+    }
+    return [...aliases];
+}
+function isCloakBrowserCommand(command) {
+    return command.includes('/.cloakbrowser/') || command.includes('\\.cloakbrowser\\');
+}
+function psOutput() {
+    return new Promise((resolve) => {
+        execFile('ps', ['-axo', 'pid=,command='], { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024, timeout: 2000 }, (err, stdout) => {
+            resolve(err ? '' : String(stdout));
+        });
+    });
+}

package/dist/src/browser/runtime/local-cloak/session-manager.test.js

@@ -42,6 +42,42 @@ describe('CloakSessionManager', () => {
         expect(launchPersistentContext).toHaveBeenCalledTimes(1);
         expect(launchPersistentContext.mock.calls[0][0]).toMatchObject({ headless: false });
     });
+    it('coalesces concurrent persistent context launches for the same profile', async () => {
+        const launched = fakeContext();
+        let resolveLaunch;
+        const launchPersistentContext = vi.fn(() => new Promise((resolve) => {
+            resolveLaunch = resolve;
+        }));
+        const manager = new CloakSessionManager({
+            baseDir: '/tmp/webcmd-test',
+            launchPersistentContext,
+        });
+        const firstPage = manager.getPage({ profileId: 'default', session: 'work', surface: 'browser' });
+        const secondPage = manager.getPage({ profileId: 'default', session: 'work', surface: 'browser' });
+        await Promise.resolve();
+        expect(launchPersistentContext).toHaveBeenCalledTimes(1);
+        resolveLaunch(launched.context);
+        const [first, second] = await Promise.all([firstPage, secondPage]);
+        expect(first.context).toBe(launched.context);
+        expect(second.context).toBe(launched.context);
+        expect(first.page).toBe(second.page);
+    });
+    it('clears a stale Cloak profile owner and retries when Chromium reports an existing session', async () => {
+        const launched = fakeContext();
+        const launchPersistentContext = vi.fn()
+            .mockRejectedValueOnce(new Error('browserType.launchPersistentContext: Opening in existing browser session.'))
+            .mockResolvedValueOnce(launched.context);
+        const recoverLockedProfile = vi.fn().mockResolvedValue(true);
+        const manager = new CloakSessionManager({
+            baseDir: '/tmp/webcmd-test',
+            launchPersistentContext,
+            recoverLockedProfile,
+        });
+        const lease = await manager.getPage({ profileId: 'default', session: 'work', surface: 'browser' });
+        expect(lease.context).toBe(launched.context);
+        expect(recoverLockedProfile).toHaveBeenCalledWith(expectedProfileDir('default'));
+        expect(launchPersistentContext).toHaveBeenCalledTimes(2);
+    });
     it('freshPage closes the existing persistent lease page and creates a new one', async () => {
         const makePage = () => ({
             goto: vi.fn().mockResolvedValue(undefined),

package/dist/src/browser.test.js

@@ -196,7 +196,7 @@ describe('BrowserBridge state', () => {
         const bridge = new BrowserBridge();
         await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Stale daemon could not be replaced');
     });
-    it('falls back to SIGKILL when stale daemon refuses graceful shutdown', async () => {
+    it('falls back to process-group SIGKILL when stale daemon refuses graceful shutdown', async () => {
         vi.spyOn(daemonTransport, 'getDaemonHealth').mockResolvedValue({
             state: 'no-runtime',
             status: {
@@ -213,8 +213,10 @@ describe('BrowserBridge state', () => {
         });
         vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'requestDaemonShutdown').mockResolvedValue(false);
         // Graceful shutdown short-circuits to false (requestDaemonShutdown -> false).
-        // After SIGKILL the port is released, so the second waitForDaemonStop returns true.
-        vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'waitForDaemonStop').mockResolvedValue(true);
+        // SIGTERM does not release the port; process-group SIGKILL does.
+        vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'waitForDaemonStop')
+            .mockResolvedValueOnce(false)
+            .mockResolvedValueOnce(true);
         vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'spawnDaemonProcess').mockReturnValue(null);
         const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
         const bridge = new BrowserBridge();
@@ -222,7 +224,9 @@ describe('BrowserBridge state', () => {
         // no-runtime wait (which times out with `timeout: 0.1`), producing the
         // runtime-not-ready error rather than the stale-daemon error.
         await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser runtime is not ready');
-        expect(killSpy).toHaveBeenCalledWith(99999, 'SIGKILL');
+        const signalPid = process.platform === 'win32' ? 99999 : -99999;
+        expect(killSpy).toHaveBeenCalledWith(signalPid, 'SIGTERM');
+        expect(killSpy).toHaveBeenCalledWith(signalPid, 'SIGKILL');
     });
     it('reports stale daemon error when SIGKILL fails to release the port', async () => {
         vi.spyOn(daemonTransport, 'getDaemonHealth').mockResolvedValue({

package/dist/src/cli.js

@@ -2999,6 +2999,102 @@ cli({
         console.log(`  ${plugins.length} plugin(s) installed`);
         console.log();
     });
+    const catalogCmd = pluginCmd
+        .command('catalog')
+        .description('Manage plugin marketplace sources');
+    catalogCmd
+        .command('list')
+        .description('List configured plugin marketplace sources')
+        .option('-f, --format <fmt>', 'Output format: table, json', 'table')
+        .action(async (opts) => {
+        const { readCatalog } = await import('./plugin-catalog.js');
+        try {
+            const catalog = readCatalog();
+            if (opts.format === 'json') {
+                renderOutput(catalog, { fmt: 'json' });
+                return;
+            }
+            renderOutput(catalog.sources, {
+                fmt: opts.format,
+                columns: ['id', 'source', 'manifestUrl'],
+                title: `${CLI_COMMAND}/plugin-catalog`,
+                source: `${CLI_COMMAND} plugin catalog list`,
+            });
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
+    catalogCmd
+        .command('add')
+        .description('Add a plugin marketplace source')
+        .argument('<source>', 'Marketplace source, e.g. github:owner/repo')
+        .option('-f, --format <fmt>', 'Output format: table, json', 'table')
+        .action(async (source, opts) => {
+        const { addCatalogSource } = await import('./plugin-catalog.js');
+        try {
+            const added = await addCatalogSource(source);
+            renderOutput(opts.format === 'json' ? added : [added], {
+                fmt: opts.format,
+                columns: ['id', 'source', 'manifestUrl'],
+                title: `${CLI_COMMAND}/plugin-catalog`,
+                source: `${CLI_COMMAND} plugin catalog add`,
+            });
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
+    catalogCmd
+        .command('remove')
+        .description('Remove a plugin marketplace source')
+        .argument('<id>', 'Catalog source id')
+        .action(async (id) => {
+        const { removeCatalogSource } = await import('./plugin-catalog.js');
+        try {
+            removeCatalogSource(id);
+            console.log(`✅ Catalog source "${id}" removed.`);
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
+    pluginCmd
+        .command('search')
+        .description('Search installable marketplace plugins')
+        .argument('[query]', 'Search query matched against plugin name and description')
+        .option('-f, --format <fmt>', 'Output format: table, json', 'table')
+        .action(async (query, opts) => {
+        const { readCatalog, searchCatalogPlugins } = await import('./plugin-catalog.js');
+        try {
+            const catalog = readCatalog();
+            const result = await searchCatalogPlugins(catalog, { query });
+            if (opts.format === 'json') {
+                renderOutput(result, { fmt: 'json' });
+            }
+            else {
+                for (const err of result.errors) {
+                    console.error(`Warning: ${err.sourceId}: ${err.message}`);
+                }
+                renderOutput(result.plugins, {
+                    fmt: opts.format,
+                    columns: ['name', 'description', 'version', 'sourceId', 'installSource', 'webcmd'],
+                    title: `${CLI_COMMAND}/plugin-search`,
+                    source: `${CLI_COMMAND} plugin search`,
+                });
+            }
+            if (catalog.sources.length > 0 && result.errors.length === catalog.sources.length) {
+                process.exitCode = EXIT_CODES.GENERIC_ERROR;
+            }
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
     pluginCmd
         .command('create')
         .description('Create a new plugin scaffold')

package/dist/src/cli.test.js

@@ -52,7 +52,7 @@ describe('createProgram root help descriptions', () => {
         expect(descriptionFor(program, 'browser')).toContain('verify');
         expect(descriptionFor(program, 'browser')).not.toContain('Browser control');
         expect(descriptionFor(program, 'auth')).toBe('refresh, status');
-        expect(descriptionFor(program, 'plugin')).toBe('create, install, list, uninstall, update');
+        expect(descriptionFor(program, 'plugin')).toBe('catalog, create, install, list, search, uninstall, update');
         expect(descriptionFor(program, 'adapter')).toBe('eject, reset, status');
         expect(descriptionFor(program, 'profile')).toBe('list, rename, use');
         expect(descriptionFor(program, 'daemon')).toBe('restart, status, stop');
@@ -648,7 +648,7 @@ describe('createProgram root help descriptions', () => {
                 description: 'Manage webcmd plugins',
                 namespace_options: [],
             });
-            expect(data.commands.map((cmd) => cmd.name)).toEqual(['create', 'install', 'list', 'uninstall', 'update']);
+            expect(data.commands.map((cmd) => cmd.name)).toEqual(['catalog add', 'catalog list', 'catalog remove', 'create', 'install', 'list', 'search', 'uninstall', 'update']);
             const update = data.commands.find((cmd) => cmd.name === 'update');
             expect(update).toMatchObject({
                 usage: 'webcmd plugin update [name] [options]',

package/dist/src/generate-release-notes-cli.test.js

@@ -68,25 +68,45 @@ describe('runGenerateReleaseNotes', () => {
                 '## Highlights',
                 '- Better summaries.',
                 '',
-                '## Improvements',
-                'None.',
-                '',
-                '## Fixes',
-                'None.',
-                '',
-                '## Adapters',
-                'None.',
-                '',
-                '## Contributors',
-                '- @alice',
-                '',
-                '## Reverts',
-                'None.',
-                '',
             ].join('\n'),
             stderr: '',
         });
     });
+    it('prints nothing when generated notes only contain empty placeholders', async () => {
+        const { io, read } = createIo();
+        const context = {
+            tag: 'v1.2.3',
+            previousTag: 'v1.2.2',
+            currentRef: 'abcdef1',
+            pullRequests: [
+                {
+                    number: 42,
+                    title: 'chore: no user visible release changes',
+                    author: { login: 'alice' },
+                    labels: [],
+                    files: [],
+                    url: 'https://example.com/42',
+                },
+            ],
+        };
+        const loadContext = vi.fn(async () => context);
+        const generateText = vi.fn(async () => [
+            '## Highlights',
+            'None.',
+            '',
+            '## Reverts',
+            'There are no reverts in this release.',
+            '',
+            '## Contributors',
+            '- @alice',
+        ].join('\n'));
+        const exitCode = await runGenerateReleaseNotes(['node', 'script', 'v1.2.3'], { GEMINI_API_KEY: 'test-key' }, { loadContext, generateText }, io);
+        expect(exitCode).toBe(0);
+        expect(read()).toEqual({
+            stdout: '',
+            stderr: '',
+        });
+    });
     it('swallows generator errors and keeps release-please notes intact', async () => {
         const { io, read } = createIo();
         const loadContext = vi.fn(async () => {

package/dist/src/plugin-catalog.d.ts

@@ -0,0 +1,46 @@
+import { type PluginManifest } from './plugin-manifest.js';
+export interface PluginCatalogSource {
+    id: string;
+    source: string;
+    manifestUrl: string;
+}
+export interface PluginCatalog {
+    version: 1;
+    sources: PluginCatalogSource[];
+}
+export interface PluginSearchRow {
+    name: string;
+    description?: string;
+    version?: string;
+    sourceId: string;
+    installSource: string;
+    webcmd?: string;
+}
+export interface PluginSearchError {
+    sourceId: string;
+    manifestUrl: string;
+    message: string;
+}
+export interface PluginSearchResult {
+    plugins: PluginSearchRow[];
+    errors: PluginSearchError[];
+}
+type FetchJson = (url: string) => Promise<unknown>;
+interface CatalogOptions {
+    packageRoot?: string;
+    homeDir?: string;
+    fetchJson?: FetchJson;
+}
+export declare function getUserPluginCatalogPath(homeDir?: string): string;
+export declare function getPackagedPluginCatalogPath(packageRoot?: string): string;
+export declare function readCatalog(options?: CatalogOptions): PluginCatalog;
+export declare function writeCatalog(catalog: PluginCatalog, options?: CatalogOptions): void;
+export declare function deriveGithubCatalogSource(source: string): PluginCatalogSource;
+export declare function addCatalogSource(source: string, options?: CatalogOptions): Promise<PluginCatalogSource>;
+export declare function removeCatalogSource(id: string, options?: CatalogOptions): PluginCatalogSource;
+export declare function flattenPluginManifest(source: PluginCatalogSource, manifest: PluginManifest): PluginSearchRow[];
+export declare function searchCatalogPlugins(catalog: PluginCatalog, options?: {
+    query?: string;
+    fetchJson?: FetchJson;
+}): Promise<PluginSearchResult>;
+export {};

package/dist/src/plugin-catalog.js

@@ -0,0 +1,178 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getEnabledPlugins, isMonorepo } from './plugin-manifest.js';
+import { findPackageRoot } from './package-paths.js';
+const MODULE_FILE = fileURLToPath(import.meta.url);
+const CATALOG_FILENAME = 'plugin-catalog.json';
+export function getUserPluginCatalogPath(homeDir = os.homedir()) {
+    return path.join(homeDir, '.webcmd', CATALOG_FILENAME);
+}
+export function getPackagedPluginCatalogPath(packageRoot = findPackageRoot(MODULE_FILE)) {
+    return path.join(packageRoot, CATALOG_FILENAME);
+}
+export function readCatalog(options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const userPath = getUserPluginCatalogPath(homeDir);
+    if (!fs.existsSync(userPath))
+        seedUserCatalog(options.packageRoot, homeDir);
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(userPath, 'utf-8'));
+    }
+    catch (err) {
+        throw new Error(`Malformed plugin catalog at ${userPath}: ${errorMessage(err)}`);
+    }
+    return normalizeCatalog(parsed, userPath);
+}
+export function writeCatalog(catalog, options = {}) {
+    const userPath = getUserPluginCatalogPath(options.homeDir ?? os.homedir());
+    fs.mkdirSync(path.dirname(userPath), { recursive: true });
+    fs.writeFileSync(userPath, `${JSON.stringify(catalog, null, 2)}\n`);
+}
+export function deriveGithubCatalogSource(source) {
+    const parsed = parseGithubSource(source);
+    if (!parsed)
+        throw new Error(`Unsupported catalog source "${source}". Use github:owner/repo.`);
+    const { owner, repo } = parsed;
+    return {
+        id: `${owner}/${repo}`,
+        source,
+        manifestUrl: `https://raw.githubusercontent.com/${owner}/${repo}/main/webcmd-plugin.json`,
+    };
+}
+export async function addCatalogSource(source, options = {}) {
+    const entry = deriveGithubCatalogSource(source);
+    const catalog = readCatalog(options);
+    const duplicate = catalog.sources.find((existing) => (existing.id === entry.id || existing.source === entry.source || existing.manifestUrl === entry.manifestUrl));
+    if (duplicate)
+        throw new Error(`Catalog source already exists: ${duplicate.id}`);
+    const manifest = await fetchManifest(entry, options.fetchJson);
+    validateMarketplaceManifest(manifest, entry.manifestUrl);
+    catalog.sources.push(entry);
+    writeCatalog(catalog, options);
+    return entry;
+}
+export function removeCatalogSource(id, options = {}) {
+    const catalog = readCatalog(options);
+    const index = catalog.sources.findIndex((source) => source.id === id);
+    if (index < 0)
+        throw new Error(`Catalog source not found: ${id}`);
+    const [removed] = catalog.sources.splice(index, 1);
+    writeCatalog(catalog, options);
+    return removed;
+}
+export function flattenPluginManifest(source, manifest) {
+    if (isMonorepo(manifest)) {
+        return getEnabledPlugins(manifest).map(({ name, entry }) => ({
+            name,
+            description: entry.description,
+            version: entry.version,
+            sourceId: source.id,
+            installSource: `${source.source}/${name}`,
+            webcmd: entry.webcmd ?? manifest.webcmd,
+        }));
+    }
+    if (!manifest.name)
+        return [];
+    return [{
+            name: manifest.name,
+            description: manifest.description,
+            version: manifest.version,
+            sourceId: source.id,
+            installSource: source.source,
+            webcmd: manifest.webcmd,
+        }];
+}
+export async function searchCatalogPlugins(catalog, options = {}) {
+    const plugins = [];
+    const errors = [];
+    await Promise.all(catalog.sources.map(async (source) => {
+        try {
+            const manifest = await fetchManifest(source, options.fetchJson);
+            validateMarketplaceManifest(manifest, source.manifestUrl);
+            plugins.push(...flattenPluginManifest(source, manifest));
+        }
+        catch (err) {
+            errors.push({ sourceId: source.id, manifestUrl: source.manifestUrl, message: errorMessage(err) });
+        }
+    }));
+    const query = options.query?.trim().toLowerCase();
+    const filtered = query
+        ? plugins.filter((plugin) => `${plugin.name} ${plugin.description ?? ''}`.toLowerCase().includes(query))
+        : plugins;
+    filtered.sort((a, b) => a.name.localeCompare(b.name));
+    errors.sort((a, b) => a.sourceId.localeCompare(b.sourceId));
+    return { plugins: filtered, errors };
+}
+function seedUserCatalog(packageRoot, homeDir) {
+    const packagedPath = getPackagedPluginCatalogPath(packageRoot);
+    const userPath = getUserPluginCatalogPath(homeDir);
+    if (!fs.existsSync(packagedPath))
+        throw new Error(`Packaged plugin catalog not found: ${packagedPath}`);
+    fs.mkdirSync(path.dirname(userPath), { recursive: true });
+    fs.copyFileSync(packagedPath, userPath);
+}
+function normalizeCatalog(value, filePath) {
+    if (!isRecord(value))
+        throw new Error(`Malformed plugin catalog at ${filePath}: expected object`);
+    if (value.version !== 1)
+        throw new Error(`Malformed plugin catalog at ${filePath}: expected version 1`);
+    if (!Array.isArray(value.sources))
+        throw new Error(`Malformed plugin catalog at ${filePath}: expected sources array`);
+    return {
+        version: 1,
+        sources: value.sources.map((source, index) => normalizeCatalogSource(source, `${filePath} sources[${index}]`)),
+    };
+}
+function normalizeCatalogSource(value, label) {
+    if (!isRecord(value))
+        throw new Error(`Malformed plugin catalog at ${label}: expected object`);
+    if (typeof value.id !== 'string' || !value.id)
+        throw new Error(`Malformed plugin catalog at ${label}: expected id`);
+    if (typeof value.source !== 'string' || !value.source)
+        throw new Error(`Malformed plugin catalog at ${label}: expected source`);
+    if (typeof value.manifestUrl !== 'string' || !value.manifestUrl)
+        throw new Error(`Malformed plugin catalog at ${label}: expected manifestUrl`);
+    const github = parseGithubSource(value.source);
+    return {
+        id: github ? `${github.owner}/${github.repo}` : value.id,
+        source: value.source,
+        manifestUrl: value.manifestUrl,
+    };
+}
+function parseGithubSource(source) {
+    const match = /^github:([\w.-]+)\/([\w.-]+)$/.exec(source);
+    if (!match)
+        return null;
+    return { owner: match[1], repo: match[2] };
+}
+async function fetchManifest(source, fetchJson = defaultFetchJson) {
+    const value = await fetchJson(source.manifestUrl);
+    if (!isRecord(value))
+        throw new Error(`Invalid plugin manifest at ${source.manifestUrl}: expected object`);
+    return value;
+}
+function validateMarketplaceManifest(manifest, manifestUrl) {
+    if (isMonorepo(manifest)) {
+        if (getEnabledPlugins(manifest).length === 0) {
+            throw new Error(`Invalid plugin manifest at ${manifestUrl}: no enabled plugins`);
+        }
+        return;
+    }
+    if (!manifest.name)
+        throw new Error(`Invalid plugin manifest at ${manifestUrl}: missing name or plugins`);
+}
+async function defaultFetchJson(url) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status} ${response.statusText}`.trim());
+    return response.json();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/src/plugin-catalog.test.d.ts

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

package/dist/src/plugin-catalog.test.js

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { addCatalogSource, deriveGithubCatalogSource, flattenPluginManifest, getUserPluginCatalogPath, readCatalog, removeCatalogSource, searchCatalogPlugins, } from './plugin-catalog.js';
+describe('plugin catalog', () => {
+    let tmpDir;
+    let packageRoot;
+    let homeDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webcmd-plugin-catalog-'));
+        packageRoot = path.join(tmpDir, 'package');
+        homeDir = path.join(tmpDir, 'home');
+        fs.mkdirSync(packageRoot, { recursive: true });
+        fs.mkdirSync(homeDir, { recursive: true });
+        fs.writeFileSync(path.join(packageRoot, 'plugin-catalog.json'), JSON.stringify({
+            version: 1,
+            sources: [{
+                    id: 'agentrhq/webcmd',
+                    source: 'github:agentrhq/webcmd',
+                    manifestUrl: 'https://raw.githubusercontent.com/agentrhq/webcmd/main/webcmd-plugin.json',
+                }],
+        }));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('seeds the user catalog from the packaged default', () => {
+        const catalog = readCatalog({ packageRoot, homeDir });
+        expect(catalog.sources).toEqual([{ id: 'agentrhq/webcmd', source: 'github:agentrhq/webcmd', manifestUrl: 'https://raw.githubusercontent.com/agentrhq/webcmd/main/webcmd-plugin.json' }]);
+        expect(fs.existsSync(getUserPluginCatalogPath(homeDir))).toBe(true);
+    });
+    it('derives catalog metadata from github shorthand', () => {
+        expect(deriveGithubCatalogSource('github:other-org/webcmd-travel-plugins')).toEqual({
+            id: 'other-org/webcmd-travel-plugins',
+            source: 'github:other-org/webcmd-travel-plugins',
+            manifestUrl: 'https://raw.githubusercontent.com/other-org/webcmd-travel-plugins/main/webcmd-plugin.json',
+        });
+    });
+    it('adds and removes catalog sources in the user catalog', async () => {
+        const fetchJson = async () => ({ name: 'travel', description: 'Travel tools' });
+        const added = await addCatalogSource('github:other-org/webcmd-travel-plugins', { packageRoot, homeDir, fetchJson });
+        expect(added.id).toBe('other-org/webcmd-travel-plugins');
+        expect(readCatalog({ packageRoot, homeDir }).sources.map((source) => source.id)).toEqual([
+            'agentrhq/webcmd',
+            'other-org/webcmd-travel-plugins',
+        ]);
+        removeCatalogSource('other-org/webcmd-travel-plugins', { packageRoot, homeDir });
+        expect(readCatalog({ packageRoot, homeDir }).sources.map((source) => source.id)).toEqual(['agentrhq/webcmd']);
+    });
+    it('rejects duplicate catalog sources', async () => {
+        const fetchJson = async () => ({ name: 'travel', description: 'Travel tools' });
+        await addCatalogSource('github:other-org/webcmd-travel-plugins', { packageRoot, homeDir, fetchJson });
+        await expect(addCatalogSource('github:other-org/webcmd-travel-plugins', { packageRoot, homeDir, fetchJson })).rejects.toThrow('already exists');
+    });
+    it('flattens monorepo manifests into installable rows', () => {
+        const rows = flattenPluginManifest({
+            id: 'agentrhq/webcmd',
+            source: 'github:agentrhq/webcmd',
+            manifestUrl: 'https://example.com/webcmd-plugin.json',
+        }, {
+            webcmd: '>=0.2.0',
+            plugins: {
+                skyscanner: { path: 'plugins/skyscanner', version: '0.1.0', description: 'Flights', webcmd: '>=0.2.1' },
+                disabled: { path: 'plugins/disabled', disabled: true },
+            },
+        });
+        expect(rows).toEqual([{ name: 'skyscanner', description: 'Flights', version: '0.1.0', sourceId: 'agentrhq/webcmd', installSource: 'github:agentrhq/webcmd/skyscanner', webcmd: '>=0.2.1' }]);
+    });
+    it('flattens single-plugin manifests into installable rows', () => {
+        const rows = flattenPluginManifest({
+            id: 'research-tools',
+            source: 'github:someone/research-tools',
+            manifestUrl: 'https://example.com/webcmd-plugin.json',
+        }, { name: 'research-tools', version: '0.1.0', description: 'Research helpers', webcmd: '>=0.2.0' });
+        expect(rows).toEqual([{ name: 'research-tools', description: 'Research helpers', version: '0.1.0', sourceId: 'research-tools', installSource: 'github:someone/research-tools', webcmd: '>=0.2.0' }]);
+    });
+    it('fetches manifests live and preserves remote errors in search output', async () => {
+        const catalog = {
+            version: 1,
+            sources: [
+                { id: 'ok', source: 'github:ok/repo', manifestUrl: 'https://ok.test/webcmd-plugin.json' },
+                { id: 'bad', source: 'github:bad/repo', manifestUrl: 'https://bad.test/webcmd-plugin.json' },
+            ],
+        };
+        const fetchJson = async (url) => {
+            if (url.includes('bad'))
+                throw new Error('network failed');
+            return { plugins: { flights: { path: 'plugins/flights', description: 'Flight search' } } };
+        };
+        const result = await searchCatalogPlugins(catalog, { query: 'flight', fetchJson });
+        expect(result.plugins.map((plugin) => plugin.name)).toEqual(['flights']);
+        expect(result.errors).toEqual([{ sourceId: 'bad', manifestUrl: 'https://bad.test/webcmd-plugin.json', message: 'network failed' }]);
+    });
+});

package/dist/src/release-notes.d.ts

@@ -1,4 +1,4 @@
-export declare const RELEASE_NOTE_SECTIONS: readonly ["Highlights", "Improvements", "Fixes", "Adapters", "Contributors", "Reverts"];
+export declare const RELEASE_NOTE_SECTIONS: readonly ["Highlights", "Improvements", "Fixes", "Adapters", "Reverts"];
 export type ReleaseNoteSection = typeof RELEASE_NOTE_SECTIONS[number];
 export interface PullRequestLabel {
     name: string;
@@ -36,5 +36,5 @@ export declare function releaseVersionFromTag(tag: string): string;
 export declare function replaceChangelogReleaseNotes(changelog: string, tag: string, notes: string): string;
 export declare function extractPullRequestNumber(message: string): number | null;
 export declare function filterReleasePullRequests(prs: PullRequestDetails[]): PullRequestDetails[];
-export declare function normalizeReleaseNotes(raw: string, contributors: string[]): string;
+export declare function normalizeReleaseNotes(raw: string): string;
 export declare function buildReleaseNotesPrompt(context: ReleaseContext): string;

package/dist/src/release-notes.js

@@ -3,22 +3,29 @@ export const RELEASE_NOTE_SECTIONS = [
     'Improvements',
     'Fixes',
     'Adapters',
-    'Contributors',
     'Reverts',
 ];
 const SQUASH_MERGE_PR_NUMBER_PATTERN = /\(#(?<number>\d+)\)\s*$/;
 const MERGE_COMMIT_PR_NUMBER_PATTERN = /^Merge pull request #(?<number>\d+) /;
 const RELEASE_PLEASE_TITLE_PATTERN = /^chore(?:\([^)]+\))?: release(?:\s|$)/;
-function normalizeHandle(handle) {
-    const trimmed = handle.trim();
-    return trimmed.startsWith('@') ? trimmed.slice(1) : trimmed;
+function isNoChangeContent(content) {
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim().replace(/^[-*]\s+/, '').replace(/[.。]+$/, '').trim().toLowerCase())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return true;
+    return lines.every((line) => (line === 'none'
+        || line === 'n/a'
+        || line === 'not applicable'
+        || /^no .*?(?:changes|updates|reverts|fixes|improvements|adapters|highlights)(?: in this release)?$/.test(line)
+        || /^there (?:are|were) no .*?(?:changes|updates|reverts|fixes|improvements|adapters|highlights)(?: in this release)?$/.test(line)));
 }
-function uniqueSortedHandles(handles) {
-    return [...new Set(handles.map(normalizeHandle).filter(Boolean))].sort((left, right) => left.localeCompare(right));
-}
-function formatSectionContent(content) {
+function normalizeSectionContent(content) {
     const trimmed = content?.trim();
-    return trimmed && trimmed.length > 0 ? trimmed : 'None.';
+    if (!trimmed || isNoChangeContent(trimmed))
+        return null;
+    return trimmed;
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -26,7 +33,7 @@ function escapeRegExp(value) {
 function formatReleaseNotesForChangelog(notes) {
     const trimmed = notes.trim();
     if (!trimmed)
-        return '### Highlights\nNone.';
+        return '';
     return trimmed.replace(/^##\s+/gm, '### ');
 }
 export function releaseVersionFromTag(tag) {
@@ -97,16 +104,11 @@ function parseReleaseNoteSections(raw) {
     }
     return sections;
 }
-export function normalizeReleaseNotes(raw, contributors) {
+export function normalizeReleaseNotes(raw) {
     const sections = parseReleaseNoteSections(raw);
-    const normalizedContributors = uniqueSortedHandles(contributors).map((handle) => `- @${handle}`);
-    return RELEASE_NOTE_SECTIONS.map((section) => {
-        if (section === 'Contributors') {
-            const content = normalizedContributors.length > 0 ? normalizedContributors.join('\n') : 'None.';
-            return `## ${section}\n${content}`;
-        }
-        const content = formatSectionContent(sections[section]?.join('\n'));
-        return `## ${section}\n${content}`;
+    return RELEASE_NOTE_SECTIONS.flatMap((section) => {
+        const content = normalizeSectionContent(sections[section]?.join('\n'));
+        return content ? [`## ${section}\n${content}`] : [];
     }).join('\n\n');
 }
 function formatPullRequest(pr) {
@@ -130,11 +132,13 @@ export function buildReleaseNotesPrompt(context) {
         `Write user-facing release notes for ${context.tag}.`,
         `Release range: ${context.previousTag}...${context.currentRef}.`,
         'Use only the supplied pull requests below. Do not invent changes or pull in information from elsewhere.',
-        `Required sections: ${RELEASE_NOTE_SECTIONS.map((section) => `## ${section}`).join(', ')}.`,
-        'Each section must be present in the final notes.',
+        `Allowed sections: ${RELEASE_NOTE_SECTIONS.map((section) => `## ${section}`).join(', ')}.`,
+        'Include only sections that have user-visible changes. Omit empty sections entirely; do not write "None", "N/A", or similar placeholder text.',
+        'Do not include a Contributors section.',
         'In this project, CLI commands and adapters are the same thing. Treat any PR that adds, removes, or changes files under clis/** as an adapter change, even if the PR title says "CLI" instead of "adapter".',
         'Put new site adapters/CLIs, adapter promotions, adapter hardening, adapter output changes, selector/API updates, and site-specific workflow improvements in ## Adapters.',
         'Use ## Improvements for non-adapter product, runtime, CLI, docs, or workflow improvements.',
+        'Use ## Reverts only when the release includes actual reverted changes.',
         '',
         `Pull requests included for this release:`,
         prSummaries,

package/dist/src/release-notes.test.js

@@ -17,22 +17,39 @@ describe('release notes helpers', () => {
         ];
         expect(filterReleasePullRequests(prs).map((pr) => pr.number)).toEqual([1]);
     });
-    it('normalizes all required sections and fills empty sections with None', () => {
+    it('normalizes only sections with real release-note content', () => {
         const raw = [
             '## Highlights',
             '- Better release notes.',
             '',
+            '## Improvements',
+            'No improvements.',
+            '',
+            '## Adapters',
+            'No adapter changes.',
+            '',
             '## Fixes',
             '- Fixed release fallback.',
+            '',
+            '## Contributors',
+            '- @alice',
+            '',
+            '## Reverts',
+            'There are no reverts in this release.',
         ].join('\n');
-        const normalized = normalizeReleaseNotes(raw, ['alice', 'bob']);
-        for (const section of RELEASE_NOTE_SECTIONS) {
-            expect(normalized).toContain(`## ${section}`);
-        }
-        expect(normalized).toContain('## Adapters\nNone.');
-        expect(normalized).toContain('## Improvements\nNone.');
-        expect(normalized).toContain('## Contributors\n- @alice\n- @bob');
-        expect(normalized).toContain('## Reverts\nNone.');
+        const normalized = normalizeReleaseNotes(raw);
+        expect(RELEASE_NOTE_SECTIONS).toEqual(['Highlights', 'Improvements', 'Fixes', 'Adapters', 'Reverts']);
+        expect(normalized).toBe([
+            '## Highlights',
+            '- Better release notes.',
+            '',
+            '## Fixes',
+            '- Fixed release fallback.',
+        ].join('\n'));
+        expect(normalized).not.toContain('## Improvements');
+        expect(normalized).not.toContain('## Contributors');
+        expect(normalized).not.toContain('## Reverts');
+        expect(normalized).not.toContain('None.');
     });
     it('replaces a matching changelog release entry with generated notes', () => {
         const changelog = [
@@ -91,6 +108,9 @@ describe('release notes helpers', () => {
         expect(prompt).toContain('docs/docs.json');
         expect(prompt).toContain('## Highlights');
         expect(prompt).toContain('## Adapters');
+        expect(prompt).not.toContain('## Contributors');
+        expect(prompt).toContain('Omit empty sections entirely');
+        expect(prompt).toContain('Do not include a Contributors section');
         expect(prompt).toContain('CLI commands and adapters are the same thing');
         expect(prompt).toContain('files under clis/** as an adapter change');
         expect(prompt).toContain('Put new site adapters/CLIs, adapter promotions, adapter hardening');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrhq/webcmd",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Turn websites, browser sessions, desktop apps, and local tools into deterministic CLI surfaces for humans and AI agents.",
   "engines": {
     "node": ">=20.0.0"
@@ -32,6 +32,7 @@
     "clis/",
     "skills/**",
     "cli-manifest.json",
+    "plugin-catalog.json",
     "scripts/",
     "README.md",
     "LICENSE",

package/plugin-catalog.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "sources": [
+    {
+      "id": "agentrhq/webcmd",
+      "source": "github:agentrhq/webcmd",
+      "manifestUrl": "https://raw.githubusercontent.com/agentrhq/webcmd/main/webcmd-plugin.json"
+    }
+  ]
+}

package/scripts/generate-release-notes.ts

@@ -193,10 +193,6 @@ async function generateText(prompt: string, model: string, apiKey: string): Prom
   return text;
 }
 
-function contributorHandles(pullRequests: PullRequestDetails[]): string[] {
-  return pullRequests.flatMap((pr) => (pr.author?.login ? [pr.author.login] : []));
-}
-
 function updateChangelog(tag: string | undefined, notesPath: string | undefined, changelogPath: string | undefined, io: Io): number {
   if (!tag || !notesPath) {
     io.writeStderr('Usage: generate-release-notes --update-changelog <tag> <notes-file> [changelog-file]\n');
@@ -249,8 +245,10 @@ export async function runGenerateReleaseNotes(
     const model = env.GEMINI_RELEASE_NOTES_MODEL || DEFAULT_MODEL;
     const prompt = buildReleaseNotesPrompt(context);
     const raw = await (deps.generateText ?? generateText)(prompt, model, apiKey);
-    const normalized = normalizeReleaseNotes(raw, contributorHandles(context.pullRequests));
-    io.writeStdout(`${normalized}\n`);
+    const normalized = normalizeReleaseNotes(raw);
+    if (normalized) {
+      io.writeStdout(`${normalized}\n`);
+    }
     return 0;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);