@trim21/personal-pi-extensions 0.1.612 → 0.1.619

package/src/talk/core.ts

@@ -102,12 +102,20 @@ export const TALK_JOIN_ENTRY_TYPE = "talk:join";
 export function restoreTalkAgentId(branchEntries: readonly unknown[]): string | undefined {
   let agentId: string | undefined;
   for (const entry of branchEntries) {
-    if (!isRecord(entry)) continue;
+    if (!isRecord(entry)) {
+      continue;
+    }
     const { type, customType, data } = entry;
-    if (type !== "custom" || customType !== TALK_JOIN_ENTRY_TYPE) continue;
-    if (!isRecord(data)) continue;
+    if (type !== "custom" || customType !== TALK_JOIN_ENTRY_TYPE) {
+      continue;
+    }
+    if (!isRecord(data)) {
+      continue;
+    }
     const recorded = data.agentId;
-    if (typeof recorded === "string" && recorded.length > 0) agentId = recorded;
+    if (typeof recorded === "string" && recorded.length > 0) {
+      agentId = recorded;
+    }
   }
   return agentId;
 }
@@ -161,7 +169,9 @@ export class TalkCore {
 
   private requireSelf(): AgentRecord {
     const self = this.self;
-    if (!self) throw new Error("Talk core is not started");
+    if (!self) {
+      throw new Error("Talk core is not started");
+    }
     return self;
   }
 
@@ -201,10 +211,18 @@ export class TalkCore {
   }
 
   async stop(): Promise<void> {
-    if (this.initialDrain) clearTimeout(this.initialDrain);
-    if (this.watchPoller) clearInterval(this.watchPoller);
-    if (this.inboxPoll) clearInterval(this.inboxPoll);
-    if (this.sweeper) clearInterval(this.sweeper);
+    if (this.initialDrain) {
+      clearTimeout(this.initialDrain);
+    }
+    if (this.watchPoller) {
+      clearInterval(this.watchPoller);
+    }
+    if (this.inboxPoll) {
+      clearInterval(this.inboxPoll);
+    }
+    if (this.sweeper) {
+      clearInterval(this.sweeper);
+    }
     if (this.self) {
       try {
         await this.writeSelf({ status: "idle", offline: true });
@@ -232,7 +250,9 @@ export class TalkCore {
   }
 
   private async writeSelf(patch: Partial<AgentRecord>): Promise<void> {
-    if (!this.self) return;
+    if (!this.self) {
+      return;
+    }
     // A dead agent pins lastSeenAt to 0 so no later event re-freshens it.
     this.self = { ...this.self, ...patch, lastSeenAt: this.dead ? 0 : this.now() };
     try {
@@ -247,7 +267,9 @@ export class TalkCore {
    * 该动作下次成功后再失败会重新上报。通知通道本身出错也不能逃逸。
    */
   private notifyBackgroundFailure(action: string, error: unknown): void {
-    if (this.backgroundFailuresReported.has(action)) return;
+    if (this.backgroundFailuresReported.has(action)) {
+      return;
+    }
     this.backgroundFailuresReported.add(action);
     const detail = error instanceof Error ? error.message : String(error);
     try {
@@ -271,7 +293,9 @@ export class TalkCore {
   }
 
   private startInboxPoll(): void {
-    if (this.inboxPoll) return;
+    if (this.inboxPoll) {
+      return;
+    }
     this.inboxPoll = setInterval(() => {
       this.runInBackground("inbox poll", () => this.checkInbox());
     }, INBOX_POLL_MS);
@@ -283,11 +307,17 @@ export class TalkCore {
   /** Drain the inbox and hand each letter to the adapter. Public so tests can drive it. */
   async checkInbox(): Promise<void> {
     const self = this.self;
-    if (!self) return;
-    if (this.now() - this.lastDeliveryFailureAt < DELIVERY_BACKOFF_MS) return;
+    if (!self) {
+      return;
+    }
+    if (this.now() - this.lastDeliveryFailureAt < DELIVERY_BACKOFF_MS) {
+      return;
+    }
     // Refuse mode: never drain — letters stay queued (receipts honestly read
     // 'queued') instead of being silently consumed and dropped.
-    if (!inboundAccepts()) return;
+    if (!inboundAccepts()) {
+      return;
+    }
     const items = await listInbox(this.storage, self.addr);
     for (const item of items) {
       if (this.deliveredIds.has(item.letter.id)) {
@@ -388,7 +418,9 @@ export class TalkCore {
     const memberIds = await this.myGroupMemberIds();
     const others = records.filter((r) => r.addr !== self.addr && memberIds?.has(r.agentId));
     const target = others.find((r) => r.agentId === to);
-    if (!target) return { ok: false, error: refusalUnknown(to) };
+    if (!target) {
+      return { ok: false, error: refusalUnknown(to) };
+    }
     return { ok: true, record: target };
   }
 
@@ -404,7 +436,9 @@ export class TalkCore {
         ? 0
         : await unreadCount(this.storage, target.addr);
     const verdict = this.policy.check(body, backlog, target.addr);
-    if (!verdict.ok) return { ok: false, error: verdict.reason };
+    if (!verdict.ok) {
+      return { ok: false, error: verdict.reason };
+    }
     const letter: Letter = {
       id: newMessageId(),
       from: { addr: self.addr, name: self.name, cwd: self.cwd, agentId: self.agentId },
@@ -448,8 +482,11 @@ export class TalkCore {
       );
       const onAbort = () => settle({ reason: "aborted" });
       this.askWaiters.set(askId, settle);
-      if (signal?.aborted) onAbort();
-      else signal?.addEventListener("abort", onAbort, { once: true });
+      if (signal?.aborted) {
+        onAbort();
+      } else {
+        signal?.addEventListener("abort", onAbort, { once: true });
+      }
     });
   }
 
@@ -458,7 +495,9 @@ export class TalkCore {
     const self = this.requireSelf();
     for (const askId of await outgoingAskIds(this.storage, self.addr)) {
       const out = await readOutgoingAsk(this.storage, self.addr, askId);
-      if (out && out.toAddr === toAddr) return out;
+      if (out && out.toAddr === toAddr) {
+        return out;
+      }
     }
     return undefined;
   }
@@ -480,14 +519,20 @@ export class TalkCore {
   private async resolveInterlock(letter: Letter): Promise<void> {
     const self = this.requireSelf();
     const myAsk = await this.findOutAskTo(letter.from.addr);
-    if (!myAsk) return;
+    if (!myAsk) {
+      return;
+    }
     const waiter = this.askWaiters.get(myAsk.askId);
-    if (!waiter) return;
+    if (!waiter) {
+      return;
+    }
     const peerFirst = peerAskedFirst(
       { ts: letter.ts, cwd: letter.from.cwd, agentId: letter.from.agentId },
       { ts: myAsk.ts, cwd: self.cwd, agentId: self.agentId },
     );
-    if (!peerFirst) return; // we asked first; keep waiting — the peer will yield
+    if (!peerFirst) {
+      return; // we asked first; keep waiting — the peer will yield
+    }
     this.askWaiters.delete(myAsk.askId);
     waiter({
       reason: `peer asked first (their ask id ${letter.id.slice(-8)}) — respond with a message before re-asking`,
@@ -508,7 +553,9 @@ export class TalkCore {
     const all = await listRecords(this.storage);
     const memberIds = await this.myGroupMemberIds();
     const records = all.filter((r) => {
-      if (r.addr === self.addr) return !this.dead;
+      if (r.addr === self.addr) {
+        return !this.dead;
+      }
       return memberIds?.has(r.agentId) ?? false;
     });
     return formatListing(records, self.addr, presenceOf);
@@ -520,8 +567,12 @@ export class TalkCore {
     const records = await listRecords(this.storage);
     const memberIds = await this.myGroupMemberIds();
     const filtered = records.filter((r) => {
-      if (r.cwd !== cwd) return false;
-      if (r.addr === self.addr) return !this.dead;
+      if (r.cwd !== cwd) {
+        return false;
+      }
+      if (r.addr === self.addr) {
+        return !this.dead;
+      }
       return memberIds?.has(r.agentId) ?? false;
     });
     return formatListing(filtered, self.addr, presenceOf);
@@ -548,7 +599,9 @@ export class TalkCore {
       return "Marked this agent as dead.";
     }
     const resolved = await this.resolveTarget(target);
-    if (!resolved.ok) return resolved.error;
+    if (!resolved.ok) {
+      return resolved.error;
+    }
     await writeRecord(this.storage, { ...resolved.record, lastSeenAt: 0, offline: true });
     return `Marked "${resolved.record.name}" as dead.`;
   }
@@ -568,7 +621,9 @@ export class TalkCore {
   private async leaveCurrentGroup(): Promise<boolean> {
     const self = this.requireSelf();
     const group = await groupForAgent(this.storage, self.agentId);
-    if (!group) return false;
+    if (!group) {
+      return false;
+    }
     const others = group.members.filter((m) => m !== self.agentId);
     if (others.length === 0) {
       await deleteGroup(this.storage, group.id);
@@ -636,7 +691,9 @@ export class TalkCore {
    */
   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.";
+    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, agentName);
   }
@@ -645,7 +702,9 @@ export class TalkCore {
   async groupLeave(): Promise<string> {
     const self = this.requireSelf();
     const group = await groupForAgent(this.storage, self.agentId);
-    if (!group) return "Not in any group.";
+    if (!group) {
+      return "Not in any group.";
+    }
     const others = group.members.filter((m) => m !== self.agentId);
     if (others.length === 0) {
       await deleteGroup(this.storage, group.id);
@@ -660,9 +719,13 @@ export class TalkCore {
   /** Delete a group by name; its members become ungrouped. */
   async groupDelete(groupName: string): Promise<string> {
     const name = groupName.trim();
-    if (!isValidGroupName(name)) return `Invalid group name '${name}'.`;
+    if (!isValidGroupName(name)) {
+      return `Invalid group name '${name}'.`;
+    }
     const group = await readGroup(this.storage, name);
-    if (!group) return `Unknown group '${name}'. Run /talk-group-list to see groups.`;
+    if (!group) {
+      return `Unknown group '${name}'. Run /talk-group-list to see groups.`;
+    }
     await deleteGroup(this.storage, name);
     return `Deleted group ${name} (${group.members.length} member(s)).`;
   }
@@ -670,7 +733,9 @@ export class TalkCore {
   /** Delete every group; all agents become ungrouped. */
   async groupClear(): Promise<string> {
     const groups = await listGroups(this.storage);
-    for (const group of groups) await deleteGroup(this.storage, group.id);
+    for (const group of groups) {
+      await deleteGroup(this.storage, group.id);
+    }
     return groups.length === 0 ? "No groups." : `Deleted ${groups.length} group(s).`;
   }
 
@@ -681,7 +746,9 @@ export class TalkCore {
   async groupList(): Promise<string> {
     const self = this.requireSelf();
     const groups = await listGroups(this.storage);
-    if (groups.length === 0) return "No groups.";
+    if (groups.length === 0) {
+      return "No groups.";
+    }
     const records = await listRecords(this.storage);
     const label = (agentId: string): string => {
       const rec = records.find((r) => r.agentId === agentId);
@@ -719,32 +786,48 @@ export class TalkCore {
   async groupStatus(): Promise<string | undefined> {
     const self = this.requireSelf();
     const group = await groupForAgent(this.storage, self.agentId);
-    if (!group) return undefined;
+    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".';
+    if (!to) {
+      return 'send requires "to".';
+    }
+    if (!body) {
+      return 'send requires "message".';
+    }
     if (to === "*" || to === "cwd") {
       return "send requires a single agent id; broadcasting is disabled.";
     }
     const resolved = await this.resolveTarget(to);
-    if (!resolved.ok) return resolved.error;
+    if (!resolved.ok) {
+      return resolved.error;
+    }
     const sent = await this.sendLetter(resolved.record, "message", body);
-    if (!sent.ok) return sent.error;
+    if (!sent.ok) {
+      return sent.error;
+    }
     return `Sent to "${resolved.record.name}" (${shortAddr(resolved.record.addr)}) [id ${sent.letter.id.slice(-8)}]: ${sent.verdict}.`;
   }
 
   async ask(to: string, body: string, timeoutMs: number, signal?: AbortSignal): Promise<string> {
-    if (!to) return 'ask requires "to".';
-    if (!body) return 'ask requires "message".';
+    if (!to) {
+      return 'ask requires "to".';
+    }
+    if (!body) {
+      return 'ask requires "message".';
+    }
     if (to === "*" || to === "cwd") {
       return "ask is 1:1 and cannot broadcast.";
     }
     const self = this.requireSelf();
     const resolved = await this.resolveTarget(to);
-    if (!resolved.ok) return resolved.error;
+    if (!resolved.ok) {
+      return resolved.error;
+    }
     const record = resolved.record;
     // Fast-path deadlock avoidance: if the target already sent us something,
     // answer them first instead of blocking on a fresh ask. This closes the
@@ -755,7 +838,9 @@ export class TalkCore {
       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;
+    if (!sent.ok) {
+      return sent.error;
+    }
     await trackOutgoingAsk(this.storage, self.addr, {
       askId: sent.letter.id,
       toAddr: record.addr,
@@ -776,16 +861,22 @@ export class TalkCore {
   // ── Presence watch ─────────────────────────────────────────────────────
 
   async watch(to: string): Promise<string> {
-    if (!to) return "watch requires 'to' (a peer name or address prefix).";
+    if (!to) {
+      return "watch requires 'to' (a peer name or address prefix).";
+    }
     const resolved = await this.resolveTarget(to);
-    if (!resolved.ok) return resolved.error;
+    if (!resolved.ok) {
+      return resolved.error;
+    }
     this.watched.set(resolved.record.addr, presenceOf(resolved.record));
     this.startWatchPoller();
     return `Watching "${resolved.record.name}" (${shortAddr(resolved.record.addr)}) for presence transitions. Notifications arrive as talk messages.`;
   }
 
   private startWatchPoller(): void {
-    if (this.watchPoller) return;
+    if (this.watchPoller) {
+      return;
+    }
     this.watchPoller = setInterval(() => {
       this.runInBackground("presence watch", () => this.pollWatched());
     }, WATCH_POLL_MS);
@@ -793,11 +884,15 @@ export class TalkCore {
   }
 
   private async pollWatched(): Promise<void> {
-    if (!this.self || this.watched.size === 0) return;
+    if (!this.self || this.watched.size === 0) {
+      return;
+    }
     for (const [addr, prev] of this.watched) {
       const rec = await readRecord(this.storage, addr);
       const now: Presence = rec ? presenceOf(rec) : "offline";
-      if (now === prev) continue;
+      if (now === prev) {
+        continue;
+      }
       this.watched.set(addr, now);
       const label = rec ? `"${rec.name}"` : shortAddr(addr);
       const state = now === "live" ? (rec?.status ?? "idle") : "offline";

package/src/talk/format.ts

@@ -14,9 +14,13 @@ export function shortAddr(addr: string): string {
 
 export function age(ts: number, now: number = Date.now()): string {
   const s = Math.max(0, Math.round((now - ts) / 1000));
-  if (s < 60) return `${s}s ago`;
+  if (s < 60) {
+    return `${s}s ago`;
+  }
   const m = Math.round(s / 60);
-  if (m < 60) return `${m}m ago`;
+  if (m < 60) {
+    return `${m}m ago`;
+  }
   return `${Math.round(m / 60)}h ago`;
 }
 
@@ -45,12 +49,16 @@ export function formatListing(
   selfAddr: string,
   presence: (r: AgentRecord) => Presence,
 ): string {
-  if (records.length === 0) return "[]";
+  if (records.length === 0) {
+    return "[]";
+  }
   const items: AgentListItem[] = records.map((r) => {
     const p = presence(r);
     const status = p === "live" ? r.status : "offline";
     const item: AgentListItem = { status, work_dir: r.cwd, id: r.agentId, name: r.name };
-    if (r.addr === selfAddr) item.self = true;
+    if (r.addr === selfAddr) {
+      item.self = true;
+    }
     return item;
   });
   return JSON.stringify(items, null, 2);

package/src/talk/group.ts

@@ -39,7 +39,9 @@ export const GROUPS_NS = "groups";
 const GROUP_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
 
 export function assertGroupId(id: string): void {
-  if (!GROUP_ID_PATTERN.test(id)) throw new TypeError(`Invalid group name: ${id}`);
+  if (!GROUP_ID_PATTERN.test(id)) {
+    throw new TypeError(`Invalid group name: ${id}`);
+  }
 }
 
 export function isValidGroupName(id: string): boolean {
@@ -60,7 +62,9 @@ export async function listGroups(storage: TalkStorage): Promise<Group[]> {
   const out: Group[] = [];
   for (const key of await storage.listKeys(GROUPS_NS)) {
     const raw = await storage.readJson(GROUPS_NS, key);
-    if (Value.Check(GroupSchema, raw)) out.push(raw);
+    if (Value.Check(GroupSchema, raw)) {
+      out.push(raw);
+    }
   }
   return out.toSorted((a, b) => a.createdAt - b.createdAt);
 }
@@ -85,7 +89,9 @@ export async function deleteGroup(storage: TalkStorage, id: string): Promise<boo
  */
 export async function groupForAgent(storage: TalkStorage, agentId: string): Promise<Group | null> {
   for (const group of await listGroups(storage)) {
-    if (group.members.includes(agentId)) return group;
+    if (group.members.includes(agentId)) {
+      return group;
+    }
   }
   return null;
 }

package/src/talk/index.ts

@@ -86,7 +86,9 @@ function readTalkSettings(): { dbPath?: string; deliver?: "steer" | "queue" } {
     const raw = fs.readFileSync(path.join(getAgentDir(), "settings.json"), "utf8");
     const parsed = JSON.parse(raw) as { talk?: { db_path?: unknown; deliver?: unknown } };
     const talk = parsed.talk;
-    if (!talk) return {};
+    if (!talk) {
+      return {};
+    }
     const dbPath = typeof talk.db_path === "string" ? talk.db_path : undefined;
     const deliver = talk.deliver === "steer" || talk.deliver === "queue" ? talk.deliver : undefined;
     return { dbPath, deliver };
@@ -151,14 +153,18 @@ export default function talk(pi: ExtensionAPI) {
   });
 
   function requireInit(): string | undefined {
-    if (!core.selfAddr) return "Talk is not initialized (no session_start yet).";
+    if (!core.selfAddr) {
+      return "Talk is not initialized (no session_start yet).";
+    }
     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;
+      if (!self) {
+        return;
+      }
       try {
         const text = await core.groupStatus();
         ui.setStatus("talk", text && ui.theme.fg("accent", text));
@@ -205,7 +211,9 @@ export default function talk(pi: ExtensionAPI) {
   pi.on("session_info_changed", () => {
     // A name set explicitly via `--name` wins over pi's session title;
     // otherwise follow pi's session name.
-    if (self) core.setAgentName(explicitName ?? pi.getSessionName() ?? self.name);
+    if (self) {
+      core.setAgentName(explicitName ?? pi.getSessionName() ?? self.name);
+    }
   });
   pi.on("session_shutdown", () => {
     void core.stop();
@@ -223,7 +231,9 @@ export default function talk(pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params) {
       const initError = requireInit();
-      if (initError) return toolResult(initError);
+      if (initError) {
+        return toolResult(initError);
+      }
       return toolResult(params.cwd ? await core.listCwd(params.cwd) : await core.list());
     },
   });
@@ -243,7 +253,9 @@ export default function talk(pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params, signal) {
       const initError = requireInit();
-      if (initError) return toolResult(initError);
+      if (initError) {
+        return toolResult(initError);
+      }
       return toolResult(
         await core.ask(
           params.to,
@@ -267,7 +279,9 @@ export default function talk(pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params) {
       const initError = requireInit();
-      if (initError) return toolResult(initError);
+      if (initError) {
+        return toolResult(initError);
+      }
       return toolResult(await core.send(params.to, params.message));
     },
   });
@@ -417,7 +431,9 @@ export default function talk(pi: ExtensionAPI) {
         ctx,
         async (parsed) => {
           const agentName = parsed.flags.name?.trim() || undefined;
-          if (agentName !== undefined) explicitName = agentName;
+          if (agentName !== undefined) {
+            explicitName = agentName;
+          }
           return core.groupJoin(parsed.args[0], agentName);
         },
         { sendToContext: true },
@@ -433,7 +449,9 @@ export default function talk(pi: ExtensionAPI) {
         ctx,
         async (parsed) => {
           const agentName = parsed.flags.name?.trim() || undefined;
-          if (agentName !== undefined) explicitName = agentName;
+          if (agentName !== undefined) {
+            explicitName = agentName;
+          }
           return core.groupJoinLast(agentName);
         },
         { sendToContext: true },
@@ -496,7 +514,9 @@ export default function talk(pi: ExtensionAPI) {
   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;
+      if (!text) {
+        return;
+      }
       return {
         render: (width: number) =>
           truncateToVisualLines(text, Infinity, width, 1).visualLines.map((line) =>

package/src/talk/mailbox.ts

@@ -49,11 +49,19 @@ export type LetterKind = Letter["kind"];
  * unchanged; anything else returns null.
  */
 export function normalizeLetter(value: unknown): Letter | null {
-  if (Value.Check(LetterSchema, value)) return value;
-  if (!isRecord(value)) return null;
+  if (Value.Check(LetterSchema, value)) {
+    return value;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
   const from = value.from;
-  if (!isRecord(from)) return null;
-  if (typeof from.sessionId !== "string") return null;
+  if (!isRecord(from)) {
+    return null;
+  }
+  if (typeof from.sessionId !== "string") {
+    return null;
+  }
   const migrated = {
     ...value,
     from: { ...from, agentId: from.sessionId },
@@ -98,7 +106,9 @@ export function newMessageId(): string {
 }
 
 function assertMessageId(id: string): void {
-  if (!MESSAGE_ID_PATTERN.test(id)) throw new TypeError(`Invalid talk message id: ${id}`);
+  if (!MESSAGE_ID_PATTERN.test(id)) {
+    throw new TypeError(`Invalid talk message id: ${id}`);
+  }
 }
 
 /** The storage key for a letter: `<ts>-<id>.json`, sorted oldest-first. */
@@ -112,7 +122,9 @@ export function letterFileName(letter: Letter): string {
 
 /** Structural validation plus filename safety (id/timestamp shape). */
 export function isValidLetter(value: unknown): value is Letter {
-  if (!Value.Check(LetterSchema, value)) return false;
+  if (!Value.Check(LetterSchema, value)) {
+    return false;
+  }
   try {
     letterFileName(value);
     return true;
@@ -153,7 +165,9 @@ export async function listInbox(storage: TalkStorage, addr: string): Promise<Inb
   for (const fileName of await storage.listKeys(inboxNs(addr))) {
     const raw = await storage.readJson(inboxNs(addr), fileName);
     const letter = normalizeLetter(raw);
-    if (letter && isValidLetter(letter)) out.push({ fileName, letter });
+    if (letter && isValidLetter(letter)) {
+      out.push({ fileName, letter });
+    }
     // corrupt letters are skipped; the caller may remove them separately
   }
   return out; // keys are already sorted by listKeys
@@ -194,7 +208,9 @@ export async function awaitReceipt(
   while (Date.now() < deadline) {
     const inbox = await listInbox(storage, toAddr);
     const stillThere = inbox.some((i) => i.letter.id === letter.id);
-    if (!stillThere) return "delivered";
+    if (!stillThere) {
+      return "delivered";
+    }
     await sleep(100);
   }
   const inbox = await listInbox(storage, toAddr);
@@ -236,7 +252,9 @@ export async function clearAsk(storage: TalkStorage, addr: string, askId: string
 export async function outgoingAskIds(storage: TalkStorage, addr: string): Promise<string[]> {
   const out: string[] = [];
   for (const key of await storage.listKeys(asksNs(addr))) {
-    if (!key.startsWith("out-") || !key.endsWith(".json")) continue;
+    if (!key.startsWith("out-") || !key.endsWith(".json")) {
+      continue;
+    }
     out.push(key.slice("out-".length, -".json".length));
   }
   return out;
@@ -271,7 +289,9 @@ export async function readAudit(storage: TalkStorage, limit = 50): Promise<Audit
   for (const line of await storage.readLog(AUDIT_LOG)) {
     try {
       const parsed: unknown = JSON.parse(line);
-      if (Value.Check(AuditRecordSchema, parsed)) out.push(parsed);
+      if (Value.Check(AuditRecordSchema, parsed)) {
+        out.push(parsed);
+      }
     } catch {
       // skip corrupt line — append-only, never fatal
     }

package/src/talk/policy.ts

@@ -53,7 +53,9 @@ export class OutboundPolicy {
       };
     }
     const windowStart = now - RATE_LIMIT_WINDOW_MS;
-    while (this.sentAt.length > 0 && this.sentAt[0] < windowStart) this.sentAt.shift();
+    while (this.sentAt.length > 0 && this.sentAt[0] < windowStart) {
+      this.sentAt.shift();
+    }
     if (this.sentAt.length >= RATE_LIMIT_MAX) {
       return {
         ok: false,
@@ -73,7 +75,9 @@ export class OutboundPolicy {
     }
     const cutoff = this.now() - DEDUPE_WINDOW_MS;
     for (const [key, ts] of this.recentBodies) {
-      if (ts < cutoff) this.recentBodies.delete(key);
+      if (ts < cutoff) {
+        this.recentBodies.delete(key);
+      }
     }
   }
 }