@trim21/personal-pi-extensions 0.0.347 → 0.0.349

package/README.md

@@ -263,9 +263,8 @@ index.ts     —— pi adapter：把 core 接到 pi 的 sendMessage / 生命周
 | 工具                 | 作用                                                                                                                                                                                                      |
 | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `talk-list-sessions` | 列出会话，返回 JSON 数组（`status` / `work_dir` / `id` / `name`，自己带 `self: true`）；只列出同组成员（未入组时只有自己），`status` 区分 live（`idle` / `working` / `waiting-talk-message`）与 `offline` |
-| `talk-ask`           | 向某个 session 提问并阻塞等待回复（默认 30 分钟超时）                                                                                                                                                     |
+| `talk-ask`           | 向某个 session 提问并阻塞等待回应（默认 30 分钟超时）；对方发来任何 `talk-send` 消息都会解除等待                                                                                                          |
 | `talk-send`          | 发送纯文本消息到单个 session（`to` 只接受明确的 session id，不支持广播）                                                                                                                                  |
-| `talk-reply`         | 回复一个 ask（`replyTo` 为 ask id，显式关联、不推断）                                                                                                                                                     |
 
 对端消息自动投递（无需主动拉取）：投递方式由 `talk.deliver` 配置，`steer` 在模型工作过程中打断/唤醒，`queue` 排队到 session 下一轮自然 turn 时注入。
 
@@ -275,10 +274,10 @@ index.ts     —— pi adapter：把 core 接到 pi 的 sendMessage / 生命周
 
 ### 关键设计
 
-- **presence 不靠心跳**：presence 由 `offline` 标志 + 进程 pid 存活判定；pid 存活时还校验进程启动时间（`/proc/<pid>/stat`），排除 pid 回卷复用造成的误判。未标记 offline 且进程存活即 live，否则 offline；没有心跳，进程挂死（wedged）与健康空闲不可区分。`status` 在 live 时显示 `working` / `waiting-talk-message`（`talk-ask` 阻塞等待回复中）/ `idle`。
+- **presence 不靠心跳**：presence 由 `offline` 标志 + 进程 pid 存活判定；pid 存活时还校验进程启动时间（`/proc/<pid>/stat`），排除 pid 回卷复用造成的误判。未标记 offline 且进程存活即 live，否则 offline；没有心跳，进程挂死（wedged）与健康空闲不可区分。`status` 在 live 时显示 `working` / `waiting-talk-message`（`talk-ask` 阻塞等待回应中）/ `idle`。
 - **定期清理**：进程仍存活的记录永不回收；进程已死且最后活跃超过 24h 且无未投递 mail 的记录会被定期 sweep（30 分钟一次）回收；有 mail 的保留 30 天。resume 后 session 会自动重新注册，无 mail 即无损失。
 - **投递成功才消费**：信件只在成功交给 `sendMessage` 后才从 inbox 删除，投递失败留在 inbox 下次重试——不会因 `sendMessage` 吞异常而静默丢信。
-- **双向 ask 仲裁**：`talk-ask` 发起前先检查收件箱（有对方消息就先读/先回）；阻塞等待期间若收到对方的 ask（而非 reply），按两个 ask 的 `ts` 字段仲裁——先 ask 者主导继续等，后 ask 者让位并先回复对方。`ts` 是信件内固定字段，双方读到同一对值，结论天然对称；同毫秒碰撞用 `session dir + session id` 字符串比较兜底。
+- **双向 ask 仲裁**：`talk-ask` 发起前先检查收件箱（有对方消息就先读/先回）；阻塞等待期间若收到对方的 ask，按两个 ask 的 `ts` 字段仲裁——先 ask 者主导继续等，后 ask 者让位并先回复对方。`ts` 是信件内固定字段，双方读到同一对值，结论天然对称；同毫秒碰撞用 `session dir + session id` 字符串比较兜底。
 - **typebox runtime 验证**：所有从存储读出的值经 TypeBox schema 校验，损坏/伪造数据被拒绝，不做 `as T` 强转。
 - **安全**：纯文本 ≤32KB；10s 去重 / 30s 限速 8 条 / 50 积压上限（防环）；每条投递标注来源（来自另一个 pi session，非用户）。
 - **group 可见性**：可见性完全由 group 决定——组内 session 只能看到同组成员，不在任何 group 的 session 只能看到自己。用 `/talk-group-*` 命令建组/入组，见下方「group 可见性」。

