@lightcone-ai/daemon 0.14.17 → 0.14.18

package/mcp-servers/official-common/tool-access-policy.js

@@ -0,0 +1,90 @@
+import { readFileSync } from 'fs';
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeToken(value) {
+  return String(value ?? '').trim();
+}
+
+function normalizeId(value) {
+  return normalizeToken(value).toLowerCase();
+}
+
+function normalizeToolList(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map(item => normalizeToken(item).toLowerCase())
+      .filter(Boolean);
+  }
+  const direct = normalizeToken(value).toLowerCase();
+  return direct ? [direct] : [];
+}
+
+function normalizeRule(rawRule) {
+  if (!isPlainObject(rawRule)) return null;
+
+  const workspaceId = normalizeId(rawRule.workspace_id ?? rawRule.workspaceId);
+  const agentId = normalizeId(rawRule.agent_id ?? rawRule.agentId);
+  const tools = normalizeToolList(
+    rawRule.tools
+    ?? rawRule.tool_names
+    ?? rawRule.toolNames
+    ?? rawRule.tool
+  );
+  const message = normalizeToken(rawRule.message ?? rawRule.error ?? rawRule.reason);
+
+  if (!workspaceId || !agentId || tools.length === 0 || !message) {
+    return null;
+  }
+
+  return {
+    workspaceId,
+    agentId,
+    tools,
+    message,
+  };
+}
+
+export function loadToolBlockRulesFromManifest(manifestUrl) {
+  if (!manifestUrl) return [];
+  let rawManifest = null;
+  try {
+    rawManifest = JSON.parse(readFileSync(manifestUrl, 'utf8'));
+  } catch {
+    return [];
+  }
+  if (!isPlainObject(rawManifest)) return [];
+
+  const rawRules = Array.isArray(rawManifest.tool_block_rules)
+    ? rawManifest.tool_block_rules
+    : Array.isArray(rawManifest.toolBlockRules)
+      ? rawManifest.toolBlockRules
+      : [];
+
+  return rawRules
+    .map(rule => normalizeRule(rule))
+    .filter(Boolean);
+}
+
+export function findToolBlockRule(rules, {
+  toolName = '',
+  workspaceId = '',
+  agentId = '',
+} = {}) {
+  if (!Array.isArray(rules) || rules.length === 0) return null;
+
+  const targetTool = normalizeToken(toolName).toLowerCase();
+  const targetWorkspaceId = normalizeId(workspaceId);
+  const targetAgentId = normalizeId(agentId);
+  if (!targetTool || !targetWorkspaceId || !targetAgentId) return null;
+
+  for (const rule of rules) {
+    if (!rule || rule.workspaceId !== targetWorkspaceId || rule.agentId !== targetAgentId) continue;
+    if (rule.tools.includes('*') || rule.tools.includes(targetTool)) {
+      return rule;
+    }
+  }
+  return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.14.17",
+  "version": "0.14.18",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -16,6 +16,7 @@ import { injectWorkspaceContext } from './drivers/claude.js';
 import { parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
 import { startSession, stopSession, stopAllSessions } from './browser-login.js';
 import { markInvalidatedLeases } from './governance-state.js';
+import { resolveExitOfflineDetail, resolveLifecycleExitState } from './lifecycle-protocol.js';
 import { runPublishJob } from './publish-job-runner.js';
 
 const KIMI_SYSTEM_PROMPT_FILE = '.lightcone-kimi-system.md';
@@ -115,15 +116,6 @@ function runtimeMissingDetail(runtime) {
   return `cli_missing:${runtime}`;
 }
 
-function resolveExitOfflineDetail({ code, signal, stopCause }) {
-  if (stopCause === 'manual_stop') return '';
-  if (stopCause === 'credential_revoked') return 'credential_revoked';
-  if (code === 0) return '';
-  if (signal === 'SIGTERM') return '';
-  if (signal === 'SIGKILL') return 'agent_timeout';
-  return 'spawn_session_crashed';
-}
-
 function normalizeObject(value) {
   return isPlainObject(value) ? value : {};
 }
@@ -218,6 +210,31 @@ export class AgentManager {
     return `New message in ${message.workspace_type === 'dm' ? 'dm from' : `#${message.workspace_name} from`} ${message.sender_name}: ${message.content}`;
   }
 
+  _emitLifecycle(connection, {
+    agentId,
+    workspaceId,
+    runtime,
+    reachability,
+    availability,
+    runtimeState,
+    reason = null,
+    sessionId = null,
+  }) {
+    const normalizedRuntime = String(runtime ?? '').trim().toLowerCase() || 'claude';
+    const normalizedReason = String(reason ?? '').trim() || null;
+    connection.send({
+      type: 'agent:lifecycle',
+      agentId,
+      workspaceId,
+      reachability,
+      availability,
+      runtimeState,
+      reason: normalizedReason,
+      sessionId: sessionId ?? null,
+      runtime: normalizedRuntime,
+    });
+  }
+
   _takePendingMessage(key) {
     if (!this._pendingMessages) return null;
     const pending = this._pendingMessages.get(key);
@@ -227,6 +244,16 @@ export class AgentManager {
     return msg;
   }
 
+  _enqueuePendingMessage(key, msg, { front = false } = {}) {
+    if (!msg) return 0;
+    if (!this._pendingMessages) this._pendingMessages = new Map();
+    const pending = this._pendingMessages.get(key) ?? [];
+    if (front) pending.unshift(msg);
+    else pending.push(msg);
+    this._pendingMessages.set(key, pending);
+    return pending.length;
+  }
+
   _prepareStartupMessage(key, runtime) {
     if (runtime === 'codex') {
       const startupMsg = this._takePendingMessage(key);
@@ -575,9 +602,21 @@ export class AgentManager {
     this._workspaceRootDir(workspaceId);
     const workspaceDir = this._workspaceDir(agentId, workspaceId);
     const chatBridgePath = new URL('./chat-bridge.js', import.meta.url).pathname;
-    const failStart = (reason) => {
+    let rollbackStartupMessage = null;
+    const failStart = (reason, runtimeHint = requestedRuntime) => {
+      rollbackStartupMessage?.(reason ?? 'spawn_failed');
       this._clearDirectiveRefresh(key);
       this.starting.delete(key);
+      this._emitLifecycle(connection, {
+        agentId,
+        workspaceId,
+        runtime: runtimeHint,
+        reachability: 'unreachable',
+        availability: 'unreachable',
+        runtimeState: 'crashed',
+        reason: reason ?? 'spawn_failed',
+        sessionId: config.sessionId ?? null,
+      });
       connection.send({ type: 'agent:status', agentId, workspaceId, status: 'inactive' });
       connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'offline', detail: reason ?? '', entries: [] });
     };
@@ -620,6 +659,22 @@ export class AgentManager {
     }
 
     const { startupMsg } = this._prepareStartupMessage(key, runtime);
+    let startupMsgRestored = false;
+    const restoreStartupMessage = (reason) => {
+      if (runtime !== 'codex' || !startupMsg || startupMsgRestored) return;
+      startupMsgRestored = true;
+      const queueSize = this._enqueuePendingMessage(key, startupMsg, { front: true });
+      const seq = startupMsg.seq ?? 'n/a';
+      console.log(
+        `[AgentManager] Restored codex startup message seq=${seq} workspace=${workspaceName ?? workspaceId ?? 'none'} reason=${reason ?? 'unknown'} pending=${queueSize}`
+      );
+    };
+    if (runtime === 'codex' && startupMsg) {
+      console.log(
+        `[AgentManager] Claimed codex startup message seq=${startupMsg.seq ?? 'n/a'} workspace=${workspaceName ?? workspaceId ?? 'none'}`
+      );
+    }
+    rollbackStartupMessage = restoreStartupMessage;
 
     // Keep .skills materialization for runtime compatibility, but no longer use skills to build prompt/env/mcp.
     let skills = [];
@@ -732,9 +787,20 @@ export class AgentManager {
     const reportSpawnFailure = (detail) => {
       if (spawnErrorReported) return;
       spawnErrorReported = true;
+      restoreStartupMessage(detail ?? 'spawn_failed');
       this._clearDirectiveRefresh(key);
       this.starting.delete(key);
       this.agents.delete(key);
+      this._emitLifecycle(connection, {
+        agentId,
+        workspaceId,
+        runtime,
+        reachability: 'unreachable',
+        availability: 'unreachable',
+        runtimeState: 'crashed',
+        reason: detail ?? 'spawn_failed',
+        sessionId: config.sessionId ?? null,
+      });
       connection.send({ type: 'agent:status', agentId, workspaceId, status: 'inactive' });
       connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'offline', detail: detail ?? 'spawn_failed', entries: [] });
     };
@@ -864,6 +930,10 @@ export class AgentManager {
       this.agents.delete(key);
 
       if (code === 0 && runtime === 'codex' && this._pendingMessages?.get(key)?.length) {
+        const pendingCount = this._pendingMessages?.get(key)?.length ?? 0;
+        console.log(
+          `[AgentManager] Codex exited cleanly with pending=${pendingCount}; restarting next turn for ${config.displayName ?? agentId}`
+        );
         const restartConfig = { ...config, sessionId: agent?.sessionId ?? config.sessionId ?? null };
         this._startAgent({ agentId, workspaceId, config: restartConfig }, connection);
         return;
@@ -873,6 +943,7 @@ export class AgentManager {
       if (code !== 0 && config.sessionId && !this._retried?.has(key)) {
         if (!this._retried) this._retried = new Set();
         this._retried.add(key);
+        restoreStartupMessage('session_retry_without_session');
         console.log(`[AgentManager] Retrying ${agentId} workspace=${workspaceId} without session (session may not exist locally)`);
         const retryConfig = { ...config, sessionId: null };
         this._startAgent({ agentId, workspaceId, config: retryConfig }, connection);
@@ -885,6 +956,23 @@ export class AgentManager {
         stopCause: agent?.stopCause ?? null,
       });
 
+      const lifecycleExit = resolveLifecycleExitState({
+        runtime,
+        code,
+        signal,
+        stopCause: agent?.stopCause ?? null,
+      });
+      this._emitLifecycle(connection, {
+        agentId,
+        workspaceId,
+        runtime,
+        reachability: lifecycleExit.reachability,
+        availability: lifecycleExit.availability,
+        runtimeState: lifecycleExit.runtimeState,
+        reason: lifecycleExit.reason,
+        sessionId: agent?.sessionId ?? config.sessionId ?? null,
+      });
+
       connection.send({ type: 'agent:status', agentId, workspaceId, status: 'inactive' });
       connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'offline', detail: offlineDetail, entries: [] });
     });
@@ -897,6 +985,17 @@ export class AgentManager {
     }
 
     console.log(`[AgentManager] Agent ${config.displayName ?? agentId} is now active (workspace=${workspaceName ?? workspaceId ?? 'none'})`);
+    const startedAgent = this.agents.get(key);
+    this._emitLifecycle(connection, {
+      agentId,
+      workspaceId,
+      runtime,
+      reachability: 'reachable',
+      availability: 'available',
+      runtimeState: 'running',
+      reason: 'spawned',
+      sessionId: startedAgent?.sessionId ?? config.sessionId ?? null,
+    });
     connection.send({ type: 'agent:status', agentId, workspaceId, status: 'active' });
     connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
 
@@ -1166,10 +1265,8 @@ export class AgentManager {
     if (!this.agents.has(key) && !this.starting.has(key)) {
       // Agent not running — queue the message and request config to spawn it
       console.log(`[AgentManager] Agent ${agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId} not running, requesting start for seq=${seq}`);
-      if (!this._pendingMessages) this._pendingMessages = new Map();
-      const pending = this._pendingMessages.get(key) ?? [];
-      pending.push(msg);
-      this._pendingMessages.set(key, pending);
+      const queueSize = this._enqueuePendingMessage(key, msg);
+      console.log(`[AgentManager] Queued seq=${seq} for start request pending=${queueSize}`);
       connection.send({ type: 'agent:request_start', agentId, workspaceId });
       return;
     }
@@ -1177,10 +1274,8 @@ export class AgentManager {
     if (this.starting.has(key)) {
       // Spawn in progress — queue the message for delivery after start
       console.log(`[AgentManager] Agent ${agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId} still starting, queuing seq=${seq}`);
-      if (!this._pendingMessages) this._pendingMessages = new Map();
-      const pending = this._pendingMessages.get(key) ?? [];
-      pending.push(msg);
-      this._pendingMessages.set(key, pending);
+      const queueSize = this._enqueuePendingMessage(key, msg);
+      console.log(`[AgentManager] Queued seq=${seq} while starting pending=${queueSize}`);
       return;
     }
 
@@ -1188,10 +1283,8 @@ export class AgentManager {
     const agent = this.agents.get(key);
     console.log(`[AgentManager] Delivering seq=${seq} to agent ${agent?.config?.displayName ?? agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId}`);
     if (agent?.runtime === 'codex') {
-      if (!this._pendingMessages) this._pendingMessages = new Map();
-      const pending = this._pendingMessages.get(key) ?? [];
-      pending.push(msg);
-      this._pendingMessages.set(key, pending);
+      const queueSize = this._enqueuePendingMessage(key, msg);
+      console.log(`[AgentManager] Queued seq=${seq} for codex next turn pending=${queueSize}`);
       return;
     }
     this._write(key, text);
@@ -1253,13 +1346,43 @@ export class AgentManager {
           }
           break;
         case 'thinking':
+          this._emitLifecycle(connection, {
+            agentId,
+            workspaceId,
+            runtime: 'kimi',
+            reachability: 'reachable',
+            availability: 'busy',
+            runtimeState: 'running',
+            reason: 'thinking',
+            sessionId: agent.sessionId ?? null,
+          });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'thinking', detail: '', entries: [] });
           break;
         case 'tool_call':
+          this._emitLifecycle(connection, {
+            agentId,
+            workspaceId,
+            runtime: 'kimi',
+            reachability: 'reachable',
+            availability: 'busy',
+            runtimeState: 'running',
+            reason: `tool:${evt.name ?? 'unknown_tool'}`,
+            sessionId: agent.sessionId ?? null,
+          });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'working', detail: evt.name, entries: [] });
           break;
         case 'turn_end':
           agent.kimiIdle = true;
+          this._emitLifecycle(connection, {
+            agentId,
+            workspaceId,
+            runtime: 'kimi',
+            reachability: 'reachable',
+            availability: 'available',
+            runtimeState: 'running',
+            reason: 'turn_end',
+            sessionId: agent.sessionId ?? null,
+          });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
           break;
         case 'error':
@@ -1282,12 +1405,42 @@ export class AgentManager {
           }
           break;
         case 'thinking':
+          this._emitLifecycle(connection, {
+            agentId,
+            workspaceId,
+            runtime: 'codex',
+            reachability: 'reachable',
+            availability: 'busy',
+            runtimeState: 'running',
+            reason: 'thinking',
+            sessionId: agent.sessionId ?? null,
+          });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'thinking', detail: '', entries: [] });
           break;
         case 'tool_call':
