pi-link 0.1.1 → 0.1.3

package/README.md

@@ -83,7 +83,9 @@ Here's a concrete example of two terminals collaborating. Open two separate `pi
 ✓ Renamed to "builder"
 
 > /link
-⚡ Link: "builder" (hub) · 2 terminals online: builder, researcher
+⚡ Link: builder (hub) · 2 online
+  builder: idle (5s)
+  researcher: idle (12s)
 ```
 
 **Terminal 2** — rename it too:
@@ -122,11 +124,11 @@ Every other terminal sees:
 
 Link is **off by default**. Without `--link`, the extension is completely silent — no status bar, no connections, no warnings.
 
-| Method              | When                                | Auto-reconnect? |
-| ------------------- | ----------------------------------- | --- |
-| `pi --link`         | Auto-connect on startup             | Yes |
-| `/link-connect`     | Opt-in mid-session (no flag needed) | Yes |
-| `/link-disconnect`  | Opt-out mid-session                 | Suppressed until `/link-connect` |
+| Method             | When                                | Auto-reconnect?                  |
+| ------------------ | ----------------------------------- | -------------------------------- |
+| `pi --link`        | Auto-connect on startup             | Yes                              |
+| `/link-connect`    | Opt-in mid-session (no flag needed) | Yes                              |
+| `/link-disconnect` | Opt-out mid-session                 | Suppressed until `/link-connect` |
 
 `/link-connect` enables full participation in Pi Link regardless of whether `--link` was passed. `/link-disconnect` always wins — even over `--link` — until you explicitly `/link-connect` again.
 
@@ -140,11 +142,11 @@ The extension registers three tools that the LLM can invoke during agent runs.
 
 ### Which tool should I use?
 
-| Tool           | Behavior                                             | Returns                                  |
-| -------------- | ---------------------------------------------------- | ---------------------------------------- |
-| `link_send`    | Send a message; optionally trigger the remote LLM    | Send/delivery status only                |
-| `link_prompt`  | Run a prompt on a remote terminal and wait for reply | The remote terminal's assistant response |
-| `link_list`    | List currently connected terminals                   | Terminal directory with roles            |
+| Tool          | Behavior                                             | Returns                                  |
+| ------------- | ---------------------------------------------------- | ---------------------------------------- |
+| `link_send`   | Send a message; optionally trigger the remote LLM    | Send/delivery status only                |
+| `link_prompt` | Run a prompt on a remote terminal and wait for reply | The remote terminal's assistant response |
+| `link_list`   | List currently connected terminals                   | Terminal directory with roles and status |
 
 **If you need the other terminal's answer back, use `link_prompt`.** Use `link_send` to notify or steer without waiting.
 
@@ -182,34 +184,47 @@ Send a prompt to a remote terminal and **wait** for the LLM's response (synchron
 
 ### `link_list`
 
-Lists all connected terminals with role info and self-identification. Takes no parameters.
+Lists all connected terminals with role info, live agent status, and self-identification. Takes no parameters.
+
+Each terminal's status is derived automatically from Pi lifecycle events — agents can't set it manually. Three states:
+
+| Status            | Meaning                 |
+| ----------------- | ----------------------- |
+| `idle (2m)`       | Waiting for user input  |
+| `thinking (3s)`   | LLM is generating       |
+| `tool:bash (12s)` | Running a specific tool |
+
+Durations are computed at render time from a `since` timestamp — no timer traffic over the wire. Terminals that just joined with no status data yet render as blank, not fake idle.
 
 **Example output:**
 
 ```
