@lightcone-ai/daemon 0.15.58 → 0.15.60

package/mcp-servers/publisher/official-tool-client.js

@@ -138,13 +138,14 @@ export async function callOfficialTool({
   toolName,
   argumentsPayload = {},
   timeoutMs = 10000,
+  env = {},
 }) {
-  const entrypointPath = resolveMcpServerEntrypoint(serverId, { strict: true });
+  const entrypointPath = resolveMcpServerEntrypoint(serverId);
   if (!entrypointPath) {
     throw new Error(`official_server_not_found:${serverId}`);
   }
 
-  const client = new StdioJsonRpcClient(process.execPath, [entrypointPath]);
+  const client = new StdioJsonRpcClient(process.execPath, [entrypointPath], env);
   try {
     await client.start();
     await client.request('initialize', {

package/package.json

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

package/src/agent-manager.js

@@ -179,10 +179,53 @@ export class AgentManager {
     return `${workspaceId ?? ''}:${agentId}`;
   }
 
+  /**
+   * Snapshot of agents this daemon process is currently managing. Sent to the
+   * server alongside 'ready' so the server can reconcile lifecycle state
+   * after a reconnect — agents previously on this machine but absent from
+   * the inventory get reset from stale `crashed unreachable` back to a clean
+   * `standby reachable available` baseline (machine is healthy, agent will
+   * be spawned on demand).
+   *
+   * Each entry mirrors the daemon-internal agent state machine:
+   *   - 'starting': spawn in progress (entry exists in this.starting)
+   *   - 'running':  child process is alive (this.agents has it)
+   * The server treats whatever is NOT in this list as 'standby' (spawnable
+   * but not currently running on this machine).
+   */
+  getAgentInventory() {
+    const inventory = [];
+    for (const key of this.starting) {
+      const colonIdx = key.indexOf(':');
+      const workspaceId = colonIdx === -1 ? null : (key.slice(0, colonIdx) || null);
+      const agentId = colonIdx === -1 ? key : key.slice(colonIdx + 1);
+      inventory.push({
+        agentId,
+        workspaceId,
+        runtimeState: 'starting',
+      });
+    }
+    for (const [key, agent] of this.agents.entries()) {
+      const colonIdx = key.indexOf(':');
+      const workspaceId = agent.workspaceId
+        ?? (colonIdx === -1 ? null : (key.slice(0, colonIdx) || null));
+      const agentId = agent.agentId
+        ?? (colonIdx === -1 ? key : key.slice(colonIdx + 1));
+      inventory.push({
+        agentId,
+        workspaceId,
+        runtimeState: 'running',
+        sessionId: agent.sessionId ?? null,
+      });
+    }
+    return inventory;
+  }
+
   handle(msg, connection) {
     switch (msg.type) {
       case 'agent:start':       return this._startAgent(msg, connection);
       case 'agent:stop':        return this._stopAgent(msg.agentId, msg.workspaceId, connection);
+      case 'agent:cancel_turn': return this._cancelAgentTurn(msg.agentId, msg.workspaceId, connection);
       case 'agent:deliver':     return this._deliverMessage(msg, connection);
       case 'agent:reprobe':     return this._reprobeCapability(msg, connection);
       case 'publish:job':       return this._handlePublishJob(msg, connection);
@@ -1714,6 +1757,61 @@ export class AgentManager {
     // exit handler will report status
   }
 
+  _cancelAgentTurn(agentId, workspaceId, connection) {
+    const key = this._key(agentId, workspaceId);
+    const queued = this._pendingMessages?.get(key)?.length ?? 0;
+    if (queued > 0) {
+      this._pendingMessages.delete(key);
+    }
+
+    const agent = this.agents.get(key);
+    if (!agent?.proc) {
+      console.log(`[AgentManager] Cancel turn requested for inactive agent ${agentId} workspace=${workspaceId ?? 'none'} queued_cleared=${queued}`);
+      connection.send({
+        type: 'agent:cancel_turn:ack',
+        agentId,
+        workspaceId,
+        ok: queued > 0,
+        queuedCleared: queued,
+        running: false,
+      });
+      return;
+    }
+
+    console.log(`[AgentManager] Cancelling current turn for agent ${agentId} workspace=${workspaceId ?? 'none'} queued_cleared=${queued}`);
+    agent.stopCause = 'user_cancelled';
+    connection.send({
+      type: 'agent:cancel_turn:ack',
+      agentId,
+      workspaceId,
+      ok: true,
+      queuedCleared: queued,
+      running: true,
+    });
+    this._emitLifecycle(connection, {
+      agentId,
+      workspaceId,
+      runtime: agent.runtime ?? 'claude',
+      reachability: 'reachable',
+      availability: 'available',
+      runtimeState: 'running',
+      reason: 'user_cancelled',
+      sessionId: agent.sessionId ?? null,
+    });
+
+    try {
+      agent.proc.kill('SIGINT');
+    } catch (err) {
+      console.error(`[AgentManager] cancel SIGINT failed for ${key}:`, err?.message ?? err);
+    }
+    setTimeout(() => {
+      if (this.agents.get(key) !== agent) return;
+      try {
+        agent.proc.kill('SIGTERM');
+      } catch {}
+    }, 1500);
+  }
+
   _deliverMessage(msg, connection) {
     const { agentId, workspaceId, seq, message } = msg;
     const key = this._key(agentId, workspaceId);

package/src/chat-bridge.js

@@ -141,6 +141,7 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   write_governance_correction: 'local',
   get_orchestrate_context: 'local',
   complete_orchestrate_trigger: 'local',
+  propose_goal_candidate: 'local',
 
   send_message: 'mandatory',
   create_tasks: 'mandatory',
@@ -302,6 +303,7 @@ function inferToolForApi(method, apiPath, body) {
   if (method === 'POST' && cleanPath === '/orchestrate/correction') return 'write_governance_correction';
   if (method === 'GET'  && cleanPath === '/orchestrate/context') return 'get_orchestrate_context';
   if (method === 'POST' && cleanPath === '/orchestrate/complete') return 'complete_orchestrate_trigger';
+  if (method === 'POST' && cleanPath === '/orchestrate/propose-goal-candidate') return 'propose_goal_candidate';
   if (method === 'POST' && cleanPath === '/context-proposals') return 'promote_context';
 
   if (method === 'GET' && cleanPath === '/host/scenarios/search') return 'search_scenarios';
@@ -1747,6 +1749,49 @@ server.tool('get_orchestrate_context',
   }
 );
 
+// ── propose_goal_candidate ────────────────────────────────────────────────────
+server.tool('propose_goal_candidate',
+  'Orchestrator-only: propose a goal_state_candidate for human review. Use when D1 (goal_extraction_opportunity) fires and you have extracted a goal/constraint shape from the user\'s recent messages. The candidate enters the existing candidate→confirm→promote flow; ONLY Human can promote it to active goal_states. Always include `source_excerpts` (verbatim user quotes the proposal is derived from) so the confirm card can show provenance.',
+  {
+    workspace_id: z.string().describe('Target workspace id; you must be the registered orchestrator for it.'),
+    goal: z.record(z.any()).describe('Proposed goal object. Required: a non-empty object describing the workspace goal, e.g. { title, description, kpis, ... }. Be concrete — vague platitudes like "comply with brand" are useless.'),
+    constraints: z.array(z.any()).optional().describe('Proposed constraints array (optional). Each item should be enforceable by detector A4 / worker review, not a slogan.'),
+    current_phase: z.string().optional().describe('Current phase label (optional, e.g. "exploration" / "stable_publish").'),
+    source_excerpts: z.array(z.string()).describe('Verbatim user quotes the proposal is derived from. REQUIRED for non-trivial proposals — the confirm card surfaces these to the user as provenance.'),
+    source_risk: z.enum(['trusted', 'normal', 'untrusted', 'hostile']).optional().describe('Source risk classification: "trusted" if quoting user directly, "normal" if interpreting user intent, "untrusted" if drawing from worker output / external content. Default normal.'),
+    trigger_id: z.string().optional().describe('Originating trigger id, e.g. "D1". Default "D1".'),
+    detector_version: z.string().optional().describe('Detector version that fired, e.g. "rule-v1".'),
+    reason: z.string().optional().describe('Human-readable rationale for the proposal.'),
+    expires_in_minutes: z.number().int().optional().describe('Candidate TTL in minutes (default 30, max 7 days).'),
+  },
+  async ({ workspace_id, goal, constraints, current_phase, source_excerpts, source_risk, trigger_id, detector_version, reason, expires_in_minutes }) => {
+    try {
+      const data = await api('POST', '/orchestrate/propose-goal-candidate', {
+        workspaceId: workspace_id,
+        goal,
+        constraints,
+        currentPhase: current_phase,
+        sourceExcerpts: source_excerpts,
+        sourceRisk: source_risk,
+        triggerId: trigger_id,
+        detectorVersion: detector_version,
+        reason,
+        expiresInMinutes: expires_in_minutes,
+      });
+      const c = data?.candidate;
+      return {
+        content: [{
+          type: 'text',
+          text: `Goal candidate proposed. id=${c?.id} status=${c?.status} expires_at=${c?.expiresAt}\n`
+            + `Awaiting human confirm via UI; no active goal_states change yet.`,
+        }],
+      };
+    } catch (err) {
+      return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+    }
+  }
+);
+
 // ── complete_orchestrate_trigger ──────────────────────────────────────────────
 server.tool('complete_orchestrate_trigger',
   'Orchestrator-only: mark a processing orchestrator trigger as completed (status processing→completed) and reset its circuit breaker. Call this once you have written all governance actions for the current trigger.',

package/src/connection.js

@@ -45,10 +45,16 @@ function parseOptionalDeviceHints() {
 }
 
 export class DaemonConnection {
-  constructor({ serverUrl, machineApiKey, onMessage }) {
+  constructor({ serverUrl, machineApiKey, onMessage, getAgentInventory = null }) {
     this.serverUrl = serverUrl.replace(/^http/, 'ws');
     this.machineApiKey = machineApiKey;
     this.onMessage = onMessage;
+    // Optional callback invoked at 'ready' time to snapshot which agents
+    // this daemon is currently managing. Server uses this to reconcile
+    // stale lifecycle state after reconnects (see src/daemon/index.js
+    // 'ready' handler — agents previously on this machine but missing
+    // from inventory get reset from stale crashed→standby).
+    this.getAgentInventory = typeof getAgentInventory === 'function' ? getAgentInventory : null;
     this.ws = null;
     this.reconnectDelay = RECONNECT_INITIAL;
     this.stopped = false;
@@ -111,7 +117,20 @@ export class DaemonConnection {
       ...parseOptionalDeviceHints(),
     };
 
-    console.log(`[Connection] Ready — host=${hostname} runtimes=[${runtimes.join(',')}] v${DAEMON_VERSION}`);
+    let agentInventory = [];
+    if (this.getAgentInventory) {
+      try {
+        const snapshot = this.getAgentInventory();
+        if (Array.isArray(snapshot)) agentInventory = snapshot;
+      } catch (err) {
+        console.warn(`[Connection] getAgentInventory failed: ${err?.message ?? err}`);
+      }
+    }
+
+    console.log(
+      `[Connection] Ready — host=${hostname} runtimes=[${runtimes.join(',')}] v${DAEMON_VERSION}`
+      + ` inventory=${agentInventory.length}`
+    );
     this.send({
       type: 'ready',
       hostname,
@@ -119,6 +138,7 @@ export class DaemonConnection {
       runtimes,
       daemonVersion: DAEMON_VERSION,
       deviceHints,
+      agentInventory,
     });
   }
 

package/src/index.js

@@ -58,6 +58,7 @@ const connection = new DaemonConnection({
   serverUrl: SERVER_URL,
   machineApiKey: MACHINE_API_KEY,
   onMessage: (msg) => agentManager.handle(msg, connection),
+  getAgentInventory: () => agentManager.getAgentInventory(),
 });
 
 connection.connect();

package/src/lifecycle-protocol.js

@@ -1,5 +1,6 @@
 export function resolveExitOfflineDetail({ code, signal, stopCause }) {
   if (stopCause === 'manual_stop') return '';
+  if (stopCause === 'user_cancelled') return '';
   if (stopCause === 'credential_revoked') return 'credential_revoked';
   if (stopCause === 'contract_violation') return 'contract_violation:visible_text_without_send_message';
   if (stopCause === 'outbound_rate_limited') return 'outbound_rate_limited';
@@ -27,6 +28,14 @@ export function resolveLifecycleExitState({ runtime, code, signal, stopCause })
       reason: 'manual_stop',
     };
   }
+  if (stopCause === 'user_cancelled') {
+    return {
+      reachability: 'reachable',
+      availability: 'available',
+      runtimeState: 'stopped',
+      reason: 'user_cancelled',
+    };
+  }
   if (stopCause === 'contract_violation') {
     return {
       reachability: 'reachable',

package/src/publish-job-runner.js

@@ -608,7 +608,14 @@ export async function runPublishJob({ serverUrl, machineApiKey, agentId, workspa
         text,
         tags,
         payload,
-        callTool: callOfficialTool,
+        callTool: (toolArgs) => callOfficialTool({
+          ...toolArgs,
+          env: {
+            SERVER_URL: serverUrl,
+            MACHINE_API_KEY: machineApiKey,
+            AGENT_ID: agentId,
+          },
+        }),
       });
     } catch (error) {
       emitPublishJobProgress(onProgress, 'precheck_error', {