shennian 0.2.51 → 0.2.52

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

@@ -25,7 +25,7 @@ export interface AgentAdapterEvents {
 export declare abstract class AgentAdapter extends EventEmitter<AgentAdapterEvents> {
     abstract readonly type: AgentType;
     abstract start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
-    abstract send(text: string, modelId?: string): Promise<void>;
+    abstract send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
     abstract resume(agentSessionId: string): Promise<void>;
     abstract stop(): Promise<void>;
 }

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

@@ -1,5 +1,6 @@
 import { AgentAdapter } from './adapter.js';
 export declare function normalizeClaudeModelId(modelId?: string | null): string;
+export declare function normalizeClaudeReasoningEffort(reasoningEffort?: string | null): string | undefined;
 export declare class ClaudeAdapter extends AgentAdapter {
     private readonly options;
     readonly type: "claude";
@@ -16,7 +17,7 @@ export declare class ClaudeAdapter extends AgentAdapter {
         hidden?: boolean;
     });
     start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
-    send(text: string, modelId?: string): Promise<void>;
+    send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
     resume(agentSessionId: string): Promise<void>;
     stop(): Promise<void>;
     private spawnAndParse;

package/dist/src/agents/claude.js

@@ -8,6 +8,15 @@ export function normalizeClaudeModelId(modelId) {
     const trimmed = modelId?.trim();
     return trimmed || 'default';
 }
+const CLAUDE_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+export function normalizeClaudeReasoningEffort(reasoningEffort) {
+    const trimmed = reasoningEffort?.trim();
+    if (!trimmed)
+        return undefined;
+    if (CLAUDE_REASONING_EFFORTS.has(trimmed))
+        return trimmed;
+    throw new Error(`Unsupported Claude reasoning effort "${trimmed}". Supported values: low, medium, high, xhigh, max.`);
+}
 export class ClaudeAdapter extends AgentAdapter {
     options;
     type = 'claude';
@@ -30,7 +39,7 @@ export class ClaudeAdapter extends AgentAdapter {
         if (agentSessionId)
             this.agentSessionId = agentSessionId;
     }
-    async send(text, modelId) {
+    async send(text, modelId, reasoningEffort) {
         await this.killProcess();
         this.runId = randomUUID();
         this.resetRunState();
@@ -46,6 +55,10 @@ export class ClaudeAdapter extends AgentAdapter {
             args.push('--dangerously-skip-permissions');
         }
         args.push('--model', normalizeClaudeModelId(modelId));
+        const effort = normalizeClaudeReasoningEffort(reasoningEffort);
+        if (effort) {
+            args.push('--effort', effort);
+        }
         if (this.agentSessionId) {
             args.push('--resume', this.agentSessionId);
         }

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

@@ -26,7 +26,7 @@ export declare class CodexAdapter extends AgentAdapter {
         hidden?: boolean;
     });
     start(_sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
-    send(text: string, modelId?: string): Promise<void>;
+    send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
     resume(agentSessionId: string): Promise<void>;
     stop(): Promise<void>;
     private spawnCodex;
@@ -58,4 +58,6 @@ export declare class CodexAdapter extends AgentAdapter {
     private clearForceCloseTimer;
 }
 export declare function normalizeCodexModelId(modelId?: string | null): string | undefined;
+export declare function normalizeCodexReasoningEffort(reasoningEffort?: string | null): string | undefined;
 export declare function isMissingCodexRolloutError(error: unknown): boolean;
+export declare function isCodexUnsupportedEffortError(error: unknown): boolean;

package/dist/src/agents/codex.js

@@ -38,12 +38,13 @@ export class CodexAdapter extends AgentAdapter {
         if (agentSessionId)
             this.agentSessionId = agentSessionId;
     }
-    async send(text, modelId) {
+    async send(text, modelId, reasoningEffort) {
         if (this.activeTurnId) {
             await this.interruptActiveTurn().catch(() => { });
             await this.killProcess();
         }
         const codexModelId = normalizeCodexModelId(modelId);
+        const codexReasoningEffort = normalizeCodexReasoningEffort(reasoningEffort);
         this.runId = randomUUID();
         this.seq = 0;
         this.resetRunState();
@@ -59,7 +60,7 @@ export class CodexAdapter extends AgentAdapter {
             }).catch(() => { });
             this.namedThread = true;
         }
-        const response = await this.startTurnWithRecovery(threadId, text, codexModelId);
+        const response = await this.startTurnWithRecovery(threadId, text, codexModelId, codexReasoningEffort);
         this.activeTurnId = response.turn?.id ?? null;
     }
     async resume(agentSessionId) {
@@ -227,26 +228,35 @@ export class CodexAdapter extends AgentAdapter {
         this.agentSessionId = threadId;
         this.namedThread = !!response.thread?.name;
     }
-    async startTurnWithRecovery(threadId, text, codexModelId) {
+    async startTurnWithRecovery(threadId, text, codexModelId, reasoningEffort) {
         try {
-            return await this.startTurn(threadId, text, codexModelId);
+            return await this.startTurn(threadId, text, codexModelId, reasoningEffort);
         }
         catch (error) {
             if (!isMissingCodexRolloutError(error))
                 throw error;
             await this.killProcess();
             await this.ensureAppServer(codexModelId);
-            return await this.startTurn(threadId, text, codexModelId);
+            return await this.startTurn(threadId, text, codexModelId, reasoningEffort);
         }
     }
-    async startTurn(threadId, text, codexModelId) {
-        return await this.sendRpc('turn/start', {
-            threadId,
-            input: [{ type: 'text', text, text_elements: [] }],
-            approvalPolicy: 'never',
-            sandboxPolicy: { type: 'dangerFullAccess' },
-            ...(codexModelId ? { model: codexModelId } : {}),
-        });
+    async startTurn(threadId, text, codexModelId, reasoningEffort) {
+        try {
+            return await this.sendRpc('turn/start', {
+                threadId,
+                input: [{ type: 'text', text, text_elements: [] }],
+                approvalPolicy: 'never',
+                sandboxPolicy: { type: 'dangerFullAccess' },
+                ...(codexModelId ? { model: codexModelId } : {}),
+                ...(reasoningEffort ? { effort: reasoningEffort } : {}),
+            });
+        }
+        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 error;
+        }
     }
     async interruptActiveTurn() {
         const threadId = this.agentSessionId;
@@ -793,10 +803,21 @@ export function normalizeCodexModelId(modelId) {
         return undefined;
     return trimmed.toLowerCase() === 'openai' ? undefined : trimmed;
 }
+export function normalizeCodexReasoningEffort(reasoningEffort) {
+    const trimmed = reasoningEffort?.trim();
+    return trimmed || undefined;
+}
 export function isMissingCodexRolloutError(error) {
     const message = error instanceof Error ? error.message : String(error ?? '');
     return /\bno rollout found for thread id\b/i.test(message);
 }
+export function isCodexUnsupportedEffortError(error) {
+    const message = error instanceof Error ? error.message : String(error ?? '');
+    return (/\bunknown field\b.*\beffort\b/i.test(message) ||
+        /\binvalid.*\beffort\b/i.test(message) ||
+        /\bunsupported.*\beffort\b/i.test(message) ||
+        /\breasoning effort\b/i.test(message));
+}
 function extractAppServerErrorMessage(params) {
     if (typeof params.message === 'string' && params.message.trim())
         return params.message.trim();

package/dist/src/agents/model-registry/parsers.js

@@ -123,13 +123,13 @@ export function parseClaudeModels(raw) {
     for (const [pattern, id, name] of patterns) {
         const match = rawClean.match(pattern);
         if (match) {
-            models.push({
+            models.push(withClaudeReasoningEfforts({
                 id,
                 name,
                 description: `v${match[1]}`,
                 provider: 'anthropic',
                 isDefault: id === 'default',
-            });
+            }));
         }
     }
     if (models.length > 0)
@@ -144,12 +144,12 @@ export function parseClaudeModels(raw) {
             continue;
         const version = match[2] ?? '';
         const isDefault = defaultMatch && defaultMatch[1]?.toLowerCase() === family && defaultMatch[2] === version;
-        fallback.push({
+        fallback.push(withClaudeReasoningEfforts({
             id: alias,
             name: `${titleCaseSegment(family)} ${version}`,
             provider: 'anthropic',
             isDefault: Boolean(isDefault),
-        });
+        }));
     }
     return uniqueModels(fallback);
 }
@@ -193,6 +193,20 @@ const CLAUDE_ALIAS_MODEL_ENV = {
     opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
     haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
 };
+const CLAUDE_REASONING_EFFORTS = [
+    { id: 'low', name: 'Low' },
+    { id: 'medium', name: 'Medium' },
+    { id: 'high', name: 'High' },
+    { id: 'xhigh', name: 'Extra High' },
+    { id: 'max', name: 'Max' },
+];
+function withClaudeReasoningEfforts(model) {
+    return {
+        ...model,
+        supportedReasoningEfforts: CLAUDE_REASONING_EFFORTS,
+        defaultReasoningEffort: 'medium',
+    };
+}
 function readEnvValue(env, key) {
     const value = env[key]?.trim();
     return value || null;
@@ -244,13 +258,13 @@ export function parseClaudeBinaryModels(raw) {
         if (!new RegExp(`\\b${alias}\\b`, 'i').test(clean))
             continue;
         const version = (alias === 'default' ? familyVersions.get('sonnet') : familyVersions.get(alias)) ?? null;
-        models.push({
+        models.push(withClaudeReasoningEfforts({
             id: alias,
             name: CLAUDE_ALIAS_LABELS[alias],
             description: formatClaudeVersion(version),
             provider: 'anthropic',
             isDefault: alias === 'default',
-        });
+        }));
     }
     return uniqueModels(models);
 }
@@ -260,7 +274,7 @@ export function fallbackClaudeAliasModels() {
         { id: 'sonnet', name: 'Sonnet', provider: 'anthropic' },
         { id: 'opus', name: 'Opus', provider: 'anthropic' },
         { id: 'haiku', name: 'Haiku', provider: 'anthropic' },
-    ]);
+    ]).map(withClaudeReasoningEfforts);
 }
 export function parseCodexModels(raw) {
     const clean = stripAnsi(raw);

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/session/handlers/chat.js

@@ -283,7 +283,7 @@ 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);
     if (!sessionId || !text) {
         runtime.processedReqIds.delete(req.id);
@@ -291,6 +291,11 @@ export async function handleChatSend(runtime, req) {
         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) {
@@ -365,7 +370,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 +429,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 +462,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.js

@@ -53,6 +53,7 @@ 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),
         createdAt: timestamp,
@@ -233,6 +234,7 @@ 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,
             },

package/package.json

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