-Connected terminals:
-  • pi-1 (you)
-  • pi-2
-  • pi-3
+link (hub) 3 terminal(s)
+  • builder@pi-link (you)  thinking (3s)
+  • reviewer@pi-link       idle (45s)
+  • docs@pi-link           tool:read (2s)
 ```
 
 ---
 
 ## Slash Commands
 
-| Command                  | Purpose                                                                                                   |
-| ------------------------ | --------------------------------------------------------------------------------------------------------- |
-| `/link`                  | Show link status (name, role, online count)                                                               |
-| `/link-name [name]`      | Rename this terminal. With no argument, adopts the current Pi session name if available. Collision-safe.  |
-| `/link-broadcast <msg>`  | Broadcast a chat message to all other terminals                                                           |
-| `/link-connect`          | Connect to Pi Link (works anytime, with or without `--link`)                                              |
-| `/link-disconnect`       | Disconnect from Pi Link and suppress auto-reconnect (overrides `--link`)                                  |
+| Command                 | Purpose                                                                                                                  |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `/link`                 | Show link status (name, role, online count, agent status per terminal)                                                   |
+| `/link-name [name]`     | Rename and save as this session's preferred link name. With no argument, adopts the Pi session name. Restored on resume. |
+| `/link-broadcast <msg>` | Broadcast a chat message to all other terminals                                                                          |
+| `/link-connect`         | Connect to Pi Link (works anytime, with or without `--link`)                                                             |
+| `/link-disconnect`      | Disconnect from Pi Link and suppress auto-reconnect (overrides `--link`)                                                 |
 
 ### Examples
 
 ```
 > /link
-⚡ Link: "builder" (hub) · 3 online: builder, worker-1, worker-2
+⚡ Link: builder (hub) · 3 online
+  builder: idle (12s)
+  worker-1: thinking (3s)
+  worker-2: tool:bash (5s)
 
 > /link-name orchestrator
 ✓ Renamed to "orchestrator"
@@ -228,6 +243,8 @@ Connected terminals:
 ✓ Pi Link hub started on :9900 as "orchestrator" ... if no hub exists
 ```
 
+**Name persistence:** `/link-name` saves your preferred name to the session. Resume that session later and your name is restored automatically. If the name is taken, the hub assigns a variant (e.g., `"builder-2"`), but your preferred name stays saved — the next reconnect retries it. Both `/link-name builder` and `/link-name` (no args) count as explicit saves; hub-assigned variants like `"builder-2"` are never persisted.
+
 See [Configuration](#configuration) for details on `--link`, `/link-connect`, and `/link-disconnect` behavior.
 
 ---
@@ -333,7 +350,7 @@ When the hub goes down and a client promotes itself, terminal names and in-fligh
 
 | Package                         | Purpose                                          |
 | ------------------------------- | ------------------------------------------------ |
-| `@mariozechner/pi-coding-agent` | Pi SDK types (ExtensionAPI, ExtensionContext)     |
+| `@mariozechner/pi-coding-agent` | Pi SDK types (ExtensionAPI, ExtensionContext)    |
 | `@mariozechner/pi-tui`          | TUI Text widget for custom message rendering     |
 | `@sinclair/typebox`             | JSON Schema type definitions for tool parameters |
 
@@ -365,18 +382,19 @@ The `pi.extensions` field tells Pi which files to load as extensions. Here it po
 
 ### Protocol
 
-The wire protocol consists of **8 message types**, all serialized as JSON over WebSocket frames:
+The wire protocol consists of **9 message types**, all serialized as JSON over WebSocket frames:
 
-| Type              | Direction     | Purpose                                               |
-| ----------------- | ------------- | ----------------------------------------------------- |
-| `register`        | Client → Hub  | First message after connecting; requests a name       |
-| `welcome`         | Hub → Client  | Confirms assigned name (deduplicated) + terminal list |
-| `terminal_joined` | Hub → All     | Broadcast when a terminal joins                       |
-| `terminal_left`   | Hub → All     | Broadcast when a terminal disconnects                 |
-| `chat`            | Any → Any/All | Fire-and-forget message; optionally triggers LLM turn |
-| `prompt_request`  | Any → Any     | Request a remote terminal to execute a prompt         |
-| `prompt_response` | Any → Any     | Response carrying the remote prompt result            |
-| `error`           | Hub → Client  | Error notification                                    |
+| Type              | Direction       | Purpose                                                 |
+| ----------------- | --------------- | ------------------------------------------------------- |
+| `register`        | Client → Hub    | First message after connecting; requests a name         |
+| `welcome`         | Hub → Client    | Confirms assigned name, terminal list + status snapshot |
+| `terminal_joined` | Hub → All       | Broadcast when a terminal joins                         |
+| `terminal_left`   | Hub → All       | Broadcast when a terminal disconnects                   |
+| `chat`            | Any → Any/All   | Fire-and-forget message; optionally triggers LLM turn   |
+| `prompt_request`  | Any → Any       | Request a remote terminal to execute a prompt           |
+| `prompt_response` | Any → Any       | Response carrying the remote prompt result              |
+| `status_update`   | Any → Hub → All | Terminal broadcasts its agent status change             |
+| `error`           | Hub → Client    | Error notification                                      |
 
 ### Message Flow Examples
 
@@ -388,13 +406,13 @@ Client                         Hub
   | register {name:"builder"}   |
   |---------------------------->|
   |                             |
-  | welcome {name:"builder",    |
-  | terminals:["pi-1"]}         |
+  | welcome {name, terminals,   |
+  | statuses}                   |
   |<----------------------------|
   |                             |
 ```
 