package/package.json

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

package/src/talk/core.ts

@@ -38,8 +38,6 @@ import {
   previewBody,
   readOutgoingAsk,
   removeLetter,
-  resolveAskByRef,
-  trackIncomingAsk,
   trackOutgoingAsk,
   unreadCount,
 } from "./mailbox.js";
@@ -56,8 +54,9 @@ import {
 } from "./registry.js";
 import type { TalkStorage } from "./storage.js";
 
-type AskOutcome =
-  { replied: true; body: string; from: string } | { replied: false; reason: string };
+interface AskOutcome {
+  reason: string;
+}
 type TargetResult = { ok: true; record: AgentRecord } | { ok: false; error: string };
 type SendResult = { ok: true; letter: Letter; verdict: string } | { ok: false; error: string };
 
@@ -241,32 +240,31 @@ export class TalkCore {
   }
 
   /**
-   * Shared per-letter inbound handling: route replies/cancels to their
-   * waiters, and run ask interlock arbitration + incoming-ask tracking.
-   * Returns false when the letter was fully handled here (routed to a waiter)
-   * and must not be handed to the model.
+   * Shared per-letter inbound handling: run ask interlock arbitration on
+   * incoming asks, and break the wait of an outstanding ask to the peer when
+   * the peer sends a plain message (ask = send + wait; any peer message is a
+   * response). Returns false when the letter was fully handled here (routed to
+   * a waiter) and must not be handed to the model.
    */
   private async processIncoming(letter: Letter): Promise<boolean> {
     const self = this.requireSelf();
-    if ((letter.kind === "reply" || letter.kind === "cancel") && letter.replyTo) {
-      const waiter = this.askWaiters.get(letter.replyTo);
-      await clearAsk(this.storage, self.addr, letter.replyTo);
-      if (waiter) {
-        this.askWaiters.delete(letter.replyTo);
-        waiter(
-          letter.kind === "reply"
-            ? { replied: true, body: letter.body, from: letter.from.name }
-            : { replied: false, reason: `cancelled by ${letter.from.name}` },
-        );
-        return false;
-      }
-    }
     if (letter.kind === "ask") {
       // Both sides asking each other: timestamp arbitration before delivering,
       // so the later asker yields and answers the earlier ask instead of
       // 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.
+      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({ reason: "peer sent a message in response" });
+          await clearAsk(this.storage, self.addr, myAsk.askId);
+        }
+      }
     }
     return true;
   }
