@foxden-app/foxclaw 0.5.7 → 0.5.9

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.5.9 - 2026-06-07
+
+### 中文
+- Linux 用户级 systemd 安装现在会在 `foxclaw start` / `restart` / `install-systemd` 时自动尝试启用 systemd user linger，避免用户退出 SSH 或桌面会话后 FoxClaw 停止接收 Telegram 消息。
+- `foxclaw doctor` 新增 linger 状态检查；如果自动启用失败，会提示使用 `sudo loginctl enable-linger <user>` 手动修复。
+- 中文/英文安装指南和故障排查文档更新为默认自动处理 linger，失败时再手动介入。
+
+### English
+- Linux user-systemd installation now tries to enable systemd user linger during `foxclaw start`, `restart`, and `install-systemd`, preventing FoxClaw from stopping after SSH or desktop logout.
+- `foxclaw doctor` now checks linger state and tells users to run `sudo loginctl enable-linger <user>` if automatic setup fails.
+- Updated the Chinese and English install and troubleshooting docs to describe automatic linger setup with manual recovery only when needed.
+
+## 0.5.8 - 2026-06-05
+
+### 中文
+- 为跨节点 auth 同步新增持久化事件环，记录 push、pull、lease、test 和远端导入的发送、接收、超时、跳过、导入、失败等阶段。
+- `/auth sync status` 现在展示 peer 最近活跃时间和最近事件，让“peer 在线但某次请求超时”“候选失败但同步系统正常”更容易判断。
+- 新增 `/auth sync events [过滤]` 和 `/auth sync trace <requestId>`，可按候选名、peer、事件类型或请求 ID 查看 bot_to_bot 通讯流水。
+- 事件记录包含 requestId、peer、candidateName 和阶段详情，同时保留既有加密协议兼容性。
+
+### English
+- Added a persisted event ring for cross-node auth sync, recording send, receive, timeout, skip, import, and failure stages for push, pull, lease, test, and remote-import flows.
+- `/auth sync status` now includes peer recent activity and recent events, making it easier to distinguish "peer reachable but this request timed out" from candidate-specific failures.
+- Added `/auth sync events [filter]` and `/auth sync trace <requestId>` to inspect bot-to-bot traffic by candidate name, peer, event kind, or request ID.
+- Event records include requestId, peer, candidateName, and stage details while keeping the existing encrypted protocol backward-compatible.
+
 ## 0.5.7 - 2026-06-05
 
 ### 中文

package/README.md

@@ -215,7 +215,7 @@ TG_BOT_TOKEN=123456:token_a
 
 FoxClaw 仍然只运行一个系统服务。默认情况下，它会为每个 bot 启动独立 `codex app-server` 和独立 `CODEX_HOME`。因此 A 私聊运行 turn 时，B 私聊仍可独立切换自己的 `/auth`。候选凭据由 FoxClaw 在登录或刷新在线验证后镜像同步；切换或重载前还会从其他 Codex home 恢复同账号较新凭据。各 bot 的当前选择互不影响。每个 bot 首次私聊发送 `/help` 和 `/status`；`/auth` 会标明正在操作的 bot runtime，`/status` 会列出全部 bot 的连接、runtime 类型、当前 auth 和活动 turn 摘要。
 
-多台机器共享同一合法账号池时，可以启用可选跨节点 auth 同步：`AUTH_SYNC_ENABLED=true`、`AUTH_SYNC_KEY` 和 `AUTH_SYNC_PEERS=@peer_contact_bot`。推荐每台机器只选一个联系人 bot；同一节点内的其他 bot 继续走本机 auth 镜像。多 bot 模式下，默认用 `TG_BOT_TOKENS` 的第一个 token 作为联系人 bot。FoxClaw 会通过 Telegram Bot-to-Bot 私聊传输加密 auth 包；本机验证刷新后主动 push，发现本机候选失效时主动 pull peer 已持有的有效副本，并在联系人 bot 私聊里报告发送、接收、排队、导入、失败和人工介入提示。跨节点恢复不会自动刷新 token，`/auth refresh all confirm` 会先申请跨节点刷新锁。完整配置、`@BotFather` 操作和验证步骤见 [跨节点 auth 同步配置指南](./docs/zh/cross-node-auth-sync.md)。
+多台机器共享同一合法账号池时，可以启用可选跨节点 auth 同步：`AUTH_SYNC_ENABLED=true`、`AUTH_SYNC_KEY` 和 `AUTH_SYNC_PEERS=@peer_contact_bot`。推荐每台机器只选一个联系人 bot；同一节点内的其他 bot 继续走本机 auth 镜像。多 bot 模式下，默认用 `TG_BOT_TOKENS` 的第一个 token 作为联系人 bot。FoxClaw 会通过 Telegram Bot-to-Bot 私聊传输加密 auth 包；本机验证刷新后主动 push，发现本机候选失效时主动 pull peer 已持有的有效副本，并在联系人 bot 私聊里报告发送、接收、排队、导入、失败和人工介入提示。`/auth sync events [过滤]` 和 `/auth sync trace <requestId>` 可查看最近通讯流水。跨节点恢复不会自动刷新 token，`/auth refresh all confirm` 会先申请跨节点刷新锁。完整配置、`@BotFather` 操作和验证步骤见 [跨节点 auth 同步配置指南](./docs/zh/cross-node-auth-sync.md)。
 
 如果你需要一路 Telegram 与终端互通 session，把同一个 token 同时填入 `TG_BOT_TOKENS` 和 `TG_BOT_TOKEN`。这个 bot 使用默认 `CODEX_HOME`（未设置时通常是 `~/.codex`）和默认 auth，因此能看到终端 Codex 的本地线程；它不再享有隔离 runtime 的“互不影响”保证，切换 auth 会影响终端和其他默认 runtime。
 

package/README_EN.md

@@ -215,7 +215,7 @@ TG_BOT_TOKEN=123456:token_a
 
 FoxClaw remains one system service. By default, it starts an independent `codex app-server` and `CODEX_HOME` for each bot. While bot A is running a turn, bot B can switch its own `/auth` selection. Candidate credentials are mirrored only after online-validated login or refresh; before switching or reloading, FoxClaw also restores a newer same-account credential from another Codex home when available. Current selections remain independent. Send `/help` and `/status` in a private chat with each bot after installation; `/auth` names the runtime being managed, and `/status` summarizes every bot's connection, runtime type, selected auth, and active turns.
 
-When multiple machines share the same legally owned account pool, optional cross-node auth sync can be enabled with `AUTH_SYNC_ENABLED=true`, `AUTH_SYNC_KEY`, and `AUTH_SYNC_PEERS=@peer_contact_bot`. The recommended topology is one contact bot per node; other bots on the same node continue to use local auth mirroring. In multi-bot mode, the first token in `TG_BOT_TOKENS` is the default contact bot. FoxClaw sends encrypted auth bundles through Telegram Bot-to-Bot private messages. A locally verified refresh is pushed to peers, and a node with a bad local candidate can pull an already-held valid peer copy. The contact bot private chat reports send, receive, queue, import, failure, and manual-intervention states. Cross-node recovery never auto-refreshes tokens; `/auth refresh all confirm` first requests a cross-node refresh lease. For full config, `@BotFather` operations, and verification steps, read the [Cross-Node Auth Sync Setup Guide](./docs/cross-node-auth-sync.md).
+When multiple machines share the same legally owned account pool, optional cross-node auth sync can be enabled with `AUTH_SYNC_ENABLED=true`, `AUTH_SYNC_KEY`, and `AUTH_SYNC_PEERS=@peer_contact_bot`. The recommended topology is one contact bot per node; other bots on the same node continue to use local auth mirroring. In multi-bot mode, the first token in `TG_BOT_TOKENS` is the default contact bot. FoxClaw sends encrypted auth bundles through Telegram Bot-to-Bot private messages. A locally verified refresh is pushed to peers, and a node with a bad local candidate can pull an already-held valid peer copy. The contact bot private chat reports send, receive, queue, import, failure, and manual-intervention states. `/auth sync events [filter]` and `/auth sync trace <requestId>` inspect recent traffic. Cross-node recovery never auto-refreshes tokens; `/auth refresh all confirm` first requests a cross-node refresh lease. For full config, `@BotFather` operations, and verification steps, read the [Cross-Node Auth Sync Setup Guide](./docs/cross-node-auth-sync.md).
 
 To keep one Telegram bot interoperable with terminal Codex sessions, put the same token in both `TG_BOT_TOKENS` and `TG_BOT_TOKEN`. That bot uses the default `CODEX_HOME` (usually `~/.codex` when unset) and default auth, so it can see local terminal sessions. It no longer has the isolated runtime guarantee: `/auth` switches also affect the terminal and other default runtimes.
 

