feat: 远程群控 (#243)

* feat: restore pipe IPC, LAN pipes, monitor tool, and PR-package features

Core IPC system (UDS_INBOX):
- PipeServer/PipeClient with UDS + TCP dual transport, NDJSON protocol
- PipeRegistry: machineId-based role assignment, file locking
- Master/slave attach, prompt relay, permission forwarding
- Heartbeat lifecycle with parallel isPipeAlive probes
- Commands: /pipes, /attach, /detach, /send, /claim-main, /pipe-status

LAN Pipes (LAN_PIPES):
- UDP multicast beacon (224.0.71.67:7101) for zero-config LAN discovery
- PipeServer TCP listener, PipeClient TCP connect mode
- Heartbeat auto-attaches LAN peers via TCP
- Cross-machine attach allowed regardless of role
- /pipes shows [LAN] peers with role + hostname/IP
- SendMessageTool supports tcp: scheme with user consent

Architecture — extracted hooks from REPL.tsx (~830 lines → ~20 lines):
- usePipeIpc: lifecycle (bootstrap, handlers, heartbeat, cleanup)
- usePipeRelay: slave→master message relay via module singleton
- usePipePermissionForward: permission request/cancel forwarding
- usePipeRouter: selected pipe input routing with role+IP labels
- Shared ndjsonFramer.ts replaces 3 duplicate NDJSON parsers

Key fixes applied during development:
- Multicast binds to correct LAN interface (not WSL/Docker)
- Beacon ref stored as module singleton (not Zustand state mutation)
- Heartbeat preserves LAN peers in discoveredPipes and selectedPipes
- Disconnect handler calls removeSlaveClient (fixes listener leak)
- cleanupStaleEntries probes without lock, writes briefly under lock
- getMachineId uses async execFile (not blocking execSync)
- globalThis.__pipeSendToMaster replaced with setPipeRelay singleton
- M key only toggles route mode when selector panel is expanded
- User prompt displayed in message list on pipe broadcast
- Broadcast notifications show [role] + hostname/IP for LAN peers

Other restored features:
- Monitor tool: /monitor command, MonitorTool, MonitorMcpTask lifecycle
- Daemon supervisor and remoteControlServer command
- Tools: SnipTool, SleepTool, ListPeersTool, SendUserFileTool,
  WebBrowserTool, WorkflowTool, and 10+ stub→implementation rewrites
- Feature flags: UDS_INBOX, LAN_PIPES, MONITOR_TOOL, FORK_SUBAGENT,
  KAIROS, COORDINATOR_MODE, WORKFLOW_SCRIPTS, HISTORY_SNIP

Tests: 2190 pass / 0 fail (15 new: lanBeacon 7, peerAddress 8)

* fix: resolve merge conflicts and fix all tsc/test errors after main merge

- Export ToolResultBlockParam from Tool.ts (14 tool files fixed)
- Migrate ink imports from ../../ink.js to @anthropic/ink (7 files)
- Fix toolUseID → toolUseId typo in monitor.ts and MonitorTool.tsx
- Add fallback values for string|undefined type errors (8 locations)
- Fix AppState type in assistant.ts, add NewInstallWizard stubs
- Fix ParsedRepository.repo → .name in subscribe-pr.ts
- Fix AgentId/string type mismatch in BackgroundTasksDialog.tsx
- Fix PipeRelayFn return type in pipePermissionRelay.ts
- Use PipeMessage type in usePipeRelay.ts
- Fix lanBeacon.test.ts mock type assertions
- Create missing MouseActionEvent class for ink package
- Use ansi: color format instead of bare "green"/"red"
- Resolve theme.permission access via getTheme()

Result: 0 tsc errors, 2496 tests pass, 0 fail

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: 恢复 /poor 的说明

---------

Co-authored-by: unraid <local@unraid.local>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

src/commands/attach/attach.ts

@@ -0,0 +1,137 @@
+import { feature } from 'bun:bundle'
+import type { LocalCommandCall } from '../../types/command.js'
+import {
+  connectToPipe,
+  getPipeIpc,
+  isPipeControlled,
+  type PipeClient,
+  type PipeMessage,
+  type TcpEndpoint,
+} from '../../utils/pipeTransport.js'
+import { addSlaveClient } from '../../hooks/useMasterMonitor.js'
+
+export const call: LocalCommandCall = async (args, context) => {
+  const targetName = args.trim()
+  if (!targetName) {
+    return {
+      type: 'text',
+      value: 'Usage: /attach <pipe-name>\nUse /pipes to list available pipes.',
+    }
+  }
+
+  const currentState = context.getAppState()
+
+  // Check if already attached to this slave
+  if (getPipeIpc(currentState).slaves[targetName]) {
+    return {
+      type: 'text',
+      value: `Already attached to "${targetName}".`,
+    }
+  }
+
+  // Controlled sub sessions cannot attach to other sub sessions.
+  if (isPipeControlled(getPipeIpc(currentState))) {
+    return {
+      type: 'text',
+      value:
+        'Cannot attach: this sub is currently controlled by a master. Detach it from the master first.',
+    }
+  }
+
+  // Resolve TCP endpoint for LAN peers
+  let tcpEndpoint: TcpEndpoint | undefined
+  if (feature('LAN_PIPES')) {
+    const pipeState = getPipeIpc(currentState)
+    const discoveredPeer = pipeState.discoveredPipes.find(
+      (p: { pipeName: string }) => p.pipeName === targetName,
+    )
+    if (discoveredPeer) {
+      // Check if this is a LAN peer by looking up beacon data
+      const { getLanBeacon } =
+        require('../../utils/lanBeacon.js') as typeof import('../../utils/lanBeacon.js')
+      const beaconRef = getLanBeacon()
+      if (beaconRef) {
+        const lanPeers = beaconRef.getPeers()
+        const lanPeer = lanPeers.get(targetName)
+        if (lanPeer) {
+          tcpEndpoint = { host: lanPeer.ip, port: lanPeer.tcpPort }
+        }
+      }
+    }
+  }
+
+  // Connect to the target pipe server (UDS or TCP)
+  let client: PipeClient
+  try {
+    const myName =
+      getPipeIpc(currentState).serverName ?? `master-${process.pid}`
+    client = await connectToPipe(targetName, myName, undefined, tcpEndpoint)
+  } catch (err) {
+    return {
+      type: 'text',
+      value: `Failed to connect to "${targetName}"${tcpEndpoint ? ` (TCP ${tcpEndpoint.host}:${tcpEndpoint.port})` : ''}: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+
+  // Send attach request and wait for response
+  return new Promise(resolve => {
+    const timeout = setTimeout(() => {
+      client.disconnect()
+      resolve({
+        type: 'text',
+        value: `Attach to "${targetName}" timed out (no response within 5s).`,
+      })
+    }, 5000)
+
+    client.onMessage((msg: PipeMessage) => {
+      if (msg.type === 'attach_accept') {
+        clearTimeout(timeout)
+
+        // Register the slave client in the module-level registry
+        addSlaveClient(targetName, client)
+
+        // Update AppState: add slave and switch to master role
+        context.setAppState(prev => ({
+          ...prev,
+          pipeIpc: {
+            ...getPipeIpc(prev),
+            role: 'master',
+            displayRole: 'master',
+            slaves: {
+              ...getPipeIpc(prev).slaves,
+              [targetName]: {
+                name: targetName,
+                connectedAt: new Date().toISOString(),
+                status: 'idle' as const,
+                unreadCount: 0,
+                history: [],
+              },
+            },
+          },
+        }))
+
+        const slaveCount =
+          Object.keys(getPipeIpc(currentState).slaves).length + 1
+        resolve({
+          type: 'text',
+          value: `Attached to "${targetName}" as master. Now monitoring ${slaveCount} sub session(s).\nUse /send ${targetName} <message> to send tasks.\nUse /status to see all connected subs.\nUse /detach ${targetName} to disconnect.`,
+        })
+      } else if (msg.type === 'attach_reject') {
+        clearTimeout(timeout)
+        client.disconnect()
+
+        resolve({
+          type: 'text',
+          value: `Attach rejected by "${targetName}": ${msg.data ?? 'unknown reason'}`,
+        })
+      }
+    })
+
+    // Include machineId so remote can distinguish LAN peers from local peers
+    const pipeState = getPipeIpc(currentState)
+    client.send({
+      type: 'attach_request',
+      meta: { machineId: pipeState.machineId },
+    })
+  })
+}

src/commands/attach/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const attach = {
+  type: 'local',
+  name: 'attach',
+  description: 'Attach to a sub Claude CLI instance via named pipe',
+  supportsNonInteractive: false,
+  load: () => import('./attach.js'),
+} satisfies Command
+
+export default attach