ework-qq-bridge 0.2.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-qq-bridge",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "QQ group <-> ework issue bridge (OneBot 11 reverse WebSocket)",
   "type": "module",
   "main": "src/index.ts",

package/src/bindings.ts

@@ -0,0 +1,69 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { dirname } from "node:path";
+import type { GroupBinding } from "./config";
+
+// Runtime issue pins: group -> issue number, persisted across restarts.
+// owner/repo always come from the static GROUP_MAP entry; the pin only
+// narrows which single issue the group is bound to.
+type PinFile = Record<string, number>;
+
+export class BindingStore {
+  private pins = new Map<number, number>();
+
+  constructor(private base: GroupBinding[], private file: string) {
+    try {
+      if (existsSync(file)) {
+        const raw = JSON.parse(readFileSync(file, "utf8")) as PinFile;
+        for (const [k, v] of Object.entries(raw)) {
+          if (Number.isInteger(Number(k)) && Number.isInteger(v)) {
+            this.pins.set(Number(k), v);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn(`[qq-bridge] bindings file unreadable, starting clean: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  private persist(): void {
+    const out: PinFile = {};
+    for (const [g, n] of this.pins) out[String(g)] = n;
+    try {
+      mkdirSync(dirname(this.file), { recursive: true });
+      writeFileSync(this.file, JSON.stringify(out, null, 2) + "\n");
+    } catch (err) {
+      console.error(`[qq-bridge] failed to persist bindings: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  resolve(groupId: number): GroupBinding | null {
+    const base = this.base.find((b) => b.groupId === groupId);
+    if (!base) return null;
+    const pinned = this.pins.get(groupId);
+    if (pinned === undefined) return base;
+    return { ...base, issue: pinned };
+  }
+
+  all(): GroupBinding[] {
+    return this.base.map((b) => this.resolve(b.groupId)!);
+  }
+
+  groupsFor(owner: string, repo: string, issueNumber: number): number[] {
+    return this.all()
+      .filter((b) => b.owner === owner && b.repo === repo && (b.issue === undefined || b.issue === issueNumber))
+      .map((b) => b.groupId);
+  }
+
+  pin(groupId: number, issue: number): GroupBinding | null {
+    if (!this.base.some((b) => b.groupId === groupId)) return null;
+    this.pins.set(groupId, issue);
+    this.persist();
+    return this.resolve(groupId);
+  }
+
+  unpin(groupId: number): boolean {
+    if (!this.pins.delete(groupId)) return false;
+    this.persist();
+    return true;
+  }
+}

package/src/config.ts

@@ -16,10 +16,15 @@ const Schema = z.object({
   // comment events here so agent replies can be pushed back to the group.
   EWORK_WEBHOOK_SECRET: z.string().default(""),
 
-  // group_id -> owner/repo mapping. Comma-separated:
-  //   "123456789:ranxianglei/billion-context,987654321:dog/test1"
+  // group_id -> owner/repo mapping, optionally pinned to one issue:
+  //   "123456789:ranxianglei/billion-context#7,987654321:dog/test1"
+  // A `#N` suffix binds the group to that single issue (long-memory mode);
+  // without it the group gets all agent replies from the whole repo.
   GROUP_MAP: z.string().min(1),
 
+  // Runtime pin overrides written by the 绑定/解绑 commands (JSON, group -> issue).
+  WORK_BINDINGS_FILE: z.string().default(""),
+
   // QQ user_ids allowed to dispatch AI work (comma-separated). Messages from
   // other members are logged and ignored — same trust model as the GitHub
   // side (WORK_WAKE_LOGINS): strangers never wake the AI.
@@ -36,14 +41,6 @@ const Schema = z.object({
 
   DB_PATH: z.string().default(""),
 
-  // Chat mode (instant Q&A). When WORK_CHAT_API is set, @bot messages without
-  // a recognized command are answered directly by the LLM instead of usage
-  // help. Empty = chat mode disabled.
-  WORK_CHAT_API: z.string().default(""),
-  WORK_CHAT_API_KEY: z.string().default("sk-vllm"),
-  WORK_CHAT_MODEL: z.string().default("qwen3.8-27b"),
-  WORK_CHAT_TIMEOUT_MS: z.coerce.number().int().positive().default(90_000),
-  WORK_CHAT_MAX_HISTORY: z.coerce.number().int().positive().default(20),
 
   VERBOSE: z.coerce.boolean().default(false),
 
@@ -58,6 +55,7 @@ export interface GroupBinding {
   groupId: number;
   owner: string;
   repo: string;
+  issue?: number;
 }
 
 export function parseGroupMap(raw: string): GroupBinding[] {
@@ -65,11 +63,11 @@ export function parseGroupMap(raw: string): GroupBinding[] {
   for (const part of raw.split(",")) {
     const item = part.trim();
     if (!item) continue;
-    const m = /^(\d+):([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(item);
+    const m = /^(\d+):([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:#(\d+))?$/.exec(item);
     if (!m?.[1] || !m[2] || !m[3]) {
       throw new Error(`invalid GROUP_MAP entry: ${item}`);
     }
-    out.push({ groupId: Number(m[1]), owner: m[2], repo: m[3] });
+    out.push(m[4] ? { groupId: Number(m[1]), owner: m[2], repo: m[3], issue: Number(m[4]) } : { groupId: Number(m[1]), owner: m[2], repo: m[3] });
   }
   if (out.length === 0) throw new Error("GROUP_MAP must define at least one group");
   return out;
@@ -92,5 +90,8 @@ export function loadConfig(): Config {
   if (!cfg.DB_PATH) {
     cfg.DB_PATH = `${process.env.HOME ?? "/tmp"}/.ework-qq-bridge/qq-bridge.db`;
   }
+  if (!cfg.WORK_BINDINGS_FILE) {
+    cfg.WORK_BINDINGS_FILE = `${process.env.HOME ?? "/tmp"}/.ework-qq-bridge/bindings.json`;
+  }
   return cfg;
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 import { loadConfig, parseGroupMap, parseList } from "./config";
 import { BridgeStore } from "./db";
+import { BindingStore } from "./bindings";
 import { createOneBotServer, type OneBotApi, type GroupMessageEvent } from "./onebot";
 import { createRouter } from "./router";
 import { createIngest } from "./ingest";
@@ -14,9 +15,7 @@ async function main() {
 }
 const store = new BridgeStore(cfg.DB_PATH || "/tmp/ework-qq-bridge.db");
 
-  const bindings = parseGroupMap(cfg.GROUP_MAP);
-  const groupIdOfProject = new Map<string, number>();
-  for (const b of bindings) groupIdOfProject.set(`${b.owner}/${b.repo}`, b.groupId);
+  const bindings = new BindingStore(parseGroupMap(cfg.GROUP_MAP), cfg.WORK_BINDINGS_FILE);
 
   let api: OneBotApi | null = null;
   const send = async (groupId: number, text: string) => {
@@ -40,7 +39,7 @@ const store = new BridgeStore(cfg.DB_PATH || "/tmp/ework-qq-bridge.db");
     bridgeLogin: cfg.BRIDGE_LOGIN,
     agentLogins: new Set(parseList(cfg.AGENT_LOGINS)),
     scrub,
-    projectOf: (owner, repo) => groupIdOfProject.get(`${owner}/${repo}`) ?? null,
+    groupsFor: (owner, repo, number) => bindings.groupsFor(owner, repo, number),
     commentForwarded: (id) => store.commentForwarded(id),
     send,
   });

package/src/ingest.ts

@@ -14,7 +14,7 @@ interface IngestDeps {
   bridgeLogin: string;
   agentLogins: Set<string>;
   scrub: (text: string) => string;
-  projectOf(owner: string, repo: string): number | null;
+  groupsFor(owner: string, repo: string, number: number): number[];
   commentForwarded(commentId: number): boolean;
   send(groupId: number, text: string): Promise<void>;
 }
@@ -85,8 +85,8 @@ export function createIngest(deps: IngestDeps) {
     if (body.startsWith("[system]") || body.startsWith("[SYSTEM ")) return new Response("skipped:system", { status: 200 });
     if (!deps.agentLogins.has(author)) return new Response("skipped:non-agent", { status: 200 });
 
-    const groupId = deps.projectOf(owner, String(repo.name));
-    if (groupId === null) return new Response("skipped:unmapped", { status: 200 });
+    const groups = deps.groupsFor(owner, String(repo.name), number);
+    if (groups.length === 0) return new Response("skipped:unmapped", { status: 200 });
     if (!Number.isInteger(commentId) || deps.commentForwarded(commentId)) {
       return new Response("skipped:dup", { status: 200 });
     }
@@ -97,7 +97,7 @@ export function createIngest(deps: IngestDeps) {
     }
     const text = deps.scrub(`[#${number}] ${body}`);
     try {
-      await deps.send(groupId, text);
+      for (const groupId of groups) await deps.send(groupId, text);
     } catch (err) {
       console.error(`[qq-bridge] send_group_msg failed: ${err instanceof Error ? err.message : err}`);
       return new Response("send failed", { status: 502 });

package/src/onebot.ts

@@ -59,11 +59,15 @@ export function createOneBotServer(opts: OneBotServerOptions) {
   const pending = new Map<string, PendingEntry>();
   let ws: ServerWebSocket<unknown> | null = null;
 
-  function rejectAll(reason: string) {
+  function drainPending(reason: string) {
     for (const [, entry] of pending) {
       entry.reject(new Error(reason));
     }
     pending.clear();
+  }
+
+  function rejectAll(reason: string) {
+    drainPending(reason);
     ws = null;
   }
 
@@ -75,11 +79,12 @@ export function createOneBotServer(opts: OneBotServerOptions) {
     // Bun handlers: wire these into Bun.serve({websocket:{...}})
     handlers: {
       open(client: ServerWebSocket<unknown>) {
-        if (ws) {
-          client.close(4000, "duplicate connection");
-          return;
-        }
+        // A fresh connect means the peer restarted: the old socket is dead or
+        // dying (TCP may not have noticed yet). Supersede it, never reject
+        // the newcomer, or reconnects stall behind zombie sockets.
+        if (ws) ws.close(4001, "superseded by new connection");
         ws = client;
+        drainPending("superseded by new connection");
         const api: OneBotApi = {
           call(action, params) {
             const echo = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;

package/src/router.ts

@@ -1,20 +1,22 @@
-import type { GroupBinding, Config } from "./config";
+import type { Config } from "./config";
 import type { EworkClient } from "./ework";
 import type { GroupMessageEvent } from "./onebot";
 import type { BridgeStore } from "./db";
-import { buildChatMessages, chatComplete, splitForQQ, type ChatTurn } from "./chat";
+import type { BindingStore } from "./bindings";
 
 const HELP_TEXT = [
   "用法：",
-  "  任务 <标题> —— 新建 issue，AI 自动接单",
+  "  任务 <标题> —— 新建 issue 并接单（本群已绑定时：新建并换绑到新 issue）",
   "  #<编号> <内容> —— 给指定 issue 追加内容",
+  "  绑定 #<编号> —— 把本群绑定到该 issue（长记忆模式：此后发言都进这个 issue）",
+  "  解绑 —— 恢复为项目模式（接收整个项目的回复）",
   "  查询 —— 列出最近 issue",
-  "  @我 + 任意问题 —— 即时问答（不建 issue）",
+  "  （绑定后：@我 和普通发言等效，都进入绑定的 issue，AI 回复自动回群）",
 ].join("\n");
 
 export interface RouterDeps {
   cfg: Config;
-  bindings: GroupBinding[];
+  bindings: BindingStore;
   wakeList: Set<string>;
   ework: EworkClient;
   store: BridgeStore;
@@ -22,7 +24,7 @@ export interface RouterDeps {
 }
 
 interface ParsedCommand {
-  kind: "create" | "comment" | "help";
+  kind: "create" | "comment" | "bind" | "unbind" | "help";
   title?: string;
   number?: number;
   body?: string;
@@ -32,6 +34,9 @@ export function parseCommand(raw: string): ParsedCommand | null {
   const text = raw.trim();
   const stripped = text.replace(/^\[CQ:at,qq=\d+\]\s*/, "").trim();
   if (stripped === "帮助" || stripped === "help" || stripped === "查询") return { kind: "help" };
+  const bind = /^绑定\s*#(\d{1,6})$/.exec(stripped) ?? /^绑定\s*#(\d{1,6})$/.exec(text);
+  if (bind?.[1]) return { kind: "bind", number: Number(bind[1]) };
+  if (stripped === "解绑" || stripped === "unbind") return { kind: "unbind" };
   const create = /^(?:任务|task|新任务)\s+(.+)$/i.exec(stripped) ?? /^(?:任务|task|新任务)\s+(.+)$/i.exec(text);
   if (create?.[1]) return { kind: "create", title: create[1].trim() };
   const comment = /^#(\d{1,6})\s+([\s\S]+)$/.exec(stripped) ?? /^#(\d{1,6})\s+([\s\S]+)$/.exec(text);
@@ -41,27 +46,9 @@ export function parseCommand(raw: string): ParsedCommand | null {
 
 export function createRouter(deps: RouterDeps) {
   const { cfg, bindings, wakeList, ework, store } = deps;
-  const chatHistory = new Map<number, ChatTurn[]>();
-
-  async function answerChat(ev: GroupMessageEvent, question: string): Promise<void> {
-    const turn: ChatTurn = { role: "user", name: ev.nickname, content: question };
-    const history = chatHistory.get(ev.groupId) ?? [];
-    const messages = buildChatMessages(history, turn, cfg.WORK_CHAT_MAX_HISTORY);
-    const answer = await chatComplete(cfg.WORK_CHAT_API, cfg.WORK_CHAT_API_KEY, cfg.WORK_CHAT_MODEL, messages, cfg.WORK_CHAT_TIMEOUT_MS);
-    history.push(turn, { role: "assistant", name: "bot", content: answer });
-    if (history.length > cfg.WORK_CHAT_MAX_HISTORY * 2) {
-      chatHistory.set(ev.groupId, history.slice(-cfg.WORK_CHAT_MAX_HISTORY * 2));
-    } else {
-      chatHistory.set(ev.groupId, history);
-    }
-    for (const part of splitForQQ(answer)) {
-      await deps.reply(ev.groupId, part);
-    }
-  }
-
   async function handleGroupMessage(ev: GroupMessageEvent): Promise<void> {
     if (store.seenPost(ev.postId)) return;
-    const binding = bindings.find((b) => b.groupId === ev.groupId);
+    const binding = bindings.resolve(ev.groupId);
     if (!binding) return;
 
     if (!wakeList.has(String(ev.userId))) {
@@ -69,24 +56,21 @@ export function createRouter(deps: RouterDeps) {
       return;
     }
 
-    const atBot = ev.rawMessage.includes("[CQ:at,qq=") || /^\s*(任务|task|新任务|#|帮助|help|查询)/.test(ev.rawMessage);
+    const atBot = ev.rawMessage.includes("[CQ:at,qq=") || /^\s*(任务|task|新任务|#|绑定|解绑|帮助|help|查询)/.test(ev.rawMessage);
     const cmd = parseCommand(ev.rawMessage);
-    if (!cmd && !atBot) {
-      if (cfg.VERBOSE) console.log(`[qq-bridge] unrecognized message from ${ev.userId}: ${ev.rawMessage.slice(0, 80)}`);
-      return;
-    }
     if (!cmd) {
-      const question = ev.rawMessage.replace(/\[CQ:[^\]]*\]/g, "").trim();
-      if (cfg.WORK_CHAT_API && question) {
-        try {
-          await answerChat(ev, question);
-        } catch (err) {
-          console.error(`[qq-bridge] chat failed: ${err instanceof Error ? err.message : err}`);
-          await deps.reply(ev.groupId, "🤖 回答失败了，稍后再试一次。");
+      if (binding.issue !== undefined) {
+        const text = ev.rawMessage.replace(/\[CQ:[^\]]*\]/g, "").trim();
+        if (text) {
+          await ework.addComment(binding.owner, binding.repo, binding.issue, `> 来自 QQ 群用户 **${ev.nickname}** (${ev.userId})\n\n${text}`);
         }
         return;
       }
-      await deps.reply(ev.groupId, "没看懂指令。\n" + HELP_TEXT);
+      if (atBot) {
+        await deps.reply(ev.groupId, "本群还没绑定 issue。发「绑定 #<编号>」绑定已有任务，或「任务 <标题>」新建并自动绑定。");
+        return;
+      }
+      if (cfg.VERBOSE) console.log(`[qq-bridge] ignore non-command message from ${ev.userId}`);
       return;
     }
     if (cmd.kind === "help") {
@@ -97,9 +81,25 @@ export function createRouter(deps: RouterDeps) {
     const attribution = `> 来自 QQ 群用户 **${ev.nickname}** (${ev.userId})`;
 
     try {
+      if (cmd.kind === "bind" && cmd.number !== undefined) {
+        const pinned = bindings.pin(ev.groupId, cmd.number);
+        if (!pinned) {
+          await deps.reply(ev.groupId, "❌ 本群没有配置项目映射，无法绑定");
+          return;
+        }
+        await deps.reply(ev.groupId, `📌 本群已绑定 ${pinned.owner}/${pinned.repo}#${cmd.number}，之后的发言都会进这个 issue`);
+        return;
+      }
+      if (cmd.kind === "unbind") {
+        const ok = bindings.unpin(ev.groupId);
+        await deps.reply(ev.groupId, ok ? "↩️ 已解绑，恢复项目模式（接收整个项目的回复）" : "本群本来就没有绑定 issue");
+        return;
+      }
       if (cmd.kind === "create") {
         const n = await ework.createIssue(binding.owner, binding.repo, cmd.title ?? "", `${attribution}\n\n${cmd.title ?? ""}`);
-        await deps.reply(ev.groupId, `✅ 已创建 issue #${n}，AI 已接单：${cmd.title ?? ""}`);
+        bindings.pin(ev.groupId, n);
+        const swap = binding.issue !== undefined ? `（原 #${binding.issue} 已解绑）` : "（本群已绑定，长记忆模式）";
+        await deps.reply(ev.groupId, `✅ 已创建 issue #${n}，AI 已接单 ${swap}`);
         return;
       }
       if (cmd.kind === "comment" && cmd.number !== undefined) {

package/tests/bridge.test.ts

@@ -1,5 +1,9 @@
 import { describe, test, expect } from "bun:test";
 import { parseCommand } from "../src/router";
+import { BindingStore } from "../src/bindings";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+const pinFile = () => `${tmpdir()}/qqb-test-${randomUUID()}.json`;
 import { parseGroupMap, parseList } from "../src/config";
 import { buildScrubber } from "../src/scrub";
 import { verifySignature } from "../src/ingest";
@@ -76,72 +80,52 @@ test("helps when @bot without verb", () => {
   expect(parseCommand("[CQ:at,qq=2661222094] 测试2")).toBeNull();
 });
 
-describe("chat mode", () => {
-  const { buildChatMessages, splitForQQ, CHAT_SYSTEM_PROMPT } = require("../src/chat");
-
-  test("buildChatMessages: system + capped history + new turn", () => {
-    const hist = Array.from({ length: 30 }, (_, i) => ({ role: "user" as const, name: `u${i}`, content: `m${i}` }));
-    const msgs = buildChatMessages(hist, { role: "user", name: "dog", content: "q" }, 20);
-    expect(msgs[0].role).toBe("system");
-    expect(msgs[0].content).toBe(CHAT_SYSTEM_PROMPT);
-    expect(msgs).toHaveLength(22);
-    expect(msgs[1].name).toBe("u10");
-    expect(msgs[msgs.length - 1]).toEqual({ role: "user", name: "dog", content: "q" });
-  });
-
-  test("splitForQQ keeps <=1500 chunks and prefers newline cuts", () => {
-    const short = splitForQQ("hello");
-    expect(short).toEqual(["hello"]);
-    const long = "line\n".repeat(600);
-    const parts = splitForQQ(long);
-    expect(parts.length).toBeGreaterThan(1);
-    for (const p of parts) expect(p.length).toBeLessThanOrEqual(1500);
-    expect(parts.join("\n")).toBe(long.replace(/\n$/, ""));
-  });
-
-  test("router: @bot + question hits chat when configured, help when not", async () => {
-    const { createRouter } = require("../src/router");
-    const replies: string[] = [];
-    const chatCalls: string[] = [];
-    const baseDeps = (chatApi: string) => ({
-      cfg: {
-        VERBOSE: false,
-        WORK_CHAT_API: chatApi,
-        WORK_CHAT_API_KEY: "k",
-        WORK_CHAT_MODEL: "m",
-        WORK_CHAT_TIMEOUT_MS: 1000,
-        WORK_CHAT_MAX_HISTORY: 20,
-      },
-      bindings: [{ groupId: 1, owner: "o", repo: "r" }],
-      wakeList: new Set(["1403558951"]),
-      ework: { createIssue: async () => 1, addComment: async () => {} },
-      store: { seenPost: () => false },
-      reply: async (_g: number, text: string) => { replies.push(text); },
-    });
-    // chat disabled → usage help
-    let router = createRouter(baseDeps(""));
-    await router.handleGroupMessage({ groupId: 1, userId: 1403558951, nickname: "dog", postId: "p1", rawMessage: "[CQ:at,qq=2661222094] 你好呀" });
-    expect(replies[0]).toContain("没看懂指令");
-    // chat enabled → mocked LLM answer (patch chatComplete via env endpoint failure is overkill; test buildChatMessages path instead)
-    replies.length = 0;
-    router = createRouter(baseDeps("http://invalid.test/v1"));
-    await router.handleGroupMessage({ groupId: 1, userId: 1403558951, nickname: "dog", postId: "p2", rawMessage: "[CQ:at,qq=2661222094] 你好呀" });
-    expect(replies[0]).toContain("回答失败");
-  });
-
-  test("router: @bot with CQ-only payload (no text) still gets help", async () => {
+describe("@bot unified routing", () => {
+  const mk = (bs: BindingStore) => {
     const { createRouter } = require("../src/router");
     const replies: string[] = [];
+    const comments: Array<[string, string, number, string]> = [];
     const router = createRouter({
-      cfg: { VERBOSE: false, WORK_CHAT_API: "http://x/v1", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20 },
-      bindings: [{ groupId: 1, owner: "o", repo: "r" }],
+      cfg: { VERBOSE: false },
+      bindings: bs,
       wakeList: new Set(["1"]),
-      ework: { createIssue: async () => 1, addComment: async () => {} },
+      ework: { createIssue: async () => 9, addComment: async (o: string, r: string, n: number, b: string) => { comments.push([o, r, n, b]); } },
       store: { seenPost: () => false },
-      reply: async (_g: number, text: string) => { replies.push(text); },
+      reply: async (_g: number, x: string) => { replies.push(x); },
     });
-    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p3", rawMessage: "[CQ:at,qq=2661222094]" });
-    expect(replies[0]).toContain("没看懂指令");
+    return { router, replies, comments };
+  };
+  const ev = (postId: string, raw: string) => ({ groupId: 1, userId: 1, nickname: "u", postId, rawMessage: raw });
+
+  test("pinned: @bot question goes to bound issue like plain messages", async () => {
+    const { router, replies, comments } = mk(new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 7 }], pinFile()));
+    await router.handleGroupMessage(ev("p1", "[CQ:at,qq=2661222094] 这个报错啥意思"));
+    expect(comments.length).toBe(1);
+    expect(comments[0][2]).toBe(7);
+    expect(comments[0][3]).toContain("这个报错啥意思");
+    expect(comments[0][3]).not.toContain("CQ:at");
+    expect(replies).toEqual([]);
+  });
+
+  test("pinned: @bot CQ-only payload silently dropped", async () => {
+    const { router, replies, comments } = mk(new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 7 }], pinFile()));
+    await router.handleGroupMessage(ev("p2", "[CQ:at,qq=2661222094]"));
+    expect(comments).toEqual([]);
+    expect(replies).toEqual([]);
+  });
+
+  test("unpinned: @bot question gets bind guidance", async () => {
+    const { router, replies, comments } = mk(new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile()));
+    await router.handleGroupMessage(ev("p3", "[CQ:at,qq=2661222094] 你好呀"));
+    expect(comments).toEqual([]);
+    expect(replies[0]).toContain("绑定");
+  });
+
+  test("unpinned: plain chatter stays silent", async () => {
+    const { router, replies, comments } = mk(new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile()));
+    await router.handleGroupMessage(ev("p4", "今天天气不错"));
+    expect(comments).toEqual([]);
+    expect(replies).toEqual([]);
   });
 });
 
@@ -154,10 +138,94 @@ test("onebot close ignores non-active client (reconnect race)", () => {
   srv.handlers.open(a);
   expect(ready).toBe(1);
   srv.handlers.open(b);
-  expect(ready).toBe(1);
+  expect(ready).toBe(2);
   srv.handlers.close(a);
   expect(srv.connected).toBe(true);
   srv.handlers.close(b);
   expect(srv.connected).toBe(false);
 });
 
+
+describe("issue pinning", () => {
+  test("parseGroupMap accepts #N suffix and bare form", () => {
+    const [pinned, bare] = parseGroupMap("111:o/r#7,222:o/r");
+    expect(pinned.issue).toBe(7);
+    expect(bare.issue).toBeUndefined();
+  });
+
+  test("parseCommand: 绑定/解绑", () => {
+    expect(parseCommand("绑定 #7")).toEqual({ kind: "bind", number: 7 });
+    expect(parseCommand("解绑")).toEqual({ kind: "unbind" });
+  });
+
+  test("BindingStore pin/unpin persist + groupsFor filter", () => {
+    const f = pinFile();
+    const bs = new BindingStore([{ groupId: 111, owner: "o", repo: "r" }, { groupId: 222, owner: "o", repo: "r" }], f);
+    expect(bs.groupsFor("o", "r", 7)).toEqual([111, 222]);
+    bs.pin(111, 7);
+    expect(bs.groupsFor("o", "r", 7)).toEqual([111, 222]);
+    expect(bs.groupsFor("o", "r", 8)).toEqual([222]);
+    expect(bs.pin(999, 1)).toBeNull();
+    const reloaded = new BindingStore([{ groupId: 111, owner: "o", repo: "r" }], f);
+    expect(reloaded.resolve(111)?.issue).toBe(7);
+    expect(reloaded.groupsFor("o", "r", 8)).toEqual([]);
+    expect(reloaded.unpin(111)).toBe(true);
+    expect(reloaded.groupsFor("o", "r", 8)).toEqual([111]);
+  });
+
+  test("router: pinned plain message comments bound issue silently", async () => {
+    const { createRouter } = require("../src/router");
+    const replies: string[] = [];
+    const comments: Array<[string, string, number, string]> = [];
+    const router = createRouter({
+      cfg: { VERBOSE: false },
+      bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 7 }], pinFile()),
+      wakeList: new Set(["1"]),
+      ework: { createIssue: async () => 9, addComment: async (o: string, r: string, n: number, b: string) => { comments.push([o, r, n, b]); } },
+      store: { seenPost: () => false },
+      reply: async (_g: number, t: string) => { replies.push(t); },
+    });
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p1", rawMessage: "帮我看下这个报错" });
+    expect(comments.length).toBe(1);
+    expect(comments[0][2]).toBe(7);
+    expect(comments[0][3]).toContain("帮我看下这个报错");
+    expect(replies).toEqual([]);
+  });
+
+  test("router: 绑定 #5 pins group, then plain message targets #5", async () => {
+    const { createRouter } = require("../src/router");
+    const replies: string[] = [];
+    const comments: Array<number, any> = [];
+    const bs = new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile());
+    const router = createRouter({
+      cfg: { VERBOSE: false },
+      bindings: bs,
+      wakeList: new Set(["1"]),
+      ework: { createIssue: async () => 9, addComment: async (_o: any, _r: any, n: number) => { comments.push(n); } },
+      store: { seenPost: () => false },
+      reply: async (_g: number, t: string) => { replies.push(t); },
+    });
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p1", rawMessage: "绑定 #5" });
+    expect(replies[0]).toContain("#5");
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p2", rawMessage: "第二条消息" });
+    expect(comments).toEqual([5]);
+  });
+
+  test("router: 任务 in pinned group creates AND rebinds", async () => {
+    const { createRouter } = require("../src/router");
+    const replies: string[] = [];
+    const bs = new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 3 }], pinFile());
+    const router = createRouter({
+      cfg: { VERBOSE: false },
+      bindings: bs,
+      wakeList: new Set(["1"]),
+      ework: { createIssue: async () => 12, addComment: async () => {} },
+      store: { seenPost: () => false },
+      reply: async (_g: number, t: string) => { replies.push(t); },
+    });
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p1", rawMessage: "任务 新主题" });
+    expect(replies[0]).toContain("#12");
+    expect(replies[0]).toContain("#3");
+    expect(bs.resolve(1)?.issue).toBe(12);
+  });
+});

package/src/chat.ts

@@ -1,72 +0,0 @@
-// Chat mode: instant Q&A directly against the OpenAI-compatible endpoint.
-// Issue mode (任务/#N) stays the path for long agent work — chat is for the
-// conversational 90% of group traffic that never needs a session.
-
-export interface ChatTurn {
-  role: "user" | "assistant";
-  name: string;
-  content: string;
-}
-
-export const CHAT_SYSTEM_PROMPT = [
-  "你是 QQ 群里的即时问答助手，背后是 ework 开发平台。",
-  "风格：简短直接，能用一两句话说清的就别铺开；技术问题给结论和关键理由，需要展开再展开。",
-  "群里成员通过 @你 提问。你看到的多轮对话里每条 user 消息前缀了提问者的昵称，注意区分不同人。",
-  "如果请求明显是需要长时间执行的开发任务（改代码、查仓库、提交 PR），不要假装去做——建议对方发「任务 <标题>」创建 issue，AI agent 会接单处理。",
-  "不知道就直说，不要编造。",
-].join("\n");
-
-export function buildChatMessages(
-  history: ChatTurn[],
-  question: ChatTurn,
-  maxHistory: number,
-): { role: string; name?: string; content: string }[] {
-  const kept = history.slice(-maxHistory);
-  return [
-    { role: "system", content: CHAT_SYSTEM_PROMPT },
-    ...kept.map((t) => ({ role: t.role, name: t.name, content: t.content })),
-    { role: question.role, name: question.name, content: question.content },
-  ];
-}
-
-export async function chatComplete(
-  apiBase: string,
-  apiKey: string,
-  model: string,
-  messages: { role: string; name?: string; content: string }[],
-  timeoutMs: number,
-): Promise<string> {
-  const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
-  try {
-    const res = await fetch(`${apiBase.replace(/\/+$/, "")}/chat/completions`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
-      body: JSON.stringify({ model, messages, max_tokens: 1024, temperature: 0.4 }),
-      signal: ctrl.signal,
-    });
-    if (!res.ok) {
-      throw new Error(`LLM ${res.status}: ${(await res.text()).slice(0, 120)}`);
-    }
-    const data = (await res.json()) as { choices?: { message?: { content?: string } }[] };
-    const text = data.choices?.[0]?.message?.content?.trim();
-    if (!text) throw new Error("LLM returned empty content");
-    return text;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export function splitForQQ(text: string, maxLen = 1500): string[] {
-  if (text.length <= maxLen) return [text];
-  const parts: string[] = [];
-  let rest = text;
-  while (rest.length > maxLen) {
-    let cut = rest.lastIndexOf("\n", maxLen);
-    if (cut < maxLen * 0.5) cut = maxLen;
-    parts.push(rest.slice(0, cut));
-    rest = rest.slice(cut).replace(/^\n+/, "");
-  }
-  if (rest) parts.push(rest);
-  return parts;
-}