@cuongtran001/kanna 1.76.2 → 1.76.4

package/src/server/beacon-settings.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto"
+import { validateBeaconAliasFormat } from "../shared/beacon-alias"
 import type { BeaconConfig, BeaconInput, BeaconPatch } from "../shared/beacon-config"
 import type { BeaconOs } from "../shared/beacon-protocol"
 import { DEFAULT_BEACON_SCOPE, type BeaconScope } from "../shared/beacon-scope"
@@ -27,6 +28,17 @@ export function validateBeaconLabel(
   return taken ? `Beacon label "${trimmed}" is already in use` : null
 }
 
+export function validateBeaconAlias(
+  alias: string,
+  others: readonly { id: string; alias?: string }[],
+  selfId?: string,
+): string | null {
+  const formatError = validateBeaconAliasFormat(alias)
+  if (formatError) return formatError
+  const taken = others.some((other) => other.id !== selfId && other.alias === alias)
+  return taken ? `Short name "${alias}" is already in use` : null
+}
+
 function readString(object: JsonObject, key: string): string | null {
   const value = object[key]
   return typeof value === "string" ? value : null
@@ -78,7 +90,27 @@ export function normalizeScope(raw: JsonValue | undefined): BeaconScope {
   }
 }
 
-function normalizeBeaconEntry(entry: JsonValue, warnings: string[]): BeaconConfig | null {
+function readAlias(
+  entry: JsonObject,
+  id: string,
+  warnings: string[],
+  takenAliases: ReadonlySet<string>,
+): string | null {
+  const alias = readString(entry, "alias")
+  if (alias === null) return null
+  const error = validateBeaconAliasFormat(alias) ?? (takenAliases.has(alias) ? "alias is already in use" : null)
+  if (error) {
+    warnings.push(`Beacon '${id}' alias dropped: ${error}`)
+    return null
+  }
+  return alias
+}
+
+function normalizeBeaconEntry(
+  entry: JsonValue,
+  warnings: string[],
+  takenAliases: ReadonlySet<string>,
+): BeaconConfig | null {
   if (!isJsonObject(entry)) {
     warnings.push("customBeacons entry must be an object")
     return null
@@ -92,9 +124,11 @@ function normalizeBeaconEntry(entry: JsonValue, warnings: string[]): BeaconConfi
     return null
   }
   const createdAt = readString(entry, "createdAt") ?? new Date(0).toISOString()
+  const alias = readAlias(entry, id, warnings, takenAliases)
   return {
     id,
     label,
+    ...(alias === null ? {} : { alias }),
     publicKey,
     os,
     scope: normalizeScope(entry.scope),
@@ -113,8 +147,9 @@ export function normalizeBeacons(raw: JsonValue | undefined, warnings: string[])
   const out: BeaconConfig[] = []
   const seenIds = new Set<string>()
   const seenLabels = new Set<string>()
+  const seenAliases = new Set<string>()
   for (const entry of raw) {
-    const normalized = normalizeBeaconEntry(entry, warnings)
+    const normalized = normalizeBeaconEntry(entry, warnings, seenAliases)
     if (!normalized) continue
     if (seenIds.has(normalized.id) || seenLabels.has(normalized.label)) {
       warnings.push(`Beacon '${normalized.id}' rejected: duplicate id or label`)
@@ -122,6 +157,7 @@ export function normalizeBeacons(raw: JsonValue | undefined, warnings: string[])
     }
     seenIds.add(normalized.id)
     seenLabels.add(normalized.label)
+    if (normalized.alias !== undefined) seenAliases.add(normalized.alias)
     out.push(normalized)
   }
   return out
@@ -133,6 +169,18 @@ function checkedLabel(label: string, current: readonly BeaconConfig[], selfId?:
   return label.trim()
 }
 
+function checkedAlias(
+  alias: string | null | undefined,
+  existing: BeaconConfig,
+  current: readonly BeaconConfig[],
+): string | undefined {
+  if (alias === undefined) return existing.alias
+  if (alias === null) return undefined
+  const error = validateBeaconAlias(alias, current, existing.id)
+  if (error) throw new BeaconValidationException({ code: "INVALID_ALIAS", message: error })
+  return alias
+}
+
 export function createBeacon(input: BeaconInput, current: readonly BeaconConfig[]): BeaconConfig {
   const now = new Date().toISOString()
   return {
@@ -153,8 +201,11 @@ export function updateBeacon(
   current: readonly BeaconConfig[],
 ): BeaconConfig {
   const label = patch.label === undefined ? existing.label : checkedLabel(patch.label, current, existing.id)
+  const alias = checkedAlias(patch.alias, existing, current)
+  const { alias: _previousAlias, ...withoutAlias } = existing
   return {
-    ...existing,
+    ...withoutAlias,
+    ...(alias === undefined ? {} : { alias }),
     label,
     scope: patch.scope ?? existing.scope,
     enabled: patch.enabled ?? existing.enabled,

package/src/server/claude-turn-starter-types.ts

@@ -6,6 +6,7 @@ import type {
   Subagent,
   TranscriptEntry,
 } from "../shared/types"
+import type { BeaconConfig } from "../shared/beacon-config"
 import type { CronRunTag } from "../shared/cron/types"
 import type { JsonValue } from "../shared/json"
 import type { KannaSystemPromptOptions, SkillRosterEntry } from "../shared/kanna-system-prompt"
@@ -52,6 +53,8 @@ export interface StartTurnDeps {
   clearDrainingStream: (chatId: string) => void
   emitStateChange: (chatId: string, options?: { immediate?: boolean }) => void
   getSubagents: () => Subagent[]
+  getBeacons: () => readonly BeaconConfig[]
+  isBeaconOnline: (beaconId: string) => boolean
   getAppSettingsSnapshot: () => StartTurnAppSettings
   listSkills: (chatId: string) => SkillRosterEntry[]
   generateTitleInBackground: (chatId: string, content: string, localPath: string, optimisticTitle: string) => Promise<void>

package/src/server/claude-turn-starter.test.ts

@@ -6,6 +6,8 @@ import { PendingToolSlots } from "./pending-tool-slot"
 import type { HarnessTurn } from "./harness-types"
 import type { TranscriptEntry } from "../shared/types"
 import { renderGenUIPromptSection } from "../shared/genui"
+import type { BeaconConfig } from "../shared/beacon-config"
+import { DEFAULT_BEACON_SCOPE } from "../shared/beacon-scope"
 
 
 function makeFakeTurn(): HarnessTurn {
@@ -82,6 +84,8 @@ function makeDeps(overrides: Partial<StartTurnDeps> = {}): StartTurnDeps {
     clearDrainingStream: mock(() => {}),
     emitStateChange: mock(() => {}),
     getSubagents: mock(() => []),
+    getBeacons: () => [],
+    isBeaconOnline: () => false,
     getAppSettingsSnapshot: mock(() => ({ globalPromptAppend: undefined })),
     listSkills: mock(() => []),
     generateTitleInBackground: mock(async () => {}),
@@ -641,3 +645,84 @@ describe("@project mentions", () => {
     expect(startClaudeTurn.mock.calls[0]![0].additionalDirectories).toEqual([])
   })
 })
+
+describe("@beacon mentions", () => {
+  const beacon: BeaconConfig = {
+    id: "beacon-1",
+    label: "MacBook-Pro.local",
+    alias: "office-mac",
+    publicKey: "pk",
+    os: "darwin",
+    scope: DEFAULT_BEACON_SCOPE,
+    enabled: true,
+    createdAt: "2026-10-13T00:00:00.000Z",
+    updatedAt: "2026-10-13T00:00:00.000Z",
+  }
+
+  function makeBeaconDeps() {
+    const chat = makeFakeChatRecord({ provider: "claude", title: "Existing" })
+    const project = makeFakeProjectRecord()
+    const appended: Array<{ kind?: string; content?: string }> = []
+    const sentPrompts: string[] = []
+    const claudeSessions = new Map<string, ClaudeSessionState>()
+    const deps = makeDeps({
+      claudeSessions,
+      getBeacons: () => [beacon],
+      isBeaconOnline: () => true,
+      store: {
+        requireChat: () => chat,
+        getMessages: () => [],
+        getRecentRawEntries: () => [] as readonly TranscriptEntry[],
+        getProject: () => project,
+        appendMessage: async (_chatId: string, entry: { kind?: string; content?: string }) => {
+          appended.push(entry)
+        },
+        setChatProvider: async () => {},
+        setPlanMode: async () => {},
+        renameChat: async () => {},
+        recordTurnStarted: async () => {},
+        recordTurnFailed: async () => {},
+        setPendingForkSessionToken: async () => {},
+      } as unknown as StartTurnDeps["store"],
+      startClaudeTurn: async () => {
+        claudeSessions.set("chat-1", {
+          id: "session-1",
+          nextPromptSeq: 0,
+          pendingPromptSeqs: [],
+          cancelledResultPending: 0,
+          lastUsedAt: Date.now(),
+          session: { sendPrompt: async (prompt: string) => { sentPrompts.push(prompt) } },
+        } as unknown as ClaudeSessionState)
+        return makeFakeTurn()
+      },
+    })
+    return { deps, appended, sentPrompts }
+  }
+
+  test("a resolved mention gives the provider the beacon id while the stored prompt stays as typed", async () => {
+    const { deps, appended, sentPrompts } = makeBeaconDeps()
+    const typed = "run uname on @beacon/office-mac"
+
+    await startTurnForChat(deps, makeArgs({ provider: "claude", model: "claude-opus-4-5", content: typed }))
+
+    expect(sentPrompts[0]).toContain("beaconId beacon-1")
+    expect(appended.find((entry) => entry.kind === "user_prompt")?.content).toBe(typed)
+  })
+
+  test("an unknown handle adds nothing to the provider prompt", async () => {
+    const { deps, sentPrompts } = makeBeaconDeps()
+
+    await startTurnForChat(deps, makeArgs({ provider: "claude", model: "claude-opus-4-5", content: "ping @beacon/ghost" }))
+
+    expect(sentPrompts[0]).toBe("ping @beacon/ghost")
+  })
+
+  test("a provider without beacon tools never receives the beacon block", async () => {
+    const { deps } = makeBeaconDeps()
+    const startTurn = deps.codexManager.startTurn as ReturnType<typeof mock>
+
+    await startTurnForChat(deps, makeArgs({ provider: "codex", model: "gpt-4o", content: "run it on @beacon/office-mac" }))
+
+    expect(JSON.stringify(startTurn.mock.calls[0])).not.toContain("beaconId")
+  })
+})

package/src/server/claude-turn-starter.ts

@@ -12,6 +12,7 @@ import type {
 } from "./claude-turn-starter-types"
 import { OAuthPoolUnavailableError } from "./oauth-errors"
 import { buildPromptText } from "./claude-prompt-helpers"
+import { withBeaconMentions } from "./beacon-mention-prompt"
 import { buildHistoryPrimer, shouldInjectPrimer } from "./history-primer"
 import { fallbackTitleFromMessage } from "./generate-title"
 import { parseMentions, type ParsedMention } from "./mention-parser"
@@ -299,7 +300,10 @@ async function startTurnAfterTurnStarted(
     targetProvider,
     Boolean(args.userClearedContext),
   )
-  const userPromptText = buildPromptText(args.promptOverride ?? args.content, args.attachments)
+  const typedPromptText = buildPromptText(args.promptOverride ?? args.content, args.attachments)
+  const userPromptText = providerUsesSdkSession(args.provider)
+    ? withBeaconMentions(typedPromptText, args.content, deps.getBeacons(), deps.isBeaconOnline)
+    : typedPromptText
   const primer = shouldPrime
     ? buildHistoryPrimer(loadExistingMessages(), targetProvider, userPromptText)
     : null

package/src/server/kanna-mcp-beacon-transfer.test.ts

@@ -97,6 +97,7 @@ function connectBeacon(handleRequest: (frame: Extract<BeaconFrame, { kind: "requ
     protocolVersion: TRANSFER_PROTOCOL,
     scope: DEFAULT_BEACON_SCOPE,
     socket: {
+      close(): void {},
       send(payload: SendPayload): number {
         const frame: BeaconFrame = JSON.parse(String(payload))
         sent.push(frame)

package/src/server/kanna-mcp-beacon.test.ts

@@ -67,6 +67,7 @@ function connectedRegistry(responder: Responder): { registry: BeaconRegistry; se
     protocolVersion: 1,
     scope: DEFAULT_BEACON_SCOPE,
     socket: {
+      close(): void {},
       send(payload: SendPayload): number {
         const frame: BeaconFrame = JSON.parse(String(payload))
         sent.push(frame)
@@ -133,7 +134,9 @@ describe("beacon agent tools", () => {
     const tools = toolsFor(registry, beaconConfig({}))
     const result = await tools.get("beacon_list")!.handler({})
     expect(JSON.parse(textOf(result))).toEqual({
-      beacons: [{ id: BEACON_ID, label: LABEL, os: "linux", online: true, enabled: true }],
+      beacons: [
+        { id: BEACON_ID, label: LABEL, alias: null, mention: "@beacon/build-box", os: "linux", online: true, enabled: true },
+      ],
     })
     expect(sent).toEqual([])
   })

package/src/server/kanna-mcp-beacon.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto"
 import { z } from "zod"
 import type { BeaconConfig } from "../shared/beacon-config"
 import type { BeaconRequest } from "../shared/beacon-protocol"
+import { beaconDisplayName, buildBeaconMentionIndex, BEACON_MENTION_PREFIX } from "../shared/beacon-alias"
 import { buildBeaconStatusRows } from "../shared/beacon-status"
 import { buildBeaconRequest } from "../shared/beacon-tool-request"
 import type { BeaconToolOp } from "../shared/tool-call-types"
@@ -55,8 +56,8 @@ export interface BeaconToolContext {
 }
 
 const LIST_DESCRIPTION =
-  "List the user's paired machines (beacons) with their id, label, OS, online state and whether they are enabled. "
-  + "Metadata only: nothing is sent to any machine."
+  "List the user's paired machines (beacons) with their id, label, alias, @beacon mention handle, OS, online state and "
+  + "whether they are enabled. Metadata only: nothing is sent to any machine."
 
 const READ_DESCRIPTION =
   "Read a window of a text file on a beacon (a paired remote machine). Returns at most `limit` bytes starting at `offset` "
@@ -152,7 +153,7 @@ function toJsonObject(input: ToolArgs): JsonObject {
 }
 
 function describeBeacon(beacon: BeaconConfig): string {
-  return `${beacon.label} (${beacon.id})`
+  return `${beaconDisplayName(beacon)} (${beacon.id})`
 }
 
 function formatStream(name: string, text: string): string {
@@ -244,8 +245,18 @@ export function buildBeaconToolList<TTool, TExtra>(
   return [
     ...transferTools,
     tool("beacon_list", LIST_DESCRIPTION, {}, async () => {
-      const rows = buildBeaconStatusRows(deps.getBeacons(), registry.live())
-      const summary = rows.map((row) => ({ id: row.id, label: row.label, os: row.os, online: row.online, enabled: row.enabled }))
+      const beacons = deps.getBeacons()
+      const { handleByBeaconId } = buildBeaconMentionIndex(beacons)
+      const rows = buildBeaconStatusRows(beacons, registry.live())
+      const summary = rows.map((row) => ({
+        id: row.id,
+        label: row.label,
+        alias: row.alias,
+        mention: `@${BEACON_MENTION_PREFIX}${handleByBeaconId.get(row.id) ?? row.id}`,
+        os: row.os,
+        online: row.online,
+        enabled: row.enabled,
+      }))
       return ok(JSON.stringify({ beacons: summary }))
     }),
     tool(

package/src/server/kanna-mcp-tools/chat-tasks.ts

@@ -23,7 +23,7 @@ import {
 } from "../../shared/chat-tasks/types"
 
 export const TASK_CREATE_DESCRIPTION =
-  "Add a task to THIS chat's durable task list. Unlike the CLI's own TaskCreate, this survives /clear, compaction and a server restart, and a subagent's call lands on the parent chat — which is what makes it usable as an autonomous loop's plan. Pass needs to declare dependencies, and worktree/branch when the task will be worked in its own git worktree."
+  "Add a task to THIS chat's durable task list. Unlike the CLI's own TaskCreate, this survives /clear, compaction and a server restart, and a subagent's call lands on the parent chat — which is what makes it usable as an autonomous loop's plan. Pass needs to declare dependencies, and worktree/branch when the task will be worked in its own git worktree. The list shows tasks in the order they were created and offers no way to reorder them, and parallel task_create calls are recorded in arbitrary order, so create tasks one call at a time in the order they should be listed."
 
 export const TASK_UPDATE_DESCRIPTION =
   "Change a durable task: its status (pending / in_progress / completed), subject, description, dependencies or worktree. Replacing a task's status is how progress is recorded — there is no log to append to and no way for completed work to pile up and be redone."

package/src/server/push/push-manager.test.ts

@@ -41,6 +41,7 @@ function chat(overrides: Partial<ObservedChat> = {}): ObservedChat {
     projectTitle: "P",
     chatTitle: "Hello",
     status: "idle",
+    hasPendingWork: false,
     ...overrides,
   }
 }
@@ -99,6 +100,44 @@ describe("PushManager.observeStatuses", () => {
     expect(JSON.parse(sender.sent[0].payload).kind).toBe("completed")
   })
 
+  test("holds completed while background work is pending and sends it once the work ends", async () => {
+    await registerSub(manager, store, "d1", "https://push.example/x")
+    await manager.observeStatuses([chat({ status: "running" })])
+    await manager.observeStatuses([chat({ status: "idle", hasPendingWork: true })])
+    expect(sender.sent).toHaveLength(0)
+    await manager.observeStatuses([chat({ status: "idle", hasPendingWork: false })])
+    await manager.observeStatuses([chat({ status: "idle", hasPendingWork: false })])
+    expect(sender.sent).toHaveLength(1)
+    expect(JSON.parse(sender.sent[0].payload).kind).toBe("completed")
+  })
+
+  test("does not send done when the turn was cancelled", async () => {
+    await registerSub(manager, store, "d1", "https://push.example/x")
+    await manager.observeStatuses([chat({ status: "running" })])
+    manager.noteTurnOutcome("c1", "cancelled")
+    await manager.observeStatuses([chat({ status: "idle" })])
+    expect(sender.sent).toHaveLength(0)
+  })
+
+  test("a later idle after a suppressed cancel still sends done", async () => {
+    await registerSub(manager, store, "d1", "https://push.example/x")
+    await manager.observeStatuses([chat({ status: "running" })])
+    manager.noteTurnOutcome("c1", "cancelled")
+    await manager.observeStatuses([chat({ status: "idle" })])
+    await manager.observeStatuses([chat({ status: "running" })])
+    await manager.observeStatuses([chat({ status: "idle" })])
+    expect(sender.sent).toHaveLength(1)
+    expect(JSON.parse(sender.sent[0].payload).kind).toBe("completed")
+  })
+
+  test("still notifies waiting_for_user while background work is pending", async () => {
+    await registerSub(manager, store, "d1", "https://push.example/x")
+    await manager.observeStatuses([chat({ status: "running", hasPendingWork: true })])
+    await manager.observeStatuses([chat({ status: "waiting_for_user", hasPendingWork: true })])
+    expect(sender.sent).toHaveLength(1)
+    expect(JSON.parse(sender.sent[0].payload).kind).toBe("waiting_for_user")
+  })
+
   test("fires for any -> failed", async () => {
     await registerSub(manager, store, "d1", "https://push.example/x")
     await manager.observeStatuses([chat({ status: "running" })])

package/src/server/push/push-manager.ts

@@ -12,12 +12,15 @@ import type { VapidKeypair } from "./vapid.adapter"
 
 export type { PushPayload, PushTransitionKind } from "../../shared/types"
 
+export type TurnOutcome = "finished" | "failed" | "cancelled"
+
 export interface ObservedChat {
   chatId: string
   projectLocalPath: string
   projectTitle: string
   chatTitle: string
   status: KannaStatus
+  hasPendingWork: boolean
 }
 
 export interface WebPushSendOptions {
@@ -63,6 +66,8 @@ export class PushManager {
   private readonly mutedProjects = new Set<string>()
   private readonly mutedChats = new Set<string>()
   private readonly lastStatusByChat = new Map<string, KannaStatus>()
+  private readonly heldCompletions = new Set<string>()
+  private readonly latestOutcomeByChat = new Map<string, TurnOutcome>()
   private seeded = false
   private readonly dedupKeyToTs = new Map<string, number>()
   private readonly focusedByDevice = new Map<string, string | null>()
@@ -277,6 +282,10 @@ export class PushManager {
     }
   }
 
+  noteTurnOutcome(chatId: string, outcome: TurnOutcome): void {
+    this.latestOutcomeByChat.set(chatId, outcome)
+  }
+
   async observeStatuses(snapshot: readonly ObservedChat[]): Promise<void> {
     if (!this.seeded) {
       for (const chat of snapshot) {
@@ -288,7 +297,7 @@ export class PushManager {
     for (const chat of snapshot) {
       const prev = this.lastStatusByChat.get(chat.chatId)
       this.lastStatusByChat.set(chat.chatId, chat.status)
-      const kind = this.detectTransition(prev, chat.status)
+      const kind = this.resolveKind(chat, prev)
       if (!kind) continue
       if (this.isDuplicate(chat.chatId, kind)) continue
       if (this.mutedProjects.has(chat.projectLocalPath)) continue
@@ -298,6 +307,41 @@ export class PushManager {
     }
   }
 
+  private resolveKind(chat: ObservedChat, prev: KannaStatus | undefined): PushTransitionKind | null {
+    const cancelled = this.latestOutcomeByChat.get(chat.chatId) === "cancelled"
+    const kind = this.resolveStatusKind(chat, prev)
+    if (chat.status !== "running" && chat.status !== "starting") {
+      this.latestOutcomeByChat.delete(chat.chatId)
+    }
+    if (cancelled && chat.status === "idle") {
+      this.heldCompletions.delete(chat.chatId)
+      return null
+    }
+    return kind
+  }
+
+  private resolveStatusKind(chat: ObservedChat, prev: KannaStatus | undefined): PushTransitionKind | null {
+    const kind = this.detectTransition(prev, chat.status)
+    if (chat.status === "waiting_for_user" || chat.status === "failed") {
+      this.heldCompletions.delete(chat.chatId)
+      return kind
+    }
+    if (kind === "completed" && chat.hasPendingWork) {
+      this.heldCompletions.add(chat.chatId)
+      return null
+    }
+    const releasesHeldCompletion =
+      kind === null
+      && chat.status === "idle"
+      && !chat.hasPendingWork
+      && this.heldCompletions.has(chat.chatId)
+    if (kind === "completed" || releasesHeldCompletion) {
+      this.heldCompletions.delete(chat.chatId)
+      return "completed"
+    }
+    return kind
+  }
+
   private detectTransition(
     prev: KannaStatus | undefined,
     next: KannaStatus,

package/src/server/server.ts

@@ -395,6 +395,7 @@ async function createApplicationServices(options: StartKannaServerOptions): Prom
     subagentTranscriptRegistry,
     localCatalog,
     genuiDatasets,
+    onTurnOutcome: (chatId, outcome) => pushManager.noteTurnOutcome(chatId, outcome),
     chatPolicy: { ...POLICY_DEFAULT, defaultAction: "auto-allow" },
     getSubagents: () => appSettings.getSnapshot().subagents,
     getAppSettingsSnapshot: () => buildAgentAppSettingsView(appSettings.getSnapshot()),

package/src/server/ws-router-broadcast.ts

@@ -110,7 +110,7 @@ export class BroadcastManager {
       for (const ws of this.sockets) {
         const snapshotSignatures = ensureSnapshotSignatures(ws)
         for (const [id, topic] of ws.data.subscriptions.entries()) {
-          if (topic.type !== "app-settings") continue
+          if (topic.type !== "app-settings" && topic.type !== "beacons") continue
           const envelope = deps.envelopeBuilder.createEnvelope(id, topic, undefined, ws)
           if (envelope.type !== "snapshot") continue
           const signature = JSON.stringify(envelope.snapshot)

package/src/server/ws-router-envelope.ts

@@ -18,6 +18,7 @@ import type { BackgroundTaskOutputRegistry } from "./background-task-output-regi
 import type { BoardRegistry } from "./board-registry"
 import type { BeaconRegistry } from "./beacon-registry"
 import { buildBeaconStatusRows } from "../shared/beacon-status"
+import { chatHasPendingWork } from "../shared/chat-activity"
 import type { FollowedSessionRegistry } from "./followed-session-registry"
 import type { UpdateManager } from "./update-manager"
 import type { PackageUpdateManager } from "./package-update-manager"
@@ -108,6 +109,7 @@ function buildSidebarSnapshotCacheEntry(
       projectTitle: group.localPath.split("/").filter(Boolean).pop() ?? group.localPath,
       chatTitle: chat.title,
       status: chat.status,
+      hasPendingWork: chatHasPendingWork(chat.activity),
     }))
   )
   void pushManager.observeStatuses(observed).catch((error) => {

package/src/server/ws-router-settings.test.ts

@@ -193,6 +193,7 @@ describe("beacons.update", () => {
         sent.push(String(payload))
         return sent.length
       },
+      close(): void {},
     }
   }
 

package/src/server/ws-router.test.ts

@@ -26,6 +26,9 @@ import { createBoardRegistry } from "./board-registry"
 import { createBoardStore } from "./board-store.adapter"
 import { POLICY_DEFAULT } from "../shared/permission-policy"
 import { DEFAULT_TAB_MIN_WIDTH } from "../shared/pane-tab-width"
+import type { BeaconConfig } from "../shared/beacon-config"
+import { DEFAULT_BEACON_SCOPE } from "../shared/beacon-scope"
+import { createBeaconRegistry } from "./beacon-registry"
 
 function withSidebarGroupDefaults(group: {
   groupKey: string
@@ -659,6 +662,71 @@ describe("ws-router", () => {
     ])
   })
 
+  test("a beacon removed in settings disappears from an open beacons subscription", async () => {
+    const stamp = "2026-10-13T00:00:00.000Z"
+    const beacon = (id: string): BeaconConfig => ({
+      id,
+      label: `machine-${id}`,
+      publicKey: "pk",
+      os: "linux",
+      scope: DEFAULT_BEACON_SCOPE,
+      enabled: true,
+      createdAt: stamp,
+      updatedAt: stamp,
+    })
+    let snapshot: AppSettingsSnapshot = { ...DEFAULT_APP_SETTINGS_SNAPSHOT, customBeacons: [beacon("b1"), beacon("b2")] }
+    let listener: ((nextSnapshot: AppSettingsSnapshot) => void) | null = null
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set(), getWaitStartedAtByChatId: () => new Map() } as never,
+      terminals: { getSnapshot: () => null, onEvent: () => () => {} } as never,
+      keybindings: { getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT, onChange: () => () => {} } as never,
+      appSettings: {
+        getSnapshot: () => snapshot,
+        write: async () => snapshot,
+        writePatch: async (patch) => {
+          const removedId = patch.customBeacons?.delete?.id
+          snapshot = { ...snapshot, customBeacons: snapshot.customBeacons.filter((entry) => entry.id !== removedId) }
+          listener?.(snapshot)
+          return snapshot
+        },
+        onChange: (nextListener) => {
+          listener = nextListener
+          return () => {
+            listener = null
+          }
+        },
+      },
+      beaconRegistry: createBeaconRegistry(),
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+      pushManager: NOOP_PUSH_MANAGER,
+    })
+    const ws = new FakeWebSocket()
+    router.handleOpen(ws as never)
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({ v: 1, type: "subscribe", id: "beacons-sub-1", topic: { type: "beacons" } })
+    )
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "beacon-delete-1",
+        command: { type: "settings.writeAppSettingsPatch", patch: { customBeacons: { delete: { id: "b2" } } } },
+      })
+    )
+
+    const beaconIdsPushed = ws.sent.flatMap((envelope) => {
+      const pushed = envelope as { id?: string; snapshot?: { type?: string; data?: { beacons?: Array<{ id: string }> } } }
+      return pushed.id === "beacons-sub-1" ? [pushed.snapshot?.data?.beacons?.map((row) => row.id) ?? []] : []
+    })
+    expect(beaconIdsPushed).toEqual([["b1", "b2"], ["b1"]])
+  })
+
   test("tracks analytics preference transitions in the correct order", async () => {
     const analyticsEvents: string[] = []
     let analyticsEnabled = true