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/proactive/index.ts

@@ -1,6 +1,135 @@
-// Auto-generated stub — replace with real implementation
-export {};
-export const isProactiveActive: () => boolean = () => false;
-export const activateProactive: (source?: string) => void = () => {};
-export const isProactivePaused: () => boolean = () => false;
-export const deactivateProactive: () => void = () => {};
+/**
+ * Proactive mode — tick-driven autonomous agent.
+ *
+ * State machine: inactive → active (→ paused → active) → inactive
+ *
+ * When active, the REPL periodically injects <tick> prompts so the model
+ * keeps working even when the user is idle.  SleepTool lets the model
+ * control its own wake-up cadence.
+ */
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+let active = false
+let paused = false
+let contextBlocked = false
+let nextTickAt: number | null = null
+let activationSource: string | undefined
+
+const listeners = new Set<() => void>()
+
+function notify(): void {
+  for (const cb of listeners) {
+    try {
+      cb()
+    } catch {
+      // subscriber errors must not break the notifier
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API — consumed by REPL.tsx, PromptInputFooterLeftSide, prompts.ts
+// ---------------------------------------------------------------------------
+
+export function isProactiveActive(): boolean {
+  return active
+}
+
+export function activateProactive(source?: string): void {
+  if (active) return
+  active = true
+  paused = false
+  contextBlocked = false
+  activationSource = source
+  notify()
+}
+
+export function deactivateProactive(): void {
+  if (!active) return
+  active = false
+  paused = false
+  contextBlocked = false
+  nextTickAt = null
+  activationSource = undefined
+  notify()
+}
+
+export function isProactivePaused(): boolean {
+  return paused
+}
+
+export function pauseProactive(): void {
+  if (!active || paused) return
+  paused = true
+  nextTickAt = null
+  notify()
+}
+
+export function resumeProactive(): void {
+  if (!active || !paused) return
+  paused = false
+  notify()
+}
+
+/**
+ * Block / unblock tick generation.
+ *
+ * Set to `true` on API errors to prevent tick → error → tick runaway loops.
+ * Cleared on successful response or after compaction.
+ */
+export function setContextBlocked(blocked: boolean): void {
+  if (contextBlocked === blocked) return
+  contextBlocked = blocked
+  if (blocked) {
+    nextTickAt = null
+  }
+  notify()
+}
+
+export function isContextBlocked(): boolean {
+  return contextBlocked
+}
+
+/**
+ * Schedule the next tick timestamp (epoch ms).
+ * Called by useProactive after submitting a tick.
+ */
+export function setNextTickAt(ts: number | null): void {
+  nextTickAt = ts
+  notify()
+}
+
+/**
+ * Returns the epoch-ms timestamp of the next scheduled tick, or null.
+ * Used by PromptInputFooterLeftSide to render a countdown.
+ */
+export function getNextTickAt(): number | null {
+  if (!active || paused || contextBlocked) return null
+  return nextTickAt
+}
+
+export function getActivationSource(): string | undefined {
+  return activationSource
+}
+
+/**
+ * Subscribe to any proactive state change.
+ * Returns an unsubscribe function.
+ */
+export function subscribeToProactiveChanges(cb: () => void): () => void {
+  listeners.add(cb)
+  return () => {
+    listeners.delete(cb)
+  }
+}
+
+/**
+ * Whether ticks should fire right now.
+ * Convenience predicate combining all blocking conditions.
+ */
+export function shouldTick(): boolean {
+  return active && !paused && !contextBlocked
+}

src/proactive/useProactive.ts

@@ -0,0 +1,102 @@
+/**
+ * useProactive — React hook that drives tick generation for proactive mode.
+ *
+ * Mounted inside REPL.tsx when feature('PROACTIVE') || feature('KAIROS').
+ * Generates <tick>HH:MM:SS</tick> prompts at a fixed interval while
+ * proactive mode is active and not blocked.
+ */
+import { useEffect, useRef } from 'react'
+import { TICK_TAG } from '../constants/xml.js'
+import {
+  isProactiveActive,
+  isProactivePaused,
+  isContextBlocked,
+  setNextTickAt,
+  shouldTick,
+} from './index.js'
+
+/** Default interval between ticks (ms). Prompt cache TTL is ~5 min so we
+ *  stay well under that to keep the cache warm. */
+const TICK_INTERVAL_MS = 30_000
+
+type UseProactiveOpts = {
+  isLoading: boolean
+  queuedCommandsLength: number
+  hasActiveLocalJsxUI: boolean
+  isInPlanMode: boolean
+  onSubmitTick: (prompt: string) => void
+  onQueueTick: (prompt: string) => void
+}
+
+export function useProactive(opts: UseProactiveOpts): void {
+  const optsRef = useRef(opts)
+  optsRef.current = opts
+
+  useEffect(() => {
+    if (!isProactiveActive()) return
+
+    let timer: ReturnType<typeof setTimeout> | null = null
+
+    function scheduleTick(): void {
+      const nextTs = Date.now() + TICK_INTERVAL_MS
+      setNextTickAt(nextTs)
+
+      timer = setTimeout(() => {
+        timer = null
+
+        // Guard: skip tick if any blocking condition is met
+        if (!shouldTick()) {
+          // Reschedule — conditions may clear later
+          scheduleTick()
+          return
+        }
+
+        const {
+          isLoading,
+          queuedCommandsLength,
+          hasActiveLocalJsxUI,
+          isInPlanMode,
+        } = optsRef.current
+
+        // Don't fire while a query is in-flight, plan mode is active,
+        // a local JSX UI is showing, or commands are queued
+        if (
+          isLoading ||
+          isInPlanMode ||
+          hasActiveLocalJsxUI ||
+          queuedCommandsLength > 0
+        ) {
+          scheduleTick()
+          return
+        }
+
+        const tickContent = `<${TICK_TAG}>${new Date().toLocaleTimeString()}</${TICK_TAG}>`
+
+        // If nothing is in the queue, submit directly; otherwise queue
+        if (queuedCommandsLength === 0) {
+          optsRef.current.onSubmitTick(tickContent)
+        } else {
+          optsRef.current.onQueueTick(tickContent)
+        }
+
+        // Schedule next tick
+        scheduleTick()
+      }, TICK_INTERVAL_MS)
+    }
+
+    scheduleTick()
+
+    return () => {
+      if (timer !== null) {
+        clearTimeout(timer)
+        timer = null
+      }
+      setNextTickAt(null)
+    }
+  }, [
+    // Re-mount when proactive state changes
+    isProactiveActive(),
+    isProactivePaused(),
+    isContextBlocked(),
+  ])
+}