shennian 0.2.29 → 0.2.30

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

@@ -11,6 +11,10 @@ type RestartAfterUpgradeDeps = {
 };
 export declare function restartCurrentDaemonAfterUpgrade(deps?: RestartAfterUpgradeDeps): void;
 export declare function registerUpgradeCommand(program: Command): void;
-export declare function handleUpgradeStart(client: CliRelayClient, reqId: string, targetVersion?: string): Promise<void>;
-export declare function handleUpgradeStatus(client: CliRelayClient, reqId: string): Promise<void>;
+export declare function handleUpgradeStart(client: CliRelayClient, reqId: string, targetVersion?: string, opts?: {
+    currentVersion?: string;
+}): Promise<void>;
+export declare function handleUpgradeStatus(client: CliRelayClient, reqId: string, opts?: {
+    currentVersion?: string;
+}): Promise<void>;
 export {};

package/dist/src/commands/upgrade.js

@@ -134,11 +134,11 @@ export function registerUpgradeCommand(program) {
     });
 }
 // ─── Relay-triggered upgrade (called from session manager) ───────────────────
-export async function handleUpgradeStart(client, reqId, targetVersion) {
+export async function handleUpgradeStart(client, reqId, targetVersion, opts = {}) {
     const sendEvent = (payload) => {
         client.sendEvent({ type: 'event', event: 'upgrade', payload });
     };
-    const current = getCurrentVersion();
+    const current = opts.currentVersion ?? getCurrentVersion();
     // Resolve target version
     let latest;
     try {
@@ -168,7 +168,7 @@ export async function handleUpgradeStart(client, reqId, targetVersion) {
                 sendEvent({ state: 'restarting', machineId: 'self', from: current, to: latest });
                 break;
         }
-    });
+    }, { currentVersion: current });
     if (result.ok) {
         sendEvent({ state: 'restarting', machineId: 'self', from: result.from, to: result.to });
         // Brief delay so the event is flushed before we exit
@@ -185,14 +185,14 @@ export async function handleUpgradeStart(client, reqId, targetVersion) {
         });
     }
 }
