shennian 0.2.51 → 0.2.53

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

@@ -7,6 +7,10 @@ import path from 'node:path';
 import { buildUserMessagePayload, isToolPayload } from '@shennian/wire';
 import { resolveBuiltinCommand, spawnResolvedCommandSync } from '../agents/command-spec.js';
 const MAX_JSONL_LINE_BYTES = 64 * 1024 * 1024;
+const DEFAULT_NATIVE_SCAN_IGNORED_PATHS = [
+    '/root/.claude-mem/observer-session',
+];
+const DEFAULT_NATIVE_SCAN_IGNORED_CLAUDE_PROJECT_DIRS = DEFAULT_NATIVE_SCAN_IGNORED_PATHS.map(encodeClaudeProjectDir);
 function normalizeText(text) {
     return stripGitDirectiveArtifacts(text.replace(/\r\n/g, '\n').trim());
 }
@@ -103,6 +107,33 @@ function readClaudeEventCwd(parsed) {
 function isClaudeSubagentTranscript(filePath) {
     return path.basename(path.dirname(filePath)) === 'subagents';
 }
+function normalizePathForCompare(filePath) {
+    const normalized = path.resolve(filePath);
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function isSameOrChildPath(filePath, parentPath) {
+    const normalizedFilePath = normalizePathForCompare(filePath);
+    const normalizedParentPath = normalizePathForCompare(parentPath);
+    return normalizedFilePath === normalizedParentPath
+        || normalizedFilePath.startsWith(normalizedParentPath + path.sep);
+}
+function encodeClaudeProjectDir(filePath) {
+    return path.resolve(filePath).replace(/\//g, '-');
+}
+function shouldIgnoreNativeScanPath(filePath) {
+    return DEFAULT_NATIVE_SCAN_IGNORED_PATHS.some((ignoredPath) => isSameOrChildPath(filePath, ignoredPath));
+}
+function shouldIgnoreClaudeProjectDir(projectDirName) {
+    return DEFAULT_NATIVE_SCAN_IGNORED_CLAUDE_PROJECT_DIRS.includes(projectDirName);
+}
+function shouldIgnoreClaudeTranscriptPath(filePath) {
+    const root = path.join(os.homedir(), '.claude', 'projects');
+    const relative = path.relative(root, filePath);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+        return false;
+    const [projectDirName] = relative.split(path.sep);
+    return projectDirName ? shouldIgnoreClaudeProjectDir(projectDirName) : false;
+}
 function makeCursor(filePath, offset) {
     return `${filePath}:${offset}`;
 }
@@ -715,8 +746,11 @@ export function listClaudeTranscriptFiles() {
     const walk = (dir) => {
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
             const full = path.join(dir, entry.name);
-            if (entry.isDirectory())
+            if (entry.isDirectory()) {
+                if (dir === root && shouldIgnoreClaudeProjectDir(entry.name))
+                    continue;
                 walk(full);
+            }
             else if (entry.isFile() && entry.name.endsWith('.jsonl'))
                 files.push(full);
         }
@@ -805,12 +839,16 @@ export function parseCodexRolloutChunk(filePath, startOffset) {
     return { nextOffset, events };
 }
 export function parseClaudeTranscriptChunk(filePath, startOffset) {
-    if (isClaudeSubagentTranscript(filePath)) {
-        return { nextOffset: fs.statSync(filePath).size, events: [] };
+    const fileSize = fs.statSync(filePath).size;
+    if (isClaudeSubagentTranscript(filePath) || shouldIgnoreClaudeTranscriptPath(filePath)) {
+        return { nextOffset: fileSize, events: [] };
     }
     const events = [];
     const sourceSessionKey = path.basename(filePath, '.jsonl');
     const fallbackWorkDir = relativeProjectDir(path.dirname(filePath).replace(path.join(os.homedir(), '.claude', 'projects') + path.sep, ''));
+    if (shouldIgnoreNativeScanPath(fallbackWorkDir)) {
+        return { nextOffset: fileSize, events: [] };
+    }
     let title = '';
     const nextOffset = readJsonlLines(filePath, startOffset, (line, lineOffset) => {
         const parsed = safeParse(line);
@@ -820,6 +858,9 @@ export function parseClaudeTranscriptChunk(filePath, startOffset) {
         const type = typeof parsed.type === 'string' ? parsed.type : '';
         if (!ts || !type)
             return;
+        const eventCwd = readClaudeEventCwd(parsed);
+        if (eventCwd && shouldIgnoreNativeScanPath(eventCwd))
+            return;
         if (type === 'user') {
             const message = typeof parsed.message === 'object' && parsed.message !== null
                 ? parsed.message
@@ -839,7 +880,7 @@ export function parseClaudeTranscriptChunk(filePath, startOffset) {
                 ts,
                 payload: text,
                 title,
-                workDir: readClaudeEventCwd(parsed) ?? fallbackWorkDir,
+                workDir: eventCwd ?? fallbackWorkDir,
             });
         }
         else if (type === 'assistant') {
@@ -867,7 +908,7 @@ export function parseClaudeTranscriptChunk(filePath, startOffset) {
                 payload: text,
                 title,
                 modelId,
-                workDir: readClaudeEventCwd(parsed) ?? fallbackWorkDir,
+                workDir: eventCwd ?? fallbackWorkDir,
             });
         }
     });

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);
@@ -283,20 +325,27 @@ export async function handleChatSend(runtime, req) {
         return;
     }
     rememberProcessedReqId(runtime, req.id);
-    const { sessionId, text, agentType, workDir, agentSessionId: incomingAgentSid, modelId, clientMessageId, sessionListProjection, waitForDispatch } = req.params;
+    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' });
         return;
     }
     const requestedAgentType = agentType;
+    const resolvedReasoningEffort = (requestedAgentType === 'claude' || requestedAgentType === 'codex') &&
+        typeof reasoningEffort === 'string' &&
+        reasoningEffort.trim()
+        ? reasoningEffort.trim()
+        : undefined;
     const resolvedWorkDir = runtime.resolvePath(maybeResolveClaudeImportedWorkDir(requestedAgentType, workDir || os.homedir(), incomingAgentSid) || os.homedir());
     let session = runtime.sessions.get(sessionId);
     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 {
@@ -326,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:')
@@ -365,7 +414,7 @@ export async function handleChatSend(runtime, req) {
         level: 'info',
         sessionId,
         wsEvent: 'chat.send.start',
-        metadata: { reqId: req.id, agentType: requestedAgentType, modelId },
+        metadata: { reqId: req.id, agentType: requestedAgentType, modelId, reasoningEffort: resolvedReasoningEffort },
     });
     const markAccepted = () => {
         sendSessionUpdateEvent(runtime, {
@@ -424,7 +473,10 @@ export async function handleChatSend(runtime, req) {
     };
     if (waitForDispatch) {
         try {
-            await session.adapter.send(text, modelId);
+            if (resolvedReasoningEffort)
+                await session.adapter.send(text, modelId, resolvedReasoningEffort);
+            else
+                await session.adapter.send(text, modelId);
             reportLog({
                 level: 'info',
                 sessionId,
@@ -454,7 +506,10 @@ export async function handleChatSend(runtime, req) {
         wsEvent: 'chat.send.res',
         metadata: { reqId: req.id, ok: true },
     });
-    void session.adapter.send(text, modelId)
+    const sendPromise = resolvedReasoningEffort
+        ? session.adapter.send(text, modelId, resolvedReasoningEffort)
+        : session.adapter.send(text, modelId);
+    void sendPromise
         .then(() => {
         reportLog({
             level: 'info',

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: {} };
@@ -53,8 +54,11 @@ function queueMessageFromParams(params) {
         workDir: params.workDir,
         agentSessionId: params.agentSessionId ?? null,
         modelId: params.modelId ?? null,
+        reasoningEffort: params.reasoningEffort ?? null,
         clientMessageId: params.clientMessageId ?? null,
         attachments: normalizeAttachments(params.attachments),
+        externalChannel: params.externalChannel ?? null,
+        origin: params.origin,
         createdAt: timestamp,
         updatedAt: timestamp,
     };
@@ -75,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',
@@ -207,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
@@ -215,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',
@@ -233,8 +259,10 @@ export class ChatQueueManager {
                 workDir: message.workDir,
                 agentSessionId: message.agentSessionId ?? null,
                 modelId: message.modelId ?? undefined,
+                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.51",
+  "version": "0.2.53",
   "description": "Shennian — AI Agent Control Plane CLI",
   "type": "module",
   "bin": {