-Hub then broadcasts `terminal_joined` to the other connected terminals.
+Hub then broadcasts `terminal_joined` to the other connected terminals. The `welcome` message includes a status snapshot for all connected terminals (fields omitted above for brevity).
 
 **Sending a chat message:**
 
@@ -423,12 +441,14 @@ Client A            Hub              Client B
   |<-----------------|                  |
 ```
 
-### Name Uniqueness
+### Name Uniqueness & Persistence
 
 The hub enforces unique terminal names via a `uniqueName()` function. If `"builder"` is already taken, the next terminal requesting that name is assigned `"builder-2"`, then `"builder-3"`, and so on.
 
 Default names are random 4-character hex IDs: `t-a1b2`, `t-c3d4`, etc.
 
+**Persistence:** `/link-name` saves the preferred name to the session via `pi.appendEntry("link-name", { name })`. On session resume, the saved name is restored and requested from the hub. Only explicit `/link-name` calls persist — hub-assigned variants like `"builder-2"` are not saved. On reconnect, the terminal always requests the preferred name, not the last runtime name.
+
 **Rename guards:**
 
 - If you're already using the requested name, `/link-name` returns early (`"Already using..."`).
@@ -439,13 +459,13 @@ Default names are random 4-character hex IDs: `t-a1b2`, `t-c3d4`, etc.
 
 ### State Management
 
-| State Field              | Type                                    | Purpose                                               |
-| ------------------------ | --------------------------------------- | ----------------------------------------------------- |
-| `role`                   | `"hub" \| "client" \| "disconnected"`   | Current network role                                  |
-| `isAgentBusy`            | `boolean`                               | Prevents accepting remote prompts during agent runs   |
-| `manuallyDisconnected`   | `boolean`                               | Set by `/link-disconnect`; suppresses auto-reconnect  |
-| `pendingRemotePrompt`    | `object \| null`                        | Tracks the single in-flight remote prompt execution   |
-| `pendingPromptResponses` | `Map`                                   | Outstanding prompt RPCs awaiting responses            |
+| State Field              | Type                                  | Purpose                                              |
+| ------------------------ | ------------------------------------- | ---------------------------------------------------- |
+| `role`                   | `"hub" \| "client" \| "disconnected"` | Current network role                                 |
+| `isAgentBusy`            | `boolean`                             | Prevents accepting remote prompts during agent runs  |
+| `manuallyDisconnected`   | `boolean`                             | Set by `/link-disconnect`; suppresses auto-reconnect |
+| `pendingRemotePrompt`    | `object \| null`                      | Tracks the single in-flight remote prompt execution  |
+| `pendingPromptResponses` | `Map`                                 | Outstanding prompt RPCs awaiting responses           |
 
 ### Message Routing & Error Handling
 
@@ -467,10 +487,14 @@ The `manuallyDisconnected` flag distinguishes user-initiated disconnects (`/link
 
 The extension hooks into Pi's agent lifecycle events:
 
