@zhin.js/adapter-github 6.0.0 → 6.0.1

package/src/client.ts

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import type { PluginDatabaseHost } from 'zhin.js';
+import { defineEndpointClient } from 'zhin.js/adapter';
+import { GhClient } from './gh-client.js';
+import { lookupGithubOauthAccessToken } from './oauth-users.js';
+import type { ResolvedGithubConfig } from './protocol.js';
+import { WorkspaceManager } from './workspace-manager.js';
+
+/** GitHub SDK surface exposed to plugin handlers and Agent tools. */
+export class GithubClient {
+  #workspaceManager?: WorkspaceManager;
+
+  constructor(
+    readonly name: string,
+    readonly api: GhClient,
+    readonly config: ResolvedGithubConfig,
+    readonly database?: PluginDatabaseHost,
+  ) {}
+
+  async getUserOrDefaultApi(platform?: string, platformUid?: string): Promise<GhClient> {
+    if (platform && platformUid) {
+      const token = await lookupGithubOauthAccessToken(this.database, platform, platformUid);
+      if (token) return this.api.withToken(token);
+    }
+    return this.api;
+  }
+
+  get clientId(): string | null {
+    return this.api.clientId || null;
+  }
+
+  get host(): string | undefined {
+    return this.config.host;
+  }
+
+  get appSlug(): string | null {
+    return this.api.appSlug || null;
+  }
+
+  get installations() {
+    return this.api.installations || [];
+  }
+
+  get workspaceManager(): WorkspaceManager {
+    if (!this.#workspaceManager) {
+      const root = this.config.workspaceRoot
+        ?? path.join(process.cwd(), 'data', 'github-workspaces');
+      this.#workspaceManager = new WorkspaceManager(this.api, root);
+    }
+    return this.#workspaceManager;
+  }
+}
+
+export type GithubClientEventMap = Record<string, unknown>;
+
+declare module '@zhin.js/feature-kit' {
+  interface AdapterClientRegistry {
+    readonly github: {
+      readonly client: GithubClient;
+      readonly events: GithubClientEventMap;
+    };
+  }
+}
+
+export const githubClient = defineEndpointClient<GithubClient, GithubClientEventMap>('github');

package/src/endpoint.ts

@@ -1,15 +1,12 @@
+import { Endpoint } from 'zhin.js/adapter';
 /**
  * GithubEndpoint — lifecycle, outbound send, inbound admit.
  */
-import path from 'node:path';
-import type { EndpointInstance, EndpointSendRequest } from 'zhin.js/adapter';
-import type { MessageGateway, SideEventGateway } from '@zhin.js/core/runtime';
+import { type EndpointSendRequest } from 'zhin.js/adapter';
 import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import type { CapabilityId, PluginDatabaseHost } from 'zhin.js';
 import { GhClient } from './gh-client.js';