package/dist/auth/cross_node_sync.d.ts

@@ -31,6 +31,8 @@ export interface AuthSyncStatus {
     lastError: string | null;
     candidateFailures: AuthSyncCandidateFailure[];
     activeLeaseId: string | null;
+    peerStatuses: AuthSyncPeerStatus[];
+    recentEvents: AuthSyncEventRecord[];
 }
 export interface AuthSyncCandidateFailure {
     candidateName: string;
@@ -41,6 +43,21 @@ export interface AuthSyncCandidateFailure {
     mode: AuthSyncRemoteImportMode;
     updatedAt: string;
 }
+export interface AuthSyncPeerStatus {
+    peer: string;
+    lastReceivedAt: string | null;
+}
+export interface AuthSyncEventRecord {
+    id: string;
+    createdAt: string;
+    direction: 'in' | 'out' | 'local';
+    kind: string;
+    stage: string;
+    peer: string | null;
+    requestId: string | null;
+    candidateName: string | null;
+    detail: string | null;
+}
 export interface AuthSyncValidationResult {
     ok: boolean;
     reason?: string | null;
@@ -240,6 +257,7 @@ export declare class CrossNodeAuthSync {
     private recordCandidateFailure;
     private clearCandidateFailure;
     private notePeerActivity;
+    private recordEvent;
     private describePeerReachability;
     private notify;
     private notifyError;

package/dist/auth/cross_node_sync.js

@@ -10,6 +10,7 @@ const TEST_TIMEOUT_MS = 8_000;
 const LEASE_TIMEOUT_MS = 8_000;
 const LEASE_TTL_MS = 10 * 60_000;
 const REMOTE_ACCESS_TOKEN_MIN_TTL_MS = 60_000;
+const RECENT_EVENT_LIMIT = 120;
 export class CrossNodeAuthSync {
     config;
     logger;
@@ -39,6 +40,7 @@ export class CrossNodeAuthSync {
         lastPullCandidate: null,
         lastError: null,
         lastCandidateFailures: {},
+        recentEvents: [],
     };
     constructor(config, logger, transport, callbacks) {
         this.config = config;
@@ -67,6 +69,7 @@ export class CrossNodeAuthSync {
             lastPullCandidate: stored.lastPullCandidate ?? null,
             lastError: stored.lastError ?? null,
             lastCandidateFailures: normalizeCandidateFailures(stored.lastCandidateFailures ?? {}),
+            recentEvents: normalizeRecentEvents(stored.recentEvents ?? []),
         };
         await fs.mkdir(this.config.tempDir, { recursive: true, mode: 0o700 });
         await this.writeState();
@@ -109,6 +112,14 @@ export class CrossNodeAuthSync {
             candidateFailures: Object.values(this.state.lastCandidateFailures)
                 .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)),
             activeLeaseId: this.activeLocalLease?.leaseId ?? this.activeRemoteLease?.leaseId ?? null,
+            peerStatuses: this.peers.map((peer) => {
+                const lastActivityAt = this.lastPeerActivityAt.get(peer) ?? null;
+                return {
+                    peer,
+                    lastReceivedAt: lastActivityAt === null ? null : new Date(lastActivityAt).toISOString(),
+                };
+            }),
+            recentEvents: [...this.state.recentEvents],
         };
     }
     isIdle() {
@@ -126,16 +137,29 @@ export class CrossNodeAuthSync {
         const record = await this.callbacks.readLocalCandidate(candidateName);
         if (!record)
             return false;
+        const requestId = crypto.randomUUID();
+        this.recordEvent({
+            direction: 'local',
+            kind: 'candidate.publish',
+            stage: 'started',
+            peer: null,
+            requestId,
+            candidateName,
+            detail: `peers=${this.peers.join(', ') || 'none'}`,
+        });
         this.notify({ kind: 'candidate_publish_started', candidateName, peers: [...this.peers] });
         try {
             await this.sendToAll({
                 kind: 'push.bundle',
+                requestId,
                 ...bundleFromRecord(record),
             });
+            this.recordEvent({ direction: 'local', kind: 'candidate.publish', stage: 'completed', peer: null, requestId, candidateName, detail: null });
             this.notify({ kind: 'candidate_publish_completed', candidateName, peers: [...this.peers] });
         }
         catch (error) {
             this.recordError(`candidate publish failed for ${candidateName}: ${formatError(error)}`, false);
+            this.recordEvent({ direction: 'local', kind: 'candidate.publish', stage: 'failed', peer: null, requestId, candidateName, detail: formatError(error) });
             this.notify({
                 kind: 'candidate_publish_failed',
                 candidateName,
@@ -161,6 +185,7 @@ export class CrossNodeAuthSync {
                 }
                 await this.sendToAll({
                     kind: 'push.bundle',
+                    requestId: crypto.randomUUID(),
                     ...bundleFromRecord(record),
                 });
                 sent += 1;
@@ -213,6 +238,15 @@ export class CrossNodeAuthSync {
                         waitMs,
                         peerReachability,
                     });
+                    this.recordEvent({
+                        direction: 'local',
+                        kind: 'pull.request',
+                        stage: 'timeout',
+                        peer: null,
+                        requestId,
+                        candidateName,
+                        detail: reason,
+                    });
                     this.notify({
                         kind: 'recovery_failed',
                         candidateName,
@@ -247,6 +281,15 @@ export class CrossNodeAuthSync {
                 this.pendingPulls.delete(requestId);
                 this.recordError(`pull request failed: ${formatError(error)}`, false);
                 const waitMs = Date.now() - startedAt;
+                this.recordEvent({
+                    direction: 'local',
+                    kind: 'pull.request',
+                    stage: 'send_failed',
+                    peer: null,
+                    requestId,
+                    candidateName,
+                    detail: formatError(error),
+                });
                 this.notify({
                     kind: 'recovery_failed',
                     candidateName,
@@ -272,6 +315,7 @@ export class CrossNodeAuthSync {
         if (!this.isReady() || this.peers.length === 0) {
             const leaseId = crypto.randomUUID();
             this.activeLocalLease = { leaseId, expiresAt: Date.now() + LEASE_TTL_MS };
+            this.recordEvent({ direction: 'local', kind: 'lease.request', stage: 'granted_local', peer: null, requestId: leaseId, candidateName: null, detail: reason });
             return { ok: true, leaseId };
         }
         if (!this.callbacks.isIdle()) {
@@ -282,6 +326,15 @@ export class CrossNodeAuthSync {
         const result = await new Promise((resolve) => {
             const timer = setTimeout(() => {
                 this.pendingLeases.delete(leaseId);
+                this.recordEvent({
+                    direction: 'local',
+                    kind: 'lease.request',
+                    stage: 'timeout',
+                    peer: null,
+                    requestId: leaseId,
+                    candidateName: null,
+                    detail: `timed out waiting for ${this.peers.length} auth sync peer lease grant(s); reason=${reason}`,
+                });
                 resolve({
                     ok: false,
                     leaseId: null,
@@ -299,13 +352,16 @@ export class CrossNodeAuthSync {
             void this.sendToAll({ kind: 'lease.request', leaseId, reason, expiresAt }).catch((error) => {
                 clearTimeout(timer);
                 this.pendingLeases.delete(leaseId);
+                this.recordEvent({ direction: 'local', kind: 'lease.request', stage: 'send_failed', peer: null, requestId: leaseId, candidateName: null, detail: formatError(error) });
                 resolve({ ok: false, leaseId: null, reason: formatError(error) });
             });
         });
         if (result.ok) {
             this.activeLocalLease = { leaseId, expiresAt };
+            this.recordEvent({ direction: 'local', kind: 'lease.request', stage: 'granted', peer: null, requestId: leaseId, candidateName: null, detail: reason });
         }
         else {
+            this.recordEvent({ direction: 'local', kind: 'lease.request', stage: 'denied', peer: null, requestId: leaseId, candidateName: null, detail: result.reason ?? reason });
             await this.releaseRefreshLease(leaseId);
         }
         return result;
@@ -329,6 +385,7 @@ export class CrossNodeAuthSync {
         const peers = [...this.peers];
         const resultPromise = new Promise((resolve) => {
             const timer = setTimeout(() => {
+                this.recordEvent({ direction: 'local', kind: 'test.ping', stage: 'timeout', peer: null, requestId, candidateName: null, detail: null });
                 this.finishPendingTest(requestId);
             }, TEST_TIMEOUT_MS);
             timer.unref();
@@ -370,8 +427,18 @@ export class CrossNodeAuthSync {
         }
         this.seenNonces.set(nonceKey, Date.now());
         this.state.lastReceivedAt = new Date().toISOString();
+        const normalizedPeer = normalizePeerIdentity(peer);
+        this.recordEvent({
+            direction: 'in',
+            kind: opened.message.kind,
+            stage: 'received',
+            peer: normalizedPeer,
+            requestId: requestIdFromMessage(opened.message),
+            candidateName: candidateNameFromMessage(opened.message),
+            detail: `sender=${opened.sender}`,
+        });
         await this.writeState();
-        this.notePeerActivity(normalizePeerIdentity(peer));
+        this.notePeerActivity(normalizedPeer);
         await this.handleMessage(opened.message, opened.sender, peer);
         return true;
     }
@@ -411,6 +478,7 @@ export class CrossNodeAuthSync {
             case 'lease.release':
                 if (this.activeRemoteLease?.leaseId === message.leaseId) {
                     this.activeRemoteLease = null;
+                    this.recordEvent({ direction: 'in', kind: 'lease.release', stage: 'released', peer: normalizePeerIdentity(peer), requestId: message.leaseId, candidateName: null, detail: null });
                 }
                 return;
             default:
@@ -429,6 +497,7 @@ export class CrossNodeAuthSync {
         const record = await this.callbacks.readLocalCandidate(message.candidateName);
         if (!record) {
             await this.sendToPeer(peer, { kind: 'pull.response', requestId: message.requestId, bundle: null, reason: 'candidate not found' });
+            this.recordEvent({ direction: 'local', kind: 'pull.response', stage: 'candidate_not_found', peer, requestId: message.requestId, candidateName: message.candidateName, detail: 'candidate not found' });
             this.notify({
                 kind: 'pull_response_sent',
                 candidateName: message.candidateName,
@@ -440,6 +509,7 @@ export class CrossNodeAuthSync {
         }
         if (message.accountId && record.accountId !== message.accountId) {
             await this.sendToPeer(peer, { kind: 'pull.response', requestId: message.requestId, bundle: null, reason: 'account mismatch' });
+            this.recordEvent({ direction: 'local', kind: 'pull.response', stage: 'account_mismatch', peer, requestId: message.requestId, candidateName: message.candidateName, detail: 'account mismatch' });
             this.notify({
                 kind: 'pull_response_sent',
                 candidateName: message.candidateName,
@@ -451,6 +521,7 @@ export class CrossNodeAuthSync {
         }
         if (message.lastRefreshMs !== null && record.lastRefreshMs <= message.lastRefreshMs) {
             await this.sendToPeer(peer, { kind: 'pull.response', requestId: message.requestId, bundle: null, reason: 'not newer' });
+            this.recordEvent({ direction: 'local', kind: 'pull.response', stage: 'not_newer', peer, requestId: message.requestId, candidateName: message.candidateName, detail: 'not newer' });
             this.notify({
                 kind: 'pull_response_sent',
                 candidateName: message.candidateName,
@@ -465,6 +536,7 @@ export class CrossNodeAuthSync {
             requestId: message.requestId,
             bundle: bundleFromRecord(record),
         });
+        this.recordEvent({ direction: 'local', kind: 'pull.response', stage: 'sent_bundle', peer, requestId: message.requestId, candidateName: message.candidateName, detail: null });
         this.notify({
             kind: 'pull_response_sent',
             candidateName: message.candidateName,
@@ -480,6 +552,7 @@ export class CrossNodeAuthSync {
         const matchedPeer = this.matchConfiguredPeer(peer) ?? peer;
         if (!message.bundle || message.bundle.candidateName !== pending.candidateName) {
             const reason = message.reason ?? 'peer did not return a matching candidate';
+            this.recordEvent({ direction: 'local', kind: 'pull.response', stage: 'empty', peer, requestId: message.requestId, candidateName: pending.candidateName, detail: reason });
             this.notify({
                 kind: 'recovery_peer_empty',
                 candidateName: pending.candidateName,
@@ -498,12 +571,14 @@ export class CrossNodeAuthSync {
         const outcome = await this.validateAndImport(message.bundle, senderNodeId, sourceLabel, peer, 'pull');
         if (!outcome.imported) {
             this.markPullPeerUnavailable(message.requestId, matchedPeer, outcome.reason ?? 'peer candidate was not imported');
+            this.recordEvent({ direction: 'local', kind: 'pull.response', stage: 'not_imported', peer, requestId: message.requestId, candidateName: pending.candidateName, detail: outcome.reason ?? 'peer candidate was not imported' });
             return;
         }
         pending.finished = true;
         clearTimeout(pending.timer);
         this.pendingPulls.delete(message.requestId);
         pending.resolve(true);
+        this.recordEvent({ direction: 'local', kind: 'pull.response', stage: 'imported', peer, requestId: message.requestId, candidateName: pending.candidateName, detail: null });
     }
     markPullPeerUnavailable(requestId, peer, reason) {
         const pending = this.pendingPulls.get(requestId);
@@ -525,6 +600,15 @@ export class CrossNodeAuthSync {
             peers: pending.peers,
             reason: `all peers replied without an importable auth candidate${details ? ` (${details})` : ''}`,
         });
+        this.recordEvent({
+            direction: 'local',
+            kind: 'pull.request',
+            stage: 'failed',
+            peer: null,
+            requestId,
+            candidateName: pending.candidateName,
+            detail: `all peers replied without an importable auth candidate${details ? ` (${details})` : ''}`,
+        });
         pending.resolve(false);
     }
     async handleDigest(message, peer) {
@@ -546,10 +630,12 @@ export class CrossNodeAuthSync {
         this.expireLeases();
         if (!this.callbacks.isIdle()) {
             await this.sendToPeer(peer, { kind: 'lease.deny', leaseId: message.leaseId, reason: 'runtime is not idle' });
+            this.recordEvent({ direction: 'local', kind: 'lease.deny', stage: 'sent', peer, requestId: message.leaseId, candidateName: null, detail: 'runtime is not idle' });
             return;
         }
         if (this.activeRemoteLease && this.activeRemoteLease.leaseId !== message.leaseId) {
             await this.sendToPeer(peer, { kind: 'lease.deny', leaseId: message.leaseId, reason: 'another refresh lease is active' });
+            this.recordEvent({ direction: 'local', kind: 'lease.deny', stage: 'sent', peer, requestId: message.leaseId, candidateName: null, detail: 'another refresh lease is active' });
             return;
         }
         this.activeRemoteLease = {
@@ -558,6 +644,7 @@ export class CrossNodeAuthSync {
             expiresAt: Math.min(message.expiresAt, Date.now() + LEASE_TTL_MS),
         };
         await this.sendToPeer(peer, { kind: 'lease.grant', leaseId: message.leaseId, expiresAt: this.activeRemoteLease.expiresAt });
+        this.recordEvent({ direction: 'local', kind: 'lease.grant', stage: 'sent', peer, requestId: message.leaseId, candidateName: null, detail: null });
     }
     handleLeaseReply(message, peer) {
         const pending = this.pendingLeases.get(message.leaseId);
@@ -565,9 +652,11 @@ export class CrossNodeAuthSync {
             return;
         if (message.kind === 'lease.deny') {
             pending.denies.push(`${peer}: ${message.reason}`);
+            this.recordEvent({ direction: 'in', kind: 'lease.deny', stage: 'received', peer, requestId: message.leaseId, candidateName: null, detail: message.reason });
         }
         else {
             pending.grants.add(peer);
+            this.recordEvent({ direction: 'in', kind: 'lease.grant', stage: 'received', peer, requestId: message.leaseId, candidateName: null, detail: null });
         }
         if (pending.denies.length > 0) {
             clearTimeout(pending.timer);
@@ -590,6 +679,15 @@ export class CrossNodeAuthSync {
             receivedAt: Date.now(),
             fromPeer,
         });
+        this.recordEvent({
+            direction: 'local',
+            kind: 'push.bundle',
+            stage: queued ? 'queued' : 'processing',
+            peer: fromPeer,
+            requestId: bundle.requestId ?? null,
+            candidateName: bundle.candidateName,
+            detail: `source=${sourceNodeId}; queue=${this.pendingImports.length}`,
+        });
         this.notify({
             kind: 'remote_bundle_received',
             candidateName: bundle.candidateName,
@@ -655,6 +753,15 @@ export class CrossNodeAuthSync {
             this.state.lastError = null;
             await this.writeState();
             this.logger.info('auth.sync.imported', { candidateName: bundle.candidateName, sourceNodeId });
+            this.recordEvent({
+                direction: 'local',
+                kind: mode === 'pull' ? 'pull.response' : 'push.bundle',
+                stage: 'imported',
+                peer: fromPeer,
+                requestId: bundle.requestId ?? null,
+                candidateName: bundle.candidateName,
+                detail: `source=${sourceNodeId}`,
+            });
             this.notify({
                 kind: 'remote_import_imported',
                 candidateName: bundle.candidateName,
@@ -665,6 +772,15 @@ export class CrossNodeAuthSync {
             });
         }
         else {
+            this.recordEvent({
+                direction: 'local',
+                kind: mode === 'pull' ? 'pull.response' : 'push.bundle',
+                stage: 'skipped',
+                peer: fromPeer,
+                requestId: bundle.requestId ?? null,
+                candidateName: bundle.candidateName,
+                detail: result.reason ?? 'local candidate did not need an update',
+            });
             this.notify({
                 kind: 'remote_import_skipped',
                 candidateName: bundle.candidateName,
@@ -685,7 +801,30 @@ export class CrossNodeAuthSync {
     }
     async sendToPeer(peer, message) {
         const envelope = this.sealEnvelope(message);
-        await this.transport.send(peer, envelope);
+        try {
+            await this.transport.send(peer, envelope);
+            this.recordEvent({
+                direction: 'out',
+                kind: message.kind,
+                stage: 'sent',
+                peer,
+                requestId: requestIdFromMessage(message),
+                candidateName: candidateNameFromMessage(message),
+                detail: null,
+            });
+        }
+        catch (error) {
+            this.recordEvent({
+                direction: 'out',
+                kind: message.kind,
+                stage: 'send_failed',
+                peer,
+                requestId: requestIdFromMessage(message),
+                candidateName: candidateNameFromMessage(message),
+                detail: formatError(error),
+            });
+            throw error;
+        }
         this.state.lastSentAt = new Date().toISOString();
         if (this.state.lastError?.includes('USER_BOT_TO_BOT_DISABLED')) {
             this.state.lastError = null;
@@ -698,6 +837,7 @@ export class CrossNodeAuthSync {
             return;
         const matchedPeer = this.matchConfiguredPeer(peer) ?? peer;
         pending.replies.add(matchedPeer);
+        this.recordEvent({ direction: 'local', kind: 'test.pong', stage: 'matched', peer: matchedPeer, requestId, candidateName: null, detail: null });
         if (pending.peers.every(peerName => pending.replies.has(peerName))) {
             this.finishPendingTest(requestId);
         }
@@ -804,6 +944,15 @@ export class CrossNodeAuthSync {
         }
     }
     async rejectImport(bundle, sourceNodeId, sourceLabel, fromPeer, mode, reason) {
+        this.recordEvent({
+            direction: 'local',
+            kind: mode === 'pull' ? 'pull.response' : 'push.bundle',
+            stage: 'failed',
+            peer: fromPeer,
+            requestId: bundle.requestId ?? null,
+            candidateName: typeof bundle.candidateName === 'string' ? bundle.candidateName : null,
+            detail: reason,
+        });
         await this.recordCandidateFailure(bundle, sourceNodeId, sourceLabel, fromPeer, mode, reason);
         this.notify({
             kind: 'remote_import_failed',
@@ -851,6 +1000,24 @@ export class CrossNodeAuthSync {
         const matchedPeer = this.matchConfiguredPeer(peer) ?? peer;
         this.lastPeerActivityAt.set(matchedPeer, Date.now());
     }
+    recordEvent(event) {
+        const record = {
+            id: crypto.randomBytes(6).toString('hex'),
+            createdAt: new Date().toISOString(),
+            direction: event.direction,
+            kind: event.kind,
+            stage: event.stage,
+            peer: event.peer,
+            requestId: event.requestId,
+            candidateName: event.candidateName,
+            detail: event.detail,
+        };
+        this.state.recentEvents = pruneRecentEvents([...this.state.recentEvents, record]);
+        this.logger.info('auth.sync.event', record);
+        void this.writeState().catch((error) => {
+            this.logger.warn('auth.sync.state_write_failed', { error: formatError(error) });
+        });
+    }
     describePeerReachability(peers, sinceMs) {
         return peers.map((peer) => {
             const lastActivityAt = this.lastPeerActivityAt.get(peer) ?? null;
@@ -879,7 +1046,7 @@ export class CrossNodeAuthSync {
             return;
         this.seenNonces = pruneSeenNonces(this.seenNonces);
         await fs.mkdir(path.dirname(this.config.statePath), { recursive: true, mode: 0o700 });
-        const temporary = `${this.config.statePath}.${process.pid}.${Date.now()}.tmp`;
+        const temporary = `${this.config.statePath}.${process.pid}.${Date.now()}.${crypto.randomBytes(3).toString('hex')}.tmp`;
         const state = {
             seenNonces: Object.fromEntries(this.seenNonces),
             ...this.state,
@@ -998,6 +1165,56 @@ function pruneCandidateFailures(failures) {
         .sort(([, left], [, right]) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))
         .slice(0, 20));
 }
+function normalizeRecentEvents(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return pruneRecentEvents(raw.filter((event) => (event
+        && typeof event.id === 'string'
+        && typeof event.createdAt === 'string'
+        && Number.isFinite(Date.parse(event.createdAt))
+        && (event.direction === 'in' || event.direction === 'out' || event.direction === 'local')
+        && typeof event.kind === 'string'
+        && typeof event.stage === 'string'
+        && (typeof event.peer === 'string' || event.peer === null)
+        && (typeof event.requestId === 'string' || event.requestId === null)
+        && (typeof event.candidateName === 'string' || event.candidateName === null)
+        && (typeof event.detail === 'string' || event.detail === null))));
+}
+function pruneRecentEvents(events) {
+    return events
+        .sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt))
+        .slice(-RECENT_EVENT_LIMIT);
+}
+function requestIdFromMessage(message) {
+    switch (message.kind) {
+        case 'push.bundle':
+            return message.requestId ?? null;
+        case 'pull.request':
+        case 'pull.response':
+        case 'test.ping':
+        case 'test.pong':
+            return message.requestId;
+        case 'lease.request':
+            return message.leaseId;
+        case 'lease.grant':
+        case 'lease.deny':
+        case 'lease.release':
+            return message.leaseId;
+        case 'digest':
+            return null;
+    }
+}
+function candidateNameFromMessage(message) {
+    switch (message.kind) {
+        case 'push.bundle':
+        case 'pull.request':
+            return message.candidateName;
+        case 'pull.response':
+            return message.bundle?.candidateName ?? null;
+        default:
+            return null;
+    }
+}
 function formatPullTimeoutReason(pending, waitMs, peerReachability) {
     const reachable = peerReachability
         .filter((entry) => entry.reachableDuringRequest)

package/dist/controller/controller.js

@@ -4101,6 +4101,19 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, formatAuthSyncStatus(locale, this.coordinator?.getAuthSyncStatus?.() ?? null));
             return;
         }
+        if (action === 'events') {
+            await this.sendMessage(scopeId, formatAuthSyncEvents(locale, this.coordinator?.getAuthSyncStatus?.() ?? null, args.slice(1).join(' ').trim() || null));
+            return;
+        }
+        if (action === 'trace') {
+            const requestId = args[1]?.trim() || null;
+            if (!requestId) {
+                await this.sendMessage(scopeId, t(locale, 'auth_sync_trace_missing'));
+                return;
+            }
+            await this.sendMessage(scopeId, formatAuthSyncTrace(locale, this.coordinator?.getAuthSyncStatus?.() ?? null, requestId));
+            return;
+        }
         if (action === 'test') {
             const result = await this.coordinator?.authSyncTest?.();
             if (!result) {
@@ -8249,6 +8262,15 @@ function formatAuthSyncStatus(locale, status) {
     if (status.lastError) {
         lines.push(t(locale, 'auth_sync_status_error', { value: status.lastError }));
     }
+    if (status.peerStatuses?.length) {
+        lines.push(t(locale, 'auth_sync_status_peer_activity'));
+        for (const peer of status.peerStatuses.slice(0, 5)) {
+            lines.push(t(locale, 'auth_sync_status_peer_activity_item', {
+                peer: peer.peer,
+                time: peer.lastReceivedAt ?? t(locale, 'none'),
+            }));
+        }
+    }
     if (status.candidateFailures?.length) {
         lines.push(t(locale, 'auth_sync_status_candidate_failures'));
         for (const failure of status.candidateFailures.slice(0, 5)) {
@@ -8261,8 +8283,77 @@ function formatAuthSyncStatus(locale, status) {
             }));
         }
     }
+    const recentEvents = [...(status.recentEvents ?? [])].slice(-5);
+    if (recentEvents.length > 0) {
+        lines.push(t(locale, 'auth_sync_status_recent_events'));
+        for (const event of recentEvents) {
+            lines.push(formatAuthSyncEventLine(event));
+        }
+    }
     return lines.join('\n');
 }
+function formatAuthSyncEvents(locale, status, filter) {
+    if (!status?.enabled) {
+        return t(locale, 'auth_sync_disabled');
+    }
+    const events = filterAuthSyncEvents(status.recentEvents ?? [], filter).slice(-15);
+    if (events.length === 0) {
+        return [
+            t(locale, 'auth_sync_events_title'),
+            t(locale, 'auth_sync_events_empty'),
+        ].join('\n');
+    }
+    return [
+        t(locale, 'auth_sync_events_title'),
+        ...events.map(formatAuthSyncEventLine),
+    ].join('\n');
+}
+function formatAuthSyncTrace(locale, status, requestId) {
+    if (!status?.enabled) {
+        return t(locale, 'auth_sync_disabled');
+    }
+    const events = (status.recentEvents ?? [])
+        .filter(event => event.requestId === requestId || event.id === requestId)
+        .slice(-25);
+    if (events.length === 0) {
+        return [
+            t(locale, 'auth_sync_trace_title', { value: requestId }),
+            t(locale, 'auth_sync_events_empty'),
+        ].join('\n');
+    }
+    return [
+        t(locale, 'auth_sync_trace_title', { value: requestId }),
+        ...events.map(formatAuthSyncEventLine),
+    ].join('\n');
+}
+function filterAuthSyncEvents(events, filter) {
+    const normalized = filter?.trim().toLowerCase() ?? '';
+    if (!normalized) {
+        return events;
+    }
+    return events.filter((event) => [
+        event.id,
+        event.requestId,
+        event.candidateName,
+        event.peer,
+        event.kind,
+        event.stage,
+        event.detail,
+    ].some(value => value?.toLowerCase().includes(normalized)));
+}
+function formatAuthSyncEventLine(event) {
+    const fields = [
+        event.createdAt,
+        event.direction,
+        event.kind,
+        event.stage,
+        event.peer ? `peer=${event.peer}` : null,
+        event.requestId ? `requestId=${event.requestId}` : null,
+        event.candidateName ? `candidate=${event.candidateName}` : null,
+        event.detail ? truncateInline(event.detail, 160) : null,
+    ].filter(Boolean);
+    return `- ${fields.join(' | ')}`;
+}
 function normalizeHelpUsageKey(name) {
     const normalized = name.toLowerCase();
     switch (normalized) {

package/dist/i18n.d.ts

@@ -142,7 +142,7 @@ declare const MESSAGES: {
         readonly auth_reload_done: "Codex app-server restarted. Current auth has been reloaded.";
         readonly auth_reload_blocked_active: "Cannot reload Codex auth while a turn, approval, or question is active. Wait or use /interrupt first.";
         readonly usage_auth: "Usage: /auth [list [keyword]|filter <all|enabled|attention>|page <n>|use <n>|enable <n>|disable <n>|reload|refresh all [confirm]|sync <status|test|push all>|add <name>]";
-        readonly usage_auth_sync: "Usage: /auth sync <status|test|push all>";
+        readonly usage_auth_sync: "Usage: /auth sync <status|events [filter]|trace <requestId>|test|push all>";
         readonly usage_auth_add: "Usage: /auth add <name>. Use letters, numbers, dot, dash, or underscore.";
         readonly auth_list_title: "Codex auth files:";
         readonly auth_bot: "Bot runtime: {value}";
@@ -224,6 +224,13 @@ declare const MESSAGES: {
         readonly auth_sync_status_error: "Last error: {value}";
         readonly auth_sync_status_candidate_failures: "Candidate failures:";
         readonly auth_sync_status_candidate_failure: "- {candidate}: {reason} (source {source}, peer {peer}, at {time})";
+        readonly auth_sync_status_peer_activity: "Peer activity:";
+        readonly auth_sync_status_peer_activity_item: "- {peer}: last received {time}";
+        readonly auth_sync_status_recent_events: "Recent events:";
+        readonly auth_sync_events_title: "Auth sync events:";
+        readonly auth_sync_events_empty: "No matching auth sync events.";
+        readonly auth_sync_trace_title: "Auth sync trace: {value}";
+        readonly auth_sync_trace_missing: "Usage: /auth sync trace <requestId>";
         readonly button_login_device: "🔑 Login";
         readonly button_auth_reload: "🔄 Reload auth";
         readonly button_auth_refresh_all_confirm: "⚠️ Accept risk & refresh";
@@ -776,7 +783,7 @@ declare const MESSAGES: {
         readonly auth_reload_done: "Codex app-server 已重启，当前 auth 已重新读取。";
         readonly auth_reload_blocked_active: "当前有回复、审批或问题在进行中，不能重载 Codex auth。请先等待，或使用 /interrupt。";
         readonly usage_auth: "用法：/auth [list [关键词]|filter <all|enabled|attention>|page <页码>|use <编号>|enable <编号>|disable <编号>|reload|refresh all [confirm]|sync <status|test|push all>|add <名称>]";
-        readonly usage_auth_sync: "用法：/auth sync <status|test|push all>";
+        readonly usage_auth_sync: "用法：/auth sync <status|events [过滤]|trace <requestId>|test|push all>";
         readonly usage_auth_add: "用法：/auth add <名称>。名称只能包含字母、数字、点、短横线或下划线。";
         readonly auth_list_title: "Codex auth 文件：";
         readonly auth_bot: "Bot runtime：{value}";
@@ -858,6 +865,13 @@ declare const MESSAGES: {
         readonly auth_sync_status_error: "最近错误：{value}";
         readonly auth_sync_status_candidate_failures: "候选失败：";
         readonly auth_sync_status_candidate_failure: "- {candidate}：{reason}（来源 {source}，peer {peer}，时间 {time}）";
+        readonly auth_sync_status_peer_activity: "Peer 活动：";
+        readonly auth_sync_status_peer_activity_item: "- {peer}：最近接收 {time}";
+        readonly auth_sync_status_recent_events: "最近事件：";
+        readonly auth_sync_events_title: "auth sync 事件：";
+        readonly auth_sync_events_empty: "没有匹配的 auth sync 事件。";
+        readonly auth_sync_trace_title: "auth sync trace：{value}";
+        readonly auth_sync_trace_missing: "用法：/auth sync trace <requestId>";
         readonly button_login_device: "🔑 设备登录";
         readonly button_auth_reload: "🔄 重载 auth";
         readonly button_auth_refresh_all_confirm: "⚠️ 接受风险并刷新";

package/dist/i18n.js

@@ -140,7 +140,7 @@ const MESSAGES = {
         auth_reload_done: 'Codex app-server restarted. Current auth has been reloaded.',
         auth_reload_blocked_active: 'Cannot reload Codex auth while a turn, approval, or question is active. Wait or use /interrupt first.',
         usage_auth: 'Usage: /auth [list [keyword]|filter <all|enabled|attention>|page <n>|use <n>|enable <n>|disable <n>|reload|refresh all [confirm]|sync <status|test|push all>|add <name>]',
-        usage_auth_sync: 'Usage: /auth sync <status|test|push all>',
+        usage_auth_sync: 'Usage: /auth sync <status|events [filter]|trace <requestId>|test|push all>',
         usage_auth_add: 'Usage: /auth add <name>. Use letters, numbers, dot, dash, or underscore.',
         auth_list_title: 'Codex auth files:',
         auth_bot: 'Bot runtime: {value}',
@@ -222,6 +222,13 @@ const MESSAGES = {
         auth_sync_status_error: 'Last error: {value}',
         auth_sync_status_candidate_failures: 'Candidate failures:',
         auth_sync_status_candidate_failure: '- {candidate}: {reason} (source {source}, peer {peer}, at {time})',
+        auth_sync_status_peer_activity: 'Peer activity:',
+        auth_sync_status_peer_activity_item: '- {peer}: last received {time}',
+        auth_sync_status_recent_events: 'Recent events:',
+        auth_sync_events_title: 'Auth sync events:',
+        auth_sync_events_empty: 'No matching auth sync events.',
+        auth_sync_trace_title: 'Auth sync trace: {value}',
+        auth_sync_trace_missing: 'Usage: /auth sync trace <requestId>',
         button_login_device: '🔑 Login',
         button_auth_reload: '🔄 Reload auth',
         button_auth_refresh_all_confirm: '⚠️ Accept risk & refresh',
@@ -774,7 +781,7 @@ const MESSAGES = {
         auth_reload_done: 'Codex app-server 已重启，当前 auth 已重新读取。',
         auth_reload_blocked_active: '当前有回复、审批或问题在进行中，不能重载 Codex auth。请先等待，或使用 /interrupt。',
         usage_auth: '用法：/auth [list [关键词]|filter <all|enabled|attention>|page <页码>|use <编号>|enable <编号>|disable <编号>|reload|refresh all [confirm]|sync <status|test|push all>|add <名称>]',
-        usage_auth_sync: '用法：/auth sync <status|test|push all>',
+        usage_auth_sync: '用法：/auth sync <status|events [过滤]|trace <requestId>|test|push all>',
         usage_auth_add: '用法：/auth add <名称>。名称只能包含字母、数字、点、短横线或下划线。',
         auth_list_title: 'Codex auth 文件：',
         auth_bot: 'Bot runtime：{value}',
@@ -856,6 +863,13 @@ const MESSAGES = {
         auth_sync_status_error: '最近错误：{value}',
         auth_sync_status_candidate_failures: '候选失败：',
         auth_sync_status_candidate_failure: '- {candidate}：{reason}（来源 {source}，peer {peer}，时间 {time}）',
+        auth_sync_status_peer_activity: 'Peer 活动：',
+        auth_sync_status_peer_activity_item: '- {peer}：最近接收 {time}',
+        auth_sync_status_recent_events: '最近事件：',
+        auth_sync_events_title: 'auth sync 事件：',
+        auth_sync_events_empty: '没有匹配的 auth sync 事件。',
+        auth_sync_trace_title: 'auth sync trace：{value}',
+        auth_sync_trace_missing: '用法：/auth sync trace <requestId>',
         button_login_device: '🔑 设备登录',
         button_auth_reload: '🔄 重载 auth',
         button_auth_refresh_all_confirm: '⚠️ 接受风险并刷新',

package/dist/main.js

@@ -1132,6 +1132,7 @@ function runDoctorChecks() {
     warnIfProxyEnvMissingFromLoadedEnv();
     warnIfProxyConfigNeedsAttention();
     warnIfInstalledServiceNodeLooksWrong();
+    warnIfSystemdUserLingerDisabled();
     return passed;
 }
 function warnIfProxyConfigNeedsAttention() {
@@ -1204,6 +1205,21 @@ function warnIfInstalledServiceNodeLooksWrong() {
     console.log(`[WARN] installed service node is older than 24: ${nodePath}${version ? ` (${version})` : ''}`);
     console.log('[WARN] Run foxclaw start from a Node 24 shell to refresh the service unit.');
 }
+function warnIfSystemdUserLingerDisabled() {
+    if (process.platform !== 'linux' || !hasCommand('loginctl')) {
+        return;
+    }
+    const user = currentServiceUser();
+    const linger = readSystemdUserLinger(user);
+    if (linger === 'enabled') {
+        console.log(`[OK] systemd user linger enabled: ${user}`);
+        return;
+    }
+    if (linger === 'disabled') {
+        console.log(`[WARN] systemd user linger is disabled for ${user}; user services may stop after logout.`);
+        console.log('[WARN] Run foxclaw start to let FoxClaw enable it, or run: sudo loginctl enable-linger "$USER"');
+    }
+}
 function extractNodePathFromExecStart(execStart) {
     const tokens = execStart.split(/\s+/).map(systemdUnescape).filter(Boolean);
     const directNode = tokens[0] || '';
@@ -1262,6 +1278,7 @@ function installSystemd() {
             console.log(`[OK] updated FoxClaw ExecStart override: ${update.path}`);
         }
     }
+    ensureSystemdUserLingerEnabled();
     spawnChecked('systemctl', ['--user', 'daemon-reload']);
     spawnChecked('systemctl', ['--user', 'enable', unitName]);
     const restarted = spawnSync('systemctl', ['--user', 'restart', unitName], { stdio: 'inherit' });
@@ -1272,6 +1289,32 @@ function installSystemd() {
     console.log(`Status: systemctl --user status ${unitName}`);
     console.log(`Logs:   journalctl --user -u ${unitName} -f`);
 }
+function ensureSystemdUserLingerEnabled() {
+    if (process.platform !== 'linux') {
+        return;
+    }
+    if (!hasCommand('loginctl')) {
+        console.log('[WARN] loginctl not found; cannot enable systemd user linger automatically.');
+        return;
+    }
+    const user = currentServiceUser();
+    const before = readSystemdUserLinger(user);
+    if (before === 'enabled') {
+        console.log(`[OK] systemd user linger enabled: ${user}`);
+        return;
+    }
+    console.log(`[INFO] Enabling systemd user linger for ${user} so FoxClaw keeps running after logout.`);
+    let result = spawnSync('loginctl', ['enable-linger', user], { stdio: 'inherit' });
+    if (result.status !== 0 && hasCommand('sudo')) {
+        result = spawnSync('sudo', ['-n', 'loginctl', 'enable-linger', user], { stdio: 'inherit' });
+    }
+    if (result.status === 0 && readSystemdUserLinger(user) === 'enabled') {
+        console.log(`[OK] systemd user linger enabled: ${user}`);
+        return;
+    }
+    console.log(`[WARN] Could not enable systemd user linger automatically for ${user}.`);
+    console.log(`[WARN] FoxClaw is installed, but it may stop after logout until you run: sudo loginctl enable-linger ${shellQuote(user)}`);
+}
 function uninstallSystemd() {
     if (!hasCommand('systemctl')) {
         console.error('systemctl not found');
@@ -1392,6 +1435,36 @@ function buildServicePath(nodeDir) {
 function serviceEnvPath() {
     return path.resolve(process.env.FOXCLAW_ENV?.trim() || getLoadedEnvPath() || DEFAULT_ENV_PATH);
 }
+function currentServiceUser() {
+    return process.env.USER?.trim()
+        || process.env.LOGNAME?.trim()
+        || os.userInfo().username;
+}
+function readSystemdUserLinger(user) {
+    const valueResult = spawnSync('loginctl', ['show-user', user, '-p', 'Linger', '--value'], { encoding: 'utf8' });
+    if (valueResult.status === 0) {
+        return parseSystemdUserLinger(valueResult.stdout);
+    }
+    const propertyResult = spawnSync('loginctl', ['show-user', user, '-p', 'Linger'], { encoding: 'utf8' });
+    if (propertyResult.status === 0) {
+        return parseSystemdUserLinger(propertyResult.stdout);
+    }
+    return 'unknown';
+}
+function parseSystemdUserLinger(output) {
+    const value = output.trim().replace(/^Linger=/, '').toLowerCase();
+    if (value === 'yes')
+        return 'enabled';
+    if (value === 'no')
+        return 'disabled';
+    return 'unknown';
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 function hasStandardNodeProxyEnv() {
     return STANDARD_NODE_PROXY_ENV_KEYS.some((key) => Boolean(proxyEnvValue(key)));
 }

package/dist/types.d.ts

@@ -383,6 +383,21 @@ export interface RuntimeStatus {
             updatedAt: string;
         }>;
         activeLeaseId: string | null;
+        peerStatuses?: Array<{
+            peer: string;
+            lastReceivedAt: string | null;
+        }>;
+        recentEvents?: Array<{
+            id: string;
+            createdAt: string;
+            direction: 'in' | 'out' | 'local';
+            kind: string;
+            stage: string;
+            peer: string | null;
+            requestId: string | null;
+            candidateName: string | null;
+            detail: string | null;
+        }>;
     } | null;
     lastUpdate?: {
         state: string;

package/docs/cross-node-auth-sync.md

@@ -172,6 +172,8 @@ Starting in 0.5.2, `/auth sync status` separates sync-system `Last error` from p
 
 Manual `/auth` switches and `/auth reload` recover from same-node local mirrors only and do not send cross-node pull requests. FoxClaw queries peers only during automatic recovery after it detects a real auth problem. Recovery timeout notifications include the request id, candidate name, peer list, and wait duration; if another auth sync message arrived from the same peer during that wait, the notification says the peer was reachable but this request timed out.
 
+Starting in 0.5.8, `/auth sync status` also shows peer activity and the latest sync events. Use `/auth sync events [filter]` to search recent event records by candidate, peer, request id, kind, stage, or detail. Use `/auth sync trace <requestId>` when a notification includes a request id and you want the recent send/receive/result records for that request.
+
 If an upgrade or restart interrupts remote candidate usage validation, older versions could leave `auth.json -> .auth-sync-validate-*` behind. Starting in 0.5.2, FoxClaw checks for this at startup, restores `auth.json` to the mirror-status candidate or the newest parseable real `auth.json_*` candidate in the same directory, and removes stale validation temp files.
 
 5. Only test refresh-token rotation after you understand the risk:
@@ -197,6 +199,7 @@ With cross-node sync enabled, this command first requests a cross-node refresh l
 - The local node may not be globally idle. Active turns, approvals, inputs, login flows, and mirror writes make imports wait.
 - Usage validation failure rejects the write.
 - Same-name candidates from different account ids are refused.
+- Run `/auth sync events <candidate>` or `/auth sync trace <requestId>` to see the receive, validation, skip, or failure records kept by FoxClaw.
 
 **Should I periodically run `/auth refresh all confirm` as keepalive?**
 

package/docs/install-for-beginners.md

@@ -250,17 +250,17 @@ Create a short README-style summary of this folder.
 
 ## 10. Service Commands
 
-On Linux, `foxclaw start` manages a user-level systemd service. Check it with:
+On Linux, `foxclaw start` manages a user-level systemd service and tries to enable systemd user linger so the service keeps running after you leave SSH or log out. Check it with:
 
 ```bash
 systemctl --user status foxclaw.service
 journalctl --user -u foxclaw.service -f
 ```
 
-The service starts again when your user session starts. If you need it to start after reboot before you log in, run:
+If install reports that linger could not be enabled automatically, run:
 
 ```bash
-loginctl enable-linger "$USER"
+sudo loginctl enable-linger "$USER"
 ```
 
 On macOS, `foxclaw start` manages launchd and starts FoxClaw when you log in.

package/docs/troubleshooting.md

@@ -261,10 +261,10 @@ Linux user systemd:
 systemctl --user is-enabled foxclaw.service
 ```
 
-`enabled` means it starts with your user session. To start after reboot before login:
+`enabled` means it starts with your user session. `foxclaw start` tries to enable systemd user linger automatically so the service keeps running after SSH logout and before login. If automatic linger setup fails:
 
 ```bash
-loginctl enable-linger "$USER"
+sudo loginctl enable-linger "$USER"
 ```
 
 macOS launchd starts FoxClaw when you log in after running:

package/docs/user-manual.md

@@ -423,7 +423,7 @@ OpenAI does not publish a fixed ChatGPT refresh-token lifetime or an old-token r
 
 ### 6.4 Cross-Node Auth Sync
 
-Cross-node auth sync is disabled by default. It is for multiple machines you control that share the same legally owned ChatGPT auth candidate pool, so a token refreshed by Codex on one node can be copied to the others. v1 uses Telegram Bot-to-Bot private messages to carry encrypted files, so it does not require public IPs or FRP. The recommended default is one contact bot per node; other bots on the same node keep using local auth mirroring. In multi-bot mode, the default contact is the first token in `TG_BOT_TOKENS`. The contact bot private chat reports send, receive, queue, import, failure, recovery-query, and manual-intervention states; per-candidate validation failures are shown as candidate failures instead of overwriting the sync-system last error.
+Cross-node auth sync is disabled by default. It is for multiple machines you control that share the same legally owned ChatGPT auth candidate pool, so a token refreshed by Codex on one node can be copied to the others. v1 uses Telegram Bot-to-Bot private messages to carry encrypted files, so it does not require public IPs or FRP. The recommended default is one contact bot per node; other bots on the same node keep using local auth mirroring. In multi-bot mode, the default contact is the first token in `TG_BOT_TOKENS`. The contact bot private chat reports send, receive, queue, import, failure, recovery-query, and manual-intervention states; per-candidate validation failures are shown as candidate failures instead of overwriting the sync-system last error. Recent bot-to-bot traffic is also kept in an event ring so `/auth sync events [filter]` and `/auth sync trace <requestId>` can explain a specific candidate, peer, or request.
 
 For the full design, safety boundaries, `.env` examples, and troubleshooting, read the [Cross-Node Auth Sync Setup Guide](./cross-node-auth-sync.md).
 
@@ -464,7 +464,9 @@ Dual-active behavior:
 
 Commands:
 
-- `/auth sync status`: show node id, peers, recent sends/receives/imports, pending imports, the sync-system latest error, and per-candidate failures.
+- `/auth sync status`: show node id, peers, peer activity, recent sync events, pending imports, the sync-system latest error, and per-candidate failures.
+- `/auth sync events [filter]`: show recent sync event records, optionally filtered by candidate, peer, request id, kind, stage, or detail.
+- `/auth sync trace <requestId>`: show recent records for one request id or event id.
 - `/auth sync test`: send an encrypted ping and wait for peer pong replies to verify peer config, shared key, and Bot-to-Bot private messages.
 - `/auth sync push all`: manually broadcast all locally verified candidates without refreshing tokens. “Sent” does not mean the peer imported files; check `/auth sync status` and `/auth` on the peer.
 
@@ -479,7 +481,7 @@ Equivalent commands:
 - `/auth reload` or `/auth_reload`: restart app-server and reload the current `auth.json`.
 - `/auth refresh all`: show the refresh-token rotation risk confirmation.
 - `/auth refresh all confirm`: run Refresh all after accepting the token-rotation risk.
-- `/auth sync status|test|push all`: inspect, test, or manually push cross-node auth sync.
+- `/auth sync status|events|trace|test|push all`: inspect, trace, test, or manually push cross-node auth sync.
 
 If the requesting bot runtime has active turns, pending approvals, pending user inputs, or MCP elicitations, FoxClaw refuses manual auth switching to avoid changing accounts mid-request; another idle bot is unaffected.
 

package/docs/zh/cross-node-auth-sync.md

@@ -172,6 +172,8 @@ auth sync 测试完成：已发送 1，收到回应 1。
 
 手动 `/auth` 切换和 `/auth reload` 只会尝试同节点本地 mirror 恢复，不会主动向跨节点 peer 发起 pull。只有 FoxClaw 检测到当前 auth 真的出现认证问题并进入自动恢复时，才会向 peer 查询可用副本。恢复超时通知会包含 request id、候选名、peer 列表和等待时长；如果等待期间收到过同 peer 的其他 auth sync 消息，通知会标明 peer 可达但该请求超时。
 
+从 0.5.8 起，`/auth sync status` 还会显示 peer 最近活跃时间和最近同步事件。`/auth sync events [过滤]` 可按候选名、peer、request id、事件类型、阶段或详情搜索近期事件。通知里带 request id 时，可用 `/auth sync trace <requestId>` 查看该请求最近的发送、接收和处理结果。
+
 如果升级或重启正好打断远端候选 usage 验证，旧版本可能留下 `auth.json -> .auth-sync-validate-*` 临时 symlink。0.5.2 起 FoxClaw 启动时会自动检测并恢复到 mirror 状态记录的候选，或同目录最近修改且可解析的真实 `auth.json_*` 候选，然后清理临时文件。
 
 5. 只有在完全理解 refresh token 轮换风险时，才测试：
@@ -197,6 +199,7 @@ auth sync 测试完成：已发送 1，收到回应 1。
 - 本机可能不是全局空闲；有 turn、审批、待输入、登录流程或镜像写入时会排队。
 - usage 验证失败会拒绝写盘。
 - 同名候选属于不同 account id 时会拒绝覆盖。
+- 执行 `/auth sync events <候选名>` 或 `/auth sync trace <requestId>`，查看 FoxClaw 记录的接收、验证、跳过或失败流水。
 
 **要不要定期 `/auth refresh all confirm` 保活**
 

package/docs/zh/install-for-beginners.md

@@ -248,17 +248,17 @@ Create a short README-style summary of this folder.
 
 ## 10. 服务命令
 
-Linux 上 `foxclaw start` 管理用户级 systemd 服务。查看状态：
+Linux 上 `foxclaw start` 管理用户级 systemd 服务，并会尝试启用 systemd user linger，让服务在你退出 SSH 或桌面会话后继续运行。查看状态：
 
 ```bash
 systemctl --user status foxclaw.service
 journalctl --user -u foxclaw.service -f
 ```
 
-如果希望重启后未登录也能启动用户服务：
+如果安装时提示 linger 启用失败，手动执行：
 
 ```bash
-loginctl enable-linger "$USER"
+sudo loginctl enable-linger "$USER"
 ```
 
 macOS 上 `foxclaw start` 管理 launchd，并在你登录后启动 FoxClaw。

package/docs/zh/troubleshooting.md

@@ -262,10 +262,10 @@ Linux 用户级 systemd：
 systemctl --user is-enabled foxclaw.service
 ```
 
-`enabled` 表示会随用户会话启动。如果希望机器重启后未登录也启动用户服务：
+`enabled` 表示会随用户会话启动。`foxclaw start` 会尝试自动启用 systemd user linger，让服务在退出 SSH 或未登录时也继续运行。如果自动启用失败：
 
 ```bash
-loginctl enable-linger "$USER"
+sudo loginctl enable-linger "$USER"
 ```
 
 macOS 上，运行过下面命令后，FoxClaw 会在你登录时由 launchd 启动：

package/docs/zh/user-manual.md

@@ -423,7 +423,7 @@ OpenAI 没有公开 ChatGPT refresh token 的固定有效期或旧 token 重放
 
 ### 6.4 跨节点 auth 同步
 
-跨节点 auth 同步默认关闭。它适合你在多台自己控制的机器上使用同一组合法 ChatGPT 账号候选，并希望某台机器上 Codex 自动刷新出的新 token 能同步到其他机器。v1 使用 Telegram Bot-to-Bot 私聊传输加密文件，不需要公网 IP 或 FRP。推荐每台机器选择一个联系人 bot；同一节点内其他 bot 继续使用本机 auth 镜像。多 bot 模式下，默认联系人是 `TG_BOT_TOKENS` 的第一个 token。联系人 bot 的私聊会报告发送、接收、排队、导入、失败、恢复查询和人工介入提示；单个候选验证失败会作为“候选失败”显示，不会覆盖同步系统级最近错误。
+跨节点 auth 同步默认关闭。它适合你在多台自己控制的机器上使用同一组合法 ChatGPT 账号候选，并希望某台机器上 Codex 自动刷新出的新 token 能同步到其他机器。v1 使用 Telegram Bot-to-Bot 私聊传输加密文件，不需要公网 IP 或 FRP。推荐每台机器选择一个联系人 bot；同一节点内其他 bot 继续使用本机 auth 镜像。多 bot 模式下，默认联系人是 `TG_BOT_TOKENS` 的第一个 token。联系人 bot 的私聊会报告发送、接收、排队、导入、失败、恢复查询和人工介入提示；单个候选验证失败会作为“候选失败”显示，不会覆盖同步系统级最近错误。最近 bot-to-bot 通讯会保存在事件环里，可用 `/auth sync events [过滤]` 和 `/auth sync trace <requestId>` 追查某个候选、peer 或请求。
 
 完整设计、安全边界、`.env` 示例和排查步骤见 [跨节点 auth 同步配置指南](./cross-node-auth-sync.md)。
 
@@ -464,7 +464,9 @@ AUTH_SYNC_NODE_ID=workstation-a
 
 命令：
 
-- `/auth sync status`：查看 node id、peer、最近收发、最近导入、待导入、系统级最近错误和单候选失败。
+- `/auth sync status`：查看 node id、peer、peer 活跃时间、最近同步事件、待导入、系统级最近错误和单候选失败。
+- `/auth sync events [过滤]`：查看最近同步事件，可按候选名、peer、request id、事件类型、阶段或详情过滤。
+- `/auth sync trace <requestId>`：查看某个 request id 或事件 id 的最近流水。
 - `/auth sync test`：发送加密 ping 并等待 peer 返回 pong，确认 peer、共享密钥和 Bot-to-Bot 私聊可用。
 - `/auth sync push all`：手动广播当前节点已验证的全部候选，不刷新 token；“已发送”不等于对端已经导入，需要在 peer 上看 `/auth sync status` 和 `/auth`。
 
@@ -479,7 +481,7 @@ AUTH_SYNC_NODE_ID=workstation-a
 - `/auth reload` 或 `/auth_reload`：重启 app-server，重新加载当前 `auth.json`。
 - `/auth refresh all`：显示 refresh token 轮换风险确认。
 - `/auth refresh all confirm`：接受 token 轮换风险后执行刷新全部。
-- `/auth sync status|test|push all`：查看、测试或手动推送跨节点 auth 同步。
+- `/auth sync status|events|trace|test|push all`：查看、追踪、测试或手动推送跨节点 auth 同步。
 
 切换 auth 时，如果当前 bot runtime 还有活跃 turn、待审批、待用户输入或 MCP elicitation，FoxClaw 会先拒绝切换，避免中途换号破坏正在进行的请求；另一个空闲 bot 不受影响。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",