@trim21/personal-pi-extensions 0.0.197 → 0.0.199

package/README.md

@@ -242,9 +242,11 @@ index.ts     —— pi adapter：把 core 接到 pi 的 sendMessage / 生命周
 
 **定位只认 session id**：`talk-send` / `talk-ask` / `talk-watch` 的 `to` 只接受 `talk-list-sessions` 返回的 `id`（pi 的 session uuid）精确匹配，不做 name/路径/前缀匹配。
 
+**标记废弃 session**：`/talk-dead` 把 session 的 `lastSeenAt` 置 0（从默认列表消失，下次 sweep 无 mail 即回收）：无参标记当前 session（同时停止其心跳），`/talk-dead <sessionId>` 标记指定 session，`/talk-dead --all` 标记所有其他可见 session。
+
 ### 关键设计
 
-- **心跳即活跃**：每个 session 每 15s 写一次 `lastSeenAt`；`talk-list-sessions` 默认只显示最近 15 分钟内有心跳的 session，已结束/挂起的 session 自动从默认列表消失（`includeOffline: true` 可见全部）。`status` 用 45s 心跳阈值区分 live / not responding / offline。
+- **心跳即活跃**：每个 session 每 15s 写一次 `lastSeenAt`；`talk-list-sessions` 默认只显示最近 15 分钟内有心跳的 session，已结束/挂起的 session 自动从默认列表消失（`includeOffline: true` 可见全部）。`status` 用 45s 心跳阈值区分 live / not responding / offline，并显示 `working` / `waiting-talk-message`（`talk-wait` / `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` 字符串比较兜底。

package/package.json

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

package/src/lib/jsonc.ts

@@ -0,0 +1,67 @@
+/**
+ * Minimal JSONC → JSON conversion for small user-edited config files.
+ *
+ * Strips line and block comments and trailing commas outside of string
+ * literals, so a stray comment in a config file does not silently void the
+ * whole file (the way a plain `JSON.parse` would).
+ */
+
+export function jsoncToJson(raw: string): string {
+  let out = "";
+  let inString = false;
+  let i = 0;
+  while (i < raw.length) {
+    const c = raw[i];
+    if (inString) {
+      out += c;
+      if (c === "\\" && i + 1 < raw.length) {
+        out += raw[i + 1];
+        i += 2;
+        continue;
+      }
+      if (c === '"') inString = false;
+      i++;
+      continue;
+    }
+    switch (c) {
+      case '"': {
+        inString = true;
+        out += c;
+        i++;
+        continue;
+      }
+      case "/": {
+        if (raw[i + 1] === "/") {
+          while (i < raw.length && raw[i] !== "\n") i++;
+          continue;
+        }
+        if (raw[i + 1] === "*") {
+          i += 2;
+          while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) i++;
+          i += 2;
+          continue;
+        }
+        out += c;
+        i++;
+        continue;
+      }
+      case ",": {
+        // Drop a trailing comma before } or ] (outside strings).
+        let j = i + 1;
+        while (j < raw.length && /\s/.test(raw[j])) j++;
+        if (raw[j] === "}" || raw[j] === "]") {
+          i++;
+          continue;
+        }
+        out += c;
+        i++;
+        continue;
+      }
+      default: {
+        out += c;
+        i++;
+      }
+    }
+  }
+  return out;
+}

package/src/talk/core.ts

