@event4u/agent-config 17.2.0 → 17.3.0

package/src/scripts/_lib/listing_manifests.ts

@@ -0,0 +1,85 @@
+/**
+ * The listing manifests outside the npm tarball that start the MCP server
+ * through `npx`: the GitHub Copilot discovery plugin and the Gemini CLI
+ * extension. Both carry the package version twice — in `version` and pinned
+ * inside the `npx` argument — and a crawler installs whatever the default
+ * branch says, so both copies follow `package.json` through the release.
+ *
+ * One module because three readers must agree on the same two facts: the
+ * release writes them (`release_env`), the release-PR content gate admits a
+ * change to them and nothing else (`check_release_manifest_content`), and the
+ * marketplace lint fails a tree where they drifted (`lint_marketplace`).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export const LISTING_MANIFESTS = ['.github/plugin/plugin.json', 'gemini-extension.json'] as const;
+
+export const PACKAGE_NAME = '@event4u/agent-config';
+
+/** An `npx` argument pinning this package to an exact release, prereleases included. */
+export const PINNED_PACKAGE_ARG_RE = /^@event4u\/agent-config@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u;
+
+export function pinnedPackageArg(version: string): string {
+    return `${PACKAGE_NAME}@${version}`;
+}
+
+type Obj = Record<string, unknown>;
+
+function _isObject(v: unknown): v is Obj {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+/** Every `[serverName, args]` pair under `mcpServers`, args left `unknown` for the caller to judge. */
+export function mcpServerArgs(manifest: unknown): Array<[string, unknown]> {
+    if (!_isObject(manifest) || !_isObject(manifest['mcpServers'])) return [];
+    return Object.entries(manifest['mcpServers']).map(([name, server]) => [
+        name,
+        _isObject(server) ? server['args'] : undefined,
+    ]);
+}
+
+/**
+ * Every way `manifest` disagrees with `version`: the `version` field, and each
+ * server whose `npx` arguments do not pin exactly this release. An unpinned
+ * `@event4u/agent-config` argument is a finding too — it resolves to whatever
+ * is latest on the day a user installs, which is the drift being prevented.
+ */
+export function listingVersionFindings(label: string, manifest: unknown, version: string): string[] {
+    const out: string[] = [];
+    const declared = _isObject(manifest) ? manifest['version'] : undefined;
+    if (declared !== version) {
+        out.push(`${label}: version \`${String(declared)}\` does not match package.json version \`${version}\``);
+    }
+    const servers = mcpServerArgs(manifest);
+    if (servers.length === 0) out.push(`${label}: declares no mcpServers entry`);
+    for (const [name, args] of servers) {
+        const own = Array.isArray(args)
+            ? args.filter((a): a is string => typeof a === 'string' && a.startsWith(PACKAGE_NAME))
+            : [];
+        if (own.length !== 1 || own[0] !== pinnedPackageArg(version)) {
+            out.push(
+                `${label}: mcpServers.${name}.args must pin \`${pinnedPackageArg(version)}\` ` +
+                    `(found ${own.length === 0 ? 'none' : own.map((a) => `\`${a}\``).join(', ')})`,
+            );
+        }
+    }
+    return out;
+}
+
+/** Rewrite `version` and every pinned package argument; `jsonDump` is the release's own serializer. */
+export function setListingManifestVersion(p: string, version: string, jsonDump: (v: unknown) => string): void {
+    const data = JSON.parse(fs.readFileSync(p, 'utf-8')) as unknown;
+    if (_isObject(data) && 'version' in data) data['version'] = version;
+    for (const [, args] of mcpServerArgs(data)) {
+        if (!Array.isArray(args)) continue;
+        args.forEach((a, i) => {
+            if (typeof a === 'string' && PINNED_PACKAGE_ARG_RE.test(a)) args[i] = pinnedPackageArg(version);
+        });
+    }
+    fs.writeFileSync(p, jsonDump(data) + '\n', 'utf-8');
+}
+
+export function listingManifestPaths(root: string): string[] {
+    return LISTING_MANIFESTS.map((rel) => path.join(root, rel));
+}

package/src/scripts/_lib/neighbour_census.ts

@@ -86,6 +86,7 @@ export type Effect =
     | 'memory'
     | 'notification'
     | 'formatting'
+    | 'execution'
     | 'unknown';
 
 export interface NeighbourEntry {

package/src/scripts/_lib/release_settings_surface.ts

@@ -33,7 +33,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { toJsonSchema7 } from '../../shared/zodJsonSchema.js';
 
 import { settingsSchema } from '../../server/schemas/settings.js';
 import { computeSurfaceDelta, flattenSurface, type SettingsSurface, type SurfaceEntry } from '../../shared/settingsSurface.js';
@@ -50,11 +50,7 @@ import { RENAMED_KEYS, SETTINGS_REMOVAL_RULE } from './settings_renamed_keys.js'
  * "keep a preview fast" rule was written about.
  */
 function _jsonSchema(): Parameters<typeof flattenSurface>[0] {
-    return zodToJsonSchema(settingsSchema, {
-        name: 'AgentSettings',
-        $refStrategy: 'none',
-        target: 'jsonSchema7',
-    }) as Parameters<typeof flattenSurface>[0];
+    return toJsonSchema7(settingsSchema, 'AgentSettings') as Parameters<typeof flattenSurface>[0];
 }
 
 /** The one committed copy of the last release's surface. */

package/src/scripts/adoption_status.ts

@@ -22,7 +22,7 @@
  *
  * CLI:
  *
- *   ./scripts-run src/scripts/adoption_status [--json] [--branch main] [--check-upstream]
+ *   ./scripts-run src/scripts/adoption_status [--json] [--branch main] [--check-upstream] [--fail-on-action]
  *
  * `--check-upstream` reads each ledger row's upstream (`gh pr view` for a pull
  * request, one `curl` for a listing page or registry query) and appends what it
@@ -30,10 +30,19 @@
  * report exactly as before, and stderr names that mode plus every row whose
  * `Last read` date is missing or older than the sheet's re-read threshold.
  *
+ * With `--check-upstream`, a row whose sheet and upstream disagree in a way that
+ * needs a person also carries an action (`sheet-behind`, `needs-response`,
+ * `listing-lost`, `listing-stale`) next to its unchanged verdict, and the report
+ * names the next act. A submission is done when its entry is live, not when it
+ * was sent, so `--fail-on-action` turns any action into a non-zero exit for the
+ * daily watcher. Without `--check-upstream` there is nothing to judge and the
+ * flag is reported on stderr and ignored.
+ *
  * Exit codes:
  *
  *   0 — printed successfully (status itself does not gate the exit).
  *   1 — IO error reading the registry-submissions sheet.
+ *   2 — `--check-upstream --fail-on-action` and at least one row needs an action.
  */
 
 import { spawnSync } from 'node:child_process';
@@ -243,25 +252,29 @@ interface Args {
     json: boolean;
     branch: string;
     checkUpstream: boolean;
+    failOnAction: boolean;
 }
 
 export function parse_args(argv: string[]): Args {
     let json = false;
     let branch = 'main';
     let checkUpstream = false;
+    let failOnAction = false;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         if (a === '--json') {
             json = true;
         } else if (a === '--check-upstream') {
             checkUpstream = true;
+        } else if (a === '--fail-on-action') {
+            failOnAction = true;
         } else if (a === '--branch') {
             branch = argv[++i] ?? '';
         } else if (a !== undefined && a.startsWith('--branch=')) {
             branch = a.slice('--branch='.length);
         }
     }
-    return { json, branch, checkUpstream };
+    return { json, branch, checkUpstream, failOnAction };
 }
 
 export function main(argv: string[] = process.argv.slice(2)): number {
@@ -293,10 +306,21 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         for (const u of unread) {
             process.stderr.write(`  row ${u.id} ${u.registry}: ${u.label}\n`);
         }
+        if (args.failOnAction) {
+            process.stderr.write(
+                '--fail-on-action ignored: actions are judged only with --check-upstream\n',
+            );
+        }
         return 0;
     }
 
-    const verdicts = judge_upstream(rows, live_upstream_reader, today);
+    const verdicts = judge_upstream(
+        rows,
+        live_upstream_reader,
+        today,
+        _releasedServer(),
+        parse_reread_threshold(registryText),
+    );
     if (args.json) {
         const base = JSON.parse(render_json(registryCounts, reports, ci, args.branch)) as Record<
             string,
@@ -308,7 +332,32 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         process.stdout.write(render_text(registryCounts, reports, ci, args.branch) + '\n');
         process.stdout.write(render_upstream_text(verdicts, unread) + '\n');
     }
-    return 0;
+    const code = upstream_exit_code(verdicts, args.failOnAction);
+    if (code !== 0) {
+        // On a runner the `::error::` prefix turns each line into an annotation
+        // naming the row, so the red job says what to do without opening the log.
+        const prefix = process.env.GITHUB_ACTIONS === 'true' ? '::error title=adoption_status::' : 'action: ';
+        for (const line of action_lines(verdicts)) {
+            process.stderr.write(prefix + line + '\n');
+        }
+    }
+    return code;
+}
+
+/** `name` and `version` the registry should carry, from package.json. */
+function _releasedServer(): ReleasedServer | undefined {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf-8')) as {
+            mcpName?: unknown;
+            version?: unknown;
+        };
+        if (typeof pkg.mcpName === 'string' && typeof pkg.version === 'string') {
+            return { name: pkg.mcpName, version: pkg.version };
+        }
+    } catch {
+        // Without a readable package.json there is nothing to compare against.
+    }
+    return undefined;
 }
 
 // --- upstream reading --------------------------------------------------------
@@ -325,7 +374,15 @@ export interface LedgerRow {
 }
 
 export type UpstreamReading =
-    | { ok: true; state: 'open' | 'closed' | 'merged' | 'listed' | 'not-listed'; at?: string }
+    | {
+          ok: true;
+          state: 'open' | 'closed' | 'merged' | 'listed' | 'not-listed';
+          at?: string;
+          /** `gh pr view` reviewDecision, e.g. `CHANGES_REQUESTED`; pull requests only. */
+          reviewDecision?: string;
+          /** Server name → the version the registry marks latest; registry queries only. */
+          latestVersions?: Record<string, string>;
+      }
     | { ok: false; reason: string };
 
 export type UpstreamReader = (row: LedgerRow) => UpstreamReading;
@@ -340,11 +397,25 @@ export type UpstreamVerdict =
     | 'unreachable'
     | 'no-upstream';
 
+/**
+ * Reported next to the verdict, never instead of it: the verdict says what the
+ * upstream reads, the action says the sheet and that reading disagree in a way a
+ * person has to resolve.
+ */
+export type ActionVerdict = 'sheet-behind' | 'needs-response' | 'listing-lost' | 'listing-stale' | 'read-overdue';
+
 export interface RowVerdict {
     id: string;
     registry: string;
     verdict: UpstreamVerdict;
     detail: string;
+    action?: ActionVerdict;
+    next?: string;
+}
+
+export interface ReleasedServer {
+    name: string;
+    version: string;
 }
 
 export interface UnreadFinding {
@@ -451,6 +522,8 @@ export function judge_upstream(
     rows: LedgerRow[],
     reader: UpstreamReader,
     today: string,
+    released?: ReleasedServer,
+    thresholdDays: number = DEFAULT_REREAD_THRESHOLD_DAYS,
 ): RowVerdict[] {
     return rows.map((row): RowVerdict => {
         const base = { id: row.id, registry: row.registry };
@@ -459,27 +532,116 @@ export function judge_upstream(
         }
         const r = reader(row);
         if (!r.ok) {
-            return { ...base, verdict: 'unreachable', detail: r.reason };
-        }
-        switch (r.state) {
-            case 'closed':
-                return { ...base, verdict: 'answered-closed', detail: `closed ${r.at ?? 'date unknown'}` };
-            case 'merged':
-                return { ...base, verdict: 'answered-merged', detail: `merged ${r.at ?? 'date unknown'}` };
-            case 'listed':
-            case 'not-listed':
-                return { ...base, verdict: r.state, detail: row.ref };
-            case 'open': {
-                const age = row.date === '' ? null : _daysBetween(row.date, today);
-                if (row.status === 'submitted' && age !== null && age >= STALLED_AFTER_DAYS) {
-                    return { ...base, verdict: 'stalled', detail: `open ${age} days, no answer` };
-                }
-                return { ...base, verdict: 'open', detail: age === null ? 'open' : `open ${age} days` };
+            const out = { ...base, verdict: 'unreachable' as const, detail: r.reason };
+            // One outage never reds the watcher; a listing nobody has been able to read
+            // for longer than the sheet's own threshold does, or it could vanish unseen.
+            const age = row.lastRead === '' ? null : _daysBetween(row.lastRead, today);
+            const live = row.status === 'accepted' || row.status === 'submitted';
+            if (live && (age === null || age > thresholdDays)) {
+                return {
+                    ...out,
+                    action: 'read-overdue',
+                    next: `read the upstream another way (a headless browser) and set Last read; unread ${age === null ? 'ever' : `for ${age} days`}`,
+                };
             }
+            return out;
         }
+        const out = { ...base, ..._verdictOf(row, r, today) };
+        const action = _actionFor(row, r, released);
+        // Spread only when present: the JSON writer prints an undefined value as `null`.
+        return action === null ? out : { ...out, ...action };
     });
 }
 
+function _verdictOf(
+    row: LedgerRow,
+    r: Extract<UpstreamReading, { ok: true }>,
+    today: string,
+): { verdict: UpstreamVerdict; detail: string } {
+    switch (r.state) {
+        case 'closed':
+            return { verdict: 'answered-closed', detail: `closed ${r.at ?? 'date unknown'}` };
+        case 'merged':
+            return { verdict: 'answered-merged', detail: `merged ${r.at ?? 'date unknown'}` };
+        case 'listed':
+        case 'not-listed':
+            return { verdict: r.state, detail: row.ref };
+        case 'open': {
+            const age = row.date === '' ? null : _daysBetween(row.date, today);
+            if (row.status === 'submitted' && age !== null && age >= STALLED_AFTER_DAYS) {
+                return { verdict: 'stalled', detail: `open ${age} days, no answer` };
+            }
+            return { verdict: 'open', detail: age === null ? 'open' : `open ${age} days` };
+        }
+    }
+}
+
+/**
+ * The cases where the sheet and the live upstream disagree in a way that needs a
+ * person. `rejected` and `stalled` rows are left alone: the sheet already says
+ * the attempt ended, and an unreadable upstream is never an action, so a network
+ * outage cannot red the watcher.
+ */
+function _actionFor(
+    row: LedgerRow,
+    r: Extract<UpstreamReading, { ok: true }>,
+    released: ReleasedServer | undefined,
+): { action: ActionVerdict; next: string } | null {
+    const awaiting = row.status === 'submitted' || row.status === 'pending';
+    if (awaiting && (r.state === 'closed' || r.state === 'merged')) {
+        return {
+            action: 'sheet-behind',
+            next: `update the ledger row: the upstream ${r.state} ${r.at ?? 'on an unknown date'} while the sheet says ${row.status}`,
+        };
+    }
+    // Row 4's path after its first CI publish: the entry went live, the sheet still waits.
+    if (awaiting && r.state === 'listed') {
+        return {
+            action: 'sheet-behind',
+            next: `update the ledger row: the listing reads listed while the sheet says ${row.status}`,
+        };
+    }
+    if (r.state === 'open' && r.reviewDecision === 'CHANGES_REQUESTED') {
+        return { action: 'needs-response', next: `answer the review on ${row.ref}` };
+    }
+    if (row.status === 'accepted' && r.state === 'not-listed') {
+        return { action: 'listing-lost', next: `re-check or re-submit the listing at ${row.ref}` };
+    }
+    if (
+        row.status === 'accepted' &&
+        row.kind === 'registry-query' &&
+        r.state === 'listed' &&
+        released !== undefined &&
+        r.latestVersions !== undefined
+    ) {
+        const live = r.latestVersions[released.name];
+        if (live === undefined) {
+            return {
+                action: 'listing-lost',
+                next: `re-check or re-submit the listing: the registry answer carries no ${released.name}`,
+            };
+        }
+        if (live !== released.version) {
+            return {
+                action: 'listing-stale',
+                next: `publish ${released.version} to the registry: it carries ${live} for ${released.name}`,
+            };
+        }
+    }
+    return null;
+}
+
+/** The rows `--fail-on-action` reds on, one line each: row, action, next act. */
+export function action_lines(verdicts: RowVerdict[]): string[] {
+    return verdicts
+        .filter((v) => v.action !== undefined)
+        .map((v) => `row ${v.id} ${v.action} (${v.registry}) — ${v.next ?? ''}`);
+}
+
+export function upstream_exit_code(verdicts: RowVerdict[], failOnAction: boolean): number {
+    return failOnAction && verdicts.some((v) => v.action !== undefined) ? 2 : 0;
+}
+
 export function upstream_mode_note(checked: boolean): string {
     return checked
         ? 'upstream: read live (--check-upstream)'
@@ -508,6 +670,14 @@ export function render_upstream_text(verdicts: RowVerdict[], unread: UnreadFindi
     for (const u of unread) {
         lines.push(`  row ${u.id.padEnd(3)} ${u.label} ${u.registry}`);
     }
+    const actions = action_lines(verdicts);
+    if (actions.length > 0) {
+        lines.push('');
+        lines.push('Actions needed (a submission is done only once it is live):');
+        for (const a of actions) {
+            lines.push(`  ${a}`);
+        }
+    }
     return lines.join('\n');
 }
 
@@ -521,14 +691,14 @@ function _readPullRequest(ref: string): UpstreamReading {
     }
     const proc = spawnSync(
         'gh',
-        ['pr', 'view', m[2] as string, '--repo', m[1] as string, '--json', 'state,closedAt,mergedAt'],
+        ['pr', 'view', m[2] as string, '--repo', m[1] as string, '--json', 'state,closedAt,mergedAt,reviewDecision'],
         { encoding: 'utf8', timeout: 20_000 },
     );
     if (proc.status !== 0) {
         const snip = sanitize_text(_pyStrip(proc.stderr ?? '')).slice(0, 80);
         return { ok: false, reason: `gh exit=${proc.status}: ${snip}` };
     }
-    let d: { state?: string; closedAt?: string; mergedAt?: string };
+    let d: { state?: string; closedAt?: string; mergedAt?: string; reviewDecision?: string };
     try {
         d = JSON.parse(proc.stdout) as typeof d;
     } catch {
@@ -536,7 +706,10 @@ function _readPullRequest(ref: string): UpstreamReading {
     }
     if (d.state === 'MERGED') return { ok: true, state: 'merged', at: sanitize_text(d.mergedAt ?? '').slice(0, 10) };
     if (d.state === 'CLOSED') return { ok: true, state: 'closed', at: sanitize_text(d.closedAt ?? '').slice(0, 10) };
-    if (d.state === 'OPEN') return { ok: true, state: 'open' };
+    if (d.state === 'OPEN') {
+        const review = sanitize_text(d.reviewDecision ?? '').slice(0, 40);
+        return review === '' ? { ok: true, state: 'open' } : { ok: true, state: 'open', reviewDecision: review };
+    }
     return { ok: false, reason: `unknown pull-request state ${sanitize_text(String(d.state)).slice(0, 40)}` };
 }
 
@@ -574,9 +747,21 @@ export function read_url(
         if (code === '404') return { ok: true, state: 'not-listed' };
         return { ok: false, reason: `HTTP ${code} from ${ref}` };
     }
-    let body: { metadata?: { count?: unknown } };
+    return read_registry_answer(out.slice(0, cut), ref);
+}
+
+const _REGISTRY_META_KEY = 'io.modelcontextprotocol.registry/official';
+
+/**
+ * Shape read live from `GET /v0/servers?search=` on 2026-10-24:
+ * `{servers: [{server: {name, version}, _meta: {"<key>": {isLatest}}}], metadata: {count}}`.
+ * A search returns every published version, so only the one flagged `isLatest`
+ * names what a client installs.
+ */
+export function read_registry_answer(text: string, ref: string): UpstreamReading {
+    let body: { metadata?: { count?: unknown }; servers?: unknown };
     try {
-        body = JSON.parse(out.slice(0, cut)) as typeof body;
+        body = JSON.parse(text) as typeof body;
     } catch {
         return { ok: false, reason: `registry answer from ${ref} not parseable as JSON` };
     }
@@ -584,7 +769,26 @@ export function read_url(
     if (typeof n !== 'number') {
         return { ok: false, reason: 'registry answer has no metadata.count' };
     }
-    return { ok: true, state: n > 0 ? 'listed' : 'not-listed' };
+    if (n === 0) {
+        return { ok: true, state: 'not-listed' };
+    }
+    const latestVersions: Record<string, string> = {};
+    let flagged = false;
+    for (const entry of Array.isArray(body.servers) ? body.servers : []) {
+        const e = entry as {
+            server?: { name?: unknown; version?: unknown };
+            _meta?: Record<string, { isLatest?: unknown } | undefined>;
+        };
+        const name = e.server?.name;
+        const version = e.server?.version;
+        if (typeof name !== 'string' || typeof version !== 'string') continue;
+        if (e._meta?.[_REGISTRY_META_KEY]?.isLatest !== true) continue;
+        flagged = true;
+        latestVersions[sanitize_text(name).slice(0, 200)] = sanitize_text(version).slice(0, 40);
+    }
+    // No `isLatest` flag anywhere means the answer is not the shape read above;
+    // comparing against an empty map would report a live listing as lost.
+    return flagged ? { ok: true, state: 'listed', latestVersions } : { ok: true, state: 'listed' };
 }
 
 /** Reads the real upstream: `gh` for a pull request, `curl` otherwise. */

package/src/scripts/build_mcp_registry_manifest.ts

@@ -208,31 +208,40 @@ function _render_cf_json(m: JsonObject): string {
     return pyJsonDumps(payload, { indent: 2, sortKeys: true }) + '\n';
 }
 
+/** The registry schema the payload is validated against; its `description` caps at 100 characters. */
+export const SERVER_SCHEMA_URL = 'https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json';
+export const REGISTRY_DESCRIPTION_MAX = 100;
+
 /**
  * Official MCP Registry server.json (registry.modelcontextprotocol.io).
- * Minimal valid shape per the registry's server.schema.json: reverse-DNS
- * name (matches package.json `mcpName` + the README `mcp-name:` marker),
- * the npm package pointer, and the stdio transport. The version is asserted
- * equal to package.json.version by lint_mcp_registry_manifest (CI).
+ * The name matches package.json `mcpName` + the README `mcp-name:` marker; the
+ * description is `agentConfig.registryDescription`, because the npm description
+ * is longer than the registry accepts. The positional `mcp-server` argument is
+ * what makes a registry client start the server instead of the bare CLI.
+ * Version- and length-equality are asserted by lint_mcp_registry_manifest (CI).
  */
-function _render_server_json(m: JsonObject): string {
-    const pkg = m['package'] as JsonObject;
+export function renderServerJson(pkg: JsonObject): string {
     const version = pkg['version'] as string;
+    const agentConfig = (pkg['agentConfig'] as JsonObject | undefined) ?? {};
     const payload: JsonObject = {
-        $schema: 'https://static.modelcontextprotocol.io/schemas/2025-07-09/server.schema.json',
-        name: 'io.github.event4u-app/agent-config',
-        description: pkg['description'],
+        $schema: SERVER_SCHEMA_URL,
+        name: pkg['mcpName'] as string,
+        title: 'agent-config',
+        description: (agentConfig['registryDescription'] as string | undefined) ?? '',
+        websiteUrl: pkg['homepage'] as string,
         repository: {
-            url: pkg['repository'],
+            url: _repo_url(pkg),
             source: 'github',
         },
         version,
         packages: [
             {
                 registryType: 'npm',
-                identifier: '@event4u/agent-config',
+                identifier: pkg['name'] as string,
                 version,
+                runtimeHint: 'npx',
                 transport: { type: 'stdio' },
+                packageArguments: [{ type: 'positional', value: 'mcp-server' }],
             },
         ],
     };
@@ -280,7 +289,9 @@ export function main(argv: readonly string[]): number {
     const manifest_text = pyJsonDumps(manifest, { indent: 2, sortKeys: true }) + '\n';
     const row_md = _render_row_md(manifest);
     const cf_json = _render_cf_json(manifest);
-    const server_json = _render_server_json(manifest);
+    const server_json = renderServerJson(
+        JSON.parse(fs.readFileSync(_config.PKG_FILE, 'utf-8')) as JsonObject,
+    );
 
     const outputs: Array<[string, string]> = [
         [_config.OUT_MANIFEST, manifest_text],

package/src/scripts/check_dependency_floors.ts

@@ -75,6 +75,13 @@ export const SECURITY_FLOOR_EXCEPTIONS: Readonly<Record<string, { required: stri
             'high-severity route-guard bypass via path traversal (CVSS 7.5) affects <=10.1.1; ' +
             '10.1.2 is the fix. Verified with npm audit on a clean 10.1.0 install, 2026-07-31.',
     },
+    zod: {
+        required: '^4.6.6',
+        reason:
+            'high-severity memory exhaustion while validating oversized constrained collections ' +
+            '(GHSA-mrhx-c7xc-m3w5) affects <4.6.6; 4.6.6 is the fix. Verified with npm audit on ' +
+            'clean 4.6.5 (1 high) and 4.6.6 (0) installs, 2026-10-24.',
+    },
 };
 
 /** A settled caret floor: `^X.Y.0`. */

package/src/scripts/check_release_manifest_content.ts

@@ -4,7 +4,7 @@
  * `check_release_pr_shape`.
  *
  * The shape check lets a release PR carry `package.json`, `package-lock.json`
- * and the three plugin manifests, and it reads only their NAMES. Smoke is
+ * and the plugin and extension manifests, and it reads only their NAMES. Smoke is
  * skipped on release heads (`docs/contracts/release-pr-gating.md`), so an added
  * script, a new dependency or a changed `bin` path could ride a release PR with
  * no gate reading it. This compares each manifest against the base and fails on
@@ -27,6 +27,7 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { CONSUMER_IMPACT_VALUES } from './_lib/consumer_impact.js';
+import { PINNED_PACKAGE_ARG_RE } from './_lib/listing_manifests.js';
 import { DeadScopeError, reportScanned } from './_lib/scan_scope.js';
 
 const _HERE = fileURLToPath(import.meta.url);
@@ -43,8 +44,17 @@ export const VERSION_FIELDS: Readonly<Record<string, readonly Pattern[]>> = {
     '.claude-plugin/marketplace.json': [['version'], ['metadata', 'version'], ['plugins', '*', 'version']],
     '.augment-plugin/plugin.json': [['version']],
     '.augment-plugin/marketplace.json': [['version'], ['metadata', 'version'], ['plugins', '*', 'version']],
+    '.github/plugin/plugin.json': [['version'], ['mcpServers', 'agent-config', 'args', '*']],
+    'gemini-extension.json': [['version'], ['mcpServers', 'agent-config', 'args', '*']],
 };
 
+/**
+ * Patterns admitted only as a re-pin: an `npx` argument may move from one
+ * `@event4u/agent-config@X.Y.Z` to another, never to any other string — the
+ * arguments around it are the command a crawler runs.
+ */
+const PINNED_ARG_PATTERN: Pattern = ['mcpServers', 'agent-config', 'args', '*'];
+
 function _matches(p: readonly Segment[], pat: Pattern): boolean {
     if (p.length !== pat.length) return false;
     return pat.every((seg, i) => seg === p[i] || (seg === '*' && /^\d+$/u.test(p[i] ?? '')));
@@ -137,7 +147,12 @@ export function manifestDifferences(file: string, base: string | null, head: str
             before = (before as Record<string, unknown> | undefined)?.[s];
             after = (after as Record<string, unknown> | undefined)?.[s];
         }
-        if (atVersion && typeof before === 'string' && typeof after === 'string') continue;
+        const pinOnly = _matches(p, PINNED_ARG_PATTERN);
+        const inShape =
+            typeof before === 'string' &&
+            typeof after === 'string' &&
+            (!pinOnly || (PINNED_PACKAGE_ARG_RE.test(before) && PINNED_PACKAGE_ARG_RE.test(after)));
+        if (atVersion && inShape) continue;
         out.push(`${file}: ${_render(p)} differs outside the version fields`);
     }
     return out;

package/src/scripts/check_release_pr_shape.ts

@@ -36,6 +36,11 @@ const ALLOWLIST_GLOBS = [
     // the tarball (publish-surface.json roots), so a release PR must carry them.
     '.augment-plugin/plugin.json',
     '.augment-plugin/marketplace.json',
+    // Listing manifests — version and the `npx` pin rewritten by release.ts
+    // set_plugin_manifest_versions; neither ships in the tarball, but a crawler
+    // reads them from the default branch.
+    '.github/plugin/plugin.json',
+    'gemini-extension.json',
     'src/packs/*/pack.yaml',
     'src/packs/*/README.md',
     'src/domains/*/pack.yaml',