@trim21/personal-pi-extensions 0.0.344 → 0.0.347

package/README.md

@@ -321,7 +321,7 @@ sqlite 文件路径按优先级取第一个可用值：
 ```
 /talk-group-join              # 无参：自动创建一个新 group（uuid 作为组名）并加入
 /talk-group-join <name>       # 加入名为 name 的 group；不存在则创建（名字允许字母/数字/-/_）
-/talk-group-join-last         # 加入最近创建的 group（方便新开 session 快速归队）
+/talk-group-join-last         # 加入最近创建的 group（方便新开 session 快速归队）；支持 --name <alias> 设置显示名
 /talk-group-leave             # 离开当前 group（组空了自动删除）
 /talk-group-list              # 列出所有 group 及其成员，最新创建的在前
 /talk-group-del <name>        # 删除指定 group（成员随之变为未入组）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.344",
+  "version": "0.0.347",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/talk/core.ts

@@ -530,12 +530,12 @@ export class TalkCore {
       return `Invalid group name '${name}'. Allowed: letters, digits, '-' and '_' (max 64 chars).`;
     }
     if (agentName !== undefined) {
-      await this.writeSelf({ name: agentName });
+      await this.writeSelf({ name: agentName, alias: agentName });
     }
     const nameNote = agentName === undefined ? "" : ` You are visible as "${agentName}".`;
     const existing = await readGroup(this.storage, name);
     if (existing?.members.includes(self.agentId)) {
-      return `Already in group ${name} (${existing.members.length} member(s)).${nameNote}`;
+      return `Already in group ${name} (${existing.members.length} member(s)). Members: ${await this.groupMemberNames(existing.members)}.${nameNote}`;
     }
     await this.leaveCurrentGroup();
     if (existing) {
@@ -544,7 +544,12 @@ export class TalkCore {
         members: [...existing.members, self.agentId],
         updatedAt: this.now(),
       });
-      return `Joined group ${name} (${existing.members.length + 1} member(s)). You now see only co-members.${nameNote}`;
+      return `Joined group ${name} (${
+        existing.members.length + 1
+      } member(s)). Members: ${await this.groupMemberNames([
+        ...existing.members,
+        self.agentId,
+      ])}. You now see only co-members.${nameNote}`;
     }
     const now = this.now();
     await writeGroup(this.storage, {
@@ -553,15 +558,18 @@ export class TalkCore {
       createdAt: now,
       updatedAt: now,
     });
-    return `Created group ${name}.${nameNote} Other agents join it with /talk-group-join ${name}.`;
+    return `Created group ${name}. Members: ${await this.groupMemberNames([self.agentId])}.${nameNote} Other agents join it with /talk-group-join ${name}.`;
   }
 
-  /** Join the most recently created group; no-op when already in it. */
-  async groupJoinLast(): Promise<string> {
+  /**
+   * Join the most recently created group; no-op when already in it. When
+   * `agentName` is given, the agent's display name is set to it.
+   */
+  async groupJoinLast(agentName?: string): Promise<string> {
     const groups = await listGroups(this.storage);
     if (groups.length === 0) return "No groups. Create one with /talk-group-join.";
     const latest = groups.reduce((a, b) => (b.createdAt > a.createdAt ? b : a));
-    return this.groupJoin(latest.id);
+    return this.groupJoin(latest.id, agentName);
   }
 
   /** Leave the current group; an emptied group is deleted. */
@@ -618,6 +626,32 @@ export class TalkCore {
     return `Groups (${groups.length}):\n${lines.join("\n")}`;
   }
 
+  /** Human-readable member list: `name (shortId)`, self marked `← you`. */
+  private async groupMemberNames(memberIds: string[]): Promise<string> {
+    const self = this.requireSelf();
+    const records = await listRecords(this.storage);
+    const label = (agentId: string): string => {
+      const rec = records.find((r) => r.agentId === agentId);
+      const id = agentId.length > 8 ? `${agentId.slice(0, 8)}…` : agentId;
+      return rec ? `${rec.name} (${id})` : `unknown agent (${id})`;
+    };
+    return memberIds
+      .map((agentId) => (agentId === self.agentId ? `${label(agentId)} ← you` : label(agentId)))
+      .join(", ");
+  }
+
+  /**
+   * Status-bar text for the caller: "alias@group" when an explicit alias was
+   * set via `talk-group-join --name`, "@group" otherwise; undefined when the
+   * caller is in no group (the adapter clears its status bar).
+   */
+  async groupStatus(): Promise<string | undefined> {
+    const self = this.requireSelf();
+    const group = await groupForAgent(this.storage, self.agentId);
+    if (!group) return undefined;
+    return self.alias ? `${self.alias}@${group.id}` : `@${group.id}`;
+  }
+
   async send(to: string, body: string): Promise<string> {
     if (!to) return 'send requires "to".';
     if (!body) return 'send requires "message".';

package/src/talk/index.ts

@@ -14,7 +14,9 @@ import * as path from "node:path";
 
 import {
   type ExtensionAPI,
+  type ExtensionCommandContext,
   type ExtensionContext,
+  type ExtensionUIContext,
   getAgentDir,
   truncateToVisualLines,
 } from "@earendil-works/pi-coding-agent";
@@ -146,12 +148,9 @@ export default function talk(pi: ExtensionAPI) {
     events: {
       deliver: deliverToAgent,
       notify(content) {
-        // Presence transitions are informational — queue for the next turn
-        // rather than steering into a busy agent.
-        pi.sendMessage(
-          { customType: NOTIFY_TYPE, content, display: true },
-          { deliverAs: "nextTurn" },
-        );
+        // Presence transitions are informational — show in the TUI only, never
+        // in LLM context.
+        pi.appendEntry(NOTIFY_TYPE, content);
       },
     },
   });
@@ -161,6 +160,19 @@ export default function talk(pi: ExtensionAPI) {
     return undefined;
   }
 
+  /** Refresh the talk footer/status-bar text: "alias@group", or "@group" with no explicit alias. */
+  function refreshGroupStatus(ui: ExtensionUIContext): void {
+    void (async () => {
+      if (!self) return;
+      try {
+        const text = await core.groupStatus();
+        ui.setStatus("talk", text && ui.theme.fg("accent", text));
+      } catch {
+        // status bar is best-effort; never break the agent
+      }
+    })();
+  }
+
   // ── Lifecycle ──────────────────────────────────────────────────────────
 
   pi.on("session_start", (_event, ctx: ExtensionContext) => {
@@ -177,7 +189,7 @@ export default function talk(pi: ExtensionAPI) {
       lastSeenAt: now,
       status: "idle",
     };
-    void core.start(self);
+    void core.start(self).then(() => refreshGroupStatus(ctx.ui));
   });
 
   pi.on("agent_start", () => core.setWorking());
@@ -274,21 +286,37 @@ export default function talk(pi: ExtensionAPI) {
 
   type OkResult<TFlags extends TObject> = Extract<CommandResult<TFlags>, { kind: "ok" }>;
 
-  /** Parse a /talk command; on help/error or init failure the text is sent, otherwise run() produces the listing text. */
+  /**
+   * Parse a /talk command; on help/error or init failure the text is sent,
+   * otherwise run() produces the listing text. With `sendToContext` the result
+   * is injected into the LLM context (sendMessage); otherwise it is appended
+   * as a display-only session entry (appendEntry, never sent to the LLM).
+   */
   function handleCommand<TFlags extends TObject>(
     spec: CommandSpec<TFlags>,
     args: string,
+    ctx: ExtensionCommandContext,
     run: (parsed: OkResult<TFlags>) => Promise<string> | string,
+    options?: { sendToContext?: boolean },
   ): Promise<void> {
+    const emit = (text: string): void => {
+      if (options?.sendToContext) {
+        pi.sendMessage({ customType: LIST_TYPE, content: text, display: true });
+      } else {
+        pi.appendEntry(LIST_TYPE, text);
+      }
+    };
     const parsed = parseCommand(spec, args);
     if (parsed.kind !== "ok") {
-      pi.sendMessage({ customType: LIST_TYPE, content: parsed.text, display: true });
+      emit(parsed.text);
       return Promise.resolve();
     }
     return (async () => {
       const initError = requireInit();
-      const text = initError ?? (await run(parsed));
-      pi.sendMessage({ customType: LIST_TYPE, content: text, display: true });
+      emit(initError ?? (await run(parsed)));
+      // Group membership can change under any of these commands; keep the
+      // footer/status-bar text in sync.
+      refreshGroupStatus(ctx.ui);
     })();
   }
 
@@ -327,9 +355,13 @@ export default function talk(pi: ExtensionAPI) {
 
   const TALK_GROUP_JOIN_LAST_SPEC = {
     name: "talk-group-join-last",
-    usage: "",
-    description: "Join the most recently created agent group (no-op when already in it).",
-    flags: Type.Object({}),
+    usage: "[options]",
+    description:
+      "Join the most recently created agent group (no-op when already in it); --name <alias> additionally sets this agent's display name",
+    flags: Type.Object({
+      name: Type.Optional(Type.String({ description: "Set this agent's display name" })),
+    }),
+    flagMeta: { name: { short: "n", valuePlaceholder: "<alias>" } },
     arity: { max: 0 },
   };
 
@@ -368,13 +400,13 @@ export default function talk(pi: ExtensionAPI) {
 
   pi.registerCommand("talk", {
     description: TALK_SPEC.description,
-    handler: (args) => handleCommand(TALK_SPEC, args, async () => core.list()),
+    handler: (args, ctx) => handleCommand(TALK_SPEC, args, ctx, async () => core.list()),
   });
 
   pi.registerCommand("talk-dead", {
     description: TALK_DEAD_SPEC.description,
-    handler: (args) =>
-      handleCommand(TALK_DEAD_SPEC, args, async (parsed) => {
+    handler: (args, ctx) =>
+      handleCommand(TALK_DEAD_SPEC, args, ctx, async (parsed) => {
         if (parsed.flags.all && parsed.args.length > 0) {
           return "--all cannot be combined with an agent id.\nTry '/talk-dead --help' for usage.";
         }
@@ -388,39 +420,62 @@ export default function talk(pi: ExtensionAPI) {
 
   pi.registerCommand("talk-group-join", {
     description: TALK_GROUP_JOIN_SPEC.description,
-    handler: (args) =>
-      handleCommand(TALK_GROUP_JOIN_SPEC, args, async (parsed) => {
-        const agentName = parsed.flags.name?.trim() || undefined;
-        if (agentName !== undefined) explicitName = agentName;
-        return core.groupJoin(parsed.args[0], agentName);
-      }),
+    handler: (args, ctx) =>
+      handleCommand(
+        TALK_GROUP_JOIN_SPEC,
+        args,
+        ctx,
+        async (parsed) => {
+          const agentName = parsed.flags.name?.trim() || undefined;
+          if (agentName !== undefined) explicitName = agentName;
+          return core.groupJoin(parsed.args[0], agentName);
+        },
+        { sendToContext: true },
+      ),
   });
 
   pi.registerCommand("talk-group-join-last", {
     description: TALK_GROUP_JOIN_LAST_SPEC.description,
-    handler: (args) =>
-      handleCommand(TALK_GROUP_JOIN_LAST_SPEC, args, async () => core.groupJoinLast()),
+    handler: (args, ctx) =>
+      handleCommand(
+        TALK_GROUP_JOIN_LAST_SPEC,
+        args,
+        ctx,
+        async (parsed) => {
+          const agentName = parsed.flags.name?.trim() || undefined;
+          if (agentName !== undefined) explicitName = agentName;
+          return core.groupJoinLast(agentName);
+        },
+        { sendToContext: true },
+      ),
   });
 
   pi.registerCommand("talk-group-leave", {
     description: TALK_GROUP_LEAVE_SPEC.description,
-    handler: (args) => handleCommand(TALK_GROUP_LEAVE_SPEC, args, async () => core.groupLeave()),
+    handler: (args, ctx) =>
+      handleCommand(TALK_GROUP_LEAVE_SPEC, args, ctx, async () => core.groupLeave(), {
+        sendToContext: true,
+      }),
   });
 
   pi.registerCommand("talk-group-list", {
     description: TALK_GROUP_LIST_SPEC.description,
-    handler: (args) => handleCommand(TALK_GROUP_LIST_SPEC, args, async () => core.groupList()),
+    handler: (args, ctx) =>
+      handleCommand(TALK_GROUP_LIST_SPEC, args, ctx, async () => core.groupList()),
   });
 
   pi.registerCommand("talk-group-del", {
     description: TALK_GROUP_DEL_SPEC.description,
-    handler: (args) =>
-      handleCommand(TALK_GROUP_DEL_SPEC, args, async (parsed) => core.groupDelete(parsed.args[0])),
+    handler: (args, ctx) =>
+      handleCommand(TALK_GROUP_DEL_SPEC, args, ctx, async (parsed) =>
+        core.groupDelete(parsed.args[0]),
+      ),
   });
 
   pi.registerCommand("talk-group-clear", {
     description: TALK_GROUP_CLEAR_SPEC.description,
-    handler: (args) => handleCommand(TALK_GROUP_CLEAR_SPEC, args, async () => core.groupClear()),
+    handler: (args, ctx) =>
+      handleCommand(TALK_GROUP_CLEAR_SPEC, args, ctx, async () => core.groupClear()),
   });
 
   // ── Delivery card ──────────────────────────────────────────────────────
@@ -454,4 +509,20 @@ export default function talk(pi: ExtensionAPI) {
       invalidate: (): void => undefined,
     };
   });
+
+  // ── Display-only entries (appendEntry): shown in chat, persisted, never in LLM context ──
+
+  for (const type of [LIST_TYPE, NOTIFY_TYPE]) {
+    pi.registerEntryRenderer<string>(type, (entry, _options, theme) => {
+      const text = typeof entry.data === "string" ? entry.data : "";
+      if (!text) return;
+      return {
+        render: (width: number) =>
+          truncateToVisualLines(text, Infinity, width, 1).visualLines.map((line) =>
+            theme.bg("customMessageBg", line),
+          ),
+        invalidate: (): void => undefined,
+      };
+    });
+  }
 }

package/src/talk/registry.ts

@@ -36,6 +36,8 @@ export const AgentRecordSchema = Type.Object({
   addr: Type.String(),
   agentId: Type.String(),
   name: Type.String(),
+  /** Display name explicitly set via `talk-group-join --name`, distinct from the session name. */
+  alias: Type.Optional(Type.String()),
   cwd: Type.String(),
   pid: Type.Number(),
   pidStart: Type.Optional(Type.Number()),