-export async function handleUpgradeStatus(client, reqId) {
-    const result = await checkForUpdate();
+export async function handleUpgradeStatus(client, reqId, opts = {}) {
+    const result = await checkForUpdate(opts.currentVersion);
     client.sendRes({
         type: 'res',
         id: reqId,
         ok: true,
         payload: result.hasUpdate
             ? { hasUpdate: true, current: result.current, latest: result.latest, changeType: result.changeType }
-            : { hasUpdate: false, current: getCurrentVersion() },
+            : { hasUpdate: false, current: opts.currentVersion ?? getCurrentVersion() },
     });
 }

package/dist/src/daemon-log.d.ts

@@ -0,0 +1,9 @@
+export declare function getDaemonLogRetention(): {
+    maxLines: number;
+    maxBytes: number;
+};
+export declare function trimDaemonLogFile(filePath?: string, retention?: {
+    maxLines: number;
+    maxBytes: number;
+}): boolean;
+export declare function startDaemonLogRetention(): ReturnType<typeof setInterval>;

package/dist/src/daemon-log.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import { resolveShennianPath } from './config/index.js';
+const DEFAULT_MAX_LINES = 5_000;
+const DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+const TRIM_INTERVAL_MS = 5 * 60_000;
+function readPositiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+export function getDaemonLogRetention() {
+    return {
+        maxLines: readPositiveInt(process.env.SHENNIAN_DAEMON_LOG_MAX_LINES, DEFAULT_MAX_LINES),
+        maxBytes: readPositiveInt(process.env.SHENNIAN_DAEMON_LOG_MAX_BYTES, DEFAULT_MAX_BYTES),
+    };
+}
+export function trimDaemonLogFile(filePath = resolveShennianPath('daemon.log'), retention = getDaemonLogRetention()) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (stat.size === 0)
+            return false;
+        const bytesToRead = Math.min(stat.size, retention.maxBytes);
+        const fd = fs.openSync(filePath, 'r');
+        let text = '';
+        try {
+            const buffer = Buffer.allocUnsafe(bytesToRead);
+            fs.readSync(fd, buffer, 0, bytesToRead, stat.size - bytesToRead);
+            text = buffer.toString('utf8');
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        if (bytesToRead < stat.size) {
+            const firstNewline = text.indexOf('\n');
+            text = firstNewline >= 0 ? text.slice(firstNewline + 1) : '';
+        }
+        const hadTrailingNewline = text.endsWith('\n');
+        let lines = text.split('\n');
+        if (hadTrailingNewline)
+            lines = lines.slice(0, -1);
+        if (lines.length > retention.maxLines) {
+            lines = lines.slice(-retention.maxLines);
+        }
+        const next = `${lines.join('\n')}${lines.length > 0 ? '\n' : ''}`;
+        if (next.length === stat.size && bytesToRead === stat.size)
+            return false;
+        fs.writeFileSync(filePath, next, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function startDaemonLogRetention() {
+    trimDaemonLogFile();
+    return setInterval(() => {
+        trimDaemonLogFile();
+    }, TRIM_INTERVAL_MS);
+}

package/dist/src/index.js

@@ -21,6 +21,7 @@ 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 { NativeSessionFusionService } from './native-fusion/service.js';
+import { startDaemonLogRetention } from './daemon-log.js';
 const SHENNIAN_DIR = getShennianDir();
 const PID_FILE = resolveShennianPath('daemon.pid');
 function httpToWs(url) {
@@ -74,10 +75,6 @@ program
     .description('(internal) Connect to relay server, called by the background service')
     .option('--api <url>', 'Server URL override')
     .action(async (opts) => {
-    if (isRemoteAccessDisabled()) {
-        console.log(`[${new Date().toISOString()}] remote access disabled, service start skipped`);
-        process.exit(0);
-    }
     const envFile = resolveShennianPath('env.json');
     try {
         const saved = JSON.parse(fs.readFileSync(envFile, 'utf-8'));
@@ -89,6 +86,12 @@ program
     catch {
         // env.json may not exist yet
     }
+    const logRetentionTimer = startDaemonLogRetention();
+    if (isRemoteAccessDisabled()) {
+        console.log(`[${new Date().toISOString()}] remote access disabled, service start skipped`);
+        clearInterval(logRetentionTimer);
+        process.exit(0);
+    }
     // Single-instance guard. Service-manager starts are authoritative and may
     // need to take over from an older detached process after app/daemon upgrades.
     const pidFile = resolveShennianPath('daemon.pid');
@@ -216,7 +219,7 @@ program
                 }
             })
                 .catch(() => { });
-            void scheduleAutoUpgrade(client, config.autoUpgrade ?? 'patch');
+            void scheduleAutoUpgrade(client, config.autoUpgrade ?? 'patch', cliVersion);
             nativeFusion?.handleConnected();
         },
         onDisconnected: (info) => {
@@ -250,7 +253,7 @@ program
         process.env.SHENNIAN_NATIVE_FUSION_DISABLED === '1'
             ? null
             : new NativeSessionFusionService(client);
-    const sessionManager = new SessionManager(client, nativeFusion);
+    const sessionManager = new SessionManager(client, nativeFusion, cliVersion);
     fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
     fs.writeFileSync(PID_FILE, String(process.pid));
     writeDaemonLauncher(process.pid);
@@ -259,6 +262,7 @@ program
     const shutdown = () => {
         console.log(chalk.gray('\nDisconnecting...'));
         reportLog({ level: 'info', wsEvent: 'daemon.stop' });
+        clearInterval(logRetentionTimer);
         sessionManager.cleanup();
         nativeFusion?.stop();
         client.disconnect();
@@ -319,7 +323,7 @@ registerAgentCommand(program);
 registerUpgradeCommand(program);
 program.parse();
 // ─── Auto-upgrade helper ──────────────────────────────────────────────────────
-async function scheduleAutoUpgrade(client, policy) {
+async function scheduleAutoUpgrade(client, policy, currentVersion) {
     if (policy === 'none')
         return;
     let upgradeInFlight = false;
@@ -328,7 +332,7 @@ async function scheduleAutoUpgrade(client, policy) {
             return;
         let result;
         try {
-            result = await checkForUpdate();
+            result = await checkForUpdate(currentVersion);
         }
         catch {
             return; // silently skip on network error
@@ -348,7 +352,7 @@ async function scheduleAutoUpgrade(client, policy) {
         try {
             const { handleUpgradeStart } = await import('./commands/upgrade.js');
             // Use a dummy reqId since this is self-triggered
-            await handleUpgradeStart(client, 'auto-upgrade', latest);
+            await handleUpgradeStart(client, 'auto-upgrade', latest, { currentVersion });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);

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

@@ -6,6 +6,7 @@ import os from 'node:os';
 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;
 function normalizeText(text) {
     return stripGitDirectiveArtifacts(text.replace(/\r\n/g, '\n').trim());
 }
@@ -38,6 +39,51 @@ function safeParse(line) {
         return null;
     }
 }
+function readJsonlLines(filePath, startOffset, onLine) {
+    const stat = fs.statSync(filePath);
+    const fileSize = stat.size;
+    if (startOffset >= fileSize)
+        return fileSize;
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const chunkSize = 256 * 1024;
+        const buffer = Buffer.allocUnsafe(chunkSize);
+        let position = startOffset;
+        let nextOffset = startOffset;
+        let carry = Buffer.alloc(0);
+        while (position < fileSize) {
+            const bytesRead = fs.readSync(fd, buffer, 0, Math.min(chunkSize, fileSize - position), position);
+            if (bytesRead <= 0)
+                break;
+            position += bytesRead;
+            let chunk = buffer.subarray(0, bytesRead);
+            if (carry.length > 0) {
+                chunk = Buffer.concat([carry, chunk]);
+                carry = Buffer.alloc(0);
+            }
+            let lineStart = 0;
+            while (lineStart < chunk.length) {
+                const newlineIndex = chunk.indexOf(0x0a, lineStart);
+                if (newlineIndex < 0)
+                    break;
+                const lineBuffer = chunk.subarray(lineStart, newlineIndex);
+                const lineOffset = nextOffset;
+                nextOffset += newlineIndex - lineStart + 1;
+                lineStart = newlineIndex + 1;
+                if (lineBuffer.length > 0 && lineBuffer.length <= MAX_JSONL_LINE_BYTES) {
+                    onLine(lineBuffer.toString('utf8'), lineOffset);
+                }
+            }
+            if (lineStart < chunk.length) {
+                carry = Buffer.from(chunk.subarray(lineStart));
+            }
+        }
+        return nextOffset;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 function readClaudeEventCwd(parsed) {
     return typeof parsed.cwd === 'string' && parsed.cwd.trim() ? parsed.cwd : null;
 }
@@ -627,9 +673,10 @@ function lookupCodexThreadName(sourceSessionKey) {
     return null;
 }
 export function listCodexRolloutFiles() {
-    const root = path.join(os.homedir(), '.codex', 'sessions');
-    if (!fs.existsSync(root))
-        return [];
+    const roots = [
+        path.join(os.homedir(), '.codex', 'sessions'),
+        path.join(os.homedir(), '.codex', 'archived_sessions'),
+    ];
     const files = [];
     const walk = (dir) => {
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -640,8 +687,11 @@ export function listCodexRolloutFiles() {
                 files.push(full);
         }
     };
-    walk(root);
-    return files.sort();
+    for (const root of roots) {
+        if (fs.existsSync(root))
+            walk(root);
+    }
+    return [...new Set(files)].sort();
 }
 export function listClaudeTranscriptFiles() {
     const root = path.join(os.homedir(), '.claude', 'projects');
@@ -666,61 +716,47 @@ export function lookupClaudeTranscriptCwd(sourceSessionKey) {
     const match = listClaudeTranscriptFiles().find((filePath) => path.basename(filePath, '.jsonl') === sourceSessionKey);
     if (!match)
         return null;
-    const content = fs.readFileSync(match, 'utf8');
-    for (const line of content.split('\n')) {
-        if (!line.trim())
-            continue;
+    let found = null;
+    readJsonlLines(match, 0, (line) => {
+        if (found || !line.trim())
+            return;
         const parsed = safeParse(line);
         if (!parsed)
-            continue;
+            return;
         const cwd = readClaudeEventCwd(parsed);
         if (cwd)
-            return cwd;
-    }
-    return null;
+            found = cwd;
+    });
+    return found;
 }
 export function parseCodexRolloutChunk(filePath, startOffset) {
-    const stat = fs.statSync(filePath);
-    const fileSize = stat.size;
-    if (startOffset >= fileSize)
-        return { nextOffset: fileSize, events: [] };
-    const chunkBuffer = fs.readFileSync(filePath).subarray(startOffset);
-    const lastNewline = chunkBuffer.lastIndexOf(0x0a);
-    if (lastNewline < 0)
-        return { nextOffset: startOffset, events: [] };
-    const nextOffset = startOffset + lastNewline + 1;
-    const chunk = chunkBuffer.subarray(0, lastNewline + 1).toString('utf8');
-    const lines = chunk.split('\n').filter(Boolean);
     const events = [];
     let { sourceSessionKey, workDir, modelId, title } = readCodexSessionMeta(filePath);
     let pendingTerminal = false;
-    for (let index = 0, offset = startOffset; index < lines.length; index++) {
-        const line = lines[index];
+    const nextOffset = readJsonlLines(filePath, startOffset, (line, lineOffset) => {
         const parsed = safeParse(line);
-        const lineOffset = offset;
-        offset += Buffer.byteLength(line, 'utf8') + 1;
         if (!parsed)
-            continue;
+            return;
         const type = typeof parsed.type === 'string' ? parsed.type : '';
         const payload = typeof parsed.payload === 'object' && parsed.payload !== null
             ? parsed.payload
             : null;
         const ts = readTimestamp(parsed.timestamp);
         if (!payload || !ts)
-            continue;
+            return;
         if (type === 'session_meta') {
             sourceSessionKey = typeof payload.id === 'string' ? payload.id : sourceSessionKey;
             workDir = typeof payload.cwd === 'string' ? payload.cwd : workDir;
             modelId = readCodexModelId(payload) ?? modelId;
             if (!title)
                 title = lookupCodexThreadName(sourceSessionKey) ?? '';
-            continue;
+            return;
         }
         if (!sourceSessionKey)
-            continue;
+            return;
         if (type === 'response_item') {
             parseCodexResponseItem(events, filePath, lineOffset, payload, sourceSessionKey, ts, title, modelId, workDir);
-            continue;
+            return;
         }
         if (type === 'event_msg') {
             const eventType = typeof payload.type === 'string' ? payload.type : '';
@@ -737,7 +773,7 @@ export function parseCodexRolloutChunk(filePath, startOffset) {
                     pendingTerminal = false;
                     break;
                 }
-                continue;
+                return;
             }
             if (eventType === 'user_message') {
                 const parsedUser = parseCodexUserMessage(payload);
@@ -751,43 +787,29 @@ export function parseCodexRolloutChunk(filePath, startOffset) {
                 pendingTerminal = false;
             }
         }
-    }
+    });
     return { nextOffset, events };
 }
 export function parseClaudeTranscriptChunk(filePath, startOffset) {
-    const stat = fs.statSync(filePath);
-    const fileSize = stat.size;
-    if (startOffset >= fileSize)
-        return { nextOffset: fileSize, events: [] };
-    const chunkBuffer = fs.readFileSync(filePath).subarray(startOffset);
-    const lastNewline = chunkBuffer.lastIndexOf(0x0a);
-    if (lastNewline < 0)
-        return { nextOffset: startOffset, events: [] };
-    const nextOffset = startOffset + lastNewline + 1;
-    const chunk = chunkBuffer.subarray(0, lastNewline + 1).toString('utf8');
-    const lines = chunk.split('\n').filter(Boolean);
     const events = [];
     const sourceSessionKey = path.basename(filePath, '.jsonl');
     const fallbackWorkDir = relativeProjectDir(path.dirname(filePath).replace(path.join(os.homedir(), '.claude', 'projects') + path.sep, ''));
     let title = '';
-    for (let index = 0, offset = startOffset; index < lines.length; index++) {
-        const line = lines[index];
+    const nextOffset = readJsonlLines(filePath, startOffset, (line, lineOffset) => {
         const parsed = safeParse(line);
-        const lineOffset = offset;
-        offset += Buffer.byteLength(line, 'utf8') + 1;
         if (!parsed)
-            continue;
+            return;
         const ts = readTimestamp(parsed.timestamp);
         const type = typeof parsed.type === 'string' ? parsed.type : '';
         if (!ts || !type)
-            continue;
+            return;
         if (type === 'user') {
             const message = typeof parsed.message === 'object' && parsed.message !== null
                 ? parsed.message
                 : null;
             const text = typeof message?.content === 'string' ? normalizeText(message.content) : '';
             if (!text)
-                continue;
+                return;
             if (!title)
                 title = text.slice(0, 80);
             events.push({
@@ -815,7 +837,7 @@ export function parseClaudeTranscriptChunk(filePath, startOffset) {
                 .filter(Boolean)
                 .join('\n\n'));
             if (!text)
-                continue;
+                return;
             const modelId = typeof message?.model === 'string' ? message.model : null;
             events.push({
                 agentType: 'claude',
@@ -831,6 +853,6 @@ export function parseClaudeTranscriptChunk(filePath, startOffset) {
                 workDir: readClaudeEventCwd(parsed) ?? fallbackWorkDir,
             });
         }
-    }
+    });
     return { nextOffset, events };
 }

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

@@ -42,6 +42,9 @@ export class NativeSessionFusionService {
     }
     handleConnected() {
         this.start();
+        void this.scanNow().catch((error) => {
+            console.error('[native-fusion] initial scan failed', error);
+        });
     }
     registerManagedSend(params) {
         if (!params.canonicalMessageId)

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

@@ -11,6 +11,7 @@ export declare function resolveSessionWorkDir(input: string): string;
 export declare class SessionManager {
     private client;
     private nativeFusion;
+    private cliVersion?;
     private sessions;
     /** Track processed request IDs to deduplicate replayed offline messages */
     private processedReqIds;
@@ -18,7 +19,7 @@ export declare class SessionManager {
     private runTextAcc;
     /** In-flight chunked uploads: transferId → metadata */
     private pendingTransfers;
-    constructor(client: CliRelayClient, nativeFusion?: NativeSessionFusionService | null);
+    constructor(client: CliRelayClient, nativeFusion?: NativeSessionFusionService | null, cliVersion?: string | undefined);
     private getRuntime;
     private reloadCustomAgents;
     handleReq(req: ReqFrame): Promise<void>;

package/dist/src/session/manager.js

@@ -50,6 +50,7 @@ export function resolveSessionWorkDir(input) {
 export class SessionManager {
     client;
     nativeFusion;
+    cliVersion;
     sessions = new Map();
     /** Track processed request IDs to deduplicate replayed offline messages */
     processedReqIds = new Set();
@@ -57,9 +58,10 @@ export class SessionManager {
     runTextAcc = new Map();
     /** In-flight chunked uploads: transferId → metadata */
     pendingTransfers = new Map();
-    constructor(client, nativeFusion = null) {
+    constructor(client, nativeFusion = null, cliVersion) {
         this.client = client;
         this.nativeFusion = nativeFusion;
+        this.cliVersion = cliVersion;
         this.reloadCustomAgents();
     }
     getRuntime() {
@@ -124,10 +126,12 @@ export class SessionManager {
                     await handleRegionSwitch(runtime, req);
                     break;
                 case 'upgrade.start':
-                    await handleUpgradeStart(this.client, req.id, req.params.version);
+                    await handleUpgradeStart(this.client, req.id, req.params.version, {
+                        currentVersion: this.cliVersion,
+                    });
                     break;
                 case 'upgrade.status':
-                    await handleUpgradeStatus(this.client, req.id);
+                    await handleUpgradeStatus(this.client, req.id, { currentVersion: this.cliVersion });
                     break;
                 case 'upgrade.set-policy':
                     await handleUpgradeSetPolicy(runtime, req);

package/dist/src/upgrade/engine.d.ts

@@ -68,7 +68,9 @@ export declare function clearUpgradeFailure(version: string): void;
  * Returns true if rollback was performed (caller should exit and let service manager restart).
  */
 export declare function handleStartupCrashCheck(): Promise<boolean>;
-export declare function performUpgrade(targetVersion: string, onProgress: (p: UpgradeProgress) => void): Promise<UpgradeResult>;
+export declare function performUpgrade(targetVersion: string, onProgress: (p: UpgradeProgress) => void, opts?: {
+    currentVersion?: string;
+}): Promise<UpgradeResult>;
 export type VersionCheckResult = {
     hasUpdate: false;
 } | {
@@ -77,5 +79,5 @@ export type VersionCheckResult = {
     latest: string;
     changeType: 'patch' | 'minor' | 'major';
 };
-export declare function checkForUpdate(): Promise<VersionCheckResult>;
+export declare function checkForUpdate(currentVersion?: string): Promise<VersionCheckResult>;
 export {};

package/dist/src/upgrade/engine.js

@@ -212,8 +212,9 @@ export async function handleStartupCrashCheck() {
     return false;
 }
 // ─── Core upgrade ─────────────────────────────────────────────────────────────
-export async function performUpgrade(targetVersion, onProgress) {
-    const currentVersion = getCurrentVersion();
+export async function performUpgrade(targetVersion, onProgress, opts = {}) {
+    const currentVersion = opts.currentVersion ?? getCurrentVersion();
+    const installedVersion = getCurrentVersion();
     if (currentVersion === targetVersion) {
         clearUpgradeFailure(targetVersion);
         return { ok: false, error: `Already on version ${targetVersion}` };
@@ -226,6 +227,30 @@ export async function performUpgrade(targetVersion, onProgress) {
     catch {
         return { ok: false, error: 'npm is not available in PATH' };
     }
+    if (installedVersion === targetVersion) {
+        onProgress({ step: 'verifying', version: targetVersion });
+        try {
+            const binScript = getGlobalBinScript();
+            const { stdout } = await exec(`node "${binScript}" --version`, { timeout: 10_000 });
+            if (!stdout.trim())
+                throw new Error('Empty output from --version check');
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: `Smoke test failed: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        writeUpgradeAttempt({
+            from: currentVersion,
+            to: targetVersion,
+            attemptCount: 0,
+            attemptAt: Date.now(),
+        });
+        clearUpgradeFailure(targetVersion);
+        onProgress({ step: 'restarting', from: currentVersion, to: targetVersion });
+        return { ok: true, from: currentVersion, to: targetVersion };
+    }
     // Step 2: Backup current version
     onProgress({ step: 'backing-up' });
     try {
@@ -284,8 +309,8 @@ export async function performUpgrade(targetVersion, onProgress) {
     onProgress({ step: 'restarting', from: currentVersion, to: targetVersion });
     return { ok: true, from: currentVersion, to: targetVersion };
 }
-export async function checkForUpdate() {
-    const current = getCurrentVersion();
+export async function checkForUpdate(currentVersion) {
+    const current = currentVersion ?? getCurrentVersion();
     const latest = await fetchLatestVersion();
     const changeType = compareVersions(current, latest);
     if (changeType === 'none')

package/package.json

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