-- **`agent_start`** → Sets `isAgentBusy = true`, blocking incoming remote prompts.
-- **`agent_end`** → Checks if a remote prompt was running. If so, extracts the last assistant response from `event.messages` and sends back a `prompt_response`.
+- **`agent_start`** → Sets `isAgentBusy = true`, blocking incoming remote prompts. Broadcasts `status_update` (`thinking`).
+- **`agent_end`** → Checks if a remote prompt was running. If so, extracts the last assistant response from `event.messages` and sends back a `prompt_response`. Broadcasts `status_update` (`idle`).
+- **`tool_execution_start`** → Broadcasts `status_update` (`tool:<name>`).
+- **`tool_execution_end`** → Clears tool status; broadcasts `status_update` (`thinking`) while the agent run continues.
 - **`session_shutdown`** → Full cleanup via `cleanup()`: closes all sockets, resolves pending promises, and disposes the extension.
 
+Status updates are push-based: each terminal broadcasts changes to the hub, which fans them out. New joiners receive a status snapshot for all terminals in the `welcome` message. Durations are computed at render time from a `since` timestamp — no polling or timer traffic over the wire.
+
 ### Rendering
 
 Incoming link chat messages render with a styled `⚡ [sender]` prefix using the theme's accent color. The link status text in Pi's footer uses `theme.fg("dim", ...)` to match Pi's standard footer styling.

package/index.ts

