@trim21/personal-pi-extensions 0.0.346 → 0.0.348

package/package.json

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

package/src/talk/core.ts

@@ -267,6 +267,21 @@ export class TalkCore {
       // both timing out.
       await this.resolveInterlock(letter);
       await trackIncomingAsk(this.storage, self.addr, letter);
+    } else if (letter.kind === "message") {
+      // A plain message from a peer we are blocked asking breaks the wait: the
+      // peer is engaging, so do not keep the caller stuck waiting for a reply.
+      const myAsk = await this.findOutAskTo(letter.from.addr);
+      if (myAsk) {
+        const waiter = this.askWaiters.get(myAsk.askId);
+        if (waiter) {
+          this.askWaiters.delete(myAsk.askId);
+          waiter({
+            replied: false,
+            reason: "peer sent a message instead of replying to your ask",
+          });
+          await clearAsk(this.storage, self.addr, myAsk.askId);
+        }
+      }
     }
     return true;
   }
@@ -535,7 +550,7 @@ export class TalkCore {
     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 +559,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,7 +573,7 @@ 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}.`;
   }
 
   /**
@@ -621,6 +641,20 @@ 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

package/src/talk/index.ts

@@ -148,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);
       },
     },
   });
@@ -289,22 +286,34 @@ 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);
@@ -412,27 +421,41 @@ export default function talk(pi: ExtensionAPI) {
   pi.registerCommand("talk-group-join", {
     description: TALK_GROUP_JOIN_SPEC.description,
     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);
-      }),
+      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, 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);
-      }),
+      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, ctx) =>
-      handleCommand(TALK_GROUP_LEAVE_SPEC, args, ctx, async () => core.groupLeave()),
+      handleCommand(TALK_GROUP_LEAVE_SPEC, args, ctx, async () => core.groupLeave(), {
+        sendToContext: true,
+      }),
   });
 
   pi.registerCommand("talk-group-list", {
@@ -486,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,
+      };
+    });
+  }
 }