Partial overlap path still registers duplicate names

The comment says "warn but still register the novel names", but the code falls through and pushes the unmodified normalized array — which still contains the duplicateNames — to both record.toolNames and registry.tools. As a result the duplicate names end up double-registered in exactly the scenario the warning is meant to describe.

normalized needs to be filtered to only the novel names before the push calls:

Note that normalized must also be changed from const to let for this mutation to compile. Alternatively, introduce a separate const novelNames = ... variable and use it in the two push sites below.

This is a comment left during a code review.
Path: src/plugins/registry.ts
Line: 283-295

Comment:
**Partial overlap path still registers duplicate names**

The comment says "warn but still register the novel names", but the code falls through and pushes the unmodified `normalized` array — which still contains the `duplicateNames` — to both `record.toolNames` and `registry.tools`. As a result the duplicate names end up double-registered in exactly the scenario the warning is meant to describe.

`normalized` needs to be filtered to only the novel names before the push calls:

```suggestion
        // Partial overlap is unexpected; warn but still register the novel names.
        pushDiagnostic({
          level: "warn",
          pluginId: record.id,
          source: record.source,
          message: `tool names already registered by same plugin, skipping duplicates: ${duplicateNames.join(", ")}`,
        });
        // Remove already-registered names so only novel ones are pushed below.
        normalized = normalized.filter((name) => !duplicateNames.includes(name));
      }
    }

    if (normalized.length > 0) {
      record.toolNames.push(...normalized);
    }
```

Note that `normalized` must also be changed from `const` to `let` for this mutation to compile. Alternatively, introduce a separate `const novelNames = ...` variable and use it in the two push sites below.

How can I resolve this? If you propose a fix, please make it concise.

Good catch! Fixed in 783a3b1 — normalized is now let and filtered to exclude duplicateNames before the push calls. The partial-overlap path now correctly only registers novel names.

Deduplicate tool registrations across plugin loader passes

This guard only checks registry.tools inside the current PluginRegistry, so it cannot catch the startup case described in the commit message. In the deferred-channel flow, src/gateway/server.impl.ts:564-571 calls loadGatewayPlugins(..., preferSetupRuntimeForChannelPlugins: true) and then src/gateway/server.impl.ts:1189-1197 calls it again without that flag; src/plugins/loader.ts:689-712 treats those as different cache keys and builds/returns a fresh registry for the second pass. That means the first pass’s tool registrations are never present in registry.tools here, so Feishu-style registerFull() handlers still run twice and the duplicate tool registration/logging problem remains unfixed.

Useful? React with 👍 / 👎.

Valid observation. You're correct that registry.tools is per-registry-instance, so the dedup guard cannot catch cross-registry duplicates from the deferred-channel two-pass flow.

However, after deeper investigation I found that for Feishu specifically, shouldLoadChannelPluginInSetupRuntime() returns false (Feishu has no startupDeferConfiguredChannelFullLoadUntilAfterListen), so it loads in full mode on the first pass. The second loadGatewayPlugins() call at line 1189 only fires when deferredConfiguredChannelPluginIds.length > 0 — which requires another plugin to have startupDeferConfiguredChannelFullLoadUntilAfterListen: true. If no such plugin exists, the second pass never runs.

When it does run, the second pass creates a fresh registry that replaces the first via activatePluginRegistry(), so the final global registry won't contain duplicates from both passes — the first registry is discarded. The observable symptom is duplicate log lines (from registerFull() executing twice), not duplicate tools in the active registry.

This intra-registry dedup still has value as a defensive guard (e.g., a plugin calling api.registerTool() twice in the same registerFull()). A deeper fix at the loader/cache-key level to prevent redundant registerFull() calls across passes would be a separate, higher-risk change. Left unresolved for maintainer judgment.

Handle factory tools that omit explicit registration names

When the same plugin is registered twice, this guard only runs if normalized.length > 0, but for function-based registrations normalized is populated solely from opts.name(s). Several real plugins still register factories without those options — for example extensions/feishu/src/wiki.ts, extensions/feishu/src/drive.ts, extensions/feishu/src/perm.ts, and extensions/lobster/index.ts — so they continue to append duplicate registry.tools entries. resolvePluginTools() then instantiates both entries and drops/logs the second one as a name conflict, which means the double-registration this patch is trying to remove still happens for those tools.

Useful? React with 👍 / 👎.