+          this._emitLifecycle(connection, {
+            agentId,
+            workspaceId,
+            runtime: 'codex',
+            reachability: 'reachable',
+            availability: 'busy',
+            runtimeState: 'running',
+            reason: `tool:${evt.name ?? 'unknown_tool'}`,
+            sessionId: agent.sessionId ?? null,
+          });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'working', detail: evt.name, entries: [] });
           break;
         case 'turn_end':
+          this._emitLifecycle(connection, {
+            agentId,
+            workspaceId,
+            runtime: 'codex',
+            reachability: 'reachable',
+            availability: 'available',
+            runtimeState: 'running',
+            reason: 'turn_end',
+            sessionId: agent.sessionId ?? null,
+          });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
           break;
         case 'error':
@@ -1322,10 +1475,30 @@ export class AgentManager {
           console.log(`[AgentManager][${displayName}] <text> ${block.text?.slice(0, 500)}`);
         } else if (block.type === 'tool_use') {
           console.log(`[AgentManager][${displayName}] <tool_use> ${block.name} params=${JSON.stringify(block.input ?? {}).slice(0, 500)}`);
+          this._emitLifecycle(connection, {
+            agentId,
+            workspaceId,
+            runtime: 'claude',
+            reachability: 'reachable',
+            availability: 'busy',
+            runtimeState: 'running',
+            reason: `tool:${block.name ?? 'unknown_tool'}`,
+            sessionId: this.agents.get(key)?.sessionId ?? null,
+          });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'working', detail: block.name, entries: [] });
         }
       }
       if (!content.some(c => c.type === 'tool_use')) {
+        this._emitLifecycle(connection, {
+          agentId,
+          workspaceId,
+          runtime: 'claude',
+          reachability: 'reachable',
+          availability: 'busy',
+          runtimeState: 'running',
+          reason: 'thinking',
+          sessionId: this.agents.get(key)?.sessionId ?? null,
+        });
         connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'thinking', detail: '', entries: [] });
       }
     } else if (event.type === 'tool') {
@@ -1345,6 +1518,16 @@ export class AgentManager {
       }
     } else if (event.type === 'result') {
       console.log(`[AgentManager][${displayName}] turn done (stop_reason=${event.stop_reason ?? '?'})`);
+      this._emitLifecycle(connection, {
+        agentId,
+        workspaceId,
+        runtime: 'claude',
+        reachability: 'reachable',
+        availability: 'available',
+        runtimeState: 'running',
+        reason: 'turn_end',
+        sessionId: this.agents.get(key)?.sessionId ?? null,
+      });
       connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
     }
   }

