@lightcone-ai/daemon 0.15.57 → 0.15.59

package/mcp-servers/mysql/core.js

@@ -4,6 +4,7 @@ export const DEFAULT_LIMIT = 200;
 export const MAX_LIMIT = 1000;
 
 const READ_QUERY_PREFIX = /^(SELECT|SHOW|DESCRIBE|DESC|EXPLAIN|WITH)\b/i;
+const AUTO_LIMIT_PREFIX = /^(SELECT|WITH)\b/i;
 const REQUIRED_DB_KEYS = ['DB_HOST', 'DB_PORT', 'DB_USER', 'DB_PASSWORD', 'DB_NAME'];
 
 function trimTrailingSemicolons(sql) {
@@ -27,6 +28,10 @@ export function isReadQuery(sql) {
   return READ_QUERY_PREFIX.test(sql);
 }
 
+export function supportsAutoLimit(sql) {
+  return AUTO_LIMIT_PREFIX.test(sql);
+}
+
 export function hasLimitClause(sql) {
   return /\bLIMIT\b/i.test(sql);
 }
@@ -36,7 +41,7 @@ export function prepareSql(sql, limit) {
   if (!normalizedSql) throw new Error('sql must be a non-empty string');
 
   const effectiveLimit = normalizeLimit(limit);
-  if (!isReadQuery(normalizedSql) || hasLimitClause(normalizedSql)) {
+  if (!supportsAutoLimit(normalizedSql) || hasLimitClause(normalizedSql)) {
     return {
       sql: normalizedSql,
       limit: effectiveLimit,

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.57",
+  "version": "0.15.59",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -183,6 +183,7 @@ export class AgentManager {
     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 +1715,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/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', {