-import { registerGithubAgentEndpoint } from './github-agent-deps.js';
-import { lookupGithubOauthAccessToken } from './oauth-users.js';
 import {
   enrichInboundContent,
   formatInboundContent,
@@ -20,12 +17,10 @@ import {
   type ResolvedGithubConfig,
 } from './protocol.js';
 import { registerGithubWebhookRoutes } from './webhook.js';
-import { WorkspaceManager } from './workspace-manager.js';
+import { GithubClient } from './client.js';
 
 export interface GithubEndpointOptions {
   readonly id: CapabilityId;
-  readonly gateway: MessageGateway;
-  readonly sideEvents?: SideEventGateway;
   readonly http?: HttpHost;
   readonly database?: PluginDatabaseHost;
   readonly config: ResolvedGithubConfig;
@@ -36,94 +31,49 @@ export interface GithubEndpointOptions {
  * GitHub 是代码协作面（issue/PR），无好友/群/频道等 IM 社交概念，
  * 不适用 EndpointManagement 语义端口；本 endpoint 不暴露该端口。
  */
-export class GithubEndpoint implements EndpointInstance {
+export class GithubEndpoint extends Endpoint<GithubClient> {
   readonly #logger!: ReturnType<typeof getAdapterLogger>;
 
   readonly #options: GithubEndpointOptions;
-  readonly gh: GhClient;
-  readonly config: ResolvedGithubConfig;
-  readonly name: string;
-  #workspaceManager: WorkspaceManager | null = null;
+  readonly client: GithubClient;
   #routeReleases: HttpRouteRegistration[] = [];
   #open = false;
   #started = false;
-  #unregisterAgent?: () => void;
 
   constructor(options: GithubEndpointOptions) {
+    super();
     this.#logger = getAdapterLogger('github', options.config.id);
     this.#options = options;
-    this.config = options.config;
-    this.name = options.config.id;
-    this.gh = options.createClient?.(options.config) ?? defaultCreateClient(options.config);
-  }
-
-  getAPI(): GhClient {
-    return this.gh;
-  }
-
-  async getUserOrDefaultAPI(platform?: string, platformUid?: string): Promise<GhClient | null> {
-    if (platform && platformUid) {
-      const token = await lookupGithubOauthAccessToken(
-        this.#options.database,
-        platform,
-        platformUid,
-      );
-      if (token) return this.gh.withToken(token);
-    }
-    return this.gh;
-  }
-
-  getClientId(): string | null {
-    return this.gh.clientId || null;
-  }
-
-  getHost(): string | undefined {
-    return this.config.host;
-  }
-
-  getAppSlug(): string | null {
-    return this.gh.appSlug || null;
-  }
-
-  getInstallations() {
-    return this.gh.installations || [];
+    const api = options.createClient?.(options.config) ?? defaultCreateClient(options.config);
+    this.client = new GithubClient(options.config.id, api, options.config, options.database);
   }
 
-  getWorkspaceManager(): WorkspaceManager {
-    if (this.#workspaceManager) return this.#workspaceManager;
-    const workspaceRoot = this.config.workspaceRoot
-      ?? path.join(process.cwd(), 'data', 'github-workspaces');
-    this.#workspaceManager = new WorkspaceManager(this.gh, workspaceRoot);
-    return this.#workspaceManager;
-  }
-
-  getDatabase(): PluginDatabaseHost | undefined {
-    return this.#options.database;
+  get config(): ResolvedGithubConfig {
+    return this.client.config;
   }
 
   async start(): Promise<void> {
     if (this.#started) return;
     this.#started = true;
     try {
-      const result = await this.gh.verifyAuth();
+      const result = await this.client.api.verifyAuth();
       if (!result.ok) throw new Error(`GitHub 认证失败: ${result.message}`);
-      this.#unregisterAgent = registerGithubAgentEndpoint(this.name, this);
-      if (this.config.webhookSecret) {
+      if (this.client.config.webhookSecret) {
         if (!this.#options.http) {
           throw new TypeError('GitHub webhook_secret requires httpHostToken');
         }
         this.#routeReleases.push(...registerGithubWebhookRoutes(this.#options.http, this));
         this.#logger.debug(formatCompact({
-          endpoint: this.name,
+          endpoint: this.client.name,
           op: 'webhook',
-          path: this.config.webhookPath,
+          path: this.client.config.webhookPath,
         }));
       } else {
         this.#logger.debug(formatCompact({
-          endpoint: this.name,
+          endpoint: this.client.name,
           op: 'connect',
           mode: 'api-only',
-          bot: this.gh.authenticatedUser,
+          bot: this.client.api.authenticatedUser,
         }));
       }
     } catch (error) {
@@ -144,8 +94,6 @@ export class GithubEndpoint implements EndpointInstance {
   async stop(): Promise<void> {
     this.#open = false;
     for (const release of this.#routeReleases.splice(0)) release();
-    this.#unregisterAgent?.();
-    this.#unregisterAgent = undefined;
     this.#started = false;
     this.#logger.debug(formatCompact({ op: 'disconnect' }));
   }
@@ -155,12 +103,12 @@ export class GithubEndpoint implements EndpointInstance {
     if (!parsed) throw new Error(`无效的 GitHub conversation ID: ${conversation.id}`);
     const text = formatOutboundBody(payload);
     const r = parsed.type === 'issue'
-      ? await this.gh.createIssueComment(parsed.repo, parsed.number, text)
-      : await this.gh.createPRComment(parsed.repo, parsed.number, text);
+      ? await this.client.api.createIssueComment(parsed.repo, parsed.number, text)
+      : await this.client.api.createPRComment(parsed.repo, parsed.number, text);
     if (!r.ok) throw new Error(`发送失败: ${JSON.stringify(r.data)}`);
     this.#logger.debug(formatCompact({
       op: 'github_send',
-      endpoint: this.name,
+      endpoint: this.client.name,
       target: `${conversation.kind}:${conversation.id}`,
       messageId: r.data.id,
     }));
@@ -170,21 +118,23 @@ export class GithubEndpoint implements EndpointInstance {
   /** Test / internal: admit a parsed comment when open. */
   admit(comment: GithubInboundComment): void {
     if (!this.#open) return;
-    const botUser = this.config.botLogin || this.gh.getBotLogin() || this.gh.authenticatedUser;
+    const botUser = this.client.config.botLogin
+      || this.client.api.getBotLogin()
+      || this.client.api.authenticatedUser;
     if (botUser && comment.sender === botUser) return;
     const conversation = githubInboundConversation(String(this.#options.id), comment);
     const content = enrichInboundContent(
       formatInboundContent(comment.content),
-      this.config,
+      this.client.config,
       botUser ?? undefined,
       comment.repo,
     );
-    void this.#options.gateway.receive({
+    void this.emit('message.receive', {
       conversation,
       message: { conversation, id: comment.id },
       content,
       sender: { id: comment.sender, name: comment.sender },
-      endpointId: this.name,
+      endpointId: this.client.name,
       metadata: Object.freeze({
         repo: comment.repo,
         kind: comment.kind,
@@ -198,6 +148,17 @@ export class GithubEndpoint implements EndpointInstance {
       }));
     });
   }
+
+  admitPlatform(name: string, event: unknown): void {
+    if (!this.#open) return;
+    void this.emitPlatform(name, event).catch((error) => {
+      this.#logger.warn(formatCompact({
+        op: 'github_platform_event_failed',
+        event: name,
+        error: error instanceof Error ? error.message : String(error),
+      }));
+    });
+  }
 }
 
 export function defaultCreateClient(config: ResolvedGithubConfig): GhClient {

package/src/github-bot-handlers.ts

@@ -3,15 +3,15 @@
  */
 import type { Message } from 'zhin.js';
 import { getCurrentCommMessage } from '@zhin.js/agent/security';
-import { getAdapter, getGithubAgentDeps } from './github-agent-deps.js';
+import type { GithubClient } from './client.js';
 import {
   parseMessageChannel,
   resolveWorkspaceBranch,
   formatChannelContext,
 } from './github-channel-context.js';
 
-function requireBotGh() {
-  const gh = getAdapter().getAPI();
+function requireBotGh(client: GithubClient) {
+  const gh = client.api;
   if (!gh?.isAppAuth) {
     throw new Error('需要 GitHub App 认证（app_id + private_key），Bot 写操作不可用');
   }
@@ -35,12 +35,13 @@ function resolveChannel(msg: Message, repo?: string) {
 
 export async function executeGithubPrepareWorkspace(
   args: { repo?: string },
+  client: GithubClient,
   commMessage?: Message,
 ) {
   const msg = resolveCommMessage(commMessage);
   const ctx = resolveChannel(msg, args.repo);
-  const gh = requireBotGh();
-  const wm = getGithubAgentDeps().getWorkspaceManager();
+  const gh = requireBotGh(client);
+  const wm = client.workspaceManager;
   const { branch, base } = await resolveWorkspaceBranch(gh, ctx);
   const repoPath = await wm.checkoutBranch(ctx.repo, branch, base);
   return [
@@ -53,11 +54,12 @@ export async function executeGithubPrepareWorkspace(
 
 export async function executeGithubPatchFile(
   args: { repo?: string; path: string; content: string; message: string; branch?: string },
+  client: GithubClient,
   commMessage?: Message,
 ) {
   const msg = resolveCommMessage(commMessage);
   const ctx = resolveChannel(msg, args.repo);
-  const gh = requireBotGh();
+  const gh = requireBotGh(client);
   const { branch } = args.branch
     ? { branch: args.branch }
     : await resolveWorkspaceBranch(gh, ctx);
@@ -80,12 +82,13 @@ export async function executeGithubPatchFile(
 
 export async function executeGithubPushBranch(
   args: { repo?: string; branch?: string; message: string },
+  client: GithubClient,
   commMessage?: Message,
 ) {
   const msg = resolveCommMessage(commMessage);
   const ctx = resolveChannel(msg, args.repo);
-  const gh = requireBotGh();
-  const wm = getGithubAgentDeps().getWorkspaceManager();
+  const gh = requireBotGh(client);
+  const wm = client.workspaceManager;
   const branch = args.branch ?? (await resolveWorkspaceBranch(gh, ctx)).branch;
   const result = await wm.commitAndPush(ctx.repo, branch, args.message);
   return `✅ ${result}\n📍 ${ctx.repo} @ \`${branch}\``;
@@ -93,11 +96,12 @@ export async function executeGithubPushBranch(
 
 export async function executeGithubCreatePr(
   args: { repo?: string; title: string; body?: string; head?: string; base?: string },
+  client: GithubClient,
   commMessage?: Message,
 ) {
   const msg = resolveCommMessage(commMessage);
   const ctx = resolveChannel(msg, args.repo);
-  const gh = requireBotGh();
+  const gh = requireBotGh(client);
   const resolved = await resolveWorkspaceBranch(gh, ctx);
   const head = args.head ?? resolved.branch;
   const base = args.base ?? resolved.base;

package/src/github-tool-handlers.ts

@@ -3,10 +3,10 @@ import type { Message } from 'zhin.js';
 import { getCurrentCommMessage } from '@zhin.js/agent/security';
 import { GhClient } from './gh-client.js';
 import type { EventType } from './types.js';
-import { getAdapter, getGithubAgentDeps } from './github-agent-deps.js';
+import type { GithubClient } from './client.js';
 
-function oauthModel() {
-  const db = getGithubAgentDeps().getDatabase?.() as {
+function oauthModel(client: GithubClient) {
+  const db = client.database as {
     models?: Map<string, unknown>;
   } | null | undefined;
   return db?.models?.get('github_oauth_users') as {
@@ -16,8 +16,8 @@ function oauthModel() {
   } | undefined;
 }
 
-function subscriptionsModel() {
-  const db = getGithubAgentDeps().getDatabase?.() as {
+function subscriptionsModel(client: GithubClient) {
+  const db = client.database as {
     models?: Map<string, unknown>;
   } | null | undefined;
   return db?.models?.get('github_subscriptions') as {
@@ -29,18 +29,16 @@ function subscriptionsModel() {
 }
 
 function depsLogger() {
-  return getGithubAgentDeps().logger ?? {
+  return {
     debug: (...args: unknown[]) => console.debug(...args),
     warn: (...args: unknown[]) => console.warn(...args),
     error: (...args: unknown[]) => console.error(...args),
   };
 }
 
-export async function executeGithubStar(args: { action: 'star' | 'unstar' | 'check'; repo: string }, commMessage?: Message) {
-  const adapter = getAdapter();
+export async function executeGithubStar(args: { action: 'star' | 'unstar' | 'check'; repo: string }, client: GithubClient, commMessage?: Message) {
   const msg = commMessage ?? getCurrentCommMessage();
-  const gh = await adapter.getUserOrDefaultAPI(msg?.$adapter, msg?.$sender.id);
-  if (!gh) return '❌ 没有可用的 GitHub bot';
+  const gh = await client.getUserOrDefaultApi(msg?.$adapter, msg?.$sender.id);
   switch (args.action) {
     case 'star': {
       const r = await gh.starRepo(args.repo);
@@ -59,16 +57,15 @@ export async function executeGithubStar(args: { action: 'star' | 'unstar' | 'che
   }
 }
 
-export async function executeGithubBind(_args: Record<string, never>, commMessage?: Message) {
-  const adapter = getAdapter();
+export async function executeGithubBind(_args: Record<string, never>, client: GithubClient, commMessage?: Message) {
   const log = depsLogger();
   const msg = commMessage ?? getCurrentCommMessage();
   if (!msg?.$adapter || !msg?.$sender?.id) return '❌ 无法获取当前用户信息';
 
-  const clientId = adapter.getClientId();
+  const clientId = client.clientId;
   if (!clientId) return '❌ Endpoint 未配置 GitHub App 或 App 无 client_id，无法进行账号绑定';
 
-  const model = oauthModel();
+  const model = oauthModel(client);
   if (!model) return '❌ 数据库未就绪';
 
   const [existing] = await model.select().where({ platform: msg.$adapter, platform_uid: msg.$sender.id });
@@ -77,7 +74,7 @@ export async function executeGithubBind(_args: Record<string, never>, commMessag
   }
 
   try {
-    const host = adapter.getHost();
+    const host = client.host;
     const codeResp = await GhClient.deviceFlowRequestCode(clientId, host);
     const tokenPromise = GhClient.deviceFlowPollToken(
       clientId, codeResp.device_code, codeResp.interval, codeResp.expires_in, host,
@@ -125,11 +122,11 @@ export async function executeGithubBind(_args: Record<string, never>, commMessag
   }
 }
 
-export async function executeGithubUnbind(_args: Record<string, never>, commMessage?: Message) {
+export async function executeGithubUnbind(_args: Record<string, never>, client: GithubClient, commMessage?: Message) {
   const msg = commMessage ?? getCurrentCommMessage();
   if (!msg?.$adapter || !msg?.$sender?.id) return '❌ 无法获取当前用户信息';
 
-  const model = oauthModel();
+  const model = oauthModel(client);
   if (!model) return '❌ 数据库未就绪';
 
   const [existing] = await model.select().where({ platform: msg.$adapter, platform_uid: msg.$sender.id });
@@ -139,18 +136,17 @@ export async function executeGithubUnbind(_args: Record<string, never>, commMess
   return `✅ 已解除 GitHub 账号绑定: ${existing.github_login}`;
 }
 
-export async function executeGithubWhoami(_args: Record<string, never>, commMessage?: Message) {
-  const adapter = getAdapter();
+export async function executeGithubWhoami(_args: Record<string, never>, client: GithubClient, commMessage?: Message) {
   const msg = commMessage ?? getCurrentCommMessage();
   if (!msg?.$adapter || !msg?.$sender?.id) return '❌ 无法获取当前用户信息';
 
-  const model = oauthModel();
+  const model = oauthModel(client);
   if (!model) return '❌ 数据库未就绪';
 
   const [existing] = await model.select().where({ platform: msg.$adapter, platform_uid: msg.$sender.id });
   if (!existing) return '📭 你尚未绑定 GitHub 账号\n🔗 使用 github_bind 绑定你的账号';
 
-  const userGh = new GhClient({ host: adapter.getHost(), token: existing.access_token });
+  const userGh = new GhClient({ host: client.host, token: existing.access_token });
   const auth = await userGh.verifyAuth();
   if (auth.ok) {
     return `👤 已绑定 GitHub 账号: ${auth.user}\n📅 绑定时间: ${new Date(existing.created_at).toLocaleString('zh-CN')}`;
@@ -158,12 +154,11 @@ export async function executeGithubWhoami(_args: Record<string, never>, commMess
   return `⚠️ 已绑定账号 ${existing.github_login}，但 Token 已失效\n🔗 请执行 github_unbind 后重新 github_bind`;
 }
 
-export async function executeGithubInstall() {
-  const adapter = getAdapter();
-  const slug = adapter.getAppSlug();
+export async function executeGithubInstall(client: GithubClient) {
+  const slug = client.appSlug;
   if (!slug) return '❌ Endpoint 未配置 GitHub App';
-  const host = adapter.getHost() || 'github.com';
-  const installations = adapter.getInstallations();
+  const host = client.host || 'github.com';
+  const installations = client.installations;
   let msg = `🔗 请点击以下链接安装 GitHub App 到你的仓库：\n   https://${host}/apps/${slug}/installations/new`;
   if (installations.length) {
     msg += `\n\n📋 当前已安装 (${installations.length}):`;
@@ -174,13 +169,13 @@ export async function executeGithubInstall() {
   return msg;
 }
 
-export async function executeGithubSubscribe(args: { repo: string; events?: string }, commMessage?: Message) {
+export async function executeGithubSubscribe(args: { repo: string; events?: string }, client: GithubClient, commMessage?: Message) {
   const msg = commMessage ?? getCurrentCommMessage();
   if (!msg?.$adapter || !msg?.$sender.id || !msg?.$channel?.id || !msg?.$endpoint) {
     return '❌ 无法获取当前聊天通道信息';
   }
 
-  const model = subscriptionsModel();
+  const model = subscriptionsModel(client);
   if (!model) return '❌ 数据库未就绪';
 
   const validEvents: EventType[] = ['push', 'issue', 'star', 'fork', 'unstar', 'pull_request'];
@@ -212,13 +207,13 @@ export async function executeGithubSubscribe(args: { repo: string; events?: stri
   return `✅ 已订阅 ${args.repo}\n📡 事件: ${events.join(', ')}\n📌 通知将推送到当前通道`;
 }
 
-export async function executeGithubUnsubscribe(args: { repo: string }, commMessage?: Message) {
+export async function executeGithubUnsubscribe(args: { repo: string }, client: GithubClient, commMessage?: Message) {
   const msg = commMessage ?? getCurrentCommMessage();
   if (!msg?.$adapter || !msg?.$channel?.id || !msg?.$endpoint) {
     return '❌ 无法获取当前聊天通道信息';
   }
 
-  const model = subscriptionsModel();
+  const model = subscriptionsModel(client);
   if (!model) return '❌ 数据库未就绪';
 
   const [existing] = await model.select().where({
@@ -233,13 +228,13 @@ export async function executeGithubUnsubscribe(args: { repo: string }, commMessa
   return `✅ 已取消订阅 ${args.repo}`;
 }
 
-export async function executeGithubSubscriptions(_args: Record<string, never>, commMessage?: Message) {
+export async function executeGithubSubscriptions(_args: Record<string, never>, client: GithubClient, commMessage?: Message) {
   const msg = commMessage ?? getCurrentCommMessage();
   if (!msg?.$adapter || !msg?.$channel?.id || !msg?.$endpoint) {
     return '❌ 无法获取当前聊天通道信息';
   }
 
-  const model = subscriptionsModel();
+  const model = subscriptionsModel(client);
   if (!model) return '❌ 数据库未就绪';
 
   const subs = await model.select().where({

package/src/index.ts

@@ -20,16 +20,8 @@ export {
 
 export * from './types.js';
 
-export {
-  getAdapter,
-  getGithubAgentDeps,
-  registerGithubAgentEndpoint,
-  setGithubAgentDeps,
-  type GithubAgentDeps,
-  type GithubAgentEndpoint,
-} from './github-agent-deps.js';
-
 export { GhClient } from './gh-client.js';
+export { GithubClient, githubClient, type GithubClientEventMap } from './client.js';
 export { WorkspaceManager } from './workspace-manager.js';
 export {
   parseMessageChannel,

package/src/protocol.ts

@@ -206,7 +206,7 @@ export function enrichInboundContent(
   return `@${login} ${content}`;
 }
 
-/** Build inbound text for MessageGateway.receive from markdown/comment body. */
+/** Build inbound text for OutboundMessageService.receive from markdown/comment body. */
 export function formatInboundContent(body: string): string {
   return body;
 }

package/src/webhook.ts

@@ -22,6 +22,7 @@ const logger = getLogger('github');
 
 export interface GithubWebhookHandler {
   readonly config: ResolvedGithubConfig;
+  admitPlatform(name: string, event: unknown): void;
   admit(comment: GithubInboundComment): void;
 }
 
@@ -106,6 +107,10 @@ export async function dispatchGithubWebhookPayload(
   const body = payload as Record<string, unknown>;
   const repo = (body.repository as { full_name?: string } | undefined)?.full_name;
   logger.debug(`Webhook: ${event}${(body.action as string) ? `.${body.action}` : ''} ${repo || ''}`);
+  handler.admitPlatform(
+    typeof body.action === 'string' && body.action ? `${event}.${body.action}` : event,
+    payload,
+  );
 
   if (event === 'issue_comment') {
     const inbound = parseIssueCommentInbound(payload as IssueCommentPayload);

package/lib/agent-prompt.d.ts

@@ -1,2 +0,0 @@
-import type { AgentPromptContributor } from 'zhin.js';
-export declare function createGithubAgentPromptContributor(): AgentPromptContributor;

package/lib/agent-prompt.js

@@ -1,84 +0,0 @@
-import { filterTools } from 'zhin.js/ai';
-function selectGithubDeferredTools(query, goal, deferredCatalog, maxTools) {
-    const pool = deferredCatalog.filter(t => !t.name.startsWith('mcp_filesystem') && !t.name.startsWith('mcp_icqq_'));
-    const pinned = [];
-    const bash = pool.find(t => t.name === 'bash');
-    if (bash)
-        pinned.push(bash);
-    const preferNames = [
-        ...pool.filter(t => t.name.startsWith('github_')).map(t => t.name),
-        ...pool.filter(t => t.name.startsWith('mcp_github_')).map(t => t.name),
-    ];
-    for (const name of preferNames) {
-        if (pinned.length >= maxTools)
-            break;
-        const t = pool.find(x => x.name === name);
-        if (t && !pinned.some(p => p.name === name))
-            pinned.push(t);
-    }
-    const extra = filterTools(`${query} ${goal}`, pool, { maxTools, minScore: 0.08 })
-        .map((t) => ({ name: t.name, description: t.description }));
-    const merged = [...pinned];
-    for (const t of extra) {
-        if (merged.length >= maxTools)
-            break;
-        if (!merged.some(p => p.name === t.name))
-            merged.push(t);
-    }
-    return merged.slice(0, maxTools);
-}
-function isGithubDelegatedTask(query, goal) {
-    const text = `${query} ${goal}`;
-    return /github|gh_|mcp_github|\bissue\b|pull\s*request|\bpr\b/i.test(text);
-}
-const ORCHESTRATOR_GITHUB = [
-    'On GitHub: use run_deferred_task with tool_query "github_".',
-    'Discuss issues/PRs in chat context; do not call github_* tools on this orchestrator.',
-    'Bot write operations use github_* tools (Installation Token), not mcp_github_*.',
-].join('\n');
-const WORKER_GITHUB = [
-    'Use github_prepare_workspace before multi-file edits in a repo.',
-    'Small single-file change: github_patch_file (Contents API).',
-    'Multi-file / tests: workspace + bash, then github_push_branch (requires approval) and github_create_pr for Issues.',
-    'Issue thread: new branch + new PR. PR thread: push to existing PR head branch.',
-    'Do NOT use mcp_github_* for writes — PAT acts as human, not Bot.',
-    'Summarize outcomes (PR link, branch) for the orchestrator.',
-].map(line => `- ${line}`).join('\n');
-export function createGithubAgentPromptContributor() {
-    return {
-        platform: 'github',
-        async buildSections(ctx) {
-            if (ctx.slot === 'orchestrator') {
-                return [{
-                        id: 'platform.github.orchestrator',
-                        title: '## GitHub',
-                        body: ORCHESTRATOR_GITHUB,
-                        priority: 50,
-                    }];
-            }
-            if (ctx.slot === 'deferred_worker') {
-                const query = ctx.deferred?.toolQuery ?? ctx.deferred?.goal ?? '';
-                const goal = ctx.deferred?.goal ?? '';
-                if (!isGithubDelegatedTask(query, goal))
-                    return null;
-                return [{
-                        id: 'platform.github.deferred_worker',
-                        title: '## GitHub（本任务）',
-                        body: WORKER_GITHUB,
-                        priority: 50,
-                    }];
-            }
-            return null;
-        },
-        matchesDeferredTask(ctx) {
-            const query = ctx.deferred?.toolQuery ?? ctx.deferred?.goal ?? ctx.userMessagePreview ?? '';
-            const goal = ctx.deferred?.goal ?? ctx.userMessagePreview ?? '';
-            return isGithubDelegatedTask(query, goal);
-        },
-        selectDeferredTools(query, goal, catalog, maxTools) {
-            if (!isGithubDelegatedTask(query, goal))
-                return null;
-            return selectGithubDeferredTools(query, goal, catalog, maxTools);
-        },
-    };
-}