shennian 0.2.52 → 0.2.53

package/dist/src/agents/adapter.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'node:events';
-import type { AgentType } from '@shennian/wire';
+import type { AgentType, ExternalChannelSessionStatus } from '@shennian/wire';
 export type AgentEvent = {
     state: string;
     runId: string;
@@ -24,6 +24,10 @@ export interface AgentAdapterEvents {
 }
 export declare abstract class AgentAdapter extends EventEmitter<AgentAdapterEvents> {
     abstract readonly type: AgentType;
+    configure?(options: {
+        externalChannel?: ExternalChannelSessionStatus | null;
+        env?: NodeJS.ProcessEnv;
+    }): void;
     abstract start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
     abstract send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
     abstract resume(agentSessionId: string): Promise<void>;

package/dist/src/agents/claude.d.ts

@@ -1,4 +1,5 @@
 import { AgentAdapter } from './adapter.js';
+import type { ExternalChannelSessionStatus } from '@shennian/wire';
 export declare function normalizeClaudeModelId(modelId?: string | null): string;
 export declare function normalizeClaudeReasoningEffort(reasoningEffort?: string | null): string | undefined;
 export declare class ClaudeAdapter extends AgentAdapter {
@@ -16,6 +17,12 @@ export declare class ClaudeAdapter extends AgentAdapter {
         systemPrompt?: string;
         hidden?: boolean;
     });
+    private externalChannel;
+    private extraEnv;
+    configure(options: {
+        externalChannel?: ExternalChannelSessionStatus | null;
+        env?: NodeJS.ProcessEnv;
+    }): void;
     start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
     send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
     resume(agentSessionId: string): Promise<void>;

package/dist/src/agents/claude.js

@@ -32,6 +32,12 @@ export class ClaudeAdapter extends AgentAdapter {
         super();
         this.options = options;
     }
+    externalChannel = null;
+    extraEnv = {};
+    configure(options) {
+        this.externalChannel = options.externalChannel ?? null;
+        this.extraEnv = options.env ?? {};
+    }
     async start(sessionId, workDir, agentSessionId) {
         this.sessionId = sessionId;
         this.workDir = workDir;
@@ -44,7 +50,7 @@ export class ClaudeAdapter extends AgentAdapter {
         this.runId = randomUUID();
         this.resetRunState();
         const args = ['-p', text, '--output-format', 'stream-json', '--verbose'];
-        const systemPrompt = this.options.systemPrompt ?? buildPlatformInstructions(this.workDir ?? process.cwd());
+        const systemPrompt = this.options.systemPrompt ?? buildPlatformInstructions(this.workDir ?? process.cwd(), this.externalChannel);
         if (systemPrompt) {
             args.push('--append-system-prompt', systemPrompt);
         }
@@ -70,7 +76,7 @@ export class ClaudeAdapter extends AgentAdapter {
         this.runId = randomUUID();
         this.resetRunState();
         const resumeArgs = ['--resume', agentSessionId, '--output-format', 'stream-json', '--verbose'];
-        const systemPrompt = this.options.systemPrompt ?? buildPlatformInstructions(this.workDir ?? process.cwd());
+        const systemPrompt = this.options.systemPrompt ?? buildPlatformInstructions(this.workDir ?? process.cwd(), this.externalChannel);
         if (systemPrompt) {
             resumeArgs.push('--append-system-prompt', systemPrompt);
         }
@@ -94,7 +100,7 @@ export class ClaudeAdapter extends AgentAdapter {
         const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
-            env: buildAgentProcessEnv(),
+            env: buildAgentProcessEnv(this.extraEnv),
         });
         this.process = proc;
         const rl = createInterface({ input: proc.stdout });

package/dist/src/agents/codex.d.ts

@@ -1,4 +1,5 @@
 import { AgentAdapter } from './adapter.js';
+import type { ExternalChannelSessionStatus } from '@shennian/wire';
 export declare class CodexAdapter extends AgentAdapter {
     private readonly options;
     readonly type: "codex";
@@ -25,6 +26,12 @@ export declare class CodexAdapter extends AgentAdapter {
         modelInstructionsFile?: string;
         hidden?: boolean;
     });
+    private externalChannel;
+    private extraEnv;
+    configure(options: {
+        externalChannel?: ExternalChannelSessionStatus | null;
+        env?: NodeJS.ProcessEnv;
+    }): void;
     start(_sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
     send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
     resume(agentSessionId: string): Promise<void>;

package/dist/src/agents/codex.js

@@ -32,6 +32,12 @@ export class CodexAdapter extends AgentAdapter {
         super();
         this.options = options;
     }
+    externalChannel = null;
+    extraEnv = {};
+    configure(options) {
+        this.externalChannel = options.externalChannel ?? null;
+        this.extraEnv = options.env ?? {};
+    }
     async start(_sessionId, workDir, agentSessionId) {
         this.workDir = workDir;
         this.seq = 0;
@@ -82,7 +88,7 @@ export class CodexAdapter extends AgentAdapter {
         const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
-            env: buildAgentProcessEnv(),
+            env: buildAgentProcessEnv(this.extraEnv),
         });
         this.process = proc;
         const rl = createInterface({ input: proc.stdout });
@@ -127,14 +133,14 @@ export class CodexAdapter extends AgentAdapter {
             return;
         }
         const args = ['app-server', '--listen', 'stdio://'];
-        const modelInstructionsFile = this.options.modelInstructionsFile ?? ensurePlatformInstructionsFile(this.workDir ?? process.cwd());
+        const modelInstructionsFile = this.options.modelInstructionsFile ?? ensurePlatformInstructionsFile(this.workDir ?? process.cwd(), this.externalChannel);
         if (modelInstructionsFile) {
             args.push('-c', `model_instructions_file=${JSON.stringify(modelInstructionsFile)}`);
         }
         const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['pipe', 'pipe', 'pipe'],
-            env: buildAgentProcessEnv({ NO_COLOR: '1' }),
+            env: buildAgentProcessEnv({ NO_COLOR: '1', ...this.extraEnv }),
         });
         this.process = proc;
         this.stderrBuf = '';
@@ -253,7 +259,7 @@ export class CodexAdapter extends AgentAdapter {
         }
         catch (error) {
             if (reasoningEffort && isCodexUnsupportedEffortError(error)) {
-                throw new Error(`Codex app-server does not accept reasoning effort "${reasoningEffort}" for this turn. Refresh models or upgrade Codex CLI, then retry.`);
+                throw new Error(`Codex app-server does not accept reasoning effort "${reasoningEffort}" for this turn. Refresh models or upgrade Codex CLI, then retry.`, { cause: error });
             }
             throw error;
         }

package/dist/src/agents/external-channel-instructions.d.ts

@@ -0,0 +1,2 @@
+import type { ExternalChannelSessionStatus } from '@shennian/wire';
+export declare function buildExternalChannelInstructions(channel?: ExternalChannelSessionStatus | null): string;

package/dist/src/agents/external-channel-instructions.js

@@ -0,0 +1,22 @@
+// @arch docs/features/wecom-managed-channel.md
+// @test src/__tests__/platform-instructions.test.ts
+export function buildExternalChannelInstructions(channel) {
+    if (!channel?.configured && !channel?.connected)
+        return '';
+    const channelName = channel.name?.trim() || '外部消息通道';
+    const customPrompt = channel.systemPrompt?.trim();
+    const sections = [
+        `当前对话已接入外部消息通道：${channelName}。`,
+        `外部消息会以如下格式进入对话：\n外部消息\n<时间> <用户昵称>: <内容>`,
+        channel.canReply === false
+            ? '当前通道只允许接收消息，不要尝试向外部通道发送回复。'
+            : [
+                '当用户明确要求你向外部消息通道发送内容，或你需要回复一条外部消息时，调用：',
+                'shennian external send --text "<要发送的消息>"',
+                '只发送用户可见的最终内容，不要发送内部推理、工具日志或实现细节。',
+            ].join('\n'),
+        '如果外部消息和当前任务无关，可以忽略或简短说明无需处理；如果处理需要时间，先简短确认，再继续完成任务。',
+        customPrompt ? `本通道附加约束：${customPrompt}` : '',
+    ].filter(Boolean);
+    return sections.join('\n\n');
+}

package/dist/src/agents/manager.js

@@ -7,6 +7,7 @@ import { MANAGER_SYSTEM_PROMPT, buildManagerPrompt } from '../manager/prompt.js'
 import { getManagerRuntimeService } from '../manager/runtime.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import { PLATFORM_OUTPUT_INSTRUCTIONS } from './platform-instructions.js';
 function normalizeManagerModel(modelId) {
     return modelId === 'claude' ? 'claude' : 'codex';
 }
@@ -38,6 +39,7 @@ function buildStableManagerInstructions(workDir, managerSessionId) {
         channelInstructions
             ? `## External Message Channel Instructions\n\n${channelInstructions}`
             : '',
+        PLATFORM_OUTPUT_INSTRUCTIONS,
     ].filter(Boolean);
     return `${sections.join('\n\n')}\n`;
 }

package/dist/src/agents/pi.d.ts

@@ -1,4 +1,5 @@
 import { AgentAdapter } from './adapter.js';
+import type { ExternalChannelSessionStatus } from '@shennian/wire';
 type ShellCommandSpec = {
     file: string;
     args: string[];
@@ -27,7 +28,13 @@ export declare class PiAdapter extends AgentAdapter {
     private pendingBaseMessages;
     private finalizePromise;
     private sendGeneration;
+    private externalChannel;
+    private extraEnv;
     private pendingSendStart;
+    configure(options: {
+        externalChannel?: ExternalChannelSessionStatus | null;
+        env?: NodeJS.ProcessEnv;
+    }): void;
     start(sessionId: string, workDir: string, _agentSessionId?: string | null): Promise<void>;
     send(text: string, modelId?: string): Promise<void>;
     private initAgent;

package/dist/src/agents/pi.js

@@ -8,6 +8,7 @@ import { promisify } from 'node:util';
 import { Agent, streamProxy } from '@mariozechner/pi-agent-core';
 import { Type } from '@sinclair/typebox';
 import { AgentAdapter, registerAgent } from './adapter.js';
+import { buildExternalChannelInstructions } from './external-channel-instructions.js';
 import { loadConfig, resolveShennianPath } from '../config/index.js';
 import { SERVERS } from '../region.js';
 const execFileAsync = promisify(execFile);
@@ -186,7 +187,7 @@ async function requestProxySummary(proxyUrl, authToken, prompt) {
 }
 // ── Local tools ───────────────────────────────────────────────────────────────
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function makeTools(workDir) {
+function makeTools(workDir, extraEnv = {}) {
     return [
         {
             name: 'read_file',
@@ -292,6 +293,7 @@ function makeTools(workDir) {
                 try {
                     const { stdout, stderr } = await execFileAsync(spec.file, spec.args, {
                         cwd: workDir,
+                        env: { ...process.env, ...extraEnv },
                         timeout: 30_000,
                         signal,
                         maxBuffer: 1024 * 1024,
@@ -395,7 +397,13 @@ export class PiAdapter extends AgentAdapter {
     pendingBaseMessages = [];
     finalizePromise = Promise.resolve();
     sendGeneration = 0;
+    externalChannel = null;
+    extraEnv = {};
     pendingSendStart = null;
+    configure(options) {
+        this.externalChannel = options.externalChannel ?? null;
+        this.extraEnv = options.env ?? {};
+    }
     async start(sessionId, workDir, _agentSessionId) {
         this.sessionId = sessionId;
         this.workDir = workDir;
@@ -483,10 +491,14 @@ export class PiAdapter extends AgentAdapter {
     // ── Agent lifecycle ──────────────────────────────────────────────────────────
     initAgent() {
         const workDir = this.workDir ?? process.cwd();
-        const tools = makeTools(workDir);
+        const tools = makeTools(workDir, this.extraEnv);
         const agent = new Agent({
             initialState: {
-                systemPrompt: SYSTEM_PROMPT + `\n\n当前工作目录：${workDir}`,
+                systemPrompt: [
+                    SYSTEM_PROMPT,
+                    `当前工作目录：${workDir}`,
+                    buildExternalChannelInstructions(this.externalChannel),
+                ].filter(Boolean).join('\n\n'),
                 model: createPiModel(),
                 tools,
             },

package/dist/src/agents/platform-instructions.d.ts

@@ -1,3 +1,4 @@
+import type { ExternalChannelSessionStatus } from '@shennian/wire';
 export declare const PLATFORM_OUTPUT_INSTRUCTIONS = "## Shennian Output Instructions\n\nWhen you mention a local file that the user may want to open in Shennian, format it as a Markdown link using the exact local path:\n\n- Use [filename.ext](</absolute/path/to/filename.ext>) for absolute Unix, macOS, or Windows paths.\n- Use [filename.ext](<relative/path/to/filename.ext>) for paths relative to the current working directory.\n- Do not use file:// URLs for local files.\n- Do not put user-openable file paths only inside code blocks.\n- Keep normal http:// and https:// links unchanged.";
-export declare function buildPlatformInstructions(workDir: string): string;
-export declare function ensurePlatformInstructionsFile(workDir: string): string;
+export declare function buildPlatformInstructions(workDir: string, externalChannel?: ExternalChannelSessionStatus | null): string;
+export declare function ensurePlatformInstructionsFile(workDir: string, externalChannel?: ExternalChannelSessionStatus | null): string;

package/dist/src/agents/platform-instructions.js

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { resolveShennianPath } from '../config/index.js';
+import { buildExternalChannelInstructions } from './external-channel-instructions.js';
 export const PLATFORM_OUTPUT_INSTRUCTIONS = `## Shennian Output Instructions
 
 When you mention a local file that the user may want to open in Shennian, format it as a Markdown link using the exact local path:
@@ -22,21 +23,28 @@ function readProjectAgentsMd(workDir) {
         return '';
     }
 }
-export function buildPlatformInstructions(workDir) {
+export function buildPlatformInstructions(workDir, externalChannel) {
     const projectInstructions = readProjectAgentsMd(workDir);
+    const channelInstructions = buildExternalChannelInstructions(externalChannel);
     const sections = [
         '# Shennian Agent Instructions',
         projectInstructions
             ? `## Project Instructions\n\n${projectInstructions}`
             : '',
         PLATFORM_OUTPUT_INSTRUCTIONS,
+        channelInstructions
+            ? `## External Message Channel Instructions\n\n${channelInstructions}`
+            : '',
     ].filter(Boolean);
     return `${sections.join('\n\n')}\n`;
 }
-export function ensurePlatformInstructionsFile(workDir) {
-    const key = createHash('sha256').update(path.resolve(workDir)).digest('hex').slice(0, 16);
+export function ensurePlatformInstructionsFile(workDir, externalChannel) {
+    const key = createHash('sha256')
+        .update(`${path.resolve(workDir)}:${JSON.stringify(externalChannel ?? null)}`)
+        .digest('hex')
+        .slice(0, 16);
     const filePath = resolveShennianPath('runtime', 'agent-instructions', `${key}.md`);
-    const content = buildPlatformInstructions(workDir);
+    const content = buildPlatformInstructions(workDir, externalChannel);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     try {
         if (fs.readFileSync(filePath, 'utf8') === content)

package/dist/src/channels/base.d.ts

@@ -3,8 +3,12 @@ export type ExternalChannelConfig = {
     id: string;
     type: ExternalChannelType;
     name: string;
+    sessionId?: string;
     managerSessionId: string;
     workDir: string;
+    agentType?: string;
+    agentSessionId?: string | null;
+    modelId?: string | null;
     enabled: boolean;
     secretRef: string;
 };
@@ -12,8 +16,12 @@ export type ExternalChannelView = {
     id: string;
     type: ExternalChannelType;
     name: string;
+    sessionId?: string;
     managerSessionId: string;
     workDir: string;
+    agentType?: string;
+    agentSessionId?: string | null;
+    modelId?: string | null;
     enabled: boolean;
     wsUrl?: string;
     token?: string;

package/dist/src/channels/runtime.d.ts

@@ -5,7 +5,7 @@ export declare class ChannelRuntime {
     private configs;
     private secrets;
     private adapters;
-    constructor(onExternalMessage: (managerSessionId: string, event: ExternalMessageEvent) => void, createReplyTarget: (input: {
+    constructor(onExternalMessage: (sessionId: string, event: ExternalMessageEvent) => void, createReplyTarget: (input: {
         managerSessionId: string;
         channelId: string;
         conversationId: string;
@@ -24,19 +24,24 @@ export declare class ChannelRuntime {
         ok: false;
         error: string;
     }>;
-    getDefaultReplyTarget(managerSessionId: string): Promise<{
+    getDefaultReplyTarget(sessionId: string): Promise<{
         channelId: string;
         conversationId: string;
     }>;
     getManagerChannel(managerSessionId: string, type: ExternalChannelConfig['type'], opts?: {
         includeSecret?: boolean;
     }): ExternalChannelView | null;
+    getChannelById(channelId: string, opts?: {
+        includeSecret?: boolean;
+    }): ExternalChannelView | null;
     getManagerChannelStatus(managerSessionId: string): {
         configured: boolean;
         connected: boolean;
         type?: string;
         channelId?: string;
         name?: string;
+        canReply?: boolean;
+        systemPrompt?: string;
     } | null;
     listManagerChannelStatuses(): Array<{
         managerSessionId: string;
@@ -52,9 +57,13 @@ export declare class ChannelRuntime {
     upsertManagerChannel(input: {
         id: string;
         managerSessionId: string;
+        sessionId?: string;
         workDir: string;
         type: 'websocket';
         name?: string;
+        agentType?: string;
+        agentSessionId?: string | null;
+        modelId?: string | null;
         enabled: boolean;
         wsUrl?: string;
         token?: string;

package/dist/src/channels/runtime.js

@@ -30,23 +30,23 @@ export class ChannelRuntime {
     }
     ingest(event) {
         const config = this.configs.get(event.channelId);
-        const managerSessionId = event.managerSessionId ?? config?.managerSessionId;
-        if (!managerSessionId)
-            throw new Error(`No manager bound for channel ${event.channelId}`);
+        const sessionId = event.managerSessionId ?? config?.sessionId ?? config?.managerSessionId;
+        if (!sessionId)
+            throw new Error(`No session bound for channel ${event.channelId}`);
         const replyTarget = event.replyTarget || this.createReplyTarget({
-            managerSessionId,
+            managerSessionId: sessionId,
             channelId: event.channelId,
             conversationId: event.conversationId,
             messageId: event.messageId,
         });
-        this.onExternalMessage(managerSessionId, { ...event, replyTarget });
+        this.onExternalMessage(sessionId, { ...event, replyTarget });
     }
     async reply(input) {
         const config = this.configs.get(input.channelId);
         if (!config)
             return { ok: false, error: `Unknown channel: ${input.channelId}` };
-        if (config.managerSessionId !== input.managerSessionId) {
-            return { ok: false, error: 'Channel is not bound to this manager' };
+        if ((config.sessionId ?? config.managerSessionId) !== input.managerSessionId) {
+            return { ok: false, error: 'Channel is not bound to this session' };
         }
         const adapter = this.adapters.get(config.type);
         if (!adapter)
@@ -59,10 +59,10 @@ export class ChannelRuntime {
             return { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
     }
-    async getDefaultReplyTarget(managerSessionId) {
-        const config = this.configs.list().find((channel) => channel.managerSessionId === managerSessionId && channel.enabled);
+    async getDefaultReplyTarget(sessionId) {
+        const config = this.configs.list().find((channel) => (channel.sessionId ?? channel.managerSessionId) === sessionId && channel.enabled);
         if (!config)
-            throw new Error('No enabled external channel is bound to this manager');
+            throw new Error('No enabled external channel is bound to this session');
         const adapter = this.adapters.get(config.type);
         if (!adapter?.defaultConversation)
             throw new Error(`External channel ${config.type} has no default conversation`);
@@ -74,7 +74,7 @@ export class ChannelRuntime {
     }
     getManagerChannel(managerSessionId, type, opts = {}) {
         const configs = this.configs.list()
-            .filter((channel) => channel.managerSessionId === managerSessionId && channel.type === type);
+            .filter((channel) => (channel.sessionId ?? channel.managerSessionId) === managerSessionId && channel.type === type);
         const config = configs.find((channel) => channel.enabled) ?? configs.at(-1);
         if (!config)
             return null;
@@ -83,8 +83,35 @@ export class ChannelRuntime {
             id: config.id,
             type: config.type,
             name: config.name,
+            sessionId: config.sessionId ?? config.managerSessionId,
             managerSessionId: config.managerSessionId,
             workDir: config.workDir,
+            agentType: config.agentType,
+            agentSessionId: config.agentSessionId,
+            modelId: config.modelId,
+            enabled: config.enabled,
+            wsUrl: secret?.wsUrl ?? '',
+            token: opts.includeSecret ? secret?.token ?? '' : '',
+            tokenConfigured: Boolean(secret?.token),
+            canReply: Boolean(secret?.canReply),
+            systemPrompt: typeof secret?.systemPrompt === 'string' ? secret.systemPrompt : '',
+        };
+    }
+    getChannelById(channelId, opts = {}) {
+        const config = this.configs.get(channelId);
+        if (!config)
+            return null;
+        const secret = this.secrets.get(config.secretRef);
+        return {
+            id: config.id,
+            type: config.type,
+            name: config.name,
+            sessionId: config.sessionId ?? config.managerSessionId,
+            managerSessionId: config.managerSessionId,
+            workDir: config.workDir,
+            agentType: config.agentType,
+            agentSessionId: config.agentSessionId,
+            modelId: config.modelId,
             enabled: config.enabled,
             wsUrl: secret?.wsUrl ?? '',
             token: opts.includeSecret ? secret?.token ?? '' : '',
@@ -94,7 +121,7 @@ export class ChannelRuntime {
         };
     }
     getManagerChannelStatus(managerSessionId) {
-        const config = this.configs.list().find((channel) => channel.managerSessionId === managerSessionId && channel.enabled);
+        const config = this.configs.list().find((channel) => (channel.sessionId ?? channel.managerSessionId) === managerSessionId && channel.enabled);
         if (!config)
             return null;
         const secret = this.secrets.get(config.secretRef);
@@ -104,32 +131,39 @@ export class ChannelRuntime {
             type: config.type,
             channelId: config.id,
             name: config.name,
+            canReply: Boolean(secret?.canReply),
+            systemPrompt: typeof secret?.systemPrompt === 'string' ? secret.systemPrompt : '',
         };
     }
     listManagerChannelStatuses() {
         return this.configs.list()
             .filter((channel) => channel.enabled)
             .map((channel) => ({
-            managerSessionId: channel.managerSessionId,
-            status: this.getManagerChannelStatus(channel.managerSessionId),
+            managerSessionId: channel.sessionId ?? channel.managerSessionId,
+            status: this.getManagerChannelStatus(channel.sessionId ?? channel.managerSessionId),
         }))
             .filter((entry) => Boolean(entry.status));
     }
     listManagerChannelSystemPrompts(managerSessionId) {
         return this.configs.list()
-            .filter((channel) => channel.enabled && channel.managerSessionId === managerSessionId)
+            .filter((channel) => channel.enabled && (channel.sessionId ?? channel.managerSessionId) === managerSessionId)
             .map((channel) => this.secrets.get(channel.secretRef)?.systemPrompt)
             .filter((prompt) => typeof prompt === 'string' && prompt.trim().length > 0);
     }
     async upsertManagerChannel(input) {
         const previous = this.configs.get(input.id);
         const allConfigs = this.configs.list();
+        const boundSessionId = input.sessionId || input.managerSessionId;
         const nextConfig = {
             id: input.id,
             type: input.type,
             name: input.name?.trim() || previous?.name || '外部消息通道',
-            managerSessionId: input.managerSessionId,
+            sessionId: boundSessionId,
+            managerSessionId: boundSessionId,
             workDir: input.workDir,
+            agentType: input.agentType || previous?.agentType,
+            agentSessionId: input.agentSessionId ?? previous?.agentSessionId ?? null,
+            modelId: input.modelId ?? previous?.modelId ?? null,
             enabled: input.enabled,
             secretRef: previous?.secretRef || `channel:${input.id}`,
         };
@@ -143,7 +177,7 @@ export class ChannelRuntime {
         }
         const configs = allConfigs
             .filter((channel) => channel.id !== nextConfig.id)
-            .map((channel) => channel.managerSessionId === input.managerSessionId && channel.type === input.type
+            .map((channel) => (channel.sessionId ?? channel.managerSessionId) === boundSessionId && channel.type === input.type
             ? { ...channel, enabled: false }
             : channel);
         configs.push(nextConfig);
@@ -159,13 +193,13 @@ export class ChannelRuntime {
         }
         const adapter = this.adapters.get(nextConfig.type);
         for (const config of allConfigs) {
-            if (config.managerSessionId === input.managerSessionId && config.type === input.type && config.enabled) {
+            if ((config.sessionId ?? config.managerSessionId) === boundSessionId && config.type === input.type && config.enabled) {
                 await this.adapters.get(config.type)?.disconnect(config).catch(() => { });
             }
         }
         if (nextConfig.enabled) {
             void adapter?.connect(nextConfig).catch(() => { });
         }
-        return this.getManagerChannel(input.managerSessionId, input.type, { includeSecret: true });
+        return this.getManagerChannel(boundSessionId, input.type, { includeSecret: true });
     }
 }

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

@@ -28,9 +28,9 @@ export declare function resolveServiceLaunchSpec(input: {
     scriptPath: string;
     shennianCommandPath?: string | null;
     npxPath?: string | null;
-    desktopBridgePath?: string | null;
 }): ServiceLaunchSpec;
 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;

package/dist/src/commands/daemon.js

@@ -33,9 +33,6 @@ const SAFE_SNAPSHOT_ENV_KEYS = new Set([
     'TMP',
     'APPDATA',
     'LOCALAPPDATA',
-    'ELECTRON_RUN_AS_NODE',
-    'SHENNIAN_DESKTOP_CLI_SCRIPT',
-    'SHENNIAN_DESKTOP_CLI_BRIDGE',
     'SHENNIAN_DESKTOP_SERVER_URL',
     'SHENNIAN_HOME',
 ]);
@@ -57,16 +54,6 @@ export function isEphemeralCliPath(candidate) {
         normalized.startsWith(tmp.endsWith('/') ? tmp : `${tmp}/`));
 }
 export function resolveServiceLaunchSpec(input) {
-    if (process.env.ELECTRON_RUN_AS_NODE === '1' &&
-        input.desktopBridgePath &&
-        fs.existsSync(input.scriptPath) &&
-        fs.existsSync(input.desktopBridgePath)) {
-        return {
-            command: input.nodeExec,
-            args: [input.desktopBridgePath, input.scriptPath, 'run-service'],
-            mode: 'direct',
-        };
-    }
     if (fs.existsSync(input.scriptPath) && !isEphemeralCliPath(input.scriptPath)) {
         return {
             command: input.nodeExec,
@@ -117,8 +104,16 @@ function isRunning(pid) {
 export function isRemoteAccessDisabled() {
     return fs.existsSync(REMOTE_ACCESS_DISABLED_FILE);
 }
+export function clearRemoteAccessDisabled() {
+    try {
+        fs.unlinkSync(REMOTE_ACCESS_DISABLED_FILE);
+    }
+    catch {
+        // Remote access may already be enabled.
+    }
+}
 export function getCurrentProcessDaemonLauncher() {
-    return process.env.SHENNIAN_DESKTOP_CLI_SCRIPT ? 'desktop-managed' : 'global-cli';
+    return 'global-cli';
 }
 export function writeDaemonLauncher(pid, launcher = getCurrentProcessDaemonLauncher()) {
     fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
@@ -164,9 +159,6 @@ function inferDaemonLauncherFromProcess(pid) {
             stdio: ['ignore', 'pipe', 'ignore'],
             timeout: 1000,
         }).replace(/\\/g, '/');
-        if (command.includes('/cli-bridge.js') || command.includes('/Resources/daemon/')) {
-            return 'desktop-managed';
-        }
         if (command.includes('/node_modules/shennian/') ||
             command.includes('/bin/shennian') ||
             command.includes(' shennian run-service') ||
@@ -259,7 +251,6 @@ function resolveCurrentServiceLaunchSpec() {
         scriptPath: SHENNIAN_SCRIPT,
         shennianCommandPath: findCommandPath('shennian'),
         npxPath: resolveNpxPath(),
-        desktopBridgePath: process.env.SHENNIAN_DESKTOP_CLI_BRIDGE,
     });
 }
 function escapeXml(text) {
@@ -655,12 +646,7 @@ async function stopDaemonProcessAndWait(timeoutMs = 5000) {
 }
 function enableRemoteAccess(opts = {}) {
     persistServerUrlOverride(resolveServerUrlOverride(opts.api));
-    try {
-        fs.unlinkSync(REMOTE_ACCESS_DISABLED_FILE);
-    }
-    catch {
-        // Remote access may already be enabled.
-    }
+    clearRemoteAccessDisabled();
     const startedByService = installService();
     if (!startedByService) {
         startDaemonProcess({ quiet: opts.json });

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

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

package/dist/src/commands/external.js

@@ -0,0 +1,45 @@
+// @arch docs/features/wecom-managed-channel.md
+// @test src/__tests__/platform-instructions.test.ts
+import chalk from 'chalk';
+function requireExternalContext() {
+    const url = process.env.SHENNIAN_MANAGER_IPC_URL;
+    const token = process.env.SHENNIAN_MANAGER_IPC_TOKEN;
+    const sessionId = process.env.SHENNIAN_EXTERNAL_SESSION_ID || process.env.SHENNIAN_MANAGER_SESSION_ID;
+    if (!url || !token || !sessionId) {
+        console.error(chalk.red('✗ This command must run inside a Shennian conversation with an external channel.'));
+        process.exit(1);
+    }
+    return { url, token, sessionId };
+}
+async function sendExternal(text, idempotencyKey) {
+    const ctx = requireExternalContext();
+    const response = await fetch(`${ctx.url}/external/reply`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${ctx.token}`,
+            'content-type': 'application/json',
+            'x-shennian-manager-session-id': ctx.sessionId,
+        },
+        body: JSON.stringify({
+            managerSessionId: ctx.sessionId,
+            text,
+            idempotencyKey,
+        }),
+    });
+    const data = await response.json().catch(() => ({ ok: false, error: response.statusText }));
+    if (!response.ok || !data.ok) {
+        throw new Error(data.error || `External send failed: ${response.status}`);
+    }
+    console.log('ok');
+}
+export function registerExternalCommand(program) {
+    const external = program.command('external').description('External channel tools for this Shennian conversation');
+    external
+        .command('send')
+        .description('Send a message to the external channel bound to this conversation')
+        .requiredOption('--text <text>', 'Message text')
+        .option('--idempotency-key <key>', 'Idempotency key')
+        .action(async (opts) => {
+        await sendExternal(opts.text, opts.idempotencyKey);
+    });
+}

package/dist/src/commands/pair.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import readline from 'node:readline';
 import { loadConfig, saveConfig } from '../config/index.js';
 import { detectAgents } from '../agents/detect.js';
-import { startDaemonProcess, installService, saveEnvSnapshot } from './daemon.js';
+import { clearRemoteAccessDisabled, startDaemonProcess, installService, saveEnvSnapshot, } from './daemon.js';
 import { detectAndChooseServer } from '../region.js';
 import { buildPairQrPayload, PAIR_QR_RENDER_OPTIONS } from './pair-qr.js';
 const POLL_INTERVAL_MS = 3000;
@@ -214,6 +214,7 @@ export async function runSmartStart(serverUrl, machineName) {
         console.log(chalk.green(`✓ Already paired (machine ID: ${config.machineId})`));
     }
     saveEnvSnapshot();
+    clearRemoteAccessDisabled();
     console.log(chalk.gray('\nStarting background service...'));
     const startedByService = installService();
     if (!startedByService) {
@@ -271,6 +272,7 @@ export function registerPairCommand(program) {
         const serverUrl = opts.server ?? opts.api ?? (await detectAndChooseServer());
         await runPairFlow({ serverUrl, machineName: opts.name, force: true, json: Boolean(opts.json) });
         saveEnvSnapshot();
+        clearRemoteAccessDisabled();
         if (opts.json)
             emitPairJson({ type: 'daemon.starting' });
         else

package/dist/src/index.js

@@ -11,6 +11,7 @@ import { registerPairCommand, runSmartStart } from './commands/pair.js';
 import { clearDaemonLauncher, isRemoteAccessDisabled, registerDaemonCommand, writeDaemonLauncher, } from './commands/daemon.js';
 import { registerAgentCommand } from './commands/agent.js';
 import { registerManagerCommand } from './commands/manager.js';
+import { registerExternalCommand } from './commands/external.js';
 import { registerUpgradeCommand } from './commands/upgrade.js';
 import { SessionManager } from './session/manager.js';
 import { SERVERS, regionToUrl, urlToRegion } from './region.js';
@@ -106,8 +107,7 @@ program
                 process.kill(oldPid, 0);
                 const serviceManagedStart = Boolean(process.env.INVOCATION_ID ||
                     process.env.JOURNAL_STREAM ||
-                    process.env.SHENNIAN_DESKTOP_CLI_SCRIPT ||
-                    process.env.SHENNIAN_DESKTOP_CLI_BRIDGE);
+                    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');
@@ -325,6 +325,7 @@ registerPairCommand(program);
 registerDaemonCommand(program);
 registerAgentCommand(program);
 registerManagerCommand(program);
+registerExternalCommand(program);
 registerUpgradeCommand(program);
 program.parse();
 // ─── Auto-upgrade helper ──────────────────────────────────────────────────────

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

@@ -42,8 +42,10 @@ export declare class ManagerRuntimeService {
     private handleIpc;
     private dispatchChatSend;
     private dispatchChatEnqueue;
+    private sendManagedWeComReply;
     private wakeManagerForWorker;
     private handleExternalMessage;
+    private dispatchExternalMessage;
     private scanWorkerHealth;
     private interruptAndResumeManager;
     bindManagerAdapterEvents(sessionId: string, adapter: AgentAdapter): void;
@@ -54,6 +56,8 @@ export declare class ManagerRuntimeService {
         type?: string;
         channelId?: string;
         name?: string;
+        canReply?: boolean;
+        systemPrompt?: string;
     } | null;
     getManagerExternalChannelSystemPrompt(managerSessionId: string): string;
 }

package/dist/src/manager/runtime.js

@@ -107,6 +107,9 @@ function appJson(runtime, reqId, ok, payload) {
         ...(ok ? { payload } : { error: String(payload.error || 'unknown error') }),
     });
 }
+function shouldFallbackToLocalChannel(error) {
+    return /binding not found|unknown method|not supported|relay is not connected|no external channel/i.test(error);
+}
 export class ManagerRuntimeService {
     opts;
     registry = new ManagerRegistry();
@@ -237,10 +240,8 @@ export class ManagerRuntimeService {
         try {
             const managerSessionId = String(body.managerSessionId || body.sessionId || '');
             if (!managerSessionId)
-                throw new Error('managerSessionId is required');
+                throw new Error('sessionId is required');
             const manager = this.registry.getManager(managerSessionId);
-            if (!manager)
-                throw new Error('Manager runtime is not registered');
             if (req.method === 'manager.channel.get') {
                 appJson(runtime, req.id, true, {
                     channel: this.channelRuntime.getManagerChannel(managerSessionId, 'websocket', { includeSecret: true }),
@@ -251,9 +252,13 @@ export class ManagerRuntimeService {
                 const channel = await this.channelRuntime.upsertManagerChannel({
                     id: String(body.id || `websocket:${managerSessionId}`),
                     managerSessionId,
-                    workDir: manager.workDir,
+                    sessionId: managerSessionId,
+                    workDir: String(body.workDir || manager?.workDir || ''),
                     type: 'websocket',
                     name: typeof body.name === 'string' ? body.name : undefined,
+                    agentType: typeof body.agentType === 'string' ? body.agentType : undefined,
+                    agentSessionId: typeof body.agentSessionId === 'string' ? body.agentSessionId : null,
+                    modelId: typeof body.modelId === 'string' ? body.modelId : null,
                     enabled: Boolean(body.enabled),
                     wsUrl: typeof body.wsUrl === 'string' ? body.wsUrl : undefined,
                     token: typeof body.token === 'string' ? body.token : undefined,
@@ -287,7 +292,7 @@ export class ManagerRuntimeService {
             payload: {
                 session: {
                     id: managerSessionId,
-                    agentType: 'manager',
+                    agentType: manager ? 'manager' : undefined,
                     agentSessionId: manager?.agentSessionId ?? null,
                     modelId: manager?.modelId ?? null,
                     workDir: manager?.workDir,
@@ -308,9 +313,9 @@ export class ManagerRuntimeService {
             if (!managerSessionId)
                 throw new Error('managerSessionId is required');
             const manager = this.registry.getManager(managerSessionId);
-            if (!manager)
-                throw new Error('Manager runtime is not registered');
             if (url.pathname === '/sessions/list') {
+                if (!manager)
+                    throw new Error('Manager runtime is not registered');
                 const runningSessionIds = new Set(this.opts.getRuntime().sessions.keys());
                 json(res, 200, {
                     ok: true,
@@ -319,6 +324,8 @@ export class ManagerRuntimeService {
                 return;
             }
             if (url.pathname === '/sessions/start') {
+                if (!manager)
+                    throw new Error('Manager runtime is not registered');
                 const agentType = String(body.agentType || body.agent || 'codex');
                 if (agentType === 'manager')
                     throw new Error('Manager cannot start another manager as a worker');
@@ -423,6 +430,8 @@ export class ManagerRuntimeService {
                 return;
             }
             if (url.pathname === '/memory/path') {
+                if (!manager)
+                    throw new Error('Manager runtime is not registered');
                 json(res, 200, { ok: true, path: path.join(manager.workDir, '.shennian') });
                 return;
             }
@@ -430,6 +439,28 @@ export class ManagerRuntimeService {
                 const replyTarget = typeof body.replyTarget === 'string'
                     ? this.registry.getReplyTarget(body.replyTarget)
                     : this.registry.getLatestReplyTargetForManager(managerSessionId);
+                const text = String(body.text || '');
+                const idempotencyKey = String(body.idempotencyKey || randomUUID());
+                try {
+                    const relayResult = await this.sendManagedWeComReply({
+                        managerSessionId,
+                        text,
+                        idempotencyKey,
+                    });
+                    if (relayResult.ok) {
+                        json(res, 200, { ok: true, payload: relayResult.payload });
+                        return;
+                    }
+                    if (!shouldFallbackToLocalChannel(relayResult.error || '')) {
+                        json(res, 400, { ok: false, error: relayResult.error || 'External send failed' });
+                        return;
+                    }
+                }
+                catch (error) {
+                    if (!shouldFallbackToLocalChannel(error instanceof Error ? error.message : String(error))) {
+                        throw error;
+                    }
+                }
                 const explicitChannelId = String(body.channelId || '');
                 const explicitConversationId = String(body.conversationId || '');
                 const defaultTarget = !replyTarget && (!explicitChannelId || !explicitConversationId)
@@ -444,8 +475,8 @@ export class ManagerRuntimeService {
                     channelId,
                     conversationId,
                     messageId: replyTarget?.messageId ?? undefined,
-                    text: String(body.text || ''),
-                    idempotencyKey: String(body.idempotencyKey || randomUUID()),
+                    text,
+                    idempotencyKey,
                 });
                 json(res, result.ok ? 200 : 400, result);
                 return;
@@ -458,6 +489,8 @@ export class ManagerRuntimeService {
                 return;
             }
             if (url.pathname === '/channel/upsert') {
+                if (!manager)
+                    throw new Error('Manager runtime is not registered');
                 const channel = await this.channelRuntime.upsertManagerChannel({
                     id: String(body.id || `websocket:${managerSessionId}`),
                     managerSessionId,
@@ -500,6 +533,27 @@ export class ManagerRuntimeService {
             params: { sessionId, text, agentType, workDir, agentSessionId, modelId },
         });
     }
+    async sendManagedWeComReply(input) {
+        if (!input.text.trim())
+            return { ok: false, error: 'text is required' };
+        const client = this.opts.getRuntime().client;
+        if (!client || typeof client.sendReq !== 'function') {
+            return { ok: false, error: 'Relay is not connected' };
+        }
+        const frame = await client.sendReq({
+            type: 'req',
+            id: `wecom-send-${randomUUID()}`,
+            method: 'wecom.send',
+            params: {
+                managerSessionId: input.managerSessionId,
+                text: input.text,
+                idempotencyKey: input.idempotencyKey,
+            },
+        });
+        return frame.ok
+            ? { ok: true, payload: frame.payload }
+            : { ok: false, error: frame.error || 'External send failed' };
+    }
     wakeManagerForWorker(managerSessionId, worker, state, message) {
         const manager = this.registry.getManager(managerSessionId);
         if (!manager)
@@ -515,11 +569,45 @@ ${message || worker.summary || '(无可见摘要)'}
         void this.interruptAndResumeManager(manager, prompt, state === 'final' ? 'worker.final' : `worker.${state}`);
     }
     handleExternalMessage(managerSessionId, event) {
+        const config = this.channelRuntime.getChannelById(event.channelId)
+            ?? this.channelRuntime.getManagerChannel(managerSessionId, event.channelType);
         const manager = this.registry.getManager(managerSessionId);
-        if (!manager)
-            return;
+        const agentType = (config?.agentType || (manager ? 'manager' : 'codex'));
+        const workDir = config?.workDir || manager?.workDir || process.cwd();
+        const agentSessionId = config?.agentSessionId ?? manager?.agentSessionId ?? null;
+        const modelId = config?.modelId || manager?.modelId || '';
         const visibleMessage = `外部消息 / ${event.sender.name || event.sender.id}\n${event.text}`;
-        void this.interruptAndResumeManager(manager, visibleMessage);
+        this.registry.createReplyTarget({
+            managerSessionId,
+            channelId: event.channelId,
+            conversationId: event.conversationId,
+            messageId: event.messageId,
+        });
+        void this.dispatchExternalMessage({
+            sessionId: managerSessionId,
+            agentType,
+            workDir,
+            agentSessionId,
+            modelId,
+            text: visibleMessage,
+            replyTarget: event.replyTarget,
+        });
+    }
+    async dispatchExternalMessage(input) {
+        await this.opts.dispatchReq({
+            type: 'req',
+            id: `external-enqueue-${randomUUID()}`,
+            method: 'chat.enqueue',
+            params: {
+                sessionId: input.sessionId,
+                text: input.text,
+                agentType: input.agentType,
+                workDir: input.workDir,
+                agentSessionId: input.agentSessionId,
+                modelId: input.modelId,
+                origin: 'external',
+            },
+        });
     }
     scanWorkerHealth() {
         const now = Date.now();

package/dist/src/relay/client.d.ts

@@ -33,11 +33,13 @@ export declare class CliRelayClient {
     /** Buffered agent events awaiting server ack, keyed by event id */
     private sendBuffer;
     private pendingAcks;
+    private pendingRequests;
     constructor(options: CliRelayOptions);
     connect(): void;
     disconnect(): void;
     sendRes(res: ResFrame): void;
     sendEvent(event: EventFrame): void;
+    sendReq(req: ReqFrame, timeoutMs?: number): Promise<ResFrame>;
     sendBufferedEvent(event: EventFrame, timeoutMs?: number): Promise<void>;
     /**
      * Send an agent event with at-least-once delivery guarantee.

package/dist/src/relay/client.js

@@ -26,6 +26,7 @@ export class CliRelayClient {
     /** Buffered agent events awaiting server ack, keyed by event id */
     sendBuffer = new Map();
     pendingAcks = new Map();
+    pendingRequests = new Map();
     constructor(options) {
         this.options = options;
     }
@@ -121,6 +122,26 @@ export class CliRelayClient {
             event.traceId = generateTraceId();
         this.ws.send(JSON.stringify(event));
     }
+    sendReq(req, timeoutMs = 60_000) {
+        if (this.state !== 'connected' || !this.ws) {
+            return Promise.reject(new Error('Relay is not connected'));
+        }
+        if (!req.traceId)
+            req.traceId = generateTraceId();
+        return new Promise((resolve, reject) => {
+            const existing = this.pendingRequests.get(req.id);
+            if (existing) {
+                clearTimeout(existing.timer);
+                existing.reject(new Error('Superseded by a newer relay request'));
+            }
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(req.id);
+                reject(new Error('Relay request timed out'));
+            }, timeoutMs);
+            this.pendingRequests.set(req.id, { resolve, reject, timer });
+            this.ws?.send(JSON.stringify(req));
+        });
+    }
     sendBufferedEvent(event, timeoutMs = 120_000) {
         if (!event.traceId)
             event.traceId = generateTraceId();
@@ -172,6 +193,12 @@ export class CliRelayClient {
                 else
                     pending.reject(new Error(frame.error ?? 'Relay event failed'));
             }
+            const pendingRequest = this.pendingRequests.get(frame.id);
+            if (pendingRequest) {
+                this.pendingRequests.delete(frame.id);
+                clearTimeout(pendingRequest.timer);
+                pendingRequest.resolve(frame);
+            }
             return;
         }
         if (frame.type === 'req') {
@@ -300,6 +327,11 @@ export class CliRelayClient {
                 // already closed
             }
         }
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Relay client disconnected'));
+            this.pendingRequests.delete(id);
+        }
         if (rejectAll) {
             for (const [id, pending] of this.pendingAcks) {
                 clearTimeout(pending.timer);

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

@@ -6,6 +6,7 @@ import { reportLog } from '../../log-reporter.js';
 import { lookupClaudeTranscriptCwd } from '../../native-fusion/parsers.js';
 import { appendMessage, recordSession } from '../store.js';
 import { mergeProjectedSessions } from '../projection.js';
+import { getManagerRuntimeService } from '../../manager/runtime.js';
 function extractSummary(text) {
     const newline = text.indexOf('\n');
     const end = newline > 0 ? Math.min(newline, 80) : Math.min(text.length, 80);
@@ -30,9 +31,7 @@ function sendSessionMessageEvent(runtime, envelope, session) {
                 modelId: session.modelId ?? null,
                 workDir: session.workDir,
                 status: 'active',
-                ...(session.agentType === 'manager'
-                    ? { externalChannel: runtime.managerRuntime?.getExternalChannelStatus(envelope.sessionId) ?? null }
-                    : {}),
+                externalChannel: getSessionExternalChannel(runtime, envelope.sessionId, session.agentType),
             },
         },
     });
@@ -56,13 +55,53 @@ function sendSessionUpdateEvent(runtime, input) {
                 modelId: input.modelId ?? null,
                 workDir: input.workDir,
                 status: 'active',
-                ...(input.agentType === 'manager'
-                    ? { externalChannel: runtime.managerRuntime?.getExternalChannelStatus(input.sessionId) ?? null }
-                    : {}),
+                externalChannel: getSessionExternalChannel(runtime, input.sessionId, input.agentType),
             },
         },
     });
 }
+function normalizeExternalChannel(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    return {
+        configured: raw.configured === undefined ? undefined : Boolean(raw.configured),
+        connected: Boolean(raw.connected),
+        type: typeof raw.type === 'string' ? raw.type : null,
+        channelId: typeof raw.channelId === 'string' ? raw.channelId : null,
+        name: typeof raw.name === 'string' ? raw.name : null,
+        canReply: raw.canReply === undefined || raw.canReply === null ? null : Boolean(raw.canReply),
+        systemPrompt: typeof raw.systemPrompt === 'string' ? raw.systemPrompt : null,
+    };
+}
+function externalChannelEnabled(channel) {
+    return Boolean(channel?.configured ?? channel?.connected);
+}
+function externalChannelEnv(sessionId, channel) {
+    if (!externalChannelEnabled(channel))
+        return {};
+    const service = getManagerRuntimeService();
+    const injected = service?.getInjectedEnv(sessionId, null, process.cwd(), 'external') ?? {};
+    return {
+        ...injected,
+        SHENNIAN_EXTERNAL_SESSION_ID: sessionId,
+        SHENNIAN_MANAGER_SESSION_ID: sessionId,
+    };
+}
+function configureAdapterForSession(adapter, sessionId, channel) {
+    adapter.configure?.({
+        externalChannel: channel ?? null,
+        env: externalChannelEnv(sessionId, channel),
+    });
+}
+function getSessionExternalChannel(runtime, sessionId, agentType) {
+    const active = runtime.sessions.get(sessionId);
+    if (active?.externalChannel)
+        return active.externalChannel;
+    if (agentType === 'manager')
+        return runtime.managerRuntime?.getExternalChannelStatus(sessionId) ?? null;
+    return null;
+}
 function maybeResolveClaudeImportedWorkDir(agentType, workDir, agentSessionId) {
     if (agentType !== 'claude')
         return workDir;
@@ -239,11 +278,12 @@ async function disposeSession(session) {
     session.adapter.removeAllListeners();
     await session.adapter.stop().catch(() => { });
 }
-async function createActiveSession(runtime, sessionId, agentType, resolvedWorkDir, incomingAgentSid) {
+async function createActiveSession(runtime, sessionId, agentType, resolvedWorkDir, incomingAgentSid, externalChannel) {
     runtime.evictIdleSessions();
     const adapter = createAgent(agentType);
     if (!adapter)
         throw new Error(`Unsupported agent: ${agentType}`);
+    configureAdapterForSession(adapter, sessionId, externalChannel);
     await adapter.start(sessionId, resolvedWorkDir, incomingAgentSid);
     const session = {
         adapter,
@@ -254,6 +294,8 @@ async function createActiveSession(runtime, sessionId, agentType, resolvedWorkDi
         currentRunId: null,
         nextEventSeq: 0,
         pendingTextEvent: null,
+        externalChannel: externalChannel ?? null,
+        externalChannelEnv: externalChannelEnv(sessionId, externalChannel),
     };
     runtime.sessions.set(sessionId, session);
     bindAdapterEvents(runtime, sessionId, agentType, adapter);
@@ -285,6 +327,7 @@ export async function handleChatSend(runtime, req) {
     rememberProcessedReqId(runtime, req.id);
     const { sessionId, text, agentType, workDir, agentSessionId: incomingAgentSid, modelId, reasoningEffort, clientMessageId, sessionListProjection, waitForDispatch } = req.params;
     mergeProjectedSessions(sessionListProjection);
+    const incomingExternalChannel = normalizeExternalChannel(req.params.externalChannel);
     if (!sessionId || !text) {
         runtime.processedReqIds.delete(req.id);
         runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'sessionId and text are required' });
@@ -301,7 +344,8 @@ export async function handleChatSend(runtime, req) {
     if (session) {
         session.lastActiveAt = Date.now();
         const sessionDrifted = session.agentType !== requestedAgentType ||
-            session.workDir !== resolvedWorkDir;
+            session.workDir !== resolvedWorkDir ||
+            JSON.stringify(session.externalChannel ?? null) !== JSON.stringify(incomingExternalChannel ?? null);
         if (sessionDrifted) {
             runtime.sessions.delete(sessionId);
             try {
@@ -331,7 +375,7 @@ export async function handleChatSend(runtime, req) {
     }
     if (!session) {
         try {
-            session = await createActiveSession(runtime, sessionId, requestedAgentType, resolvedWorkDir, incomingAgentSid);
+            session = await createActiveSession(runtime, sessionId, requestedAgentType, resolvedWorkDir, incomingAgentSid, incomingExternalChannel);
         }
         catch (err) {
             const message = err instanceof Error && err.message.startsWith('Unsupported agent:')

package/dist/src/session/queue.d.ts

@@ -15,6 +15,7 @@ export declare class ChatQueueManager {
     handleDelete(req: ReqFrame): Promise<void>;
     noteTerminal(sessionId: string): void;
     private drainNext;
+    private mergeExternalMessages;
     private dispatchQueuedMessage;
     private broadcast;
 }

package/dist/src/session/queue.js

@@ -3,6 +3,7 @@
 import fs from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { resolveShennianPath } from '../config/index.js';
+import { mergeProjectedSessions } from './projection.js';
 const QUEUE_FILE = resolveShennianPath('chat-queue.json');
 function emptyQueue() {
     return { sessions: {} };
@@ -56,6 +57,8 @@ function queueMessageFromParams(params) {
         reasoningEffort: params.reasoningEffort ?? null,
         clientMessageId: params.clientMessageId ?? null,
         attachments: normalizeAttachments(params.attachments),
+        externalChannel: params.externalChannel ?? null,
+        origin: params.origin,
         createdAt: timestamp,
         updatedAt: timestamp,
     };
@@ -76,6 +79,7 @@ export class ChatQueueManager {
     async handleEnqueue(req) {
         const runtime = this.opts.getRuntime();
         const params = req.params;
+        mergeProjectedSessions(params.sessionListProjection);
         if (!params.sessionId || !params.text || !params.agentType || !params.workDir) {
             runtime.client.sendRes({
                 type: 'res',
@@ -208,6 +212,9 @@ export class ChatQueueManager {
             this.broadcast(sessionId);
             return;
         }
+        const dispatchMessage = next.origin === 'external'
+            ? this.mergeExternalMessages(next, pending)
+            : next;
         if (pending.length)
             queue.sessions[sessionId] = pending;
         else
@@ -216,12 +223,30 @@ export class ChatQueueManager {
         this.broadcast(sessionId);
         this.draining.add(sessionId);
         try {
-            await this.dispatchQueuedMessage(next);
+            await this.dispatchQueuedMessage(dispatchMessage);
         }
         finally {
             this.draining.delete(sessionId);
         }
     }
+    mergeExternalMessages(first, pending) {
+        const batch = [first];
+        while (pending[0]?.origin === 'external') {
+            batch.push(pending.shift());
+        }
+        if (batch.length === 1)
+            return first;
+        return {
+            ...first,
+            id: `external-batch-${first.id}`,
+            text: batch.map((message, index) => {
+                const label = batch.length > 1 ? `外部消息 ${index + 1}/${batch.length}` : '外部消息';
+                return `${label}\n${message.text}`;
+            }).join('\n\n'),
+            attachments: batch.flatMap((message) => message.attachments ?? []),
+            updatedAt: nowIso(),
+        };
+    }
     async dispatchQueuedMessage(message) {
         await this.opts.dispatchReq({
             type: 'req',
@@ -237,6 +262,7 @@ export class ChatQueueManager {
                 reasoningEffort: message.reasoningEffort ?? undefined,
                 clientMessageId: message.clientMessageId ?? message.id,
                 attachments: message.attachments,
+                externalChannel: message.externalChannel,
             },
         });
     }

package/dist/src/session/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentType } from '@shennian/wire';
+import type { AgentType, ExternalChannelSessionStatus } from '@shennian/wire';
 import type { AgentAdapter } from '../agents/adapter.js';
 import type { CliRelayClient } from '../relay/client.js';
 import type { NativeSessionFusionService } from '../native-fusion/service.js';
@@ -17,6 +17,8 @@ export type ActiveSession = {
         text: string;
         thinking: boolean;
     } | null;
+    externalChannel?: ExternalChannelSessionStatus | null;
+    externalChannelEnv?: NodeJS.ProcessEnv;
 };
 export type PendingTransfer = {
     tempPath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.52",
+  "version": "0.2.53",
   "description": "Shennian — AI Agent Control Plane CLI",
   "type": "module",
   "bin": {