shennian 0.2.85 → 0.2.87

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

@@ -1,11 +1,12 @@
 import { EventEmitter } from 'node:events';
-import type { AgentType, ChatAttachmentMeta, ExternalChannelSessionStatus } from '@shennian/wire';
+import type { AgentType, ChatAttachmentMeta, ExternalChannelSessionStatus, SessionRunPhase } from '@shennian/wire';
 export type AgentEvent = {
     state: string;
     runId: string;
     seq: number;
     text?: string;
     thinking?: boolean;
+    runPhase?: SessionRunPhase;
     name?: string;
     args?: Record<string, unknown>;
     result?: string;

package/dist/src/commands/daemon.js

@@ -38,6 +38,7 @@ const SAFE_SNAPSHOT_ENV_KEYS = new Set([
     'LOCALAPPDATA',
     'SHENNIAN_DESKTOP_SERVER_URL',
     'SHENNIAN_HOME',
+    'SHENNIAN_NATIVE_FUSION_DISABLED',
 ]);
 export function isSafeSnapshotEnvKey(key) {
     return SAFE_SNAPSHOT_ENV_KEYS.has(key);
@@ -250,7 +251,7 @@ function inferDaemonLauncherFromProcess(pid) {
 }
 export function isShennianRunServiceCommand(command) {
     const normalized = command.replace(/\\/g, '/').trim();
-    return (/^(?:\S*\/)?node\s+\S*(?:\/node_modules\/shennian\/|\/dist\/bin\/shennian\.js)\s+run-service(?:\s|$)/.test(normalized) ||
+    return (/^(?:\S*\/)?node\s+\S*(?:\/node_modules\/shennian\/|\/dist\/bin\/shennian\.js|\/bin\/shennian)\s+run-service(?:\s|$)/.test(normalized) ||
         /^(?:\S*\/)?shennian(?:\.cmd)?\s+run-service(?:\s|$)/.test(normalized) ||
         /^(?:\S*\/)?npx(?:\.cmd)?\s+(?:--yes\s+)?shennian\s+run-service(?:\s|$)/.test(normalized));
 }

package/dist/src/index.js

@@ -25,6 +25,7 @@ const AUTO_UPGRADE_INITIAL_DELAY_MS = 30_000;
 const AUTO_UPGRADE_POLL_INTERVAL_MS = 5 * 60_000;
 import { getCachedAgentInfos, resolveAgentInfos } from './agents/model-registry.js';
 import { initCliLogReporter, reportLog } from './log-reporter.js';
+import { isNativeFusionEnabled } from './native-fusion/config.js';
 import { NativeSessionFusionService } from './native-fusion/service.js';
 import { startDaemonLogRetention } from './daemon-log.js';
 const SHENNIAN_DIR = getShennianDir();
@@ -285,7 +286,7 @@ program
         },
     });
     nativeFusion =
-        process.env.SHENNIAN_NATIVE_FUSION_ENABLED === '1'
+        isNativeFusionEnabled()
             ? new NativeSessionFusionService(client)
             : null;
     const sessionManager = new SessionManager(client, nativeFusion, currentCliVersion);

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

@@ -0,0 +1 @@
+export declare function isNativeFusionEnabled(env?: NodeJS.ProcessEnv): boolean;

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

@@ -0,0 +1,5 @@
+// @arch docs/architecture/cli/native-session-fusion.md
+// @test src/__tests__/native-fusion-config.test.ts
+export function isNativeFusionEnabled(env = process.env) {
+    return env.SHENNIAN_NATIVE_FUSION_DISABLED !== '1';
+}

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

@@ -49,6 +49,18 @@ function buildRelayAgentPayload(event, sessionId, extra = {}) {
     }
     return { ...event, sessionId, ...extra };
 }
+const SESSION_ACTIVITY_HEARTBEAT_INTERVAL_MS = 30_000;
+function runPhaseFromAgentEvent(event) {
+    if (event.state === 'heartbeat')
+        return event.runPhase ?? null;
+    if (event.state === 'tool-call' || event.state === 'tool-result')
+        return 'tool_running';
+    if (event.state === 'delta')
+        return event.thinking ? 'thinking' : 'streaming_text';
+    if (event.state === 'init' || event.state === 'start')
+        return 'thinking';
+    return null;
+}
 function formatAgentSendFailure(agentType, err) {
     const raw = err instanceof Error ? err.message : String(err);
     if (agentType === 'pi' &&
@@ -194,6 +206,38 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
             id: `agent-evt-${event.runId}-${event.seq}`,
         });
     }