@@ -45,6 +45,7 @@ interface WelcomeMsg {
   type: "welcome";
   name: string;
   terminals: string[];
+  statuses?: Record<string, LinkStatus>;
 }
 interface TerminalJoinedMsg {
   type: "terminal_joined";
@@ -78,11 +79,21 @@ interface PromptResponseMsg {
   response: string;
   error?: string;
 }
+interface StatusUpdateMsg {
+  type: "status_update";
+  name: string;
+  status: LinkStatus;
+}
 interface ErrorMsg {
   type: "error";
   message: string;
 }
 
+type LinkStatus =
+  | { kind: "idle"; since: number }
+  | { kind: "thinking"; since: number }
+  | { kind: "tool"; toolName: string; since: number };
+
 type LinkMessage =
   | RegisterMsg
   | WelcomeMsg
@@ -91,6 +102,7 @@ type LinkMessage =
   | ChatMsg
   | PromptRequestMsg
   | PromptResponseMsg
+  | StatusUpdateMsg
   | ErrorMsg;
 
 // ─── Extension ───────────────────────────────────────────────────────────────
@@ -106,16 +118,25 @@ export default function (pi: ExtensionAPI) {
 
   let role: "hub" | "client" | "disconnected" = "disconnected";
   let terminalName = `t-${crypto.randomUUID().slice(0, 4)}`;
+  let preferredName: string | null = null;
   let connectedTerminals: string[] = [];
   let ctx: ExtensionContext | undefined;
-  let isAgentBusy = false;
   let disposed = false;
   let manuallyDisconnected = false;
   let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
 
+  // Status tracking (local truth)
+  let agentRunning = false;
+  let activeToolName: string | null = null;
+  let stateSince = Date.now();
+  let lastPushedKind: string | null = null;
+  let lastPushedTool: string | null = null;
+  const terminalStatuses = new Map<string, LinkStatus>(); // other terminals
+
   // Hub state
   let wss: WebSocketServer | null = null;
   const hubClients = new Map<WebSocket, string>(); // ws → terminal name
+  const hubTerminalStatuses = new Map<string, LinkStatus>(); // hub-authoritative
 
   // Client state
   let ws: WebSocket | null = null;
@@ -148,6 +169,53 @@ export default function (pi: ExtensionAPI) {
     ctx.ui.setStatus("link", theme.fg("dim", info));
   }
 
+  function deriveStatus(): LinkStatus {
+    if (activeToolName)
+      return { kind: "tool", toolName: activeToolName, since: stateSince };
+    if (agentRunning) return { kind: "thinking", since: stateSince };
+    return { kind: "idle", since: stateSince };
+  }
+
+  function pushStatus(force = false) {
+    if (role === "disconnected") return;
+    const status = deriveStatus();
+    const newKind = status.kind;
+    const newTool = status.kind === "tool" ? status.toolName : null;
+    if (!force && newKind === lastPushedKind && newTool === lastPushedTool)
+      return;
+    lastPushedKind = newKind;
+    lastPushedTool = newTool;
+    const msg: StatusUpdateMsg = {
+      type: "status_update",
+      name: terminalName,
+      status,
+    };
+    if (role === "hub") {
+      hubBroadcast(msg, terminalName);
+    } else if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+
+  function formatDuration(since: number): string {
+    const sec = Math.floor((Date.now() - since) / 1000);
+    if (sec < 60) return `${sec}s`;
+    if (sec < 3600) return `${Math.floor(sec / 60)}m`;
+    return `${Math.floor(sec / 3600)}h`;
+  }
+
+  function formatStatus(s: LinkStatus): string {
+    const dur = formatDuration(s.since);
+    if (s.kind === "tool") return `tool:${s.toolName} (${dur})`;
+    return `${s.kind} (${dur})`;
+  }
+
+  function getStatusFor(name: string): LinkStatus | null {
+    if (name === terminalName) return deriveStatus();
+    const map = role === "hub" ? hubTerminalStatuses : terminalStatuses;
+    return map.get(name) ?? null;
+  }
+
   function allTerminalNames(): Set<string> {
     const names = new Set<string>();
     names.add(terminalName); // hub's own name
@@ -257,11 +325,18 @@ export default function (pi: ExtensionAPI) {
       case "welcome":
         terminalName = msg.name;
         connectedTerminals = msg.terminals;
+        terminalStatuses.clear();
+        if (msg.statuses) {
+          for (const [name, status] of Object.entries(msg.statuses)) {
+            terminalStatuses.set(name, status);
+          }
+        }
         updateStatus();
         ctx?.ui.notify(
           `Joined link as "${terminalName}" (${connectedTerminals.length} online)`,
           "info",
         );
+        pushStatus(true);
         break;
 
       // ── Directory updates ──
@@ -273,10 +348,16 @@ export default function (pi: ExtensionAPI) {
 
       case "terminal_left":
         connectedTerminals = msg.terminals;
+        terminalStatuses.delete(msg.name);
         updateStatus();
         ctx?.ui.notify(`"${msg.name}" left the link`, "info");
         break;
 
+      // ── Status update from another terminal ──
+      case "status_update":
+        terminalStatuses.set(msg.name, msg.status);
+        break;
+
       // ── Chat message ──
       case "chat":
         pi.sendMessage(
@@ -292,7 +373,7 @@ export default function (pi: ExtensionAPI) {
 
       // ── Another terminal asks us to run a prompt ──
       case "prompt_request":
-        if (isAgentBusy || pendingRemotePrompt) {
+        if (agentRunning || pendingRemotePrompt) {
           routeMessage({
             type: "prompt_response",
             id: msg.id,
@@ -353,12 +434,18 @@ export default function (pi: ExtensionAPI) {
         connectedTerminals = list;
         updateStatus();
 
-        // Confirm to the new client
+        // Confirm to the new client (include status snapshot)
+        const statuses: Record<string, LinkStatus> = {};
+        statuses[terminalName] = deriveStatus(); // hub's own status
+        for (const [name, status] of hubTerminalStatuses) {
+          if (name !== clientName) statuses[name] = status;
+        }
         clientWs.send(
           JSON.stringify({
             type: "welcome",
             name: clientName,
             terminals: list,
+            statuses,
           } satisfies WelcomeMsg),
         );
 
@@ -375,6 +462,21 @@ export default function (pi: ExtensionAPI) {
       // Ignore messages from unregistered clients
       if (!clientName) return;
 
+      // Status update — store and fan out to other clients only (not back to hub)
+      if (msg.type === "status_update") {
+        hubTerminalStatuses.set(clientName, msg.status);
+        const normalized: StatusUpdateMsg = {
+          type: "status_update",
+          name: clientName,
+          status: msg.status,
+        };
+        const json = JSON.stringify(normalized);
+        for (const [otherWs, name] of hubClients) {
+          if (name !== clientName) otherWs.send(json);
+        }
+        return;
+      }
+
       // Route chat / prompt messages
       if (
         msg.type === "chat" ||
@@ -388,6 +490,7 @@ export default function (pi: ExtensionAPI) {
     clientWs.on("close", () => {
       if (clientName) {
         hubClients.delete(clientWs);
+        hubTerminalStatuses.delete(clientName);
         const list = terminalList();
         connectedTerminals = list;
         updateStatus();
@@ -438,20 +541,20 @@ export default function (pi: ExtensionAPI) {
 
   // ── Connect as client ────────────────────────────────────────────────────
 
-  function connectAsClient(port: number): Promise<boolean> {
+  function connectAsClient(): Promise<boolean> {
     return new Promise((resolve) => {
-      const socket = new WebSocket(`ws://127.0.0.1:${port}`);
+      const socket = new WebSocket(`ws://127.0.0.1:${DEFAULT_PORT}`);
       let resolved = false;
 
       socket.on("open", () => {
         ws = socket;
         role = "client";
         resolved = true;
-        // Register with the hub
+        // Register with preferred name if available, otherwise current name
         socket.send(
           JSON.stringify({
             type: "register",
-            name: terminalName,
+            name: preferredName ?? terminalName,
           } satisfies RegisterMsg),
         );
         resolve(true);
@@ -492,7 +595,7 @@ export default function (pi: ExtensionAPI) {
     if (disposed) return;
 
     // Try connecting to an existing hub
-    if (await connectAsClient(DEFAULT_PORT)) return;
+    if (await connectAsClient()) return;
 
     // No hub found — become the hub
     if (await startHub()) return;
@@ -545,6 +648,10 @@ export default function (pi: ExtensionAPI) {
 
     role = "disconnected";
     connectedTerminals = [];
+    terminalStatuses.clear();
+    hubTerminalStatuses.clear();
+    lastPushedKind = null;
+    lastPushedTool = null;
     updateStatus();
   }
 
@@ -557,6 +664,20 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_start", async (_event, _ctx) => {
     ctx = _ctx;
+
+    // Restore preferred link name from session
+    const saved = _ctx.sessionManager
+      .getEntries()
+      .filter(
+        (e: { type: string; customType?: string }) =>
+          e.type === "custom" && e.customType === "link-name",
+      )
+      .pop() as { data?: { name?: string } } | undefined;
+    if (saved?.data?.name) {
+      preferredName = saved.data.name;
+      terminalName = preferredName;
+    }
+
     if (pi.getFlag("link") === true) await initialize();
   });
 
@@ -564,12 +685,87 @@ export default function (pi: ExtensionAPI) {
     cleanup();
   });
 
+  pi.on("session_switch", async (_event, _ctx) => {
+    ctx = _ctx;
+
+    // Restore preferred name from the new session
+    const saved = _ctx.sessionManager
+      .getEntries()
+      .filter(
+        (e: { type: string; customType?: string }) =>
+          e.type === "custom" && e.customType === "link-name",
+      )
+      .pop() as { data?: { name?: string } } | undefined;
+
+    preferredName = saved?.data?.name ?? null;
+    const desiredName = preferredName ?? `t-${crypto.randomUUID().slice(0, 4)}`;
+
+    if (desiredName === terminalName) return; // no identity change needed
+
+    if (role === "hub") {
+      // Hub rename in-place — avoid tearing down the server
+      const takenByOther = Array.from(hubClients.values()).includes(
+        desiredName,
+      );
+      if (takenByOther) {
+        // Can't use preferred name — keep current identity
+        ctx?.ui.notify(
+          `Session preferred name "${desiredName}" is taken, keeping "${terminalName}"`,
+          "warning",
+        );
+        return;
+      }
+      const old = terminalName;
+      terminalName = desiredName;
+      const list = terminalList();
+      connectedTerminals = list;
+      updateStatus();
+      // Notify clients only — hub already updated local state
+      hubBroadcast(
+        { type: "terminal_left", name: old, terminals: list },
+        terminalName,
+      );
+      hubBroadcast(
+        { type: "terminal_joined", name: desiredName, terminals: list },
+        terminalName,
+      );
+      pushStatus(true);
+    } else if (role === "client") {
+      // Client — disconnect and reconnect with new name
+      terminalName = desiredName;
+      disconnect();
+      manuallyDisconnected = false;
+      await initialize();
+    } else {
+      // Disconnected — just update local name
+      terminalName = desiredName;
+    }
+  });
+
   pi.on("agent_start", async () => {
-    isAgentBusy = true;
+    agentRunning = true;
+    activeToolName = null;
+    stateSince = Date.now();
+    pushStatus();
+  });
+
+  pi.on("tool_execution_start", async (event) => {
+    activeToolName = event.toolName;
+    stateSince = Date.now();
+    pushStatus();
+  });
+
+  pi.on("tool_execution_end", async () => {
+    activeToolName = null;
+    if (agentRunning) stateSince = Date.now();
+    pushStatus();
   });
 
   pi.on("agent_end", async (event) => {
-    isAgentBusy = false;
+    agentRunning = false;
+    activeToolName = null;
+    stateSince = Date.now();
+    pushStatus();
 
     // If we were running a remote prompt, send the response back
     if (pendingRemotePrompt) {
@@ -712,6 +908,13 @@ export default function (pi: ExtensionAPI) {
     async execute(_toolCallId, params, signal) {
       if (role === "disconnected") return notConnectedResult();
 
+      if (!connectedTerminals.includes(params.to)) {
+        return textResult(
+          `Terminal "${params.to}" not found. Connected: ${connectedTerminals.join(", ")}`,
+          { to: params.to, error: "not_found" },
+        );
+      }
+
       const requestId = crypto.randomUUID();
 
       return new Promise((resolve) => {
@@ -806,15 +1009,20 @@ export default function (pi: ExtensionAPI) {
     async execute() {
       if (role === "disconnected") return notConnectedResult();
 
+      const statuses: Record<string, string> = {};
       const list = connectedTerminals
         .map((name) => {
+          const status = getStatusFor(name);
+          const statusStr = status ? formatStatus(status) : "";
+          if (statusStr) statuses[name] = statusStr;
           const marker = name === terminalName ? " (you)" : "";
-          return `  • ${name}${marker}`;
+          return `  • ${name}${marker}${statusStr ? "  " + statusStr : ""}`;
         })
         .join("\n");
 
       return textResult(`Connected terminals:\n${list}`, {
         terminals: connectedTerminals,
+        statuses,
         self: terminalName,
         role,
       });
@@ -822,7 +1030,12 @@ export default function (pi: ExtensionAPI) {
 
     renderResult(result, _options, theme) {
       const details = result.details as
-        | { terminals?: string[]; self?: string; role?: string }
+        | {
+            terminals?: string[];
+            statuses?: Record<string, string>;
+            self?: string;
+            role?: string;
+          }
         | undefined;
       if (!details?.terminals) {
         const txt = result.content[0];
@@ -834,11 +1047,12 @@ export default function (pi: ExtensionAPI) {
       text += theme.fg("accent", `${details.terminals.length} terminal(s)`);
       for (const name of details.terminals) {
         const isSelf = name === details.self;
+        const status = details.statuses?.[name] ?? "";
+        const nameStr = isSelf ? `• ${name} (you)` : `• ${name}`;
         text +=
           "\n  " +
-          (isSelf
-            ? theme.fg("accent", `• ${name} (you)`)
-            : theme.fg("text", `• ${name}`));
+          (isSelf ? theme.fg("accent", nameStr) : theme.fg("text", nameStr)) +
+          (status ? "  " + theme.fg("dim", status) : "");
       }
       return new Text(text, 0, 0);
     },
@@ -853,9 +1067,14 @@ export default function (pi: ExtensionAPI) {
         _ctx.ui.notify("Link: not connected", "warning");
         return;
       }
-      const names = connectedTerminals.join(", ");
+      const lines = connectedTerminals.map((name) => {
+        const status = getStatusFor(name);
+        const statusStr = status ? formatStatus(status) : "";
+        const marker = name === terminalName ? " (you)" : "";
+        return `${name}${marker}${statusStr ? ": " + statusStr : ""}`;
+      });
       _ctx.ui.notify(
-        `Link: ${terminalName} (${role}) · ${connectedTerminals.length} online: ${names}`,
+        `Link: ${terminalName} (${role}) · ${connectedTerminals.length} online\n${lines.join("\n")}`,
         "info",
       );
     },
@@ -879,12 +1098,23 @@ export default function (pi: ExtensionAPI) {
         }
       }
 
-      if (newName === terminalName) {
+      if (newName === terminalName && newName === preferredName) {
         _ctx.ui.notify(`Already using "${newName}"`, "info");
         return;
       }
 
-      // If we're the hub, check uniqueness before renaming
+      function savePreference() {
+        preferredName = newName;
+        pi.appendEntry("link-name", { name: preferredName });
+      }
+
+      if (newName === terminalName) {
+        savePreference();
+        _ctx.ui.notify(`Saved "${newName}" as preferred link name`, "info");
+        return;
+      }
+
+      // If we're the hub, check uniqueness before persisting
       if (role === "hub") {
         // Check if name is taken by another terminal
         const takenByOther = Array.from(hubClients.values()).includes(newName);
@@ -900,14 +1130,21 @@ export default function (pi: ExtensionAPI) {
         const list = terminalList();
         connectedTerminals = list;
         updateStatus();
-        hubBroadcast({ type: "terminal_left", name: old, terminals: list });
+        // Notify clients only — hub already updated local state
+        hubBroadcast(
+          { type: "terminal_left", name: old, terminals: list },
+          terminalName,
+        );
         hubBroadcast(
           { type: "terminal_joined", name: newName, terminals: list },
-          newName,
+          terminalName,
         );
+        pushStatus(true);
+        savePreference();
         _ctx.ui.notify(`Renamed to "${newName}"`, "info");
       } else if (role === "client") {
         // Reconnect with new name — hub will enforce uniqueness via register
+        savePreference();
         terminalName = newName;
         ws?.close();
         // Reconnect will happen via the onClose handler → scheduleReconnect
@@ -916,6 +1153,7 @@ export default function (pi: ExtensionAPI) {
           "info",
         );
       } else {
+        savePreference();
         terminalName = newName;
         _ctx.ui.notify(`Name set to "${newName}" (not connected)`, "info");
       }

package/package.json

@@ -1,30 +1,30 @@
-{
-  "name": "pi-link",
-  "version": "0.1.1",
-  "description": "WebSocket-based inter-terminal communication for Pi. Connect multiple Pi terminals over a local link network.",
-  "author": "alvivar",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/alvivar/pi-link"
-  },
-  "keywords": [
-    "pi-package",
-    "pi",
-    "link",
-    "websocket",
-    "terminal",
-    "multi-agent"
-  ],
-  "dependencies": {
-    "ws": "^8.20.0"
-  },
-  "devDependencies": {
-    "@types/ws": "^8.18.1"
-  },
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  }
-}
+{
+  "name": "pi-link",
+  "version": "0.1.3",
+  "description": "WebSocket-based inter-terminal communication for Pi. Connect multiple Pi terminals over a local link network.",
+  "author": "alvivar",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alvivar/pi-link"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "link",
+    "websocket",
+    "terminal",
+    "multi-agent"
+  ],
+  "dependencies": {
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}