@@ -128,6 +128,8 @@ export class TalkCore {
   private readonly deliveredIds = new Set<string>();
   /** Visibility gate over peer working directories; defaults to everything visible. */
   private isPeerVisible: (peerCwd: string) => boolean = () => true;
+  /** Manually marked dead: heartbeat stopped, lastSeenAt pinned to 0. */
+  private dead = false;
 
   private inboxPoll: ReturnType<typeof setInterval> | undefined;
   private heartbeat: ReturnType<typeof setInterval> | undefined;
@@ -203,6 +205,11 @@ export class TalkCore {
     void this.writeSelf({ status: "working" });
   }
 
+  /** Blocked on talk-wait / talk-ask — visible as "waiting-talk-message". */
+  setWaiting(): void {
+    void this.writeSelf({ status: "waiting-talk-message" });
+  }
+
   setIdle(): void {
     void this.writeSelf({ status: "idle" });
   }
@@ -213,7 +220,8 @@ export class TalkCore {
 
   private async writeSelf(patch: Partial<SessionRecord>): Promise<void> {
     if (!this.self) return;
-    this.self = { ...this.self, ...patch, lastSeenAt: this.now() };
+    // A dead session pins lastSeenAt to 0 so no later event re-freshens it.
+    this.self = { ...this.self, ...patch, lastSeenAt: this.dead ? 0 : this.now() };
     try {
       await writeRecord(this.storage, this.self);
     } catch {
@@ -470,13 +478,19 @@ export class TalkCore {
   async wait(timeoutMs: number, signal?: AbortSignal): Promise<string> {
     const self = this.requireSelf();
     const deadline = this.now() + timeoutMs;
-    for (;;) {
-      const inbox = await listInbox(this.storage, self.addr);
-      const fresh = await this.consumeFresh(inbox);
-      if (fresh.length > 0) return fresh.map((l) => formatDelivery(l)).join("\n\n");
-      if (signal?.aborted) return "aborted";
-      if (this.now() >= deadline) return `No message within ${Math.round(timeoutMs / 1000)}s.`;
-      await sleep(WAIT_POLL_MS);
+    this.setWaiting();
+    try {
+      for (;;) {
+        const inbox = await listInbox(this.storage, self.addr);
+        const fresh = await this.consumeFresh(inbox);
+        if (fresh.length > 0) return fresh.map((l) => formatDelivery(l)).join("\n\n");
+        if (signal?.aborted) return "aborted";
+        if (this.now() >= deadline) return `No message within ${Math.round(timeoutMs / 1000)}s.`;
+        await sleep(WAIT_POLL_MS);
+      }
+    } finally {
+      // The tool call is still part of a running agent turn.
+      this.setWorking();
     }
   }
 
@@ -509,6 +523,44 @@ export class TalkCore {
     return formatListing(filtered, self.addr, (r) => presenceOf(r, now));
   }
 
+  /** Visible peer records (excluding self), e.g. for command completions. */
+  async listPeers(): Promise<SessionRecord[]> {
+    const self = this.requireSelf();
+    const records = await listRecords(this.storage);
+    return records.filter((r) => r.addr !== self.addr && this.isPeerVisible(r.cwd));
+  }
+
+  /**
+   * Mark a session as dead by pinning lastSeenAt to 0: it vanishes from the
+   * default listing and the next sweep reaps it (empty mailbox). Without a
+   * target, marks this session — its heartbeat is stopped and later
+   * writeSelf calls no longer refresh lastSeenAt.
+   */
+  async markDead(target?: string): Promise<string> {
+    if (!target) {
+      this.dead = true;
+      if (this.heartbeat) {
+        clearInterval(this.heartbeat);
+        this.heartbeat = undefined;
+      }
+      await this.writeSelf({});
+      return "Marked this session as dead.";
+    }
+    const resolved = await this.resolveTarget(target);
+    if (!resolved.ok) return resolved.error;
+    await writeRecord(this.storage, { ...resolved.record, lastSeenAt: 0 });
+    return `Marked "${resolved.record.name}" as dead.`;
+  }
+
+  /** Mark every visible peer (except self) as dead. */
+  async markAllDead(): Promise<string> {
+    const peers = await this.listPeers();
+    for (const peer of peers) {
+      await writeRecord(this.storage, { ...peer, lastSeenAt: 0 });
+    }
+    return `Marked ${peers.length} session(s) as dead.`;
+  }
+
   async send(to: string, body: string): Promise<string> {
     if (!to) return 'send requires "to".';
     if (!body) return 'send requires "message".';
@@ -567,11 +619,17 @@ export class TalkCore {
       body,
       ts: sent.letter.ts,
     });
-    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(0, 8)} to "${record.name}": ${outcome.reason}.`;
-    return `"${record.name}" replied:\n\n${outcome.body}`;
+    this.setWaiting();
+    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(0, 8)} to "${record.name}": ${outcome.reason}.`;
+      return `"${record.name}" replied:\n\n${outcome.body}`;
+    } finally {
+      // The ask tool call is still part of a running agent turn.
+      this.setWorking();
+    }
   }
 
   async reply(replyTo: string, body: string): Promise<string> {

package/src/talk/index.ts

@@ -17,6 +17,7 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
+import { jsoncToJson } from "../lib/jsonc.js";
 import { resolveHomePath } from "../lib/path.js";
 import { buildVisibilityFilter, TalkCore } from "./core.js";
 import { formatDelivery } from "./format.js";
@@ -104,14 +105,17 @@ function readTalkSettings(): { dbPath?: string; deliver?: "steer" | "queue" } {
  * (everything visible); an explicit `"allowed": []` hides every peer.
  */
 function readWorkspaceTalkConfig(cwd: string): { allowed?: string[] } {
+  const configPath = path.join(cwd, ".pi", "talk.json");
   try {
-    const raw = fs.readFileSync(path.join(cwd, ".pi", "talk.json"), "utf8");
-    const parsed = JSON.parse(raw) as { allowed?: unknown };
+    const raw = fs.readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(jsoncToJson(raw)) as { allowed?: unknown };
     if (Array.isArray(parsed.allowed)) {
       return { allowed: parsed.allowed.filter((p): p is string => typeof p === "string") };
     }
     return {};
-  } catch {
+  } catch (error) {
+    // eslint-disable-next-line no-console -- config errors must be visible, not silent
+    console.error(`Warning: could not parse ${configPath}: ${String(error)}`);
     return {};
   }
 }
@@ -310,7 +314,7 @@ export default function talk(pi: ExtensionAPI) {
     },
   });
 
-  // ── /talk command ─────────────────────────────────────────────────────
+  // ── /talk commands ────────────────────────────────────────────────────
 
   pi.registerCommand("talk", {
     description: "List registered pi sessions",
@@ -320,6 +324,23 @@ export default function talk(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerCommand("talk-dead", {
+    description:
+      "Mark a talk session as dead (removed from listings, swept soon): no arg = this session, <sessionId> = that session, --all = every other visible session",
+    async handler(args) {
+      const initError = requireInit();
+      const trimmed = args.trim();
+      const text =
+        initError ??
+        (trimmed === "--all"
+          ? await core.markAllDead()
+          : trimmed
+            ? await core.markDead(trimmed)
+            : await core.markDead());
+      pi.sendMessage({ customType: LIST_TYPE, content: text, display: true });
+    },
+  });
+
   // ── Delivery card ──────────────────────────────────────────────────────
 
   pi.registerMessageRenderer<DeliveryDetails>(DELIVERY_TYPE, (message, _options, theme) => {

package/src/talk/registry.ts

@@ -30,7 +30,11 @@ export const SessionRecordSchema = Type.Object({
   pid: Type.Number(),
   startedAt: Type.Number(),
   lastSeenAt: Type.Number(),
-  status: Type.Union([Type.Literal("idle"), Type.Literal("working")]),
+  status: Type.Union([
+    Type.Literal("idle"),
+    Type.Literal("working"),
+    Type.Literal("waiting-talk-message"),
+  ]),
   offline: Type.Optional(Type.Boolean()),
 });
 export type SessionRecord = Static<typeof SessionRecordSchema>;