shennian 0.2.78 → 0.2.83

package/dist/src/commands/daemon.d.ts

@@ -18,6 +18,8 @@ export type DaemonStatus = {
     machineId?: string;
     paired?: boolean;
     serverUrl?: string;
+    instanceId?: string;
+    adopted?: boolean;
 };
 export type ServiceLaunchSpec = {
     command: string;
@@ -39,9 +41,17 @@ export declare function resolveServiceLaunchSpec(input: {
 export declare function isRemoteAccessDisabled(): boolean;
 export declare function clearRemoteAccessDisabled(): void;
 export declare function getCurrentProcessDaemonLauncher(): DaemonLauncher;
-export declare function writeDaemonLauncher(pid: number, launcher?: DaemonLauncher): void;
-export declare function clearDaemonLauncher(): void;
+export declare function createDaemonInstanceId(): string;
+export declare function writeDaemonPid(pid: number, instanceId: string, meta?: {
+    version?: string;
+    launcher?: DaemonLauncher;
+    adopted?: boolean;
+}): void;
+export declare function clearDaemonPidIfOwner(pid: number, instanceId: string): void;
+export declare function writeDaemonLauncher(pid: number, launcher?: DaemonLauncher, instanceId?: string): void;
+export declare function clearDaemonLauncher(instanceId?: string): void;
 export declare function recordStartedDaemon(childPid: number | undefined): void;
+export declare function findRunningDaemonProcessIds(excludePid?: number): number[];
 export declare function getDaemonStatus(opts?: {
     cleanupStale?: boolean;
 }): DaemonStatus;

package/dist/src/commands/daemon.js

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { execSync, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { getShennianDir, loadConfig, resolveShennianPath, saveConfig } from '../config/index.js';
 import { buildAugmentedPath } from '../env-path.js';
@@ -83,17 +84,45 @@ export function resolveServiceLaunchSpec(input) {
         mode: 'direct',
     };
 }
-// ─── PID helpers ────────────────────────────────────────────────────────────
-function readPid() {
+function parsePidRecord(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            const pid = Number(parsed.pid);
+            if (!Number.isInteger(pid) || pid <= 0)
+                return null;
+            return {
+                pid,
+                ...(typeof parsed.instanceId === 'string' ? { instanceId: parsed.instanceId } : {}),
+                ...(typeof parsed.version === 'string' ? { version: parsed.version } : {}),
+                ...(parsed.launcher === 'desktop-managed' || parsed.launcher === 'global-cli' || parsed.launcher === 'unknown'
+                    ? { launcher: parsed.launcher }
+                    : {}),
+                ...(typeof parsed.startedAt === 'string' ? { startedAt: parsed.startedAt } : {}),
+                ...(parsed.adopted === true ? { adopted: true } : {}),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    const pid = parseInt(trimmed, 10);
+    return isNaN(pid) ? null : { pid };
+}
+function readPidRecord() {
     try {
-        const raw = fs.readFileSync(PID_FILE, 'utf-8').trim();
-        const pid = parseInt(raw, 10);
-        return isNaN(pid) ? null : pid;
+        return parsePidRecord(fs.readFileSync(PID_FILE, 'utf-8'));
     }
     catch {
         return null;
     }
 }
+function readPid() {
+    return readPidRecord()?.pid ?? null;
+}
 function isRunning(pid) {
     try {
         process.kill(pid, 0);
@@ -103,6 +132,15 @@ function isRunning(pid) {
         return false;
     }
 }
+function waitForPidExitSync(pid, timeoutMs = 3000) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (!isRunning(pid))
+            return true;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+    }
+    return !isRunning(pid);
+}
 export function isRemoteAccessDisabled() {
     return fs.existsSync(REMOTE_ACCESS_DISABLED_FILE);
 }
@@ -117,15 +155,51 @@ export function clearRemoteAccessDisabled() {
 export function getCurrentProcessDaemonLauncher() {
     return 'global-cli';
 }
-export function writeDaemonLauncher(pid, launcher = getCurrentProcessDaemonLauncher()) {
+export function createDaemonInstanceId() {
+    return `${process.pid}-${Date.now()}-${randomUUID()}`;
+}
+export function writeDaemonPid(pid, instanceId, meta = {}) {
+    fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
+    fs.writeFileSync(PID_FILE, JSON.stringify({
+        pid,
+        instanceId,
+        ...(meta.version ? { version: meta.version } : {}),
+        launcher: meta.launcher ?? getCurrentProcessDaemonLauncher(),
+        ...(meta.adopted ? { adopted: true } : {}),
+        startedAt: new Date().toISOString(),
+    }, null, 2));
+}
+export function clearDaemonPidIfOwner(pid, instanceId) {
+    const current = readPidRecord();
+    if (current?.pid !== pid || current.instanceId !== instanceId)
+        return;
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch {
+        // PID metadata may already be gone.
+    }
+}
+export function writeDaemonLauncher(pid, launcher = getCurrentProcessDaemonLauncher(), instanceId) {
     fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
     fs.writeFileSync(LAUNCHER_FILE, JSON.stringify({
         pid,
         launcher,
+        ...(instanceId ? { instanceId } : {}),
         updatedAt: new Date().toISOString(),
     }, null, 2));
 }
-export function clearDaemonLauncher() {
+export function clearDaemonLauncher(instanceId) {
+    if (instanceId) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(LAUNCHER_FILE, 'utf-8'));
+            if (raw.instanceId !== instanceId)
+                return;
+        }
+        catch {
+            return;
+        }
+    }
     try {
         fs.unlinkSync(LAUNCHER_FILE);
     }
@@ -174,10 +248,48 @@ function inferDaemonLauncherFromProcess(pid) {
     }
     return 'unknown';
 }
+function isShennianRunServiceCommand(command) {
+    const normalized = command.replace(/\\/g, '/');
+    return (normalized.includes(' run-service') &&
+        (normalized.includes('/node_modules/shennian/') ||
+            normalized.includes('/dist/bin/shennian.js') ||
+            normalized.includes(' shennian run-service') ||
+            normalized.includes(' shennian.js run-service')));
+}
+export function findRunningDaemonProcessIds(excludePid = process.pid) {
+    if (getPlatform() === 'win32')
+        return [];
+    try {
+        const output = execSync('ps -axo pid=,command=', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 1000,
+            windowsHide: true,
+        });
+        return output
+            .split(/\r?\n/)
+            .map((line) => {
+            const match = line.trim().match(/^(\d+)\s+(.+)$/);
+            if (!match)
+                return null;
+            const pid = Number(match[1]);
+            const command = match[2];
+            if (!Number.isInteger(pid) || pid === excludePid)
+                return null;
+            return isShennianRunServiceCommand(command) ? pid : null;
+        })
+            .filter((pid) => typeof pid === 'number');
+    }
+    catch {
+        return [];
+    }
+}
 export function getDaemonStatus(opts = {}) {
-    const pid = readPid();
-    const running = pid !== null && isRunning(pid);
-    const stale = pid !== null && !running;
+    let record = readPidRecord();
+    let pid = record?.pid ?? null;
+    let running = pid !== null && isRunning(pid);
+    let stale = pid !== null && !running;
+    let adopted = record?.adopted === true;
     const config = loadConfig();
     if (stale && opts.cleanupStale) {
         try {
@@ -186,6 +298,28 @@ export function getDaemonStatus(opts = {}) {
         catch {
             // Another process may have cleaned up the stale pid file first.
         }
+        record = null;
+        pid = null;
+        running = false;
+        stale = false;
+    }
+    if (!running) {
+        const discoveredPid = findRunningDaemonProcessIds()[0];
+        if (discoveredPid) {
+            pid = discoveredPid;
+            running = true;
+            stale = false;
+            adopted = true;
+            if (opts.cleanupStale) {
+                const instanceId = createDaemonInstanceId();
+                writeDaemonPid(discoveredPid, instanceId, {
+                    launcher: inferDaemonLauncherFromProcess(discoveredPid),
+                    adopted: true,
+                });
+                writeDaemonLauncher(discoveredPid, inferDaemonLauncherFromProcess(discoveredPid));
+                record = { pid: discoveredPid, instanceId, adopted: true };
+            }
+        }
     }
     return {
         running,
@@ -197,6 +331,8 @@ export function getDaemonStatus(opts = {}) {
         shennianDir: SHENNIAN_DIR,
         pidFile: PID_FILE,
         logFile: LOG_FILE,
+        ...(record?.instanceId ? { instanceId: record.instanceId } : {}),
+        ...(adopted ? { adopted: true } : {}),
         ...(config.machineId ? { machineId: config.machineId } : {}),
         paired: Boolean(config.machineToken && config.machineId),
         ...(config.serverUrl ? { serverUrl: config.serverUrl } : {}),
@@ -426,13 +562,28 @@ export function saveEnvSnapshot() {
 // ─── Exported helpers (used by pair.ts) ─────────────────────────────────────
 export function startDaemonProcess(opts = {}) {
     fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
-    const pid = readPid();
-    if (pid !== null && isRunning(pid)) {
+    const status = getDaemonStatus({ cleanupStale: true });
+    if (status.pid !== null && status.running && !status.adopted) {
         if (!opts.quiet) {
-            console.log(chalk.green(`✓ Background service already running (PID ${pid})`));
+            console.log(chalk.green(`✓ Background service already running (PID ${status.pid})`));
         }
         return;
     }
+    if (status.pid !== null && status.running && status.adopted) {
+        try {
+            process.kill(status.pid, 'SIGTERM');
+            waitForPidExitSync(status.pid);
+            try {
+                fs.unlinkSync(PID_FILE);
+            }
+            catch {
+                // The adopted daemon may have cleaned up or another start may have taken over.
+            }
+        }
+        catch {
+            // The adopted orphan may already have exited; continue with a clean start.
+        }
+    }
     const logFd = fs.openSync(LOG_FILE, 'a');
     const launch = buildDetachedLaunchSpec(resolveCurrentServiceLaunchSpec());
     const child = spawn(launch.command, launch.args, buildDaemonSpawnOptions(launch, logFd));
@@ -514,7 +665,8 @@ export function installService() {
 }
 // ─── Subcommand implementations ──────────────────────────────────────────────
 function stopDaemonProcess() {
-    const pid = readPid();
+    const status = getDaemonStatus({ cleanupStale: true });
+    const pid = status.pid;
     if (pid === null) {
         return {};
     }
@@ -556,6 +708,17 @@ async function stopDaemonProcessAndWait(timeoutMs = 5000) {
         // Best-effort cleanup after the process exits.
     }
     clearDaemonLauncher();
+    for (const orphanPid of findRunningDaemonProcessIds()) {
+        if (orphanPid === result.stoppedPid)
+            continue;
+        try {
+            process.kill(orphanPid, 'SIGTERM');
+            await waitForPidExit(orphanPid, 2000);
+        }
+        catch {
+            // Best-effort orphan cleanup; the main managed daemon has already stopped.
+        }
+    }
     return result;
 }
 function enableRemoteAccess(opts = {}) {

package/dist/src/commands/manager.d.ts

@@ -1,2 +1,2 @@
-import type { Command } from 'commander';
+import { type Command } from 'commander';
 export declare function registerManagerCommand(program: Command): void;

package/dist/src/commands/manager.js

@@ -2,6 +2,7 @@
 // @test src/__tests__/manager-runtime.test.ts
 // @test src/__tests__/manager-command.test.ts
 import fs from 'node:fs';
+import { Option } from 'commander';
 import chalk from 'chalk';
 import { readExternalAttachment } from './external-attachments.js';
 function requireManagerContext() {
@@ -74,9 +75,9 @@ function printWeChatRpaStatus(channel) {
         channel.wechatRpaLastRunAt ? `lastRun=${String(channel.wechatRpaLastRunAt)}` : '',
         channel.wechatRpaLastMessageAt ? `lastMessage=${String(channel.wechatRpaLastMessageAt)}` : '',
         channel.wechatRpaLastInterruptedAt ? `lastInterrupted=${String(channel.wechatRpaLastInterruptedAt)}` : '',
-        channel.wechatRpaLastCloudOcrAt ? `lastCloudOcr=${String(channel.wechatRpaLastCloudOcrAt)}` : '',
-        channel.wechatRpaLastCloudOcrPurpose ? `lastCloudOcrPurpose=${String(channel.wechatRpaLastCloudOcrPurpose)}` : '',
-        channel.wechatRpaLastCloudOcrRequestId ? `lastCloudOcrRequestId=${String(channel.wechatRpaLastCloudOcrRequestId)}` : '',
+        channel.wechatRpaLastCloudOcrAt ? `lastLocalOcr=${String(channel.wechatRpaLastCloudOcrAt)}` : '',
+        channel.wechatRpaLastCloudOcrPurpose ? `lastLocalOcrPurpose=${String(channel.wechatRpaLastCloudOcrPurpose)}` : '',
+        channel.wechatRpaLastCloudOcrRequestId ? `lastLocalOcrRequestId=${String(channel.wechatRpaLastCloudOcrRequestId)}` : '',
         channel.wechatRpaLastError ? `lastError=${String(channel.wechatRpaLastError)}` : 'lastError=none',
     ].filter(Boolean);
     console.log(fields.join('\n'));
@@ -352,8 +353,9 @@ export function registerManagerCommand(program) {
         .option('--id <id>', 'Channel id')
         .option('--name <name>', 'Channel display name')
         .requiredOption('--enabled <true|false>', 'Whether the channel should be enabled')
-        .option('--group <name>', 'WeChat group name; repeat for multiple groups', collect, [])
+        .option('--group <name>', 'Bound WeChat group name; pass once per conversation', collect, [])
         .option('--can-reply <true|false>', 'Whether reply should be allowed')
+        .option('--source <macos-flow|windows-visual-flow|wechat-rpa-lab|macos-probe|fixture-jsonl>', 'WeChat RPA implementation source')
         .option('--poll-interval-ms <n>', 'Polling interval in milliseconds')
         .option('--recent-limit <n>', 'Recent message OCR debug limit')
         .option('--idle-seconds <n>', 'Minimum user idle seconds before foreground automation')
@@ -362,17 +364,21 @@ export function registerManagerCommand(program) {
         .option('--download-attachments <true|false>', 'Click and localize inbound attachment candidates')
         .option('--download-attachments-dir <path>', 'Directory for localized inbound WeChat attachments')
         .option('--flow-script-path <path>', 'Override macOS flow script path')
-        .option('--cloud-ocr-url <url>', 'Shennian server OCR fallback URL')
-        .option('--cloud-ocr-token <token>', 'Shennian user/channel token for OCR fallback')
-        .option('--cloud-ocr-mode <off|fallback|always>', 'Cloud OCR mode')
+        .addOption(new Option('--cloud-ocr-url <url>', 'Deprecated; ignored because WeChat RPA uses local-only OCR').hideHelp())
+        .addOption(new Option('--cloud-ocr-token <token>', 'Deprecated; ignored because WeChat RPA uses local-only OCR').hideHelp())
+        .addOption(new Option('--cloud-ocr-mode <off|fallback|always>', 'Deprecated; ignored because WeChat RPA uses local-only OCR').hideHelp())
         .option('--json', 'Print JSON')
         .action(async (opts) => {
+        if (opts.enabled === 'true' && opts.group.length > 1) {
+            throw new Error('WeChat RPA 每个对话只能绑定一个群');
+        }
         const result = await ipc('/wechat-rpa/channel/upsert', {
             id: opts.id,
             name: opts.name,
             enabled: opts.enabled === 'true',
             groups: opts.group.map((name) => ({ name })),
             canReply: parseBool(opts.canReply),
+            source: opts.source,
             pollIntervalMs: parseNumber(opts.pollIntervalMs),
             recentLimit: parseNumber(opts.recentLimit),
             idleSeconds: parseNumber(opts.idleSeconds),
@@ -381,9 +387,6 @@ export function registerManagerCommand(program) {
             downloadAttachments: parseBool(opts.downloadAttachments),
             downloadAttachmentsDir: opts.downloadAttachmentsDir,
             flowScriptPath: opts.flowScriptPath,
-            cloudOcrUrl: opts.cloudOcrUrl,
-            cloudOcrToken: opts.cloudOcrToken,
-            cloudOcrMode: opts.cloudOcrMode,
         });
         if (opts.json)
             printJson(result);

package/dist/src/index.js

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import { loadConfig, saveConfig, configPath, getShennianDir, resolveShennianPath, } from './config/index.js';
 import { CliRelayClient } from './relay/client.js';
 import { registerPairCommand, runSmartStart } from './commands/pair.js';
-import { clearDaemonLauncher, isRemoteAccessDisabled, registerDaemonCommand, writeDaemonLauncher, } from './commands/daemon.js';
+import { clearDaemonPidIfOwner, createDaemonInstanceId, clearDaemonLauncher, findRunningDaemonProcessIds, isRemoteAccessDisabled, registerDaemonCommand, writeDaemonPid, writeDaemonLauncher, } from './commands/daemon.js';
 import { registerAgentCommand } from './commands/agent.js';
 import { registerManagerCommand } from './commands/manager.js';
 import { registerExternalCommand } from './commands/external.js';
@@ -29,6 +29,21 @@ import { NativeSessionFusionService } from './native-fusion/service.js';
 import { startDaemonLogRetention } from './daemon-log.js';
 const SHENNIAN_DIR = getShennianDir();
 const PID_FILE = resolveShennianPath('daemon.pid');
+function readDaemonPidFile() {
+    try {
+        const raw = fs.readFileSync(PID_FILE, 'utf-8').trim();
+        if (raw.startsWith('{')) {
+            const parsed = JSON.parse(raw);
+            const pid = Number(parsed.pid);
+            return Number.isInteger(pid) && pid > 0 ? pid : null;
+        }
+        const pid = parseInt(raw, 10);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
 function httpToWs(url) {
     return url.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://');
 }
@@ -100,23 +115,25 @@ program
     }
     // Single-instance guard. Service-manager starts are authoritative and may
     // need to take over from an older detached process after app/daemon upgrades.
-    const pidFile = resolveShennianPath('daemon.pid');
+    const serviceManagedStart = Boolean(process.env.INVOCATION_ID ||
+        process.env.JOURNAL_STREAM ||
+        process.env.SHENNIAN_DESKTOP_SERVER_URL);
+    const stopExistingDaemon = async (oldPid, reason) => {
+        console.log(`[${new Date().toISOString()}] ${reason} (PID ${oldPid})`);
+        process.kill(oldPid, 'SIGTERM');
+        const stopped = await waitForPidExit(oldPid);
+        if (!stopped) {
+            process.kill(oldPid, 'SIGKILL');
+            await waitForPidExit(oldPid, 2000);
+        }
+    };
     try {
-        const oldPid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+        const oldPid = readDaemonPidFile();
         if (oldPid && oldPid !== process.pid) {
             try {
                 process.kill(oldPid, 0);
-                const serviceManagedStart = Boolean(process.env.INVOCATION_ID ||
-                    process.env.JOURNAL_STREAM ||
-                    process.env.SHENNIAN_DESKTOP_SERVER_URL);
                 if (serviceManagedStart) {
-                    console.log(`[${new Date().toISOString()}] managed start taking over from existing daemon (PID ${oldPid})`);
-                    process.kill(oldPid, 'SIGTERM');
-                    const stopped = await waitForPidExit(oldPid);
-                    if (!stopped) {
-                        process.kill(oldPid, 'SIGKILL');
-                        await waitForPidExit(oldPid, 2000);
-                    }
+                    await stopExistingDaemon(oldPid, 'managed start taking over from existing daemon');
                 }
                 else {
                     console.log(`[${new Date().toISOString()}] daemon already running (PID ${oldPid}), skipping duplicate start`);
@@ -131,16 +148,29 @@ program
     catch {
         /* noop */
     }
-    fs.writeFileSync(pidFile, String(process.pid));
-    writeDaemonLauncher(process.pid);
-    process.on('exit', () => {
-        try {
-            fs.unlinkSync(pidFile);
+    const orphanPids = findRunningDaemonProcessIds(process.pid);
+    if (orphanPids.length > 0) {
+        if (serviceManagedStart) {
+            for (const orphanPid of orphanPids) {
+                try {
+                    await stopExistingDaemon(orphanPid, 'managed start taking over from orphan daemon');
+                }
+                catch {
+                    // Keep booting; the normal pid-file guard below still protects the managed daemon.
+                }
+            }
         }
-        catch {
-            /* noop */
+        else {
+            console.log(`[${new Date().toISOString()}] daemon already running (PID ${orphanPids[0]}), skipping duplicate start`);
+            process.exit(0);
         }
-        clearDaemonLauncher();
+    }
+    const daemonInstanceId = createDaemonInstanceId();
+    writeDaemonPid(process.pid, daemonInstanceId, { version: cliVersion });
+    writeDaemonLauncher(process.pid, undefined, daemonInstanceId);
+    process.on('exit', () => {
+        clearDaemonPidIfOwner(process.pid, daemonInstanceId);
+        clearDaemonLauncher(daemonInstanceId);
     });
     // Crash detection: if we're recovering from a failed upgrade, rollback and exit
     const didRollback = await handleStartupCrashCheck();
@@ -156,24 +186,24 @@ program
     const serverUrl = opts.api ?? process.env.SHENNIAN_DESKTOP_SERVER_URL ?? config.serverUrl ?? SERVERS.cn.url;
     const wsBase = httpToWs(serverUrl);
     const wsUrl = `${wsBase}/relay/machine`;
-    const cliVersion = getCurrentVersion();
+    const currentCliVersion = getCurrentVersion();
     const detectedAgents = detectAgents();
     const agentList = detectedAgents.map((a) => a.type);
     const cachedAgentInfos = getCachedAgentInfos(detectedAgents);
     if (config.machineId) {
         initCliLogReporter(serverUrl, config.machineId);
     }
-    console.log(`[${new Date().toISOString()}] Connecting to ${wsUrl}... (v${cliVersion}) agents: ${agentList.join(',')}`);
+    console.log(`[${new Date().toISOString()}] Connecting to ${wsUrl}... (v${currentCliVersion}) agents: ${agentList.join(',')}`);
     reportLog({
         level: 'info',
         wsEvent: 'daemon.start',
-        metadata: { version: cliVersion, agents: agentList },
+        metadata: { version: currentCliVersion, agents: agentList },
     });
     let nativeFusion = null;
     const client = new CliRelayClient({
         serverUrl: wsUrl,
         machineToken: config.machineToken,
-        cliVersion,
+        cliVersion: currentCliVersion,
         agentList,
         onConnected: () => {
             console.log(`[${new Date().toISOString()}] ✓ Connected`);
@@ -224,7 +254,7 @@ program
                 }
             })
                 .catch(() => { });
-            void scheduleAutoUpgrade(client, config.autoUpgrade ?? 'patch', cliVersion);
+            void scheduleAutoUpgrade(client, config.autoUpgrade ?? 'patch', currentCliVersion);
             nativeFusion?.handleConnected();
         },
         onDisconnected: (info) => {
@@ -255,13 +285,13 @@ program
         },
     });
     nativeFusion =
-        process.env.SHENNIAN_NATIVE_FUSION_DISABLED === '1'
-            ? null
-            : new NativeSessionFusionService(client);
-    const sessionManager = new SessionManager(client, nativeFusion, cliVersion);
+        process.env.SHENNIAN_NATIVE_FUSION_ENABLED === '1'
+            ? new NativeSessionFusionService(client)
+            : null;
+    const sessionManager = new SessionManager(client, nativeFusion, currentCliVersion);
     fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
-    fs.writeFileSync(PID_FILE, String(process.pid));
-    writeDaemonLauncher(process.pid);
+    writeDaemonPid(process.pid, daemonInstanceId, { version: currentCliVersion });
+    writeDaemonLauncher(process.pid, undefined, daemonInstanceId);
     client.connect();
     process.stdin.resume();
     const shutdown = () => {
@@ -271,13 +301,8 @@ program
         sessionManager.cleanup();
         nativeFusion?.stop();
         client.disconnect();
-        try {
-            fs.unlinkSync(PID_FILE);
-        }
-        catch {
-            /* noop */
-        }
-        clearDaemonLauncher();
+        clearDaemonPidIfOwner(process.pid, daemonInstanceId);
+        clearDaemonLauncher(daemonInstanceId);
         process.exit(0);
     };
     process.on('SIGINT', shutdown);

package/dist/src/manager/runtime.js

@@ -772,8 +772,12 @@ ${message || worker.summary || '(无可见摘要)'}
         const modelId = config?.modelId || manager?.modelId || '';
         const attachmentInputs = externalAttachmentsForAgent(event.attachments);
         const attachmentSummary = externalAttachmentSummary(event.attachments, event.text);
+        const mentionSummary = event.isMentioned ? '提及：是' : '';
         const visibleReplyTarget = event.replyTarget ? `回复目标：${event.replyTarget}` : '';
-        const visibleBody = [event.text, attachmentSummary, visibleReplyTarget].filter(Boolean).join('\n');
+        const visibleConversation = event.channelType === 'wechat-rpa' && event.conversationName
+            ? `来源群：${event.conversationName}`
+            : '';
+        const visibleBody = [visibleConversation, event.text, attachmentSummary, mentionSummary, visibleReplyTarget].filter(Boolean).join('\n');
         const visibleMessage = visibleBody
             ? `外部消息 / ${event.sender.name || event.sender.id}\n${visibleBody}`
             : `外部消息 / ${event.sender.name || event.sender.id}`;
@@ -791,7 +795,7 @@ ${message || worker.summary || '(无可见摘要)'}
             modelId,
             text: visibleMessage,
             attachments: attachmentInputs,
-            externalChannel,
+            externalChannel: externalChannelForChatEnqueue(externalChannel),
             replyTarget: event.replyTarget,
         });
     }
@@ -896,7 +900,7 @@ function parseWeChatRpaGroups(value) {
         .filter((item) => item.name);
 }
 function parseWeChatRpaSource(value) {
-    return value === 'macos-flow' || value === 'macos-probe' || value === 'windows-visual-flow' || value === 'fixture-jsonl' ? value : undefined;
+    return value === 'macos-flow' || value === 'macos-probe' || value === 'windows-visual-flow' || value === 'wechat-rpa-lab' || value === 'fixture-jsonl' ? value : undefined;
 }
 function externalAttachmentsForAgent(attachments) {
     const result = attachments
@@ -947,6 +951,34 @@ function externalAttachmentUnavailableStatus(attachment) {
         return 'edge-local-unavailable';
     return attachment.availability || 'metadata-only';
 }
+function externalChannelForChatEnqueue(channel) {
+    if (!channel)
+        return null;
+    if (channel.type !== 'wechat-rpa')
+        return channel;
+    return {
+        configured: channel.configured,
+        connected: channel.connected,
+        type: channel.type,
+        channelId: channel.channelId,
+        name: channel.name,
+        canReply: channel.canReply,
+        systemPrompt: channel.systemPrompt,
+        wechatRpaSource: channel.wechatRpaSource,
+        wechatRpaGroups: channel.wechatRpaGroups,
+        pollIntervalMs: channel.pollIntervalMs,
+        recentLimit: channel.recentLimit,
+        idleSeconds: channel.idleSeconds,
+        forceForeground: channel.forceForeground,
+        noRestore: channel.noRestore,
+        downloadAttachments: channel.downloadAttachments,
+        selfNickname: channel.selfNickname,
+        wechatRpaRuntimeState: channel.wechatRpaRuntimeState,
+        wechatRpaLastMessageAt: channel.wechatRpaLastMessageAt,
+        wechatRpaPendingReplyCount: channel.wechatRpaPendingReplyCount,
+        wechatRpaLastError: channel.wechatRpaLastError,
+    };
+}
 function canUseOriginalLocalAttachment(attachment) {
     return !attachment.providerError
         && (!attachment.availability || attachment.availability === 'edge-local');

package/dist/src/native-fusion/opencode-parser.js

@@ -113,6 +113,8 @@ export function parseOpenCodeSessionFile(filePath, startOffset) {
     const stat = fs.statSync(filePath);
     if (startOffset >= stat.size)
         return { nextOffset: stat.size, events: [] };
+    if (startOffset > 0)
+        return { nextOffset: stat.size, events: [] };
     const snapshot = JSON.parse(fs.readFileSync(filePath, 'utf8'));
     return {
         nextOffset: stat.size,

package/dist/src/native-fusion/parsers.js

@@ -70,6 +70,17 @@ function stripCodexUserMessageWrapper(text) {
 function stripCodexImagePlaceholders(text) {
     return normalizeText(text.replace(/<image>\s*<\/image>/gi, ''));
 }
+function isCodexInjectedContextText(text) {
+    const normalized = normalizeText(text);
+    if (!normalized)
+        return false;
+    const hasProjectInstructions = normalized.startsWith('# AGENTS.md instructions for ') &&
+        normalized.includes('<INSTRUCTIONS>') &&
+        normalized.includes('</INSTRUCTIONS>');
+    const hasEnvironmentContext = normalized.includes('<environment_context>') &&
+        normalized.includes('</environment_context>');
+    return hasProjectInstructions && hasEnvironmentContext;
+}
 function parseCodexUserMessage(payload) {
     const textFromElements = parseCodexTextElements(payload.text_elements);
     const textFromInput = Array.isArray(payload.input)
@@ -90,6 +101,8 @@ function parseCodexUserMessage(payload) {
         return null;
     if (isSystemControlPayload(text) && attachments.length === 0)
         return null;
+    if (isCodexInjectedContextText(text) && attachments.length === 0)
+        return null;
     if (attachments.length > 0) {
         return {
             payload: buildUserMessagePayload(text, attachments),
@@ -185,6 +198,8 @@ function parseCodexResponseMessage(payload) {
         return null;
     if (isSystemControlPayload(text) && attachments.length === 0)
         return null;
+    if (isCodexInjectedContextText(text) && attachments.length === 0)
+        return null;
     return {
         role,
         payload: attachments.length > 0 ? buildUserMessagePayload(text, attachments) : text,