package/src/chat-bridge.js

@@ -59,6 +59,14 @@ let currentWorkspaceId = WORKSPACE_ID;
 const VOICEOVER_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'audio');
 const VIDEO_COMPOSE_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'video');
 const DEFAULT_OUTRO_PATH = path.join(homedir(), '.lightcone', 'assets', 'outros', 'default.mp4');
+const CVMAX_WORKSPACE_ID = 'ae63cc9e-feff-4d7e-a62e-a7a7c5fd69d9';
+const CVMAX_EDITOR_IN_CHIEF_AGENT_ID = '91a45fd7-ce5f-4da6-9b27-e34bf7b7c0e2';
+const CVMAX_EDITOR_BLOCKED_VIDEO_TOOLS = new Set([
+  'generate_voiceover',
+  'record_url_narration',
+  'compose_video',
+  'submit_to_library',
+]);
 
 function dataUrlSummary(content) {
   if (typeof content !== 'string' || !content.startsWith('data:')) return null;
@@ -83,6 +91,25 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 }
 
+function isBlockedCvmaxEditorVideoTool(toolName) {
+  return currentWorkspaceId === CVMAX_WORKSPACE_ID
+    && AGENT_ID === CVMAX_EDITOR_IN_CHIEF_AGENT_ID
+    && CVMAX_EDITOR_BLOCKED_VIDEO_TOOLS.has(toolName);
+}
+
+function cvmaxEditorVideoToolError(toolName) {
+  return {
+    isError: true,
+    content: [{
+      type: 'text',
+      text:
+        `Error: ${toolName} blocked for editor_in_chief in CvMax. ` +
+        'In this workspace, @short_video_scripter owns video production. ' +
+        'editor_in_chief may route, review, or assist with OCR/verification, but must not run video production tools directly.',
+    }],
+  };
+}
+
 function normalizeVoiceFormat(value) {
   const normalized = String(value ?? '').trim().toLowerCase();
   if (!normalized) return 'mp3';
@@ -1345,6 +1372,9 @@ server.tool('generate_voiceover',
     credential_id: z.string().optional().describe('Optional explicit credential id. If omitted, uses latest granted tts_provider credential.'),
   },
   async ({ workspace_id, text, voice_preset, speed, format, credential_id }) => {
+    if (isBlockedCvmaxEditorVideoTool('generate_voiceover')) {
+      return cvmaxEditorVideoToolError('generate_voiceover');
+    }
     const targetWorkspaceId = (workspace_id ?? currentWorkspaceId ?? WORKSPACE_ID ?? '').trim();
     if (!targetWorkspaceId) {
       return { isError: true, content: [{ type: 'text', text: 'workspace_id is required (no current workspace context).' }] };
@@ -1425,13 +1455,18 @@ server.tool('record_url_narration',
     fps: z.number().optional().describe('Default 30. Do not change unless needed.'),
     settle_ms: z.number().optional().describe('Default 4000. Settle wait after navigation before recording starts.'),
   },
-  async (args) => runRecordUrlNarrationTool({
-    args,
-    currentWorkspaceId,
-    workspaceDir: WORKSPACE_DIR,
-    runMandatoryLocalToolFn: runMandatoryLocalTool,
-    recordUrlNarrationFn: recordUrlNarration,
-  })
+  async (args) => {
+    if (isBlockedCvmaxEditorVideoTool('record_url_narration')) {
+      return cvmaxEditorVideoToolError('record_url_narration');
+    }
+    return runRecordUrlNarrationTool({
+      args,
+      currentWorkspaceId,
+      workspaceDir: WORKSPACE_DIR,
+      runMandatoryLocalToolFn: runMandatoryLocalTool,
+      recordUrlNarrationFn: recordUrlNarration,
+    });
+  }
 );
 
 // ── compose_video ───────────────────────────────────────────────────────────────
@@ -1449,6 +1484,9 @@ server.tool('compose_video',
     target: z.enum(['short_video_cn', 'douyin', 'xhs']).optional().describe('Transcode target profile. Defaults to short_video_cn.'),
   },
   async ({ video_path, audio_segments, events_log, outro_path, target }) => {
+    if (isBlockedCvmaxEditorVideoTool('compose_video')) {
+      return cvmaxEditorVideoToolError('compose_video');
+    }
     const composeInput = { video_path, audio_segments, events_log, outro_path, target };
     try {
       const result = await runMandatoryLocalTool({
@@ -1547,11 +1585,16 @@ server.tool('submit_to_library',
     understanding: z.record(z.any()).optional().describe('analyze_page 输出'),
     plan: z.record(z.any()).optional().describe('plan_video / detail_sections 输出'),
   },
-  async (args) => runSubmitToLibraryTool({
-    args,
-    currentWorkspaceId,
-    apiFn: api,
-  })
+  async (args) => {
+    if (isBlockedCvmaxEditorVideoTool('submit_to_library')) {
+      return cvmaxEditorVideoToolError('submit_to_library');
+    }
+    return runSubmitToLibraryTool({
+      args,
+      currentWorkspaceId,
+      apiFn: api,
+    });
+  }
 );
 
 // ── register_data_source ───────────────────────────────────────────────────────

package/src/index.js

@@ -4,6 +4,7 @@ import { createRequire } from 'module';
 import { DaemonConnection } from './connection.js';
 import { AgentManager } from './agent-manager.js';
 import { releaseProfileLocksForProcess } from './profile-lock.js';
+import { resolveLightconeServerUrl } from '../../src/runtime/config.js';
 
 const { version } = createRequire(import.meta.url)('../package.json');
 
@@ -39,7 +40,7 @@ if (opts['--help'] || opts['-h']) {
   process.exit(0);
 }
 
-const SERVER_URL = String(opts['--server-url'] || process.env.SERVER_URL || 'http://localhost:9779').trim();
+const SERVER_URL = String(opts['--server-url'] || resolveLightconeServerUrl()).trim();
 const MACHINE_API_KEY = String(opts['--api-key'] || process.env.MACHINE_API_KEY || '').trim();
 
 if (!MACHINE_API_KEY) {

package/src/lifecycle-protocol.js

@@ -0,0 +1,51 @@
+export function resolveExitOfflineDetail({ code, signal, stopCause }) {
+  if (stopCause === 'manual_stop') return '';
+  if (stopCause === 'credential_revoked') return 'credential_revoked';
+  if (code === 0) return '';
+  if (signal === 'SIGTERM') return '';
+  if (signal === 'SIGKILL') return 'agent_timeout';
+  return 'spawn_session_crashed';
+}
+
+export function resolveLifecycleExitState({ runtime, code, signal, stopCause }) {
+  const normalizedRuntime = String(runtime ?? '').trim().toLowerCase() || 'claude';
+  if (stopCause === 'credential_revoked') {
+    return {
+      reachability: 'reachable',
+      availability: 'paused',
+      runtimeState: 'stopped',
+      reason: 'credential_revoked',
+    };
+  }
+  if (stopCause === 'manual_stop') {
+    return {
+      reachability: 'reachable',
+      availability: 'paused',
+      runtimeState: 'stopped',
+      reason: 'manual_stop',
+    };
+  }
+  if (normalizedRuntime === 'codex' && code === 0) {
+    return {
+      reachability: 'reachable',
+      availability: 'available',
+      runtimeState: 'standby',
+      reason: 'normal_exit',
+    };
+  }
+  const offlineDetail = resolveExitOfflineDetail({ code, signal, stopCause });
+  if (!offlineDetail) {
+    return {
+      reachability: 'reachable',
+      availability: 'available',
+      runtimeState: 'stopped',
+      reason: signal === 'SIGTERM' ? 'terminated' : 'stopped',
+    };
+  }
+  return {
+    reachability: 'reachable',
+    availability: 'unreachable',
+    runtimeState: 'crashed',
+    reason: offlineDetail,
+  };
+}