@primusclaw/personal-agent 0.6.0 → 0.7.1

package/dist/index.js

@@ -4990,6 +4990,7 @@ var ITEM_KINDS = ["task", "review", "remote"];
 
 // ../claw/packages/protocol/src/claw-api/assistant-events.ts
 var ASSISTANT_EVENT_TYPES = ["assistant.say", "work_item.needs_you", "assistant.action"];
+var TERMINAL_ASKS = ["after_card", "on_input"];
 var REVIEW_HANDOFF_ACTION = "review_for_other";
 
 // ../claw/packages/protocol/src/claw-api/notifications.ts
@@ -6137,8 +6138,8 @@ function writtenLang(text8) {
   const words3 = written3.map((w) => w.toLowerCase());
   if (words3.length < 3) return void 0;
   const first = words3[0] ?? "";
-  const sentence2 = EN_VERBS.has(first) || words3.some((w) => EN_GLUE.has(w)) || written3.some((w) => EN_FORM.test(w));
-  return sentence2 ? "en" : void 0;
+  const sentence3 = EN_VERBS.has(first) || words3.some((w) => EN_GLUE.has(w)) || written3.some((w) => EN_FORM.test(w));
+  return sentence3 ? "en" : void 0;
 }
 function pickLang2(...texts4) {
   for (const text8 of texts4) {
@@ -9557,21 +9558,34 @@ function helpLang(store, userId, locale, asked3) {
   const written3 = asked3 !== void 0 && !prefs.langSet ? writtenLang(asked3) : void 0;
   return written3 ?? langOf2(store, userId, locale);
 }
+function groupLangOf(store, conversationId, userId, locale, written3) {
+  const chosen = groupChosenLang(store, conversationId);
+  if (chosen !== void 0) return chosen;
+  const prefs = userId ? store.prefs.getPrefs(userId) : void 0;
+  return writtenLang(written3) ?? answerLang(prefs !== void 0 && !prefs.langSet ? prefs.lang : "", locale);
+}
+function groupChosenLang(store, conversationId) {
+  const lang = conversationId ? store.groupLanguage?.groupLanguage(conversationId) : null;
+  return lang === "zh" || lang === "en" ? lang : void 0;
+}
 var Chat = class {
-  constructor(store, sender, conversation, scope, locale) {
+  constructor(store, sender, conversation, scope, locale, written3 = "") {
     this.store = store;
     this.sender = sender;
     this.conversation = conversation;
     this.scope = scope;
     this.locale = locale;
+    this.written = written3;
   }
   store;
   sender;
   conversation;
   scope;
   locale;
+  written;
+  /** In a 1:1 chat the person's language (`langOf`); in a group, the group's (`groupLangOf`). */
   lang() {
-    return langOf2(this.store, this.sender.id, this.locale);
+    return this.scope ? groupLangOf(this.store, this.scope, this.sender.id, this.locale, this.written) : langOf2(this.store, this.sender.id, this.locale);
   }
   zh() {
     return this.lang() === "zh";
@@ -11017,7 +11031,12 @@ function renderHelp(language, options = {}) {
   const oneToOne = chat.group ? oneToOneBlock(lang, chat, bot) : void 0;
   if (oneToOne !== void 0) out.push(oneToOne);
   out.push(authorityText(zh, chat.parts));
-  if (chat.group) out.push(zh ? "\u8BBE\u7F6E\u53EA\u80FD\u5728\u548C\u6211\u7684 1:1 \u804A\u5929\u91CC\u6539\u3002" : "Settings are changed in a 1:1 chat with me.");
+  if (chat.group)
+    out.push(
+      zh ? `\u8BBE\u7F6E\u53EA\u80FD\u5728\u548C\u6211\u7684 1:1 \u804A\u5929\u91CC\u6539\u3002
+\u53EA\u6709\u8FD9\u4E2A\u7FA4\u7684\u56DE\u590D\u8BED\u8A00\u5728\u7FA4\u91CC\u8BBE\uFF1A@${bot} \u8BF4\u300C\u8FD9\u4E2A\u7FA4\u7528\u82F1\u6587\u300D\uFF08\u6216\u4E2D\u6587\u3001\u8DDF\u968F\u63D0\u95EE\u8005\uFF09\u3002` : `Settings are changed in a 1:1 chat with me.
+This group's language is set here: @${bot} "use English in this group" (or Chinese, or "follow the asker").`
+    );
   out.push(dataStatement(lang, !chat.group && chat.parts.has("remote"), options.groupContext));
   out.push(
     zh ? "\u968F\u65F6\u95EE\u6211\u300C\u4F60\u80FD\u505A\u4EC0\u4E48\u300D\u770B\u8FD9\u4EFD\u8BF4\u660E\u3002\u5E95\u90E8\u83DC\u5355\u91CC\u4E5F\u6709\u5E38\u7528\u7684\u6309\u94AE\u3002" : 'Ask "what can you do" any time to see this again. The menu by the compose box has the common ones too.'
@@ -11600,8 +11619,8 @@ var VALUED = [
 function personal(text8, flat2, key) {
   if (STOP_IT2.has(key)) return "/stop";
   if (DETACH2.has(detachKey(key))) return "/agent detach";
-  const phrase = lookUp(key, PERSONAL_PHRASES);
-  if (phrase !== null) return phrase;
+  const phrase2 = lookUp(key, PERSONAL_PHRASES);
+  if (phrase2 !== null) return phrase2;
   for (const read of VALUED) {
     const command = read(flat2);
     if (command !== null) return command;
@@ -12095,11 +12114,13 @@ var RouterContext = class {
   /** The chat an event is answered in: its conversation, as the person who sent it. */
   chatOf(event, scope) {
     const conversation = this.deps.surface.conversation(event.conversation);
-    return new Chat(this.deps.store, event.sender, conversation, scope, event.locale);
+    const written3 = event.type === "message" ? event.text : "";
+    return new Chat(this.deps.store, event.sender, conversation, scope, event.locale, written3);
   }
   /** A chat in another conversation of the same person (their 1:1 chat, a group a request waited in). */
   chatIn(chat, ref, scope = "") {
-    return new Chat(this.deps.store, chat.sender, this.deps.surface.conversation(ref), scope, chat.locale);
+    const written3 = scope ? chat.written : "";
+    return new Chat(this.deps.store, chat.sender, this.deps.surface.conversation(ref), scope, chat.locale, written3);
   }
   /** A click as a feature handler is given it. */
   clickRoute(action, chat) {
@@ -12152,8 +12173,8 @@ var groupText = defineCatalog({
     stopMany: (p) => `#${String(p.number)}: more than one repository has it; write it as owner/repo#${String(p.number)}.`
   },
   zh: {
-    githubOneToOne: "`/github` works only in a 1:1 chat. Please do this in a 1:1 chat with me.",
-    oneToOneOnly: (p) => `\`${p.word}\` works only in a 1:1 chat. Please do this in a 1:1 chat with me.`,
+    githubOneToOne: "`/github` \u53EA\u80FD\u5728 1:1 \u804A\u5929\u91CC\u7528\uFF0C\u8BF7\u5728\u548C\u6211\u7684 1:1 \u804A\u5929\u91CC\u64CD\u4F5C\u3002",
+    oneToOneOnly: (p) => `\`${p.word}\` \u53EA\u80FD\u5728 1:1 \u804A\u5929\u91CC\u7528\uFF0C\u8BF7\u5728\u548C\u6211\u7684 1:1 \u804A\u5929\u91CC\u64CD\u4F5C\u3002`,
     agentInGroup: "`/agent` \u5728\u7FA4\u91CC\u53EA\u80FD\u7528 attach \u548C detach\uFF0C\u5176\u4F59\u8BF7\u5728 1:1 \u804A\u5929\u91CC\u7528\u3002",
     whoami: (p) => `${p.name || "\u4F60"} \u5DF2\u8FDE\u63A5\u5230 SaFE \u7528\u6237 ${p.who}\u3002`,
     whoamiUnknown: "\u4F60\u5DF2\u8FDE\u63A5\uFF0C\u4F46 SaFE \u6CA1\u544A\u8BC9\u6211\u662F\u8C01\u7684\u8D26\u53F7\u3002",
@@ -12319,7 +12340,8 @@ var Onboarding = class {
     try {
       const conversation = await this.openPersonal(chat);
       if (conversation === void 0) throw new Error("no 1:1 conversation");
-      await this.ctx.chatIn(chat, conversation.ref).say(groupText.in(chat.lang()).targeted({ bot: config.botName }));
+      const dm = this.ctx.chatIn(chat, conversation.ref);
+      await dm.say(groupText.in(dm.lang()).targeted({ bot: config.botName }));
     } catch (error) {
       logger.warn("group: the 1:1 line about a private message did not go out", { error: errorName(error) });
       return;
@@ -13070,6 +13092,208 @@ var SettingsCommands = class {
   }
 };
 
+// packages/core/src/language/group.ts
+var WORDS = /* @__PURE__ */ new Map([
+  ["zh", "zh"],
+  ["cn", "zh"],
+  ["chinese", "zh"],
+  ["\u4E2D\u6587", "zh"],
+  ["\u6C49\u8BED", "zh"],
+  ["en", "en"],
+  ["english", "en"],
+  ["\u82F1\u6587", "en"],
+  ["\u82F1\u8BED", "en"],
+  ["auto", "auto"],
+  ["follow", "auto"],
+  ["\u81EA\u52A8", "auto"],
+  ["\u8DDF\u968F", "auto"],
+  ["\u8DDF\u968F\u63D0\u95EE\u8005", "auto"],
+  ["followtheasker", "auto"]
+]);
+var PUNCT2 = ` 	\r
+\u3002\uFF0E.\uFF01!\uFF1F?\uFF5E~\uFF0C,\u3001\uFF1B;\uFF1A:"'\u201C\u201D\u2018\u2019\uFF08\uFF09()`;
+var GROUP = "(?:\u8FD9\u4E2A\u7FA4\u804A|\u8FD9\u4E2A\u7FA4|\u672C\u7FA4|\u6B64\u7FA4|\u7FA4\u804A|\u7FA4)(?:\u91CC\u9762|\u91CC|\u5185|\u4E2D)?";
+var LANG_ZH = "(\u4E2D\u6587|\u6C49\u8BED|\u82F1\u6587|\u82F1\u8BED)";
+var ASKER = "(?:\u63D0\u95EE\u8005|\u63D0\u95EE\u4EBA|\u63D0\u95EE\u7684\u4EBA|\u95EE\u95EE\u9898\u7684\u4EBA|\u95EE\u7684\u4EBA|\u53D1\u95EE\u7684\u4EBA)";
+var ZH_SET = [
+  new RegExp(
+    `^(?:\u4EE5\u540E|\u4E4B\u540E|\u4ECA\u540E|\u4ECE\u73B0\u5728\u8D77|\u4ECE\u73B0\u5728\u5F00\u59CB)?(?:\u8BF7|\u9EBB\u70E6)?(?:\u5728)?${GROUP}(?:\u4EE5\u540E|\u4E4B\u540E|\u4ECA\u540E|\u4ECE\u73B0\u5728\u8D77|\u4ECE\u73B0\u5728\u5F00\u59CB)?(?:\u8BF7)?(?:\u90FD|\u4E00\u5F8B|\u7EDF\u4E00)?(?:\u7528|\u8BF4|\u4F7F\u7528)${LANG_ZH}(?:\u56DE\u590D|\u56DE\u7B54|\u4EA4\u6D41|\u8BF4\u8BDD|\u804A\u5929|\u804A)?(?:\u5427|\u597D\u5417|\u53EF\u4EE5\u5417)?$`,
+    "u"
+  ),
+  new RegExp(
+    `^(?:\u628A)?${GROUP}(?:\u7684)?(?:\u56DE\u590D)?\u8BED\u8A00(?:\u8BBE\u4E3A|\u8BBE\u6210|\u6539\u6210|\u6539\u4E3A|\u8BBE\u7F6E\u4E3A|\u8BBE\u7F6E\u6210|\u5207\u6362\u5230|\u5207\u6362\u6210|\u6362\u6210)${LANG_ZH}$`,
+    "u"
+  )
+];
+var ZH_AUTO = [
+  new RegExp(
+    `^(?:\u4EE5\u540E|\u4E4B\u540E|\u4ECA\u540E)?(?:\u5728)?${GROUP}(?:\u4EE5\u540E|\u4E4B\u540E|\u4ECA\u540E)?(?:\u90FD)?(?:\u8DDF\u968F|\u8DDF\u7740|\u6309|\u6309\u7167|\u7528)${ASKER}(?:\u7684)?(?:\u8BED\u8A00)?(?:\u56DE\u590D|\u56DE\u7B54)?(?:\u5427)?$`,
+    "u"
+  ),
+  new RegExp(
+    `^(?:\u628A)?${GROUP}(?:\u7684)?(?:\u56DE\u590D)?\u8BED\u8A00(?:\u8BBE\u4E3A|\u8BBE\u6210|\u6539\u6210|\u6539\u4E3A|\u8BBE\u7F6E\u4E3A|\u8BBE\u7F6E\u6210|\u5207\u6362\u5230|\u5207\u6362\u6210|\u6362\u6210)(?:\u81EA\u52A8|\u8DDF\u968F${ASKER})$`,
+    "u"
+  )
+];
+var LANG_EN = "(english|chinese)";
+var THIS_GROUP = "(?:this|the|our) (?:group chat|group|chat)";
+var ANSWER = "(?:use|speak|reply in|answer in|respond in|talk in|write in)";
+var EN_SET = [
+  new RegExp(`^(?:please )?${ANSWER} ${LANG_EN} (?:in|for) ${THIS_GROUP}(?: from now on)?(?: please)?$`),
+  new RegExp(`^(?:in|for) ${THIS_GROUP},? (?:please )?${ANSWER} ${LANG_EN}(?: from now on)?(?: please)?$`),
+  new RegExp(`^${THIS_GROUP} (?:uses|speaks|is in) ${LANG_EN}$`),
+  new RegExp(
+    `^(?:please )?(?:set|change|switch) (?:the |this )?(?:group|chat)(?:'s)? language to ${LANG_EN}(?: please)?$`
+  )
+];
+var EN_AUTO = [
+  new RegExp(
+    `^(?:please )?(?:follow the asker|use the asker'?s language|reply in the asker'?s language|answer in the language of each question)(?: (?:in|for) ${THIS_GROUP})?(?: please)?$`
+  ),
+  new RegExp(
+    `^(?:please )?(?:set|change|switch) (?:the |this )?(?:group|chat)(?:'s)? language to (?:auto|follow the asker)(?: please)?$`
+  )
+];
+function phrase(text8) {
+  return pySplit(pyLower(pyStrip(text8, PUNCT2))).join("");
+}
+function sentence(text8) {
+  return pySplit(pyLower(pyStrip(text8, PUNCT2))).join(" ");
+}
+var MAX_SENTENCE_CHARS = 120;
+function sentenceCommand(text8) {
+  if (text8.length > MAX_SENTENCE_CHARS) return void 0;
+  const zh = phrase(text8);
+  const en2 = sentence(text8);
+  for (const pattern of ZH_SET) {
+    const word2 = pattern.exec(zh)?.[1];
+    const lang = word2 === void 0 ? void 0 : WORDS.get(word2);
+    if (lang !== void 0) return { kind: "set", lang };
+  }
+  if (ZH_AUTO.some((p) => p.test(zh))) return { kind: "set", lang: "auto" };
+  for (const pattern of EN_SET) {
+    const word2 = pattern.exec(en2)?.[1];
+    const lang = word2 === void 0 ? void 0 : WORDS.get(word2);
+    if (lang !== void 0) return { kind: "set", lang };
+  }
+  if (EN_AUTO.some((p) => p.test(en2))) return { kind: "set", lang: "auto" };
+  return void 0;
+}
+function parseGroupLang(text8) {
+  const words3 = pySplit(text8);
+  if (pyLower(words3[0] ?? "") !== "/lang") return sentenceCommand(pyStrip(text8));
+  if (words3.length === 1) return { kind: "status" };
+  const lang = WORDS.get(pyLower(words3.slice(1).join("")));
+  return lang === void 0 ? { kind: "usage" } : { kind: "set", lang };
+}
+
+// packages/core/src/locales/group-language.ts
+var NAMES2 = {
+  zh: ["\u4E2D\u6587", "Chinese"],
+  en: ["\u82F1\u6587", "English"],
+  auto: ["\u8DDF\u968F\u63D0\u95EE\u8005\u7684\u8BED\u8A00", "the language each question is asked in"]
+};
+function groupLanguageSet(lang, name) {
+  const [zh, en2] = NAMES2[lang];
+  return `\u5DF2\u6539\u4E3A${zh}\u56DE\u590D\uFF0C\u7531 ${name || "\u7FA4\u6210\u5458"} \u8BBE\u7F6E\u3002
+I answer in ${en2} in this group from now on (set by ${name || "a member"}).`;
+}
+var GROUP_LANGUAGE_CARD = {
+  title: "\u8FD9\u4E2A\u7FA4\u7528\u54EA\u79CD\u8BED\u8A00\u56DE\u590D\uFF1F/ Which language should I use in this group?",
+  text: (p) => `\u7FA4\u91CC\u4EFB\u4F55\u4EBA\u90FD\u53EF\u4EE5\u9009\uFF0C\u4E4B\u540E\u4E5F\u80FD\u7528 @${p.bot} /lang zh | en | auto \u518D\u6539\u3002
+Anyone here may pick; @${p.bot} /lang zh | en | auto changes it later.`,
+  buttons: { zh: "\u4E2D\u6587", en: "English", auto: "\u8DDF\u968F\u63D0\u95EE\u8005 (Follow the asker)" }
+};
+var groupLanguageText = defineCatalog({
+  en: {
+    isZh: (p) => `This group is answered in Chinese. @${p.bot} /lang en or /lang auto changes it.`,
+    isEn: (p) => `This group is answered in English. @${p.bot} /lang zh or /lang auto changes it.`,
+    isAuto: (p) => `This group is answered in the language each question is asked in. @${p.bot} /lang zh or /lang en sets one.`,
+    isNone: (p) => `This group has no language set: each question is answered in the language it is asked in. @${p.bot} /lang zh, /lang en or /lang auto sets it.`,
+    usage: (p) => `Usage: @${p.bot} /lang zh | en | auto (follow the asker).`
+  },
+  zh: {
+    isZh: (p) => `\u8FD9\u4E2A\u7FA4\u7528\u4E2D\u6587\u56DE\u590D\u3002@${p.bot} /lang en \u6216 /lang auto \u53EF\u6539\u3002`,
+    isEn: (p) => `\u8FD9\u4E2A\u7FA4\u7528\u82F1\u6587\u56DE\u590D\u3002@${p.bot} /lang zh \u6216 /lang auto \u53EF\u6539\u3002`,
+    isAuto: (p) => `\u8FD9\u4E2A\u7FA4\u6309\u6BCF\u4E2A\u95EE\u9898\u6240\u7528\u7684\u8BED\u8A00\u56DE\u590D\u3002@${p.bot} /lang zh \u6216 /lang en \u53EF\u8BBE\u4E3A\u56FA\u5B9A\u8BED\u8A00\u3002`,
+    isNone: (p) => `\u8FD9\u4E2A\u7FA4\u8FD8\u6CA1\u8BBE\u8BED\u8A00\uFF1A\u6BCF\u4E2A\u95EE\u9898\u6309\u5B83\u6240\u7528\u7684\u8BED\u8A00\u56DE\u590D\u3002@${p.bot} /lang zh\u3001/lang en \u6216 /lang auto \u53EF\u8BBE\u7F6E\u3002`,
+    usage: (p) => `\u7528\u6CD5\uFF1A@${p.bot} /lang zh | en | auto\uFF08\u8DDF\u968F\u63D0\u95EE\u8005\uFF09\u3002`
+  }
+});
+
+// packages/core/src/routing/group-language.ts
+var GROUP_LANG_VERB = "group_lang";
+var LANGS2 = ["zh", "en", "auto"];
+function isGroupLanguage(value) {
+  return typeof value === "string" && LANGS2.includes(value);
+}
+var GroupLanguages = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** `/lang …` or a sentence that sets the group's language: answered here; false when `text` is neither. */
+  async command(chat, text8) {
+    const command = parseGroupLang(text8);
+    if (command === void 0) return false;
+    const bot = this.ctx.deps.config.botName;
+    if (command.kind === "set") {
+      this.ctx.deps.store.groupLanguage.setGroupLanguage(chat.scope, command.lang);
+      await chat.say(groupLanguageSet(command.lang, chat.sender.name));
+      return true;
+    }
+    const said2 = groupLanguageText.in(chat.lang());
+    if (command.kind === "usage") {
+      await chat.say(said2.usage({ bot }));
+      return true;
+    }
+    const lang = this.ctx.deps.store.groupLanguage.groupLanguage(chat.scope);
+    const state = lang === "zh" ? said2.isZh : lang === "en" ? said2.isEn : lang === "auto" ? said2.isAuto : said2.isNone;
+    await chat.say(state({ bot }));
+    return true;
+  }
+  /**
+   * The first @mention in a chat that has no language: the card that asks its members which, once (the chat is recorded as asked
+   * before the card goes, so two mentions at once put one; a card that could not be posted is asked again next time).
+   */
+  async askOnce(chat) {
+    const { store, logger, config } = this.ctx.deps;
+    if (!store.groupLanguage.markGroupLanguageAsked(chat.scope)) return;
+    const buttons2 = LANGS2.map(
+      (lang) => viewButtonOf({ title: GROUP_LANGUAGE_CARD.buttons[lang], verb: GROUP_LANG_VERB, data: { lang } })
+    );
+    try {
+      await chat.send(
+        noteMessage({
+          title: GROUP_LANGUAGE_CARD.title,
+          text: GROUP_LANGUAGE_CARD.text({ bot: config.botName }),
+          tone: "accent",
+          buttons: buttons2
+        })
+      );
+    } catch (error) {
+      store.groupLanguage.unmarkGroupLanguageAsked(chat.scope);
+      logger.warn("group: the language card could not be posted; it is asked again next time", {
+        error: errorName(error)
+      });
+    }
+  }
+  /** A pick on the language card, by anyone in the chat: the language is set, the card says so, and so does the chat. */
+  async click(action, chat) {
+    const lang = action.data["lang"];
+    if (!isGroupLanguage(lang)) {
+      await this.ctx.settle(
+        action,
+        chat,
+        groupLanguageText.in(chat.lang()).usage({ bot: this.ctx.deps.config.botName })
+      );
+      return;
+    }
+    this.ctx.deps.store.groupLanguage.setGroupLanguage(chat.scope, lang);
+    await this.ctx.settle(action, chat, groupLanguageSet(lang, chat.sender.name));
+  }
+};
+
 // packages/core/src/routing/show-here.ts
 var ShowHere = class {
   constructor(ctx) {
@@ -13827,10 +14051,14 @@ var TurnStarter = class {
       review: review?.fields
     };
   }
-  /** The language the sender chose to be answered in, for a chat turn (a review's answer follows its request's language). */
+  /**
+   * The language a chat turn is to be answered in, when one was chosen (a review's answer follows its request's language): in a
+   * group the group's (`groupChosenLang`; the sender's own choice is not read there), in a 1:1 chat the person's.
+   */
   replyLang(request) {
     if (request.review !== void 0) return {};
-    const lang = chosenLang(this.ctx.deps.store.prefs.getPrefs(request.chat.sender.id));
+    const { store } = this.ctx.deps;
+    const lang = request.chat.scope ? groupChosenLang(store, request.chat.scope) : chosenLang(store.prefs.getPrefs(request.chat.sender.id));
     return lang === void 0 ? {} : { replyLang: lang };
   }
   hooks(request, run, turn, turnId) {
@@ -14176,13 +14404,14 @@ var STOP_SAID = {
   item_closed: ["\u5DF2\u7ECF\u7ED3\u675F\u4E86\u3002", "it had already ended."]
 };
 var GroupRouter = class {
-  constructor(ctx, text8, sessions, onboarding, remote, starter) {
+  constructor(ctx, text8, sessions, onboarding, remote, starter, languages) {
     this.ctx = ctx;
     this.text = text8;
     this.sessions = sessions;
     this.onboarding = onboarding;
     this.remote = remote;
     this.starter = starter;
+    this.languages = languages;
   }
   ctx;
   text;
@@ -14190,6 +14419,7 @@ var GroupRouter = class {
   onboarding;
   remote;
   starter;
+  languages;
   async route(event, chat) {
     if (!chat.scope) return;
     if (event.type === "action") await this.click(event, chat);
@@ -14203,6 +14433,10 @@ var GroupRouter = class {
       await this.onboarding.click(action, chat);
       return;
     }
+    if (action.verb === GROUP_LANG_VERB) {
+      await this.languages.click(action, chat);
+      return;
+    }
     const handler = this.ctx.deps.handlers.clicks.find((h) => h.verbs.includes(action.verb));
     if (handler?.inGroup !== void 0) await handler.inGroup(this.ctx.clickRoute(action, chat));
   }
@@ -14215,6 +14449,9 @@ var GroupRouter = class {
     const words3 = this.words(message);
     learnLang(this.ctx.deps.store, chat.sender.id, message.text);
     const choice = message.choice === true;
+    const language = !choice && await this.languages.command(chat, words3.text);
+    await this.languages.askOnce(chat);
+    if (language) return;
     if (!choice && await this.groupOwn(message, chat, words3)) return;
     const route = {
       sender: chat.sender,
@@ -14244,7 +14481,7 @@ var GroupRouter = class {
     const [first = ""] = pySplit(words3.text);
     const word2 = pyLower(first);
     if (empty || word2 === "/help") {
-      const lang = helpLang(this.ctx.deps.store, chat.sender.id, chat.locale, message.text);
+      const lang = chat.lang();
       const assistant = this.ctx.deps.assistant.on(chat.sender.id);
       const groupContext = this.ctx.deps.groupHistory.kept(message.conversation.id);
       await chat.say(
@@ -14259,11 +14496,11 @@ var GroupRouter = class {
       return true;
     }
     if (github !== void 0 && word2 === "/github") {
-      await chat.say(groupText.in("en").githubOneToOne);
+      await chat.say(groupText.in(chat.lang()).githubOneToOne);
       return true;
     }
     if (!this.oneToOneOnly(word2, words3.text, remote.enabled)) return false;
-    await chat.say(groupText.in("en").oneToOneOnly({ word: word2 }));
+    await chat.say(groupText.in(chat.lang()).oneToOneOnly({ word: word2 }));
     return true;
   }
   /** A command of a 1:1 chat (`/agent attach|detach` binds the group: it stays the group's). */
@@ -14330,7 +14567,7 @@ ${quote}` : history || quote;
     };
   }
   async stopReviews(chat, pulls, text8) {
-    const zh = hasCjk2(text8);
+    const zh = (groupChosenLang(this.ctx.deps.store, chat.scope) ?? (hasCjk2(text8) ? "zh" : "en")) === "zh";
     const said2 = groupText.in(zh ? "zh" : "en");
     const key = await this.ctx.credentials.credential(chat, false);
     let items;
@@ -14500,7 +14737,8 @@ var Router = class _Router {
       sessions,
       this.onboarding,
       new GroupRemote(this.ctx, this.text),
-      this.starter
+      this.starter,
+      new GroupLanguages(this.ctx)
     );
   }
   async handle(event) {
@@ -14635,7 +14873,7 @@ var Router = class _Router {
 };
 
 // packages/core/src/approvals/sensitive.ts
-var WORDS = /* @__PURE__ */ new Set([
+var WORDS2 = /* @__PURE__ */ new Set([
   "token",
   "secret",
   "secrets",
@@ -14740,7 +14978,7 @@ function isSensitiveName(name) {
   const parts2 = nameWords(String(name));
   if (parts2.length === 0 || COUNTERS.has(parts2.join(" "))) return false;
   return parts2.some((word2, i) => {
-    if (WORDS.has(word2)) return true;
+    if (WORDS2.has(word2)) return true;
     const next = parts2[i + 1];
     if (next === void 0) return false;
     const pair = `${word2} ${next}`;
@@ -17337,11 +17575,17 @@ function choiceOf(event) {
   return { options, multiple: choice["multiple"] === true };
 }
 var REMOTE_KINDS = /* @__PURE__ */ new Set(["done", "needs_you", "error", "resolved"]);
+var TERMINAL_TOOL_NAMES = {
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor"
+};
 function resolvedOf(remote) {
   const resolved = record2(remote["resolved"]);
   const actionId = resolved?.["action_id"];
   return resolved && typeof actionId === "string" && actionId ? { actionId, by: field2(resolved["by"]) } : void 0;
 }
+var toolName = (tool2) => typeof tool2 === "string" && Object.hasOwn(TERMINAL_TOOL_NAMES, tool2) ? TERMINAL_TOOL_NAMES[tool2] : void 0;
 function remoteNoticeOf(event) {
   const remote = event["type"] === "assistant.say" ? record2(event["remote"]) : void 0;
   const kind = remote?.["kind"];
@@ -17356,7 +17600,7 @@ function remoteNoticeOf(event) {
     sessionId,
     ask: record2(remote["ask"]),
     machine: field2(remote["machine"]),
-    agent: field2(remote["agent"])
+    agent: toolName(remote["tool"]) ?? field2(remote["agent"])
   };
 }
 
@@ -19519,7 +19763,11 @@ var terminalApprovalText = defineCatalog({
     newText: "With:",
     alwaysOption: (p) => `"Always allow (this session)" means: ${p.name}`,
     firstAnswerWins: "The terminal is asking too: the first answer, here or there, counts.",
+    afterCard: "The terminal asks only after this card is answered or its wait is over: decline it here, or hand it back to the terminal and approve it there.",
+    onInput: "To answer at the terminal instead, type anything there: the question goes back to it and this card is withdrawn.",
     tooLong: "Too long to show in full here: it can only be turned down from the phone; approve it at the terminal.",
+    tooLongAfterCard: "Too long to show in full here: it can only be declined from the phone; the terminal asks once this card's wait is over.",
+    tooLongOnInput: "Too long to show in full here: it can only be turned down from the phone; to approve it, type anything at the terminal and answer it there.",
     questionOf: (p) => `Question ${String(p.n)} of ${String(p.of)}`,
     optionYes: "Yes",
     optionSession: "Always allow (this session)",
@@ -19527,6 +19775,7 @@ var terminalApprovalText = defineCatalog({
     optionNoStop: "No, and stop",
     optionPlanApprove: "Approve (ask before edits)",
     optionPlanKeep: "Keep planning",
+    optionToTerminal: "Ask me at the terminal",
     answeredInTerminal: "Answered in the terminal",
     noLongerWaiting: "No longer waiting for an answer",
     answeredInTerminalLine: "This request was answered in the terminal.",
@@ -19550,7 +19799,11 @@ var terminalApprovalText = defineCatalog({
     newText: "\u6539\u4E3A\uFF1A",
     alwaysOption: (p) => `\u201C\u672C\u4F1A\u8BDD\u59CB\u7EC8\u5141\u8BB8\u201D\u5373\uFF1A${p.name}`,
     firstAnswerWins: "\u7EC8\u7AEF\u91CC\u4E5F\u5728\u7B49\u4F60\u56DE\u7B54\uFF0C\u5148\u7B54\u7684\u7B97\u6570\u3002",
+    afterCard: "\u7EC8\u7AEF\u8981\u7B49\u8FD9\u5F20\u5361\u7247\u7B54\u5B8C\u6216\u7B49\u5F85\u65F6\u95F4\u5230\u4E86\u624D\u4F1A\u95EE\uFF1A\u5728\u8FD9\u91CC\u62D2\u7EDD\uFF0C\u6216\u4EA4\u56DE\u7EC8\u7AEF\u3001\u5230\u7EC8\u7AEF\u91CC\u6279\u51C6\u3002",
+    onInput: "\u60F3\u6539\u5728\u7EC8\u7AEF\u91CC\u56DE\u7B54\uFF0C\u5C31\u5728\u7EC8\u7AEF\u91CC\u968F\u4FBF\u8F93\u5165\u70B9\u4EC0\u4E48\uFF1A\u95EE\u9898\u56DE\u5230\u7EC8\u7AEF\uFF0C\u8FD9\u5F20\u5361\u7247\u968F\u4E4B\u64A4\u56DE\u3002",
     tooLong: "\u5185\u5BB9\u8FC7\u957F\uFF0C\u8FD9\u91CC\u663E\u793A\u4E0D\u5168\uFF1A\u624B\u673A\u4E0A\u53EA\u80FD\u62D2\u7EDD\uFF0C\u8BF7\u5230\u7EC8\u7AEF\u6279\u51C6\u3002",
+    tooLongAfterCard: "\u5185\u5BB9\u8FC7\u957F\uFF0C\u8FD9\u91CC\u663E\u793A\u4E0D\u5168\uFF1A\u624B\u673A\u4E0A\u53EA\u80FD\u62D2\u7EDD\uFF1B\u8FD9\u5F20\u5361\u7247\u7684\u7B49\u5F85\u65F6\u95F4\u4E00\u8FC7\uFF0C\u7EC8\u7AEF\u5C31\u4F1A\u95EE\u4F60\u3002",
+    tooLongOnInput: "\u5185\u5BB9\u8FC7\u957F\uFF0C\u8FD9\u91CC\u663E\u793A\u4E0D\u5168\uFF1A\u624B\u673A\u4E0A\u53EA\u80FD\u62D2\u7EDD\uFF1B\u8981\u6279\u51C6\uFF0C\u5728\u7EC8\u7AEF\u91CC\u968F\u4FBF\u8F93\u5165\u70B9\u4EC0\u4E48\uFF0C\u5230\u7EC8\u7AEF\u91CC\u56DE\u7B54\u3002",
     questionOf: (p) => `\u7B2C ${String(p.n)} \u9898\uFF0C\u5171 ${String(p.of)} \u9898`,
     optionYes: "\u5141\u8BB8",
     optionSession: "\u672C\u4F1A\u8BDD\u59CB\u7EC8\u5141\u8BB8",
@@ -19558,6 +19811,7 @@ var terminalApprovalText = defineCatalog({
     optionNoStop: "\u62D2\u7EDD\u5E76\u505C\u6B62",
     optionPlanApprove: "\u6279\u51C6\uFF08\u7F16\u8F91\u524D\u9010\u4E2A\u8BE2\u95EE\uFF09",
     optionPlanKeep: "\u7EE7\u7EED\u89C4\u5212",
+    optionToTerminal: "\u4EA4\u56DE\u7EC8\u7AEF",
     answeredInTerminal: "\u5DF2\u5728\u7EC8\u7AEF\u91CC\u56DE\u7B54",
     noLongerWaiting: "\u4E0D\u518D\u7B49\u5F85\u56DE\u7B54",
     answeredInTerminalLine: "\u8FD9\u4E2A\u8BF7\u6C42\u5DF2\u5728\u7EC8\u7AEF\u91CC\u56DE\u7B54\u3002",
@@ -19689,6 +19943,9 @@ var TERMINAL_FALLBACK_BYTES = 4e3;
 var LINE_MAX = 400;
 var LABEL_MAX2 = 200;
 var OPTION_NAME_MAX = 200;
+function terminalAsksOf(ask3) {
+  return TERMINAL_ASKS.find((t4) => t4 === ask3["terminal_asks"]);
+}
 function isTerminalAsk(ask3) {
   return ask3 !== void 0 && ask3["origin"] === "terminal";
 }
@@ -19711,7 +19968,8 @@ function optionTitle(option, lang) {
     ["deny", words3.optionNo],
     ["deny-stop", words3.optionNoStop],
     ["plan-approve", words3.optionPlanApprove],
-    ["plan-keep", words3.optionPlanKeep]
+    ["plan-keep", words3.optionPlanKeep],
+    ["terminal", words3.optionToTerminal]
   ]);
   return titles.get(option.optionId);
 }
@@ -19830,10 +20088,15 @@ function notesOf(ask3, complete, options, words3) {
   const index = Number(ask3["question_index"]);
   if (Number.isInteger(total) && total > 1 && Number.isInteger(index))
     notes.push(words3.questionOf({ n: index + 1, of: total }));
-  if (!complete) notes.push(words3.tooLong);
+  const asks = terminalAsksOf(ask3);
+  if (!complete)
+    notes.push(
+      asks === "after_card" ? words3.tooLongAfterCard : asks === "on_input" ? words3.tooLongOnInput : words3.tooLong
+    );
   for (const o of shownOptions(options))
     if (o.kind === "allow_always") notes.push(words3.alwaysOption({ name: lit(o.name, OPTION_NAME_MAX) }));
-  notes.push(words3.firstAnswerWins);
+  if (asks === void 0) notes.push(words3.firstAnswerWins);
+  else if (complete) notes.push(asks === "after_card" ? words3.afterCard : words3.onInput);
   return notes;
 }
 function terminalAskView(input, lang = "en") {
@@ -22239,9 +22502,9 @@ var SUMMARY_CHARS = 1200;
 var DM_SUMMARY_CHARS = 700;
 var VERDICT = pyRegExp(String.raw`^\s*VERDICT:\s*(CLEAN|BLOCKING|NOT_REVIEWED)\s*$`, "i");
 var CJK5 = /[一-鿿]/u;
-var NAMES2 = Object.keys(PLAIN_WORDS).sort((a, b3) => b3.length - a.length).map((n) => n.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join("|");
+var NAMES3 = Object.keys(PLAIN_WORDS).sort((a, b3) => b3.length - a.length).map((n) => n.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join("|");
 var RAW_NAME = new RegExp(
-  `\`(?<![A-Za-z0-9_])(${NAMES2})(?![A-Za-z0-9_])\`|(?<![A-Za-z0-9_])(${NAMES2})(?![A-Za-z0-9_])`,
+  `\`(?<![A-Za-z0-9_])(${NAMES3})(?![A-Za-z0-9_])\`|(?<![A-Za-z0-9_])(${NAMES3})(?![A-Za-z0-9_])`,
   "gu"
 );
 function plainWords(text8) {
@@ -26350,6 +26613,7 @@ __export(remote_view_exports, {
   statusView: () => statusView,
   takeoverView: () => takeoverView,
   terminalAskView: () => terminalAskView,
+  terminalAsksOf: () => terminalAsksOf,
   windowView: () => windowView
 });
 
@@ -28465,8 +28729,8 @@ var STATUS_REFUSALS = /* @__PURE__ */ new Map([
   [403, "keyRejected"]
 ]);
 var ERROR_CODE = /^[a-z][a-z0-9_]{0,59}$/u;
-function saidIn(lang, sentence2) {
-  return remoteAgentText.in(lang)[sentence2];
+function saidIn(lang, sentence3) {
+  return remoteAgentText.in(lang)[sentence3];
 }
 function failureText2(err2, errors, now, lang = "en") {
   if (err2 instanceof Reconnecting) return offlineText(err2.connector, now, lang);
@@ -28705,9 +28969,9 @@ var Targets = class {
    */
   takeoverOf(chatKey, connector, agent, data, now, lang) {
     const entry = resumableOf(agent).find((e) => e.ref === textOf6(data["resume"]));
-    const no = (sentence2) => ({
+    const no = (sentence3) => ({
       entry: null,
-      problem: saidIn(lang, sentence2)
+      problem: saidIn(lang, sentence3)
     });
     if (entry === void 0) return no("conversationGone");
     if (entry.state === WATCH_STATE && data["takeover"]) {
@@ -28728,9 +28992,9 @@ var Targets = class {
    * process kept when it was typed (the card carries only a token).
    */
   folderOf(chatKey, agent, data, now, lang) {
-    const no = (sentence2) => ({
+    const no = (sentence3) => ({
       path: "",
-      problem: saidIn(lang, sentence2)
+      problem: saidIn(lang, sentence3)
     });
     if ("typed" in data) {
       const path = this.chats.typedPath(chatKey, textOf6(data["typed"]), now);
@@ -29541,7 +29805,7 @@ function older(version, than) {
 function isCode(reason) {
   return CODE4.test(reason);
 }
-function sentence(code3, lang, setup) {
+function sentence2(code3, lang, setup) {
   const text8 = own(connectorReasonText.in(lang), code3) ?? "";
   return code3 === "revoked" ? text8.replaceAll("{login}", setup.login()) : text8;
 }
@@ -29565,7 +29829,7 @@ function explain(code3, version = null, setup = new Setup("", null)) {
   if (!KNOWN.has(code3)) return both((lang) => connectorReasonHints.in(lang).unknown({ code: code3 }));
   return both((lang) => {
     const after = hintAfter(code3, lang, version);
-    const own3 = sentence(code3, lang, setup);
+    const own3 = sentence2(code3, lang, setup);
     return after ? `${own3}${after.sep}${after.hint}` : own3;
   });
 }
@@ -33198,6 +33462,7 @@ export {
   TAG,
   TARGET_LINES,
   TARGET_MAX,
+  TERMINAL_ASKS,
   TERMINAL_HOOK_COMMANDS,
   TERMINAL_SESSION_LIMITS,
   THUMB_COMMENT_MAX,
@@ -33314,8 +33579,10 @@ export {
   githubConfirmButtons,
   githubConfirmMessage,
   githubConnectMessage,
+  groupChosenLang,
   groupContextLines,
   groupContextText,
+  groupLangOf,
   guardrailsText,
   hasCjk2 as hasCjk,
   hasControl,

package/dist/types/assistant/events.d.ts

@@ -64,6 +64,7 @@ export interface RemoteNotice {
     readonly sessionId: string;
     readonly ask: Event | undefined;
     readonly machine: string;
+    /** Who asked, as the person knows it: the tool's name (Claude Code, Codex, Cursor) when Claw said which, else the agent's id. */
     readonly agent: string;
     readonly resolved?: {
         readonly actionId: string;

package/dist/types/language/chosen.d.ts

@@ -4,8 +4,9 @@
  *
  * Only a choice the person said counts: a language learnt from what they write (`learnLang`), and `/lang auto`, are no
  * choice, nothing is sent, and Claw reads the language from the message as before. To the assistant the choice goes in the
- * message's `channel_context` (`reply_language`); to a plain session (a group's turn, or a 1:1 chat without the assistant) as
- * the line Claw's assistant uses for it, after the message (`replyLanguageLine`).
+ * message's `channel_context` (`reply_language`); to a plain session (a 1:1 chat without the assistant) as the line Claw's
+ * assistant uses for it, after the message (`replyLanguageLine`). A group's turn carries the group's language in that line
+ * instead (`groupChosenLang`): in a group a person's own choice is not read.
  */
 import type { Lang } from "../locales/lang.js";
 /** What of a person's preferences says the choice (`Prefs.lang`, `Prefs.langSet`). */

package/dist/types/language/group.d.ts

@@ -0,0 +1,18 @@
+/**
+ * What a group chat says to set the language it is answered in: `/lang zh|en|auto` (`/lang` alone asks which it is), or one of a
+ * few sentences that name the group ("这个群用英文", "本群跟随提问者的语言", "use English in this group", "set the group language to
+ * Chinese"). Only the whole message counts. A sentence that does not name the group ("用英文回复", "answer in English") is no
+ * setting: it asks for that one answer in that language, and goes to the agent as it is.
+ */
+import type { GroupLanguage } from "../ports/store/group-language.js";
+/** A group's language command: set it, say which it is, or how to write it. */
+export type GroupLangCommand = {
+    readonly kind: "set";
+    readonly lang: GroupLanguage;
+} | {
+    readonly kind: "status";
+} | {
+    readonly kind: "usage";
+};
+/** The group's language command `text` is (`/lang …` or a sentence that sets it), or undefined when it is none. */
+export declare function parseGroupLang(text: string): GroupLangCommand | undefined;

package/dist/types/locales/group-language.d.ts

@@ -0,0 +1,32 @@
+import type { GroupLanguage } from "../ports/store/group-language.js";
+/** The announcement, in the chat, of a change of its language by `name` ("" when the channel gave none). */
+export declare function groupLanguageSet(lang: GroupLanguage, name: string): string;
+/** The card the first @mention in a chat with no language puts to its members. */
+export declare const GROUP_LANGUAGE_CARD: {
+    title: string;
+    text: (p: {
+        bot: string;
+    }) => string;
+    buttons: {
+        zh: string;
+        en: string;
+        auto: string;
+    };
+};
+export declare const groupLanguageText: import("./catalog.js").Catalog<{
+    isZh: (p: {
+        bot: string;
+    }) => string;
+    isEn: (p: {
+        bot: string;
+    }) => string;
+    isAuto: (p: {
+        bot: string;
+    }) => string;
+    isNone: (p: {
+        bot: string;
+    }) => string;
+    usage: (p: {
+        bot: string;
+    }) => string;
+}>;

package/dist/types/locales/group.d.ts

@@ -1,4 +1,4 @@
-/** What a group chat is told. Most of it is English only, as in the Python worker. */
+/** What a group chat is told, in the group's language (`Chat.lang`). */
 export declare const groupText: import("./catalog.js").Catalog<{
     githubOneToOne: string;
     oneToOneOnly: (p: {

package/dist/types/locales/terminal-approvals.d.ts

@@ -20,7 +20,11 @@ export declare const terminalApprovalText: import("./catalog.js").Catalog<{
         name: string;
     }) => string;
     firstAnswerWins: string;
+    afterCard: string;
+    onInput: string;
     tooLong: string;
+    tooLongAfterCard: string;
+    tooLongOnInput: string;
     questionOf: (p: {
         n: number;
         of: number;
@@ -31,6 +35,7 @@ export declare const terminalApprovalText: import("./catalog.js").Catalog<{
     optionNoStop: string;
     optionPlanApprove: string;
     optionPlanKeep: string;
+    optionToTerminal: string;
     answeredInTerminal: string;
     noLongerWaiting: string;
     answeredInTerminalLine: string;

package/dist/types/ports/store/group-language.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The language each group chat is answered in, as its members set it (`@bot /lang en|zh|auto`, "这个群用英文", or a pick on the
+ * card the bot posts the first time it is @mentioned there). `auto`: each question is answered in the language it is asked in.
+ * A chat the card was put to and nobody answered yet is kept as asked (`lang` ""), so it is never asked again. Who set it is
+ * never stored: the announcement names them once, in the chat.
+ */
+export type GroupLanguage = "zh" | "en" | "auto";
+export interface GroupLanguageRepository {
+    /** The chat's language; "" when it was asked and nobody chose; null when it was never asked nor set. */
+    groupLanguage(conversationId: string): GroupLanguage | "" | null;
+    /** Sets it (anyone in the chat may). */
+    setGroupLanguage(conversationId: string, lang: GroupLanguage): void;
+    /**
+     * Records that the chat is asked now: true when this call recorded it (it was never asked nor set), false when it was already, in
+     * one step, so that two @mentions at once put one card.
+     */
+    markGroupLanguageAsked(conversationId: string): boolean;
+    /** The question could not be put after all: the chat is asked again next time (nothing is undone once somebody chose). */
+    unmarkGroupLanguageAsked(conversationId: string): void;
+}

package/dist/types/ports/store/index.d.ts

@@ -14,6 +14,7 @@ import type { AssistantButtonRepository, AssistantCardRepository, AssistantMessa
 import type { FeedbackRepository } from "./feedback.js";
 import type { GithubConfirmationRepository, ReviewDelegationRepository } from "./github.js";
 import type { GroupContextRepository } from "./group-context.js";
+import type { GroupLanguageRepository } from "./group-language.js";
 import type { IdempotencyRepository } from "./idempotency.js";
 import type { LinkRepository } from "./link.js";
 import type { NotifySubscriptionRepository } from "./notify.js";
@@ -33,6 +34,7 @@ export interface StorePort {
     readonly approvals: ApprovalRepository;
     readonly observe: ObserveRepository;
     readonly groupContext: GroupContextRepository;
+    readonly groupLanguage: GroupLanguageRepository;
     readonly assistantCards: AssistantCardRepository;
     readonly assistantButtons: AssistantButtonRepository;
     readonly assistantMessages: AssistantMessageRepository;
@@ -55,6 +57,7 @@ export type * from "./assistant.js";
 export type * from "./feedback.js";
 export type * from "./github.js";
 export type * from "./group-context.js";
+export type * from "./group-language.js";
 export type * from "./idempotency.js";
 export type * from "./link.js";
 export type * from "./notify.js";

package/dist/types/protocol/claw-api/assistant-events.d.ts

@@ -101,6 +101,11 @@ export interface AssistantRemoteNotice {
     session_id: string;
     machine: string;
     agent: string;
+    /**
+     * A terminal's request (`ask.origin` "terminal"): which tool asked there (`claude`, `codex`, `cursor`), for a channel to name it as its
+     * users know it (Claude Code, Codex, Cursor) instead of by `agent`, the connector's id for it. Absent when the connector did not say.
+     */
+    tool?: "claude" | "codex" | "cursor";
     ask?: AssistantRemoteAsk;
     /** With `kind: "resolved"`: which request, and who ended it (`terminal`, or `timeout`, `session_end`, `connector_restart` when nobody did). */
     resolved?: {
@@ -121,8 +126,8 @@ export interface AssistantRemoteAsk {
     /** When the connector stops waiting for an answer (it refuses the request then); absent when it did not say. */
     expires_at?: string;
     /**
-     * `terminal`: asked in a terminal on the machine (a conversation its person started there), whose own prompt stays open: whichever
-     * answer comes first is taken. Absent for a session opened through Claw.
+     * `terminal`: asked in a terminal on the machine (a conversation its person started there), which asks it too (when: see
+     * `terminal_asks`); whichever answer comes first is taken. Absent for a session opened through Claw.
      */
     origin?: "terminal";
     /** A terminal's request: what kind of prompt it is (`execute`, `edit`, `question`, `switch_mode` for a plan, `mcp`, `other`). */
@@ -139,7 +144,18 @@ export interface AssistantRemoteAsk {
     /** A terminal's question asked as several cards: which this is (from 0), and how many. */
     question_index?: number;
     question_count?: number;
+    /**
+     * A terminal's request: when the terminal asks it too, as its connector said (`terminal_asks` on the request). Absent: alongside
+     * the card, and the first answer counts (Claude Code). `after_card`: only once the card is answered or its time is up, and the
+     * card offers only to decline or to hand it back to the terminal (Cursor). `on_input`: only once someone types in that terminal,
+     * which withdraws the card (Codex).
+     */
+    terminal_asks?: TerminalAsks;
 }
+/** When a terminal asks a request that is also on a card, besides alongside it: see {@link AssistantRemoteAsk.terminal_asks}. */
+export type TerminalAsks = "after_card" | "on_input";
+/** The values of `terminal_asks` a channel knows; any other is read as absent. */
+export declare const TERMINAL_ASKS: readonly TerminalAsks[];
 /** A choice a say puts to the person: from 2 to 10 options, one plain line each; `multiple` when several may be picked. */
 export interface AssistantSayChoice {
     options: string[];

package/dist/types/remote-view/terminal-ask-view.d.ts

@@ -1,7 +1,9 @@
 /**
  * The card of a question a terminal asks: a coding agent its person started in their own terminal wants to run a command, change
  * a file, start on a plan or have a multiple-choice question answered, and the connector's approval hooks put it here too
- * (`remote.ask` with `origin: "terminal"`). The terminal keeps asking: the first answer counts.
+ * (`remote.ask` with `origin: "terminal"`). The terminal asks too, as the request's `terminal_asks` says (`terminalAsksOf`): alongside
+ * the card, the first answer counting (Claude Code); only once the card is answered or its wait is over (Cursor); or once someone
+ * types in that terminal, which takes the question back from the card (Codex). The card says which.
  *
  * Nothing is approved unseen. The card shows the request whole (the connector and Claw carry it whole, credentials masked); a
  * request whose content did not come (Claw leaves it out past its size), or that is longer than a card shows, keeps only the
@@ -9,6 +11,7 @@
  * masked in it (a mask can hide more than the credential), or a character the card does not show as itself.
  */
 import type { Lang } from "../locales/lang.js";
+import { type TerminalAsks } from "../protocol.js";
 import type { DecisionButton } from "../remote/actions.js";
 import { type PermissionOption } from "../remote/options.js";
 import type { Reported } from "../remote/reported.js";
@@ -62,6 +65,13 @@ export interface TerminalAsk {
     readonly machine: string;
     readonly agent: string;
 }
+/**
+ * When the terminal asks a request that is also on a card (`remote.ask`'s `terminal_asks`, from the connector through Claw):
+ * `after_card`, only once the card is answered or its wait is over, and the card offers only to decline or hand it back (Cursor);
+ * `on_input`, only once someone types in that terminal, which withdraws the card (Codex); undefined (absent, or a value this
+ * client does not know), alongside the card, the first answer counting (Claude Code).
+ */
+export declare function terminalAsksOf(ask: Reported): TerminalAsks | undefined;
 /** Whether `remote.ask` is a question a terminal asks (a connector's approval hooks), not one an agent Claw started asks. */
 export declare function isTerminalAsk(ask: Reported | undefined): boolean;
 /** The card of a question a terminal asks. */

package/dist/types/routing/chat.d.ts

@@ -19,6 +19,15 @@ export declare function learnLang(store: Pick<RouterStore, "prefs">, userId: str
  * "what can you do") and the person did not choose one (`/lang`).
  */
 export declare function helpLang(store: Pick<RouterStore, "prefs">, userId: string, locale: string, asked: string | undefined): Lang;
+/**
+ * The language a group chat is answered in, its fixed texts and its answers alike: the one its members set (`/lang zh|en` there,
+ * or a pick on its language card); else (none set, or "follow the asker") the language of the message being answered (`written`).
+ * A person's own choice (`/lang` in their 1:1 chat) is not read here: in a group the group decides. A message that says no
+ * language of its own ("/new", a link) is answered in the one the sender's messages were last written in, else their client's.
+ */
+export declare function groupLangOf(store: Pick<RouterStore, "prefs"> & Partial<Pick<RouterStore, "groupLanguage">>, conversationId: string, userId: string, locale: string, written: string): Lang;
+/** The language a group chat's members set, when it is one (`/lang zh|en`); undefined for none, and for "follow the asker". */
+export declare function groupChosenLang(store: Partial<Pick<RouterStore, "groupLanguage">>, conversationId: string): Lang | undefined;
 /** One chat as the router answers in it: who wrote, where to answer, and in which language. */
 export declare class Chat {
     private readonly store;
@@ -28,11 +37,16 @@ export declare class Chat {
     readonly scope: string;
     /** The client's locale of the event being handled ("" for work that runs on its own). */
     readonly locale: string;
-    constructor(store: Pick<RouterStore, "prefs">, sender: UserRef, conversation: Conversation, 
+    /** The words of the message being answered ("" for a click, and for work that runs on its own): a group's language without one. */
+    readonly written: string;
+    constructor(store: Pick<RouterStore, "prefs"> & Partial<Pick<RouterStore, "groupLanguage">>, sender: UserRef, conversation: Conversation, 
     /** "" for the person's 1:1 chat, the conversation id of a group. */
     scope: string, 
     /** The client's locale of the event being handled ("" for work that runs on its own). */
-    locale: string);
+    locale: string, 
+    /** The words of the message being answered ("" for a click, and for work that runs on its own): a group's language without one. */
+    written?: string);
+    /** In a 1:1 chat the person's language (`langOf`); in a group, the group's (`groupLangOf`). */
     lang(): Lang;
     zh(): boolean;
     say(text: string): Promise<void>;

package/dist/types/routing/deps.d.ts

@@ -38,7 +38,7 @@ export interface RouterConfig {
     readonly ownThumbsMobile: boolean;
 }
 /** The repositories the router reads and writes (the W1 store, as far as routing goes). */
-export type RouterStore = Pick<StorePort, "links" | "references" | "prefs" | "members" | "sessions" | "repoHistory" | "turns" | "onboarding" | "idempotency" | "assistantMessages" | "notifySubs" | "reviewDelegation" | "approvals" | "now">;
+export type RouterStore = Pick<StorePort, "links" | "references" | "prefs" | "groupLanguage" | "members" | "sessions" | "repoHistory" | "turns" | "onboarding" | "idempotency" | "assistantMessages" | "notifySubs" | "reviewDelegation" | "approvals" | "now">;
 /** The per-person limits (Python `limits.py`): messages per window and tasks at the same time. */
 export interface RouterLimits {
     readonly maxConcurrentTasks: number;

package/dist/types/routing/group-language.d.ts

@@ -0,0 +1,25 @@
+import type { InboundAction } from "../ports/surface.js";
+import type { Chat } from "./chat.js";
+import type { RouterContext } from "./context.js";
+/** The verb of the language card's buttons. */
+export declare const GROUP_LANG_VERB = "group_lang";
+/**
+ * The language a group chat is answered in, as its members set it (the store's `groupLanguage`): `@bot /lang zh|en|auto` or a
+ * sentence that names the group ("这个群用英文"), and a card the first time the bot is @mentioned in a chat that has none. Anyone in
+ * the chat may set it, with no Claw credential (it is the chat's, not one person's), and every change is announced in the chat with
+ * the name of who made it. The group's language then governs everything said there (`Chat.lang`, `groupLangOf`) and the language
+ * its turns are asked to answer in (`TurnStarter`).
+ */
+export declare class GroupLanguages {
+    private readonly ctx;
+    constructor(ctx: RouterContext);
+    /** `/lang …` or a sentence that sets the group's language: answered here; false when `text` is neither. */
+    command(chat: Chat, text: string): Promise<boolean>;
+    /**
+     * The first @mention in a chat that has no language: the card that asks its members which, once (the chat is recorded as asked
+     * before the card goes, so two mentions at once put one; a card that could not be posted is asked again next time).
+     */
+    askOnce(chat: Chat): Promise<void>;
+    /** A pick on the language card, by anyone in the chat: the language is set, the card says so, and so does the chat. */
+    click(action: InboundAction, chat: Chat): Promise<void>;
+}

package/dist/types/routing/group-router.d.ts

@@ -3,6 +3,7 @@ import type { InboundAction, InboundMessage } from "../ports/surface.js";
 import { type Chat } from "./chat.js";
 import type { SessionCommands } from "./commands-session.js";
 import type { RouterContext } from "./context.js";
+import { type GroupLanguages } from "./group-language.js";
 import type { GroupRemote } from "./group-remote.js";
 import type { Onboarding } from "./onboarding.js";
 import { type PersonalText } from "./personal-text.js";
@@ -18,7 +19,8 @@ export declare class GroupRouter {
     private readonly onboarding;
     private readonly remote;
     private readonly starter;
-    constructor(ctx: RouterContext, text: PersonalText, sessions: SessionCommands, onboarding: Onboarding, remote: GroupRemote, starter: TurnStarter);
+    private readonly languages;
+    constructor(ctx: RouterContext, text: PersonalText, sessions: SessionCommands, onboarding: Onboarding, remote: GroupRemote, starter: TurnStarter, languages: GroupLanguages);
     route(event: InboundMessage | InboundAction, chat: Chat): Promise<void>;
     /** A button in a group: only those of the presser's own cards that may be pressed there answer. */
     private click;

package/dist/types/routing/turn-runner.d.ts

@@ -44,8 +44,9 @@ export interface TurnRun {
     readonly files: readonly InboundFile[];
     readonly lang: Lang;
     /**
-     * The language the person chose to be answered in (`/lang zh|en`, `chosenLang`), told to Claw after the message; undefined: they
-     * chose none, and the answer is in the language of what they wrote. A chat turn's only: a group's is the sender's.
+     * The language the turn is to be answered in, told to Claw after the message: in a 1:1 chat the one the person chose (`/lang
+     * zh|en`, `chosenLang`), in a group the group's (`groupChosenLang`); undefined: none was chosen, and the answer is in the language
+     * of what they wrote. A chat turn's only: a review's follows its request.
      */
     readonly replyLang?: Lang;
     /** The answer gets thumbs of the worker's own (a phone, whose own thumbs never reach the worker). */

package/dist/types/routing/turn-start.d.ts

@@ -1,7 +1,7 @@
 import type { Lang } from "../locales/lang.js";
 import type { Logger } from "../ports/logger.js";
 import type { InboundFile } from "../ports/surface.js";
-import type { Chat } from "./chat.js";
+import { type Chat } from "./chat.js";
 import type { RouterContext } from "./context.js";
 import type { ReviewRunFields, TurnOutcome } from "./turn-runner.js";
 /** Teams on a phone or a tablet: its own Stop under a reply is greyed out, and its own thumbs never reach the worker. */
@@ -97,7 +97,10 @@ export declare class TurnStarter {
     /** What the run reads of the chat's session: its id, the model it has, the repository a new one is bound to. */
     private sessionPart;
     private runOf;
-    /** The language the sender chose to be answered in, for a chat turn (a review's answer follows its request's language). */
+    /**
+     * The language a chat turn is to be answered in, when one was chosen (a review's answer follows its request's language): in a
+     * group the group's (`groupChosenLang`; the sender's own choice is not read there), in a 1:1 chat the person's.
+     */
     private replyLang;
     private hooks;
     private guarded;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primusclaw/personal-agent",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "The personal agent's channel-neutral core: domain logic, ports and plugin interfaces.",
   "license": "MIT",
   "repository": {