+    function stopActivityHeartbeat(activeSession) {
+        if (!activeSession?.heartbeatTimer)
+            return;
+        clearInterval(activeSession.heartbeatTimer);
+        activeSession.heartbeatTimer = null;
+    }
+    function sendActivityHeartbeat(activeSession) {
+        if (!activeSession.currentRunId || !activeSession.currentRunPhase)
+            return;
+        const seq = activeSession.heartbeatSeq++;
+        runtime.client.sendAgentEvent({
+            type: 'event',
+            event: 'agent',
+            payload: {
+                state: 'heartbeat',
+                sessionId,
+                runId: activeSession.currentRunId,
+                seq,
+                runPhase: activeSession.currentRunPhase,
+            },
+            seq,
+            id: `agent-heartbeat-${activeSession.currentRunId}-${seq}-${Date.now()}`,
+        });
+    }
+    function ensureActivityHeartbeat(activeSession) {
+        if (!activeSession || activeSession.heartbeatTimer)
+            return;
+        activeSession.heartbeatTimer = setInterval(() => {
+            sendActivityHeartbeat(activeSession);
+        }, SESSION_ACTIVITY_HEARTBEAT_INTERVAL_MS);
+        activeSession.heartbeatTimer.unref?.();
+    }
     function flushTextBuffer(activeSession) {
         const textBuffer = activeSession?.pendingTextEvent;
         if (!activeSession || !textBuffer || !textBuffer.text)
@@ -209,9 +253,16 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
     }
     adapter.on('agentEvent', (event) => {
         const activeSession = runtime.sessions.get(sessionId);
+        const runPhase = runPhaseFromAgentEvent(event);
+        const isTerminalEvent = event.state === 'final' || event.state === 'error' || event.state === 'aborted';
         if (activeSession) {
-            activeSession.currentRunId = event.runId;
             activeSession.nextEventSeq = event.seq + 1;
+            if (!isTerminalEvent)
+                activeSession.currentRunId = event.runId;
+            if (!isTerminalEvent && runPhase) {
+                activeSession.currentRunPhase = runPhase;
+                ensureActivityHeartbeat(activeSession);
+            }
             if (event.agentSessionId)
                 activeSession.agentSessionId = event.agentSessionId;
         }
@@ -328,10 +379,12 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
         else if (event.state === 'tool-call' || event.state === 'tool-result' || event.state === 'approval-pending') {
             flushTextBuffer(activeSession);
         }
-        if ((event.state === 'final' || event.state === 'error' || event.state === 'aborted') &&
+        if (isTerminalEvent &&
             activeSession?.currentRunId === event.runId) {
             activeSession.currentRunId = null;
+            activeSession.currentRunPhase = null;
             activeSession.nextEventSeq = 0;
+            stopActivityHeartbeat(activeSession);
             runtime.chatQueue?.noteTerminal(sessionId);
         }
         sendAgentEvent(event, extra);
@@ -355,6 +408,10 @@ function rememberProcessedReqId(runtime, reqId) {
     }
 }
 async function disposeSession(session) {
+    if (session.heartbeatTimer) {
+        clearInterval(session.heartbeatTimer);
+        session.heartbeatTimer = null;
+    }
     session.adapter.removeAllListeners();
     await session.adapter.stop().catch(() => { });
 }
@@ -372,7 +429,10 @@ async function createActiveSession(runtime, sessionId, agentType, resolvedWorkDi
         agentSessionId: incomingAgentSid ?? null,
         lastActiveAt: Date.now(),
         currentRunId: null,
+        currentRunPhase: null,
         nextEventSeq: 0,
+        heartbeatSeq: 0,
+        heartbeatTimer: null,
         pendingTextEvent: null,
         externalChannel: externalChannel ?? null,
         externalReplyTarget: externalReplyTarget ?? null,
@@ -394,7 +454,12 @@ function emitSyntheticAbort(runtime, sessionId) {
     runtime.runTextAcc.delete(`${sessionId}:${runId}`);
     session.pendingTextEvent = null;
     session.currentRunId = null;
+    session.currentRunPhase = null;
     session.nextEventSeq = 0;
+    if (session.heartbeatTimer) {
+        clearInterval(session.heartbeatTimer);
+        session.heartbeatTimer = null;
+    }
     runtime.client.sendAgentEvent({
         type: 'event',
         event: 'agent',

package/dist/src/session/manager.js

@@ -228,6 +228,10 @@ export class SessionManager {
             }
         }
         if (oldest) {
+            if (oldest.session.heartbeatTimer) {
+                clearInterval(oldest.session.heartbeatTimer);
+                oldest.session.heartbeatTimer = null;
+            }
             oldest.session.adapter.removeAllListeners();
             oldest.session.adapter.stop().catch(() => { });
             this.sessions.delete(oldest.key);
@@ -242,6 +246,10 @@ export class SessionManager {
     }
     cleanup() {
         for (const [, session] of this.sessions) {
+            if (session.heartbeatTimer) {
+                clearInterval(session.heartbeatTimer);
+                session.heartbeatTimer = null;
+            }
             session.adapter.stop().catch(() => { });
         }
         this.sessions.clear();

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

@@ -1,4 +1,4 @@
-import type { AgentType, ExternalChannelSessionStatus } from '@shennian/wire';
+import type { AgentType, ExternalChannelSessionStatus, SessionRunPhase } 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';
@@ -11,7 +11,10 @@ export type ActiveSession = {
     agentSessionId: string | null;
     lastActiveAt: number;
     currentRunId: string | null;
+    currentRunPhase: SessionRunPhase | null;
     nextEventSeq: number;
+    heartbeatSeq: number;
+    heartbeatTimer: ReturnType<typeof setInterval> | null;
     pendingTextEvent: {
         runId: string;
         seq: number;

package/package.json

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