shennian 0.2.87 → 0.2.89

package/dist/src/channels/wechat-rpa.js

@@ -6,9 +6,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { ChannelSecretRegistry } from './secret-registry.js';
+import { resolveShennianPath } from '../config/index.js';
 import { probeMacWeChat, observedMessageFromProbe } from './wechat-rpa/macos.js';
 import { runMacWeChatRpaFlow } from './wechat-rpa/macos-flow.js';
-import { runWindowsWeChatRpaVisualFlow } from './wechat-rpa/windows-visual-flow.js';
 import { normalizeWeChatRpaMessage, WeChatRpaDeduper, weChatRpaConversationId, } from './wechat-rpa/normalizer.js';
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const DEFAULT_RECENT_LIMIT = 5;
@@ -159,7 +159,6 @@ export class WeChatRpaChannelAdapter {
             noteManualReview(conn, pendingKey, reason);
             return { status: 'manual-review', reason };
         }
-        recordCloudOcrRuntime(conn, flow);
         addTaskSummary(conn, {
             status: 'sent',
             runId: conn.lastRunId ?? null,
@@ -225,11 +224,6 @@ export class WeChatRpaChannelAdapter {
             wechatRpaLastTracePath: conn.lastTracePath ?? null,
             wechatRpaLastTraceSummary: conn.lastTraceSummary ?? null,
             wechatRpaRecentTaskSummaries: conn.recentTaskSummaries,
-            wechatRpaLastCloudOcrAt: conn.lastCloudOcrAt ?? null,
-            wechatRpaLastCloudOcrPurpose: conn.lastCloudOcrPurpose ?? null,
-            wechatRpaLastCloudOcrRequestId: conn.lastCloudOcrRequestId ?? null,
-            wechatRpaLastCloudOcrImageHash: conn.lastCloudOcrImageHash ?? null,
-            wechatRpaLastCloudOcrUsage: conn.lastCloudOcrUsage ?? null,
         };
     }
     ensureConnection(config) {
@@ -284,7 +278,6 @@ export class WeChatRpaChannelAdapter {
             conn.runtimeState = 'syncing';
             const observed = await this.readObservedMessages(conn.config, secret, (flow) => {
                 recordTraceRuntime(conn, flow);
-                recordCloudOcrRuntime(conn, flow);
                 if (!flow.interrupted)
                     return;
                 interrupted = true;
@@ -345,7 +338,6 @@ export class WeChatRpaChannelAdapter {
             persistPendingReplyState(conn);
             const flow = await runSendFlow(conn.config, secret, pending.conversationName, pending.skipText ? '' : pending.text, pending.attachmentPath, pending.key);
             recordTraceRuntime(conn, flow);
-            recordCloudOcrRuntime(conn, flow);
             const partial = applyPartialSendProgress(flow, {
                 text: pending.skipText ? '' : pending.text,
                 attachmentPath: pending.attachmentPath,
@@ -446,16 +438,14 @@ function isWeChatRpaTextMentioned(text, aliases) {
 export function windowsVisualFlowHealth(secret, platform = process.platform) {
     if (platform !== 'win32')
         return { ok: false, message: 'WeChat RPA Windows visual flow requires Windows' };
-    if (!configuredGroups({ type: 'wechat-rpa', groups: secret.groups, updatedAt: '' }).length) {
-        return { ok: false, message: 'WeChat RPA Windows visual flow requires at least one group' };
-    }
-    return { ok: true, message: 'WeChat RPA Windows visual flow configured' };
+    void secret;
+    return { ok: false, message: 'WeChat RPA Windows visual flow is archived; redesign Windows support before enabling it' };
 }
 async function readLabMessages(config, secret, onFlow) {
     const api = await importWeChatRpaLabApi(config.workDir);
     const result = [];
     for (const name of configuredGroups(secret)) {
-        const flow = await runLabReadFlow(api, secret, name);
+        const flow = await runLabReadFlow(api, config, secret, name);
         onFlow?.(flow);
         if (!flow.ok || flow.interrupted)
             continue;
@@ -467,7 +457,7 @@ async function readLabMessages(config, secret, onFlow) {
     }
     return result;
 }
-async function runLabReadFlow(api, secret, groupName) {
+async function runLabReadFlow(api, config, secret, groupName) {
     const kind = selectWeChatRpaLabReadKind(secret.recentLimit);
     const task = {
         kind,
@@ -475,7 +465,7 @@ async function runLabReadFlow(api, secret, groupName) {
         targetGroup: groupName,
         policy: secret.forceForeground ? 'work' : 'polite',
         limit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 1, 50),
-        readMode: secret.readMode === 'hybrid-vlm' ? 'hybrid-vlm' : 'local-ocr',
+        attachmentsDir: resolveWeChatRpaInboundAttachmentDir(config, secret),
     };
     const result = await api.runWechatRpaReadLatest(task);
     const structuredMessages = Array.isArray(result.data?.structuredMessages) ? result.data.structuredMessages : [];
@@ -497,7 +487,6 @@ async function runLabReadFlow(api, secret, groupName) {
         recentMessages: flowMessages,
         newMessages: flowMessages,
         screenshotPath: result.tracePath,
-        cloudOcrUsage: result.data?.hybrid?.usage,
         error: labResultError(result),
     };
 }
@@ -629,8 +618,7 @@ async function readMacFlowMessages(config, secret, onFlow) {
             noRestore: secret.noRestore !== false,
             idleSeconds: clampNumber(secret.idleSeconds, 15, 0, 3600),
             recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
-            downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-            cloudOcrMode: 'off',
+            downloadAttachmentsDir: resolveWeChatRpaInboundAttachmentDir(config, secret),
         });
         onFlow?.(flow);
         if (flow.interrupted)
@@ -644,26 +632,18 @@ async function readMacFlowMessages(config, secret, onFlow) {
     return result;
 }
 async function readWindowsVisualFlowMessages(config, secret, onFlow) {
-    const result = [];
-    for (const name of configuredGroups(secret)) {
-        const flow = await runWindowsWeChatRpaVisualFlow({
-            groupName: name,
-            scriptPath: secret.flowScriptPath,
-            workDir: config.workDir,
-            recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
-            downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-            cloudOcrMode: 'off',
-        });
-        onFlow?.(flow);
-        if (flow.interrupted)
-            continue;
-        for (const message of flow.newMessages ?? []) {
-            const observed = flowMessageToObservedMessage(name, message, secret);
-            if (observed)
-                result.push(observed);
-        }
-    }
-    return result;
+    void config;
+    const groupName = configuredGroups(secret)[0] || '<unbound>';
+    onFlow?.({
+        ok: false,
+        groupName,
+        interrupted: true,
+        reason: 'windows-visual-flow-archived',
+        newMessages: [],
+        recentMessages: [],
+        error: 'WeChat RPA Windows visual flow is archived; redesign Windows support before enabling it',
+    });
+    return [];
 }
 function flowMessageToObservedMessage(conversationName, message, secret) {
     const text = String(message.text || '').trim();
@@ -684,16 +664,19 @@ function flowMessageToObservedMessage(conversationName, message, secret) {
 }
 async function runSendFlow(config, secret, conversationName, text, attachmentPath, dedupeKey) {
     if (secret.source === 'windows-visual-flow') {
-        return runWindowsWeChatRpaVisualFlow({
+        void config;
+        void text;
+        void attachmentPath;
+        void dedupeKey;
+        return {
+            ok: false,
             groupName: conversationName,
-            replyText: text || undefined,
-            attachmentPath,
-            scriptPath: secret.flowScriptPath,
-            workDir: config.workDir,
-            recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
-            downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-            cloudOcrMode: 'off',
-        });
+            interrupted: true,
+            reason: 'windows-visual-flow-archived',
+            newMessages: [],
+            recentMessages: [],
+            error: 'WeChat RPA Windows visual flow is archived; redesign Windows support before enabling it',
+        };
     }
     if (secret.source === 'wechat-rpa-lab') {
         return runLabSendFlow(config, secret, conversationName, text, attachmentPath, dedupeKey);
@@ -708,12 +691,11 @@ async function runSendFlow(config, secret, conversationName, text, attachmentPat
         noRestore: secret.noRestore !== false,
         idleSeconds: clampNumber(secret.idleSeconds, 15, 0, 3600),
         recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
-        downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-        cloudOcrMode: 'off',
+        downloadAttachmentsDir: resolveWeChatRpaInboundAttachmentDir(config, secret),
     });
 }
 function isFlowSource(source) {
-    return source === 'macos-flow' || source === 'windows-visual-flow' || source === 'wechat-rpa-lab';
+    return source === 'macos-flow' || source === 'wechat-rpa-lab';
 }
 function applyPartialSendProgress(flow, input) {
     if (input.text && input.attachmentPath && flow.sentReplyObserved && !flow.sentAttachmentObserved) {
@@ -883,7 +865,6 @@ function noteInterruption(conn, flow, reason) {
         conn.interruptionCooldownUntil = Date.now() + INTERRUPTION_COOLDOWN_MS;
         conn.runtimeState = 'cooldown';
     }
-    recordCloudOcrRuntime(conn, flow);
     addTaskSummary(conn, {
         status: 'interrupted',
         runId: flow.rpaRunId || conn.lastRunId || null,
@@ -1016,10 +997,14 @@ function safeFileName(name) {
         .replace(/^[ ._]+|[ ._]+$/g, '')
         || 'attachment';
 }
-function resolveInboundAttachmentDir(workDir, secret) {
+export function resolveWeChatRpaInboundAttachmentDir(config, secret) {
     if (secret.downloadAttachments === false)
         return undefined;
-    return secret.downloadAttachmentsDir?.trim() || path.join(workDir, '.uploads', 'wechat-rpa', 'inbound');
+    const explicitDir = secret.downloadAttachmentsDir?.trim();
+    if (explicitDir)
+        return path.resolve(explicitDir);
+    const channelKey = crypto.createHash('sha256').update(config.id).digest('hex').slice(0, 16);
+    return resolveShennianPath('wechat-rpa', 'attachments', 'inbound', channelKey);
 }
 export function annotateWeChatRpaInboundAttachments(attachments) {
     if (!Array.isArray(attachments))
@@ -1041,10 +1026,3 @@ function clampNumber(value, fallback, min, max) {
         return fallback;
     return Math.min(max, Math.max(min, number));
 }
-function recordCloudOcrRuntime(conn, flow) {
-    void conn;
-    void flow;
-    // WeChat RPA production routing is local OCR only. Legacy cloud OCR payload
-    // fields may still appear in old fixtures, but the channel must not publish
-    // them as runtime status or invite a server OCR dependency back in.
-}

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,7 +2,6 @@
 // @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() {
@@ -75,9 +74,6 @@ function printWeChatRpaStatus(channel) {
         channel.wechatRpaLastRunAt ? `lastRun=${String(channel.wechatRpaLastRunAt)}` : '',
         channel.wechatRpaLastMessageAt ? `lastMessage=${String(channel.wechatRpaLastMessageAt)}` : '',
         channel.wechatRpaLastInterruptedAt ? `lastInterrupted=${String(channel.wechatRpaLastInterruptedAt)}` : '',
-        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'));
@@ -353,20 +349,18 @@ 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>', 'Bound WeChat group name; pass once per conversation', collect, [])
+        .option('--group <name>', 'Bound WeChat conversation name; pass once per Shennian 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('--source <macos-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('--recent-limit <n>', 'Recent message limit')
         .option('--idle-seconds <n>', 'Minimum user idle seconds before foreground automation')
         .option('--force-foreground <true|false>', 'Force WeChat foreground while syncing')
         .option('--restore-previous <true|false>', 'Restore previous foreground app after syncing')
         .option('--download-attachments <true|false>', 'Click and localize inbound attachment candidates')
         .option('--download-attachments-dir <path>', 'Directory for localized inbound WeChat attachments')
+        .option('--privacy-consent <true|false>', 'Confirm WeChat channel data and privacy consent')
         .option('--flow-script-path <path>', 'Override macOS flow script path')
-        .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) {
@@ -386,6 +380,7 @@ export function registerManagerCommand(program) {
             noRestore: opts.restorePrevious === undefined ? undefined : opts.restorePrevious !== 'true',
             downloadAttachments: parseBool(opts.downloadAttachments),
             downloadAttachmentsDir: opts.downloadAttachmentsDir,
+            privacyConsentAccepted: parseBool(opts.privacyConsent),
             flowScriptPath: opts.flowScriptPath,
         });
         if (opts.json)

package/dist/src/fs/text-decoder.d.ts

@@ -0,0 +1,10 @@
+export declare class BinaryTextPreviewError extends Error {
+    constructor();
+}
+export type AutoTextDecodeResult = {
+    content: string;
+    encoding: 'utf8' | 'utf16le' | 'utf16be' | 'gb18030' | 'windows-1252';
+    fallback: boolean;
+};
+export declare function isAutoTextEncoding(value: string): boolean;
+export declare function decodeTextBufferAuto(buffer: Buffer): AutoTextDecodeResult;

package/dist/src/fs/text-decoder.js

@@ -0,0 +1,110 @@
+// @arch docs/architecture/cli/daemon.md#文件系统权限边界
+// @test src/__tests__/session-manager.test.ts
+import { TextDecoder } from 'node:util';
+const AUTO_TEXT_ENCODINGS = new Set(['auto', 'utf8-auto', 'utf-8-auto', 'text-auto']);
+const TEXT_SAMPLE_BYTES = 8192;
+const MAX_SUSPICIOUS_CONTROL_RATIO = 0.01;
+export class BinaryTextPreviewError extends Error {
+    constructor() {
+        super('File appears to be binary; use encoding=base64');
+        this.name = 'BinaryTextPreviewError';
+    }
+}
+export function isAutoTextEncoding(value) {
+    return AUTO_TEXT_ENCODINGS.has(value.trim().toLowerCase());
+}
+function startsWithBytes(buffer, bytes) {
+    if (buffer.length < bytes.length)
+        return false;
+    return bytes.every((byte, index) => buffer[index] === byte);
+}
+function isAllowedTextControlByte(byte) {
+    return byte === 0x09 || byte === 0x0a || byte === 0x0c || byte === 0x0d || byte === 0x1b;
+}
+function hasBinaryMagic(buffer) {
+    return (startsWithBytes(buffer, [0x25, 0x50, 0x44, 0x46]) || // PDF
+        startsWithBytes(buffer, [0x50, 0x4b, 0x03, 0x04]) || // ZIP / Office Open XML
+        startsWithBytes(buffer, [0x50, 0x4b, 0x05, 0x06]) ||
+        startsWithBytes(buffer, [0x50, 0x4b, 0x07, 0x08]) ||
+        startsWithBytes(buffer, [0x89, 0x50, 0x4e, 0x47]) || // PNG
+        startsWithBytes(buffer, [0xff, 0xd8, 0xff]) || // JPEG
+        startsWithBytes(buffer, [0x47, 0x49, 0x46, 0x38]) || // GIF
+        startsWithBytes(buffer, [0x52, 0x49, 0x46, 0x46]) || // RIFF / WebP / WAV / AVI
+        startsWithBytes(buffer, [0x1f, 0x8b]) || // gzip
+        startsWithBytes(buffer, [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c]) || // 7z
+        startsWithBytes(buffer, [0x52, 0x61, 0x72, 0x21, 0x1a, 0x07]) || // RAR
+        startsWithBytes(buffer, [0x7f, 0x45, 0x4c, 0x46]) || // ELF
+        startsWithBytes(buffer, [0xcf, 0xfa, 0xed, 0xfe]) || // Mach-O
+        startsWithBytes(buffer, [0xca, 0xfe, 0xba, 0xbe]) ||
+        startsWithBytes(buffer, [0x4d, 0x5a]) || // Windows PE
+        startsWithBytes(buffer, [0x53, 0x51, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x66]));
+}
+function looksLikeBinaryBuffer(buffer) {
+    if (hasBinaryMagic(buffer))
+        return true;
+    const sample = buffer.subarray(0, Math.min(buffer.length, TEXT_SAMPLE_BYTES));
+    if (sample.length === 0)
+        return false;
+    let suspiciousControls = 0;
+    for (const byte of sample) {
+        if (byte === 0x00)
+            return true;
+        if (byte < 0x20 && !isAllowedTextControlByte(byte))
+            suspiciousControls += 1;
+    }
+    return suspiciousControls / sample.length > MAX_SUSPICIOUS_CONTROL_RATIO;
+}
+function isAllowedTextControlCode(codePoint) {
+    return codePoint === 0x09 || codePoint === 0x0a || codePoint === 0x0c || codePoint === 0x0d || codePoint === 0x1b;
+}
+function hasDecodedControlNoise(content) {
+    if (!content)
+        return false;
+    let suspiciousControls = 0;
+    let total = 0;
+    for (const char of content.slice(0, TEXT_SAMPLE_BYTES)) {
+        const codePoint = char.codePointAt(0) ?? 0;
+        total += 1;
+        if (((codePoint >= 0x00 && codePoint < 0x20) || (codePoint >= 0x7f && codePoint <= 0x9f)) &&
+            !isAllowedTextControlCode(codePoint)) {
+            suspiciousControls += 1;
+        }
+    }
+    return total > 0 && suspiciousControls / total > MAX_SUSPICIOUS_CONTROL_RATIO;
+}
+function decodeStrict(buffer, decoderEncoding, encoding, fallback) {
+    const content = new TextDecoder(decoderEncoding, { fatal: true }).decode(buffer);
+    if (hasDecodedControlNoise(content))
+        throw new BinaryTextPreviewError();
+    return { content, encoding, fallback };
+}
+export function decodeTextBufferAuto(buffer) {
+    if (buffer.length === 0)
+        return { content: '', encoding: 'utf8', fallback: false };
+    if (startsWithBytes(buffer, [0xef, 0xbb, 0xbf])) {
+        return decodeStrict(buffer, 'utf-8', 'utf8', false);
+    }
+    if (startsWithBytes(buffer, [0xff, 0xfe])) {
+        return decodeStrict(buffer, 'utf-16le', 'utf16le', true);
+    }
+    if (startsWithBytes(buffer, [0xfe, 0xff])) {
+        return decodeStrict(buffer, 'utf-16be', 'utf16be', true);
+    }
+    if (looksLikeBinaryBuffer(buffer))
+        throw new BinaryTextPreviewError();
+    try {
+        return decodeStrict(buffer, 'utf-8', 'utf8', false);
+    }
+    catch (error) {
+        if (error instanceof BinaryTextPreviewError)
+            throw error;
+    }
+    try {
+        return decodeStrict(buffer, 'gb18030', 'gb18030', true);
+    }
+    catch (error) {
+        if (error instanceof BinaryTextPreviewError)
+            throw error;
+    }
+    return decodeStrict(buffer, 'windows-1252', 'windows-1252', true);
+}

package/dist/src/manager/runtime.js

@@ -664,10 +664,8 @@ export class ManagerRuntimeService {
                     noRestore: body.noRestore === undefined ? undefined : Boolean(body.noRestore),
                     downloadAttachments: body.downloadAttachments === undefined ? undefined : Boolean(body.downloadAttachments),
                     downloadAttachmentsDir: typeof body.downloadAttachmentsDir === 'string' ? body.downloadAttachmentsDir : undefined,
+                    privacyConsentAccepted: body.privacyConsentAccepted === undefined ? undefined : Boolean(body.privacyConsentAccepted),
                     flowScriptPath: typeof body.flowScriptPath === 'string' ? body.flowScriptPath : undefined,
-                    cloudOcrUrl: typeof body.cloudOcrUrl === 'string' ? body.cloudOcrUrl : undefined,
-                    cloudOcrToken: typeof body.cloudOcrToken === 'string' ? body.cloudOcrToken : undefined,
-                    cloudOcrMode: parseCloudOcrMode(body.cloudOcrMode),
                 });
                 this.registry.upsertManager({
                     ...manager,
@@ -973,6 +971,9 @@ function externalChannelForChatEnqueue(channel) {
         noRestore: channel.noRestore,
         downloadAttachments: channel.downloadAttachments,
         selfNickname: channel.selfNickname,
+        wechatRpaPrivacyConsentAccepted: channel.wechatRpaPrivacyConsentAccepted,
+        wechatRpaServerDecisionAvailable: channel.wechatRpaServerDecisionAvailable,
+        wechatRpaPreflightChecks: channel.wechatRpaPreflightChecks,
         wechatRpaRuntimeState: channel.wechatRpaRuntimeState,
         wechatRpaLastMessageAt: channel.wechatRpaLastMessageAt,
         wechatRpaPendingReplyCount: channel.wechatRpaPendingReplyCount,
@@ -1004,9 +1005,6 @@ function mimeTypeFromExternalAttachment(attachment) {
         return 'audio/*';
     return 'application/octet-stream';
 }
-function parseCloudOcrMode(value) {
-    return value === 'off' || value === 'fallback' || value === 'always' ? value : undefined;
-}
 function optionalNumber(value) {
     const number = Number(value);
     return Number.isFinite(number) ? number : undefined;

package/dist/src/native-fusion/service.d.ts

@@ -1,4 +1,5 @@
 import type { CliRelayClient } from '../relay/client.js';
+import type { SessionActivitySnapshot } from '@shennian/wire';
 export declare class NativeSessionFusionService {
     private client;
     private timer;
@@ -20,6 +21,15 @@ export declare class NativeSessionFusionService {
     noteManagedSourceSession(sessionId: string, agentType: string, sourceSessionKey: string | null): void;
     private pruneState;
     scanNow(): Promise<void>;
+    getCodexThreadActivity(params: {
+        sessionId: string;
+        threadId: string;
+        workDir?: string;
+    }): Promise<SessionActivitySnapshot | null | undefined>;
+    interruptCodexThread(params: {
+        threadId: string;
+        workDir?: string;
+    }): Promise<boolean>;
     private runScan;
     private tryClaimManagedEcho;
     private isSuppressed;

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

@@ -3,6 +3,7 @@
 import { randomUUID } from 'node:crypto';
 import fs from 'node:fs';
 import { listClaudeTranscriptFiles, listCodexRolloutFiles, listOpenCodeSessionFiles, parseClaudeTranscriptChunk, parseCodexRolloutChunk, parseOpenCodeSessionFile, } from './parsers.js';
+import { probeCodexThreadActivity, interruptCodexThread } from '../agents/codex-control.js';
 import { loadNativeScannerState, saveNativeScannerState } from './state.js';
 const SCAN_INTERVAL_MS = 60_000;
 const CLAIM_TTL_MS = SCAN_INTERVAL_MS * 2;
@@ -89,6 +90,32 @@ export class NativeSessionFusionService {
         });
         return this.scanPromise;
     }
+    async getCodexThreadActivity(params) {
+        const activity = await probeCodexThreadActivity({
+            threadId: params.threadId,
+            workDir: params.workDir,
+        });
+        if (!activity)
+            return undefined;
+        if (!activity.active || !activity.runPhase)
+            return null;
+        const nowIso = new Date().toISOString();
+        return {
+            sessionId: params.sessionId,
+            runId: activity.turnId ?? `codex:${params.threadId}`,
+            runPhase: activity.runPhase,
+            startedAt: nowIso,
+            updatedAt: nowIso,
+            canStop: activity.canStop,
+        };
+    }
+    async interruptCodexThread(params) {
+        const activity = await interruptCodexThread({
+            threadId: params.threadId,
+            workDir: params.workDir,
+        });
+        return Boolean(activity);
+    }
     async runScan() {
         this.pruneState();
         const state = loadNativeScannerState();

package/dist/src/session/handlers/chat.js

@@ -36,11 +36,13 @@ function extractSummary(text) {
 }
 function buildRelayAgentPayload(event, sessionId, extra = {}) {
     if (event.state === 'tool-call' || event.state === 'tool-result') {
+        const detailRef = { runId: event.runId, sourceSeq: event.seq };
         return {
             state: event.state,
             runId: event.runId,
             seq: event.seq,
             sessionId,
+            detailRef,
             ...(event.name ? { name: event.name } : {}),
             ...(event.source ? { source: event.source } : {}),
             ...(event.agentSessionId ? { agentSessionId: event.agentSessionId } : {}),
@@ -55,6 +57,8 @@ function runPhaseFromAgentEvent(event) {
         return event.runPhase ?? null;
     if (event.state === 'tool-call' || event.state === 'tool-result')
         return 'tool_running';
+    if (event.state === 'approval-pending')
+        return 'waiting_approval';
     if (event.state === 'delta')
         return event.thinking ? 'thinking' : 'streaming_text';
     if (event.state === 'init' || event.state === 'start')
@@ -144,8 +148,6 @@ function normalizeExternalChannel(value) {
         noRestore: raw.noRestore === undefined || raw.noRestore === null ? null : Boolean(raw.noRestore),
         downloadAttachments: raw.downloadAttachments === undefined || raw.downloadAttachments === null ? null : Boolean(raw.downloadAttachments),
         downloadAttachmentsDir: typeof raw.downloadAttachmentsDir === 'string' ? raw.downloadAttachmentsDir : null,
-        cloudOcrUrl: typeof raw.cloudOcrUrl === 'string' ? raw.cloudOcrUrl : null,
-        cloudOcrMode: typeof raw.cloudOcrMode === 'string' ? raw.cloudOcrMode : null,
     };
 }
 function externalChannelEnabled(channel) {
@@ -295,6 +297,8 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
                     v: 1,
                     type: event.state === 'tool-call' ? 'tool_use' : 'tool_result',
                     name: event.name,
+                    status: event.state === 'tool-call' ? 'running' : 'completed',
+                    detailRef: { runId: event.runId, sourceSeq: event.seq },
                     args: event.args,
                     result: event.result,
                 }),
@@ -730,6 +734,18 @@ export async function handleChatAbort(runtime, req) {
         }
         catch { /* best-effort: still emit synthetic abort below */ }
         emitSyntheticAbort(runtime, sessionId);
+        runtime.activityPublisher?.publish(sessionId, null);
+    }
+    else {
+        const params = req.params;
+        if (params.agentType === 'codex' && params.agentSessionId && runtime.nativeFusion) {
+            const ok = await runtime.nativeFusion.interruptCodexThread({
+                threadId: params.agentSessionId,
+                workDir: params.workDir,
+            });
+            if (ok)
+                runtime.activityPublisher?.publish(sessionId, null);
+        }
     }
     runtime.client.sendRes({ type: 'res', id: req.id, ok: true });
 }

package/dist/src/session/handlers/fs.js

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { convertMarkdownToPdf, defaultPdfOutputPath, MarkdownPdfBrowserMissingError, } from '../../tools/markdown-to-pdf.js';
 import { createZipArchive } from '../archive-zip.js';
+import { BinaryTextPreviewError, decodeTextBufferAuto, isAutoTextEncoding, } from '../../fs/text-decoder.js';
 const FILE_SYSTEM_ROOTS_PATH = '__roots__';
 const MAX_FOLDER_UPLOAD_FILES = 2000;
 const MAX_FOLDER_UPLOAD_TOTAL_SIZE = 1024 * 1024 * 1024;
@@ -151,7 +152,8 @@ export async function handleFsRead(runtime, req) {
         return;
     }
     const filePath = resolved.path;
-    const encoding = req.params.encoding || 'utf8';
+    const requestedEncoding = req.params.encoding;
+    const encoding = typeof requestedEncoding === 'string' ? requestedEncoding : 'utf8';
     const offset = req.params.offset;
     const length = req.params.length;
     try {
@@ -214,6 +216,23 @@ export async function handleFsRead(runtime, req) {
             });
             return;
         }
+        if (isAutoTextEncoding(encoding)) {
+            const buffer = fs.readFileSync(filePath);
+            const decoded = decodeTextBufferAuto(buffer);
+            runtime.client.sendRes({
+                type: 'res',
+                id: req.id,
+                ok: true,
+                payload: {
+                    content: decoded.content,
+                    path: filePath,
+                    size: stat.size,
+                    encoding: decoded.encoding,
+                    encodingFallback: decoded.fallback,
+                },
+            });
+            return;
+        }
         const content = fs.readFileSync(filePath, 'utf-8');
         runtime.client.sendRes({
             type: 'res',
@@ -223,7 +242,12 @@ export async function handleFsRead(runtime, req) {
         });
     }
     catch (err) {
-        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: String(err) });
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: false,
+            error: err instanceof BinaryTextPreviewError ? err.message : String(err),
+        });
     }
 }
 export async function handleFsWrite(runtime, req) {
@@ -378,7 +402,19 @@ export async function handleFsExportMarkdownPdf(runtime, req) {
     }
 }
 function safeArchiveBaseName(name) {
-    const trimmed = name.trim().replace(/[<>:"/\\|?*\u0000-\u001f]+/g, '-').replace(/[. ]+$/g, '');
+    let safeName = '';
+    for (const char of name.trim()) {
+        const code = char.charCodeAt(0);
+        const unsafe = code <= 0x1f || '<>:"/\\|?*'.includes(char);
+        if (unsafe) {
+            if (!safeName.endsWith('-'))
+                safeName += '-';
+        }
+        else {
+            safeName += char;
+        }
+    }
+    const trimmed = safeName.replace(/[. ]+$/g, '');
     return trimmed || 'folder';
 }
 export async function handleFsArchiveZip(runtime, req) {

package/dist/src/session/handlers/session-refresh.js

@@ -21,6 +21,18 @@ export async function handleSessionRefresh(runtime, req) {
         return;
     }
     await runtime.nativeFusion.scanNow();
+    if (params.agentType === 'codex' &&
+        params.agentSessionId &&
+        typeof runtime.nativeFusion.getCodexThreadActivity === 'function') {
+        const activity = await runtime.nativeFusion.getCodexThreadActivity({
+            sessionId: params.sessionId,
+            threadId: params.agentSessionId,
+            workDir: params.workDir,
+        });
+        if (activity !== undefined) {
+            runtime.activityPublisher?.publish(params.sessionId, activity);
+        }
+    }
     runtime.client.sendRes({
         type: 'res',
         id: req.id,

package/dist/src/session/handlers/tool-detail.d.ts

@@ -0,0 +1,3 @@
+import type { ReqFrame } from '@shennian/wire';
+import type { SessionManagerRuntime } from '../types.js';
+export declare function handleSessionToolDetail(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;