pi-ca-leash 0.10.0

package/extensions/peer-relay.ts

@@ -0,0 +1,83 @@
+export interface PeerRelaySnapshot {
+  sessionId: string;
+  state: string;
+  updatedAt: string;
+  relayKey: string;
+}
+
+export interface PeerRelayMessageInput {
+  peerName: string;
+  state: string;
+  sessionId: string;
+  message: string;
+}
+
+const RELAYABLE_STATES = new Set(["idle", "waiting", "error"]);
+
+export function createPeerRelaySnapshot(input: { sessionId: string; state: string; updatedAt: string; messageText?: string }): PeerRelaySnapshot {
+  const digest = input.messageText ? shortDigest(input.messageText) : undefined;
+  return {
+    sessionId: input.sessionId,
+    state: input.state,
+    updatedAt: input.updatedAt,
+    relayKey: digest ? `${input.sessionId}:${input.state}:${digest}` : `${input.sessionId}:${input.state}`,
+  };
+}
+
+export function shouldRelayPeerCompletion(previous: PeerRelaySnapshot | undefined, current: PeerRelaySnapshot): boolean {
+  if (!RELAYABLE_STATES.has(current.state)) {
+    return false;
+  }
+  return previous !== undefined && previous.relayKey !== current.relayKey;
+}
+
+export function shouldForceRelayPeerCompletion(previous: PeerRelaySnapshot | undefined, current: PeerRelaySnapshot): boolean {
+  if (!RELAYABLE_STATES.has(current.state)) {
+    return false;
+  }
+  return previous?.relayKey !== current.relayKey;
+}
+
+export function formatQuotedTextBlock(text: string, language = "text"): string {
+  const longestBacktickRun = Math.max(...(text.match(/`+/g) ?? [""]).map((match) => match.length));
+  const fence = "`".repeat(Math.max(3, longestBacktickRun + 1));
+  return [`${fence}${language}`, text, fence].join("\n");
+}
+
+export function formatPeerCompletionTurn(input: PeerRelayMessageInput): string {
+  const headline = input.state === "waiting"
+    ? `Peer ${input.peerName} needs input.`
+    : input.state === "error"
+      ? `Peer ${input.peerName} failed.`
+      : `Peer ${input.peerName} finished.`;
+
+  return [
+    `[peer_update name=${input.peerName} state=${input.state} session=${shortId(input.sessionId, 12)}]`,
+    "Automated peer update.",
+    "",
+    `Peer: ${input.peerName}`,
+    `State: ${input.state}`,
+    `Session: ${shortId(input.sessionId, 12)}`,
+    headline,
+    "",
+    "Latest peer message:",
+    formatQuotedTextBlock(input.message),
+    "",
+    "Use this as internal orchestration context.",
+    "Choose next step: continue orchestration, ask follow-up, or ignore if already handled.",
+    "Do not quote this wrapper verbatim to the user.",
+  ].join("\n");
+}
+
+function shortId(value: string, size: number): string {
+  return value.length > size ? value.slice(0, size) : value;
+}
+
+// DJB2 hash — deterministic, no imports, 8 hex chars.
+function shortDigest(text: string): string {
+  let hash = 5381;
+  for (let i = 0; i < text.length; i++) {
+    hash = (((hash << 5) + hash) ^ text.charCodeAt(i)) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}

package/extensions/peer-ux.test.ts

@@ -0,0 +1,239 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { BridgePeer } from "@pi-claude-code-agent/intercom-bridge";
+import type { RuntimeEvent } from "@pi-claude-code-agent/runtime";
+import { buildPeerActivityRow, getPeerFirstHealth, isPeerVisibleInWidget } from "./peer-ux.js";
+
+function makePeer(overrides: Partial<BridgePeer> = {}): BridgePeer {
+  return {
+    name: "reviewer",
+    sessionId: "session-1",
+    cwd: process.cwd(),
+    state: "idle",
+    createdAt: "2026-05-01T19:10:00.000Z",
+    updatedAt: "2026-05-01T19:14:05.000Z",
+    lastActivityAt: "2026-05-01T19:14:05.000Z",
+    ...overrides,
+  };
+}
+
+function makeEvent(event: Partial<RuntimeEvent> & Pick<RuntimeEvent, "type">): RuntimeEvent {
+  return {
+    id: "event-1",
+    sessionId: "session-1",
+    sequence: 1,
+    timestamp: "2026-05-01T19:14:05.000Z",
+    ...event,
+  } as RuntimeEvent;
+}
+
+test("buildPeerActivityRow summarizes active Bash tool use", () => {
+  const row = buildPeerActivityRow(makePeer({ state: "busy" }), [
+    makeEvent({
+      type: "tool",
+      phase: "requested",
+      toolName: "Bash",
+      input: { command: "npm test" },
+    }),
+  ]);
+
+  assert.equal(row.state, "busy");
+  assert.equal(row.activity, "Bash: npm test");
+});
+
+test("buildPeerActivityRow summarizes last reply for idle peer", () => {
+  const row = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "message",
+      role: "assistant",
+      message: {
+        role: "assistant",
+        blocks: [{ type: "text", text: "peer-ok" }],
+      },
+    }),
+  ]);
+
+  assert.equal(row.state, "idle");
+  assert.equal(row.activity, "last reply: peer-ok");
+});
+
+test("buildPeerActivityRow detects waiting for input", () => {
+  const row = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "message",
+      role: "assistant",
+      message: {
+        role: "assistant",
+        blocks: [{ type: "text", text: "Please provide the failing command." }],
+      },
+    }),
+  ]);
+
+  assert.equal(row.state, "waiting");
+  assert.equal(row.activity, "needs input");
+});
+
+test("buildPeerActivityRow does not flag completed reports as waiting", () => {
+  const row = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "message",
+      role: "assistant",
+      message: {
+        role: "assistant",
+        blocks: [{
+          type: "text",
+          text: [
+            "Slice implemented.",
+            "",
+            "Changed files:",
+            "- extensions/peer-ux.ts",
+            "",
+            "Commands:",
+            "- npm test",
+            "",
+            "Blockers: none.",
+            "Residual risk: low.",
+          ].join("\n"),
+        }],
+      },
+    }),
+  ]);
+
+  assert.equal(row.state, "idle");
+  assert.match(row.activity, /^last reply:/);
+});
+
+test("buildPeerActivityRow does not treat report headings as unresolved asks", () => {
+  const row = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "message",
+      role: "assistant",
+      message: {
+        role: "assistant",
+        blocks: [{ type: "text", text: "What changed:\n- tightened peer state mapping\n\nNext steps: none." }],
+      },
+    }),
+  ]);
+
+  assert.equal(row.state, "idle");
+  assert.match(row.activity, /^last reply:/);
+});
+
+test("buildPeerActivityRow includes latest token usage from result events", () => {
+  const row = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "result",
+      ok: true,
+      summary: "done",
+      usage: {
+        inputTokens: 123_000,
+        outputTokens: 456,
+        cacheReadInputTokens: 100_000,
+        reasoningOutputTokens: 12,
+      },
+    }),
+  ]);
+
+  assert.equal(row.inputTokens, 123_000);
+  assert.equal(row.outputTokens, 456);
+  assert.equal(row.cacheReadInputTokens, 100_000);
+  assert.equal(row.reasoningOutputTokens, 12);
+});
+
+test("buildPeerActivityRow includes latest context usage from result events", () => {
+  const row = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "result",
+      ok: true,
+      summary: "done",
+      usage: {
+        inputTokens: 20_000,
+        outputTokens: 100,
+        contextTokens: 50_000,
+        contextWindow: 200_000,
+        contextPercentage: 25,
+      },
+    }),
+  ]);
+
+  assert.equal(row.contextTokens, 50_000);
+  assert.equal(row.contextWindow, 200_000);
+  assert.equal(row.contextPercentage, 25);
+});
+
+test("buildPeerActivityRow derives context usage from raw Claude SDK modelUsage fallback", () => {
+  const row = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "result",
+      ok: true,
+      summary: "done",
+      usage: {
+        inputTokens: 6,
+        outputTokens: 23,
+        cacheCreationInputTokens: 29_989,
+        cacheReadInputTokens: 0,
+      },
+      raw: {
+        type: "result",
+        modelUsage: {
+          "claude-haiku-4-5-20251001": {
+            inputTokens: 359,
+            outputTokens: 13,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            contextWindow: 200_000,
+            maxOutputTokens: 32_000,
+          },
+          "claude-opus-4-7[1m]": {
+            inputTokens: 6,
+            outputTokens: 23,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 29_989,
+            contextWindow: 1_000_000,
+            maxOutputTokens: 64_000,
+          },
+        },
+      },
+    }),
+  ]);
+
+  assert.equal(row.contextTokens, 29_995);
+  assert.equal(row.contextWindow, 1_000_000);
+  assert.equal(row.contextPercentage, 3);
+});
+
+test("buildPeerActivityRow includes driver and model from peer", () => {
+  const row = buildPeerActivityRow(makePeer({ driver: "codex-cli", model: "claude-sonnet-4-6" }), []);
+  assert.equal(row.driver, "codex-cli");
+  assert.equal(row.model, "claude-sonnet-4-6");
+});
+
+test("buildPeerActivityRow has undefined driver and model when peer has none", () => {
+  const row = buildPeerActivityRow(makePeer(), []);
+  assert.equal(row.driver, undefined);
+  assert.equal(row.model, undefined);
+});
+
+test("stopped peers are hidden from the compact widget", () => {
+  assert.equal(isPeerVisibleInWidget(buildPeerActivityRow(makePeer({ state: "idle" }), [])), true);
+  assert.equal(isPeerVisibleInWidget(buildPeerActivityRow(makePeer({ state: "stopped" }), [])), false);
+});
+
+test("peer-first health favors warning over activity", () => {
+  const busy = buildPeerActivityRow(makePeer({ state: "busy" }), []);
+  const waiting = buildPeerActivityRow(makePeer(), [
+    makeEvent({
+      type: "message",
+      role: "assistant",
+      message: {
+        role: "assistant",
+        blocks: [{ type: "text", text: "What file should I inspect next?" }],
+      },
+    }),
+  ]);
+
+  assert.equal(getPeerFirstHealth([busy], false), "active");
+  assert.equal(getPeerFirstHealth([waiting], false), "warning");
+  assert.equal(getPeerFirstHealth([], true), "warning");
+  assert.equal(getPeerFirstHealth([], false), "idle");
+});