@@ -328,7 +326,6 @@ export class TalkCore {
     target: AgentRecord,
     kind: LetterKind,
     body: string,
-    replyTo?: string,
   ): Promise<SendResult> {
     const self = this.requireSelf();
     const presence = presenceOf(target);
@@ -345,7 +342,6 @@ export class TalkCore {
       body,
       ts: this.now(),
     };
-    if (replyTo !== undefined) letter.replyTo = replyTo;
     await deposit(this.storage, target.addr, letter);
     this.policy.recordSend(body, target.addr);
     if (presence === "live") {
@@ -377,11 +373,10 @@ export class TalkCore {
         resolve(outcome);
       };
       const timer = setTimeout(
-        () =>
-          settle({ replied: false, reason: `no reply within ${Math.round(timeoutMs / 1000)}s` }),
+        () => settle({ reason: `no response within ${Math.round(timeoutMs / 1000)}s` }),
         timeoutMs,
       );
-      const onAbort = () => settle({ replied: false, reason: "aborted" });
+      const onAbort = () => settle({ reason: "aborted" });
       this.askWaiters.set(askId, settle);
       if (signal?.aborted) onAbort();
       else signal?.addEventListener("abort", onAbort, { once: true });
@@ -425,8 +420,7 @@ export class TalkCore {
     if (!peerFirst) return; // we asked first; keep waiting — the peer will yield
     this.askWaiters.delete(myAsk.askId);
     waiter({
-      replied: false,
-      reason: `peer asked first (their ask id ${letter.id.slice(-8)}) — answer it with talk-reply before re-asking`,
+      reason: `peer asked first (their ask id ${letter.id.slice(-8)}) — respond with a message before re-asking`,
     });
     await clearAsk(this.storage, self.addr, myAsk.askId);
   }
@@ -681,7 +675,7 @@ export class TalkCore {
     const inbox = await listInbox(this.storage, self.addr);
     const fromTarget = inbox.filter((item) => item.letter.from.addr === record.addr);
     if (fromTarget.length > 0) {
-      return `You have ${fromTarget.length} unread message(s) from "${record.name}" — reply before asking.`;
+      return `You have ${fromTarget.length} unread message(s) from "${record.name}" — respond to them before asking.`;
     }
     const sent = await this.sendLetter(record, "ask", body);
     if (!sent.ok) return sent.error;
@@ -695,46 +689,13 @@ export class TalkCore {
     try {
       const outcome = await this.waitForReply(sent.letter.id, Math.max(1000, timeoutMs), signal);
       await clearAsk(this.storage, self.addr, sent.letter.id);
-      if (!outcome.replied)
-        return `Ask ${sent.letter.id.slice(-8)} to "${record.name}": ${outcome.reason}.`;
-      return `"${record.name}" replied:\n\n${outcome.body}`;
+      return `Ask ${sent.letter.id.slice(-8)} to "${record.name}": ${outcome.reason}.`;
     } finally {
       // The ask tool call is still part of a running agent turn.
       this.setWorking();
     }
   }
 
-  async reply(replyTo: string, body: string): Promise<string> {
-    if (!body) return "reply requires 'message'.";
-    if (!replyTo) {
-      return "reply requires 'replyTo' (the ask/message id, shown in the delivered message).";
-    }
-    const self = this.requireSelf();
-    const ask = await resolveAskByRef(this.storage, self.addr, replyTo);
-    if (!ask) return `No pending ask matches '${replyTo}'.`;
-    const records = await listRecords(this.storage);
-    const asker = records.find((r) => r.addr === ask.from.addr);
-    const target = asker ?? this.recordFromLetter(ask);
-    const sent = await this.sendLetter(target, "reply", body, ask.id);
-    if (!sent.ok) return sent.error;
-    await clearAsk(this.storage, self.addr, ask.id);
-    return `Replied to "${target.name}" (ask ${ask.id.slice(-8)}): ${sent.verdict}.`;
-  }
-
-  /** Build a minimal record from a letter's sender when the peer record is gone. */
-  private recordFromLetter(letter: Letter): AgentRecord {
-    return {
-      addr: letter.from.addr,
-      agentId: letter.from.agentId,
-      name: letter.from.name,
-      cwd: letter.from.cwd,
-      pid: 0,
-      startedAt: letter.ts,
-      lastSeenAt: letter.ts,
-      status: "idle",
-    };
-  }
-
   // ── Presence watch ─────────────────────────────────────────────────────
 
   async watch(to: string): Promise<string> {

package/src/talk/format.ts

@@ -25,9 +25,7 @@ export function formatDelivery(letter: Letter, now: number = Date.now()): string
   const from = letter.from;
   const header = `From pi agent ${from.agentId} (${from.cwd}) — "${from.name}"`;
   const meta = `_id ${letter.id} · ${letter.kind} · sent ${age(letter.ts, now)}_`;
-  const hint =
-    letter.kind === "ask" ? `\n\nReply with the talk-reply tool, replyTo: "${letter.id}"` : "";
-  return `${BOUNDARY_PREAMBLE}\n\n${header}:\n\n${letter.body}\n\n${meta}${hint}`;
+  return `${BOUNDARY_PREAMBLE}\n\n${header}:\n\n${letter.body}\n\n${meta}`;
 }
 
 /** One agent as the model sees it in a listing. `id` is the stable pi

package/src/talk/index.ts

@@ -83,7 +83,6 @@ interface DeliveryDetails {
   from: Letter["from"];
   ts: number;
   body: string;
-  replyTo?: string;
 }
 
 /**
@@ -126,7 +125,6 @@ export default function talk(pi: ExtensionAPI) {
       from: letter.from,
       ts: letter.ts,
       body: letter.body,
-      ...(letter.replyTo !== undefined && { replyTo: letter.replyTo }),
     };
     try {
       // The core only removes the letter from the inbox after this returns
@@ -225,8 +223,8 @@ export default function talk(pi: ExtensionAPI) {
     name: "talk-ask",
     label: "Ask Talk",
     description:
-      "Ask another pi agent a question and block until it replies (or times out). Before asking, it checks whether that agent already sent you something; if so, you are told to read and reply first instead of asking.",
-    promptSnippet: "Ask another pi agent a question and wait for the reply",
+      "Ask another pi agent a question and block until it responds (or times out). Before asking, it checks whether that agent already sent you something; if so, you are told to read and respond first instead of asking.",
+    promptSnippet: "Ask another pi agent a question and wait for a response",
     parameters: Type.Object({
       to: Type.String({ description: "Target agent (name/address/@alias)" }),
       message: Type.String({ description: "The question" }),
@@ -265,23 +263,6 @@ export default function talk(pi: ExtensionAPI) {
     },
   });
 
-  pi.registerTool({
-    name: "talk-reply",
-    label: "Reply Talk",
-    description:
-      "Reply to a received ask. `replyTo` is the ask/message id (shown in the delivered message).",
-    promptSnippet: "Reply to a talk ask",
-    parameters: Type.Object({
-      replyTo: Type.String({ description: "The ask/message id to reply to" }),
-      message: Type.String({ description: "The reply body" }),
-    }),
-    async execute(_toolCallId, params) {
-      const initError = requireInit();
-      if (initError) return toolResult(initError);
-      return toolResult(await core.reply(params.replyTo, params.message));
-    },
-  });
-
   // ── /talk commands ────────────────────────────────────────────────────
 
   type OkResult<TFlags extends TObject> = Extract<CommandResult<TFlags>, { kind: "ok" }>;
@@ -496,9 +477,6 @@ export default function talk(pi: ExtensionAPI) {
     const header = `${theme.fg("accent", theme.bold(displayName(d.from.name)))} ${theme.fg("dim", `(${shortCwd(d.from.cwd)})`)} ${chip}`;
     const footer = theme.fg("dim", `id ${idTail} · ${d.kind} · ${relativeTime(d.ts)}`);
     const out = [header, sanitizeTerminal(d.body), "", footer];
-    if (d.kind === "ask") {
-      out.push(theme.fg("dim", `└─ reply via talk-reply, replyTo: "${idTail}"`));
-    }
     // plain 组件：不引入 pi-tui，直接输出带背景色的文本行
     const text = out.join("\n");
     return {

package/src/talk/mailbox.ts

@@ -202,28 +202,14 @@ export async function awaitReceipt(
 }
 
 // ── Ask tracking ─────────────────────────────────────────────────────────
-// Received asks live at asks/<addr>/<id>.json until we reply; our outgoing
-// asks live at asks/<addr>/out-<id>.json until a reply/cancel arrives or we
-// time out.
-
-function askKey(askId: string): string {
-  assertMessageId(askId);
-  return `${askId}.json`;
-}
+// Our outgoing asks live at asks/<addr>/out-<id>.json until a message from
+// the peer breaks the wait, the peer answers first, or we time out.
 
 function outAskKey(askId: string): string {
   assertMessageId(askId);
   return `out-${askId}.json`;
 }
 
-export async function trackIncomingAsk(
-  storage: TalkStorage,
-  addr: string,
-  letter: Letter,
-): Promise<void> {
-  await storage.writeJson(asksNs(addr), askKey(letter.id), letter);
-}
-
 export async function trackOutgoingAsk(
   storage: TalkStorage,
   addr: string,
@@ -232,15 +218,6 @@ export async function trackOutgoingAsk(
   await storage.writeJson(asksNs(addr), outAskKey(out.askId), out);
 }
 
-export async function readIncomingAsk(
-  storage: TalkStorage,
-  addr: string,
-  askId: string,
-): Promise<Letter | null> {
-  const raw = await storage.readJson(asksNs(addr), askKey(askId));
-  return normalizeLetter(raw);
-}
-
 export async function readOutgoingAsk(
   storage: TalkStorage,
   addr: string,
@@ -250,24 +227,11 @@ export async function readOutgoingAsk(
   return Value.Check(OutAskSchema, raw) ? raw : null;
 }
 
-/** Remove both sides of an ask id (incoming and/or outgoing). Idempotent. */
+/** Remove our outstanding ask. Idempotent. */
 export async function clearAsk(storage: TalkStorage, addr: string, askId: string): Promise<void> {
-  await storage.removeKey(asksNs(addr), askKey(askId));
   await storage.removeKey(asksNs(addr), outAskKey(askId));
 }
 
-/** Asks we have received and not yet answered, oldest first. */
-export async function pendingAsks(storage: TalkStorage, addr: string): Promise<Letter[]> {
-  const out: Letter[] = [];
-  for (const key of await storage.listKeys(asksNs(addr))) {
-    if (key.startsWith("out-")) continue;
-    const raw = await storage.readJson(asksNs(addr), key);
-    const letter = normalizeLetter(raw);
-    if (letter) out.push(letter);
-  }
-  return out;
-}
-
 /** Outgoing ask ids, used by the core for interlock arbitration. */
 export async function outgoingAskIds(storage: TalkStorage, addr: string): Promise<string[]> {
   const out: string[] = [];
@@ -278,21 +242,6 @@ export async function outgoingAskIds(storage: TalkStorage, addr: string): Promis
   return out;
 }
 
-/**
- * Resolve a pending ask by explicit replyTo id or unique suffix. No inference.
- * Matching is on the suffix: the prefix of a time-ordered (v7-style) id is the
- * timestamp part and collides easily, the suffix is the random part.
- */
-export async function resolveAskByRef(
-  storage: TalkStorage,
-  addr: string,
-  replyTo: string,
-): Promise<Letter | null> {
-  if (!replyTo) return null; // empty suffix matches every id — an explicit ref is required
-  const asks = await pendingAsks(storage, addr);
-  return asks.find((a) => a.id === replyTo || a.id.endsWith(replyTo)) ?? null;
-}
-
 // ── Audit log ────────────────────────────────────────────────────────────
 
 const AUDIT_LOG = "audit";

package/src/talk/skills/multi-agent-dev/SKILL.md

@@ -34,7 +34,7 @@ The core rule: **a peer only knows what you tell it.** Messages must be self-con
 
 ### Status
 
-- `idle` / `working` (agent actively running) / `waiting-talk-message` (blocked in `talk-ask` waiting for a reply)
+- `idle` / `working` (agent actively running) / `waiting-talk-message` (blocked in `talk-ask` waiting for a response)
 - `offline` (process exited or marked dead)
 - `talk-list-agents` lists every visible agent — live or offline — with its current status.
 
@@ -51,8 +51,7 @@ The core rule: **a peer only knows what you tell it.** Messages must be self-con
 | ------------------ | -------------------------------------------------------------------------------------------------------------------- |
 | `talk-list-agents` | List visible agents (`id` / `status` / `work_dir` / `name`); only group co-members (or only yourself when ungrouped) |
 | `talk-send`        | Send a plain message to a single agent id (async — the main collaboration primitive)                                 |
-| `talk-ask`         | Ask a question and block for the reply (default 30 min timeout)                                                      |
-| `talk-reply`       | Reply to a received ask; `replyTo` is the ask id shown in the delivered message                                      |
+| `talk-ask`         | Ask a question and block for a response (default 30 min timeout); any message from the peer breaks the wait          |
 
 Pairing into groups is a user action (`/talk-group-*` in the TUI); you only observe its effect through `talk-list-agents`.
 
@@ -68,7 +67,7 @@ Pairing into groups is a user action (`/talk-group-*` in the TUI); you only obse
 ### Synchronous question/answer (need the answer to continue)
 
 - Use `talk-ask` when the next step depends on the peer's information and the peer is reachable.
-- On receiving an ask, reply with `talk-reply` using the `replyTo` id from the delivered message.
+- On receiving an ask, respond with `talk-send` — any message you send breaks the peer's wait, so a plain `talk-send` back is the reply.
 - If two agents ask each other simultaneously: the later asker yields — answer the peer's ask first, then re-ask.
 
 ### Async notifications
@@ -93,5 +92,5 @@ Pairing into groups is a user action (`/talk-group-*` in the TUI); you only obse
 
 - **Avoid message loops**: if the peer sent you something or is asking you, answer it before sending new ones. Two agents pinging each other deadlock.
 - **Address from known ids**: only run `talk-list-agents` to discover agents or verify an id. If you already hold a valid id (e.g. from an incoming message or a previous listing), send directly — an unknown or invisible id is refused with `Unknown agent id`.
-- **Respect status**: asking an offline agent blocks until the 30 min timeout. Prefer `talk-send` there — the message queues on disk and the peer receives it when it resumes.
+- **Respect status**: asking an offline agent blocks until the 30 min timeout (nothing breaks the wait). Prefer `talk-send` there — the message queues on disk and the peer receives it when it resumes.
 - **Visibility boundary**: you can only collaborate with agents that share your group; ungrouped agents and other groups' members are unreachable by design. Ask the user to pair agents before collaborating.