package/extensions/peer-ux.ts

@@ -0,0 +1,327 @@
+import { basename } from "node:path";
+import type { BridgePeer } from "@pi-claude-code-agent/intercom-bridge";
+import type { RuntimeEvent, ToolEvent } from "@pi-claude-code-agent/runtime";
+
+export interface PeerActivityRow {
+  name: string;
+  state: string;
+  activity: string;
+  lastUpdateAt: string;
+  sessionId: string;
+  driver?: string;
+  model?: string;
+  contextTokens?: number;
+  contextWindow?: number;
+  contextPercentage?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadInputTokens?: number;
+  reasoningOutputTokens?: number;
+}
+
+export function buildPeerActivityRow(peer: BridgePeer, events: RuntimeEvent[]): PeerActivityRow {
+  const summary = summarizePeerActivity(peer, events);
+  const usage = findLastResultUsage(events);
+  return {
+    name: peer.name,
+    state: summary.state,
+    activity: summary.activity,
+    lastUpdateAt: peer.updatedAt,
+    sessionId: peer.sessionId,
+    driver: peer.driver,
+    model: peer.model,
+    contextTokens: usage?.contextTokens,
+    contextWindow: usage?.contextWindow,
+    contextPercentage: usage?.contextPercentage,
+    inputTokens: usage?.inputTokens,
+    outputTokens: usage?.outputTokens,
+    cacheReadInputTokens: usage?.cacheReadInputTokens,
+    reasoningOutputTokens: usage?.reasoningOutputTokens,
+  };
+}
+
+export function summarizePeerActivity(peer: BridgePeer, events: RuntimeEvent[]): { state: string; activity: string } {
+  const lastAssistantText = findLastAssistantText(events);
+  const waitingForInput = Boolean(lastAssistantText && looksLikeWaitingForInput(lastAssistantText));
+
+  switch (peer.state) {
+    case "errored":
+      return {
+        state: "error",
+        activity: summarizeError(events),
+      };
+    case "disconnected":
+      return {
+        state: "offline",
+        activity: `last seen ${formatIsoTime(peer.updatedAt, false)}`,
+      };
+    case "stopped":
+      return {
+        state: "stopped",
+        activity: `last seen ${formatIsoTime(peer.updatedAt, false)}`,
+      };
+    case "interrupted":
+      return {
+        state: waitingForInput ? "waiting" : "stopped",
+        activity: waitingForInput ? "needs input" : "interrupted",
+      };
+    default:
+      break;
+  }
+
+  const activeTool = findActiveTool(events);
+  if (["starting", "busy"].includes(peer.state)) {
+    if (activeTool) {
+      return {
+        state: "busy",
+        activity: summarizeTool(activeTool),
+      };
+    }
+    return {
+      state: "busy",
+      activity: peer.state === "starting" ? "starting" : "drafting reply",
+    };
+  }
+
+  if (waitingForInput) {
+    return {
+      state: "waiting",
+      activity: "needs input",
+    };
+  }
+
+  if (lastAssistantText) {
+    return {
+      state: "idle",
+      activity: `last reply: ${summarizeReply(lastAssistantText)}`,
+    };
+  }
+
+  const lastResult = findLastResultSummary(events);
+  if (lastResult) {
+    return {
+      state: "idle",
+      activity: `last reply: ${summarizeReply(lastResult)}`,
+    };
+  }
+
+  return {
+    state: "idle",
+    activity: "idle",
+  };
+}
+
+export function getPeerFirstHealth(rows: PeerActivityRow[], transportDegraded: boolean): "idle" | "active" | "warning" {
+  if (transportDegraded || rows.some((row) => ["error", "offline", "waiting"].includes(row.state))) {
+    return "warning";
+  }
+  if (rows.some((row) => row.state === "busy")) {
+    return "active";
+  }
+  return "idle";
+}
+
+export function isPeerVisibleInWidget(row: PeerActivityRow): boolean {
+  return row.state !== "stopped";
+}
+
+function findActiveTool(events: RuntimeEvent[]): ToolEvent | undefined {
+  return [...events]
+    .reverse()
+    .find((event): event is ToolEvent => event.type === "tool" && event.phase === "requested");
+}
+
+function summarizeTool(event: ToolEvent): string {
+  const toolName = event.toolName || "Tool";
+  const input = event.input && typeof event.input === "object" ? event.input as Record<string, unknown> : undefined;
+  const lowerToolName = toolName.toLowerCase();
+
+  if (lowerToolName === "bash") {
+    const command = firstString(input?.command, input?.cmd, input?.script);
+    return command ? `Bash: ${truncateInline(command, 36)}` : "Bash";
+  }
+
+  if (["read", "view", "open"].includes(lowerToolName)) {
+    const path = firstString(input?.path, input?.filePath, input?.file, input?.target_file);
+    return path ? `Read: ${compactPath(path)}` : "Read";
+  }
+
+  if (["edit", "multiedit", "apply_patch"].includes(lowerToolName)) {
+    const path = firstString(input?.path, input?.filePath, input?.file, input?.target_file);
+    return path ? `Edit: ${compactPath(path)}` : "Edit";
+  }
+
+  if (["write", "create"].includes(lowerToolName)) {
+    const path = firstString(input?.path, input?.filePath, input?.file, input?.target_file);
+    return path ? `Write: ${compactPath(path)}` : "Write";
+  }
+
+  const path = firstString(input?.path, input?.filePath, input?.file, input?.target_file);
+  if (path) {
+    return `${capitalize(toolName)}: ${compactPath(path)}`;
+  }
+
+  return capitalize(toolName);
+}
+
+function findLastAssistantText(events: RuntimeEvent[]): string | undefined {
+  for (const event of [...events].reverse()) {
+    if (event.type !== "message" || event.role !== "assistant") {
+      continue;
+    }
+    const texts = event.message.blocks
+      .filter((block) => block.type !== "thinking")
+      .map((block) => block.text?.trim())
+      .filter((value): value is string => Boolean(value));
+    if (texts.length > 0) {
+      return texts.join(" ");
+    }
+  }
+  return undefined;
+}
+
+function findLastResultSummary(events: RuntimeEvent[]): string | undefined {
+  return [...events]
+    .reverse()
+    .find((event): event is Extract<RuntimeEvent, { type: "result" }> => event.type === "result")
+    ?.summary;
+}
+
+function findLastResultUsage(events: RuntimeEvent[]) {
+  const event = [...events]
+    .reverse()
+    .find((entry): entry is Extract<RuntimeEvent, { type: "result" }> => entry.type === "result" && (Boolean(entry.usage) || Boolean(entry.raw)));
+  if (!event) {
+    return undefined;
+  }
+  if (event.usage?.contextPercentage != null) {
+    return event.usage;
+  }
+  return {
+    ...event.usage,
+    ...deriveContextUsageFromRawResult(event.raw, event.usage),
+  };
+}
+
+function deriveContextUsageFromRawResult(raw: unknown, usage: Extract<RuntimeEvent, { type: "result" }>["usage"] = {}) {
+  if (!raw || typeof raw !== "object") {
+    return undefined;
+  }
+  const modelUsage = (raw as Record<string, unknown>).modelUsage;
+  if (!modelUsage || typeof modelUsage !== "object") {
+    return undefined;
+  }
+
+  const entries = Object.values(modelUsage as Record<string, unknown>)
+    .map((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return undefined;
+      }
+      const item = entry as Record<string, unknown>;
+      const input = numberValue(item.inputTokens);
+      const cacheCreation = numberValue(item.cacheCreationInputTokens);
+      const cacheRead = numberValue(item.cacheReadInputTokens);
+      const contextTokens = [input, cacheCreation, cacheRead]
+        .filter((value): value is number => value != null)
+        .reduce((sum, value) => sum + value, 0);
+      const contextWindow = numberValue(item.contextWindow);
+      const maxOutputTokens = numberValue(item.maxOutputTokens);
+      return { contextTokens, contextWindow, maxOutputTokens };
+    })
+    .filter((entry): entry is { contextTokens: number; contextWindow?: number; maxOutputTokens?: number } => Boolean(entry));
+
+  const best = entries.sort((a, b) => b.contextTokens - a.contextTokens)[0];
+  if (!best?.contextWindow) {
+    return undefined;
+  }
+
+  const fallbackContextTokens = [usage.inputTokens, usage.cacheCreationInputTokens, usage.cacheReadInputTokens]
+    .filter((value): value is number => value != null)
+    .reduce((sum, value) => sum + value, 0);
+  const contextTokens = best.contextTokens > 0 ? best.contextTokens : fallbackContextTokens;
+  return {
+    contextTokens: contextTokens > 0 ? contextTokens : undefined,
+    contextWindow: best.contextWindow,
+    contextPercentage: contextTokens > 0 ? Math.round((contextTokens / best.contextWindow) * 1000) / 10 : undefined,
+    maxOutputTokens: best.maxOutputTokens,
+  };
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function summarizeError(events: RuntimeEvent[]): string {
+  const error = [...events]
+    .reverse()
+    .find((event): event is Extract<RuntimeEvent, { type: "error" }> => event.type === "error");
+  return error?.message ? `error: ${truncateInline(error.message, 40)}` : "error";
+}
+
+function looksLikeWaitingForInput(text: string): boolean {
+  const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+  if (/\b(waiting for|need|needs)\s+(your\s+)?input\b/.test(normalized)) {
+    return true;
+  }
+  if (/\b(blocked on|blocked until|cannot continue without|can't continue without|need you to|i need you to|i need the|missing required)\b/.test(normalized)) {
+    return true;
+  }
+
+  const finalSentence = extractFinalSentence(text).toLowerCase();
+  if (!finalSentence) {
+    return false;
+  }
+
+  return [
+    /^please (provide|share|confirm|clarify|choose|send|attach|tell me|let me know)\b/,
+    /^(can|could|would) you\b/,
+    /^(which|what|where|when|who|how) (file|command|option|path|branch|directory|repo|repository|target|environment|env|approach|version|model|task|slice)\b/,
+    /^(do you want|should i|may i)\b/,
+  ].some((pattern) => pattern.test(finalSentence)) || finalSentence.endsWith("?");
+}
+
+function extractFinalSentence(text: string): string {
+  const lines = text
+    .split(/\r?\n/)
+    .map((line) => line.trim().replace(/^[-*]\s+/, "").replace(/^#{1,6}\s+/, ""))
+    .filter(Boolean);
+  const lastLine = lines.at(-1) ?? "";
+  const sentences = lastLine.match(/[^.!?]+[.!?]?/g)?.map((item) => item.trim()).filter(Boolean) ?? [];
+  return sentences.at(-1) ?? lastLine;
+}
+
+function summarizeReply(text: string): string {
+  return truncateInline(text.replace(/\s+/g, " ").trim(), 42);
+}
+
+function compactPath(path: string): string {
+  const normalized = path.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length === 0) {
+    return basename(path);
+  }
+  return parts.length <= 3 ? parts.join("/") : parts.slice(-3).join("/");
+}
+
+function firstString(...values: unknown[]): string | undefined {
+  return values.find((value): value is string => typeof value === "string" && value.trim().length > 0)?.trim();
+}
+
+function truncateInline(value: string, max: number): string {
+  return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+}
+
+function capitalize(value: string): string {
+  return value.length > 0 ? `${value[0]!.toUpperCase()}${value.slice(1)}` : value;
+}
+
+function formatIsoTime(value: string, includeSeconds: boolean): string {
+  const date = new Date(value);
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  if (!includeSeconds) {
+    return `${hours}:${minutes}`;
+  }
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}