@lightcone-ai/daemon 0.12.0 → 0.13.0

package/package.json

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

package/src/chat-bridge.js

@@ -14,9 +14,19 @@ function getArg(name) {
   return idx !== -1 && cliArgs[idx + 1] ? cliArgs[idx + 1] : '';
 }
 
+function parseBooleanFlag(value, fallback = false) {
+  if (value == null) return fallback;
+  if (typeof value === 'boolean') return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+}
+
 const SERVER_URL      = process.env.SERVER_URL || getArg('--server-url') || 'http://localhost:9779';
 const MACHINE_API_KEY = process.env.MACHINE_API_KEY || getArg('--auth-token') || '';
 const AGENT_ID        = process.env.AGENT_ID || getArg('--agent-id') || '';
+const HOST_AGENT_HINT = process.env.IS_HOST_AGENT || getArg('--is-host-agent') || '';
 const WORKSPACE_ID      = process.env.WORKSPACE_ID || getArg('--workspace-id') || '';  // injected per-workspace at spawn time
 const WORKSPACE_DIR = path.resolve(process.env.WORKSPACE_DIR || getArg('--workspace-dir') || process.cwd());
 const WORKSPACE_ROOT_DIR = path.dirname(WORKSPACE_DIR);
@@ -102,6 +112,18 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   request_approval: 'mandatory',
   execute_approved_action: 'mandatory',
   promote_context: 'mandatory',
+  update_goal_field: 'mandatory',
+  supersede_goal_field: 'mandatory',
+  request_credential_auth: 'mandatory',
+  bind_workspace_scenario: 'mandatory',
+  create_workspace: 'mandatory',
+  rename_workspace: 'mandatory',
+  delete_workspace: 'mandatory',
+  revoke_credential: 'mandatory',
+  submit_feedback: 'mandatory',
+  escalate_to_human: 'mandatory',
+  navigate_to_workspace: 'mandatory',
+  navigate_to_settings: 'mandatory',
 
   search_messages: 'cacheable',
   list_server: 'cacheable',
@@ -111,6 +133,19 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   skill_list: 'cacheable',
   skill_read: 'cacheable',
   skill_search: 'cacheable',
+  search_scenarios: 'cacheable',
+  get_scenario: 'cacheable',
+  list_scenarios: 'cacheable',
+  recommend_scenario: 'cacheable',
+  list_workspaces: 'cacheable',
+  get_workspace_summary: 'cacheable',
+  query_user_history: 'cacheable',
+  list_accounts: 'cacheable',
+  list_credentials: 'cacheable',
+  get_data_locations: 'cacheable',
+  explain_concept: 'cacheable',
+  get_release_notes: 'cacheable',
+  get_known_issues: 'cacheable',
 };
 
 const TOOL_CLASSIFICATION = Object.freeze({
@@ -132,6 +167,18 @@ const CACHE_INVALIDATION_TOOLS = new Set([
   'request_approval',
   'execute_approved_action',
   'promote_context',
+  'update_goal_field',
+  'supersede_goal_field',
+  'request_credential_auth',
+  'bind_workspace_scenario',
+  'create_workspace',
+  'rename_workspace',
+  'delete_workspace',
+  'revoke_credential',
+  'submit_feedback',
+  'escalate_to_human',
+  'navigate_to_workspace',
+  'navigate_to_settings',
 ]);
 
 const governanceContext = {
@@ -196,11 +243,37 @@ function inferToolForApi(method, apiPath, body) {
   if (method === 'PATCH' && cleanPath.startsWith('/skills/')) return 'skill_update';
   if (method === 'POST' && cleanPath === '/actions/request') return 'request_approval';
   if (method === 'POST' && /^\/actions\/[^/]+\/execute$/.test(cleanPath)) return 'execute_approved_action';
+  if (method === 'POST' && cleanPath === '/goal-fields/update') return 'update_goal_field';
+  if (method === 'POST' && cleanPath === '/goal-fields/supersede') return 'supersede_goal_field';
+  if (method === 'POST' && cleanPath === '/credential-auth/request') return 'request_credential_auth';
   if (method === 'POST' && cleanPath === '/orchestrate/decision') return 'write_governance_decision';
   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 === '/context-proposals') return 'promote_context';
+
+  if (method === 'GET' && cleanPath === '/host/scenarios/search') return 'search_scenarios';
+  if (method === 'POST' && cleanPath === '/host/scenarios/recommend') return 'recommend_scenario';
+  if (method === 'GET' && /^\/host\/scenarios\/[^/]+$/.test(cleanPath)) return 'get_scenario';
+  if (method === 'GET' && cleanPath === '/host/scenarios') return 'list_scenarios';
+  if (method === 'POST' && cleanPath === '/host/workspaces/bind-scenario') return 'bind_workspace_scenario';
+  if (method === 'GET' && cleanPath === '/host/workspaces') return 'list_workspaces';
+  if (method === 'POST' && cleanPath === '/host/workspaces') return 'create_workspace';
+  if (method === 'PATCH' && /^\/host\/workspaces\/[^/]+$/.test(cleanPath)) return 'rename_workspace';
+  if (method === 'DELETE' && /^\/host\/workspaces\/[^/]+$/.test(cleanPath)) return 'delete_workspace';
+  if (method === 'GET' && /^\/host\/workspaces\/[^/]+\/summary$/.test(cleanPath)) return 'get_workspace_summary';
+  if (method === 'GET' && cleanPath === '/host/history') return 'query_user_history';
+  if (method === 'GET' && cleanPath === '/host/accounts') return 'list_accounts';
+  if (method === 'GET' && cleanPath === '/host/credentials') return 'list_credentials';
+  if (method === 'POST' && /^\/host\/credentials\/[^/]+\/revoke$/.test(cleanPath)) return 'revoke_credential';
+  if (method === 'GET' && cleanPath === '/host/data-locations') return 'get_data_locations';
+  if (method === 'GET' && cleanPath === '/host/docs/explain') return 'explain_concept';
+  if (method === 'GET' && cleanPath === '/host/docs/release-notes') return 'get_release_notes';
+  if (method === 'GET' && cleanPath === '/host/docs/known-issues') return 'get_known_issues';
+  if (method === 'POST' && cleanPath === '/host/feedback') return 'submit_feedback';
+  if (method === 'POST' && cleanPath === '/host/escalate') return 'escalate_to_human';
+  if (method === 'POST' && cleanPath === '/host/navigation/workspace') return 'navigate_to_workspace';
+  if (method === 'POST' && cleanPath === '/host/navigation/settings') return 'navigate_to_settings';
   return null;
 }
 
@@ -584,6 +657,29 @@ async function api(method, apiPath, body) {
   }
 }
 
+async function resolveHostAgentFlag() {
+  const hinted = parseBooleanFlag(HOST_AGENT_HINT, false);
+  if (!AGENT_ID || !SERVER_URL || !MACHINE_API_KEY) return hinted;
+
+  try {
+    const res = await fetch(`${SERVER_URL}/internal/agent/${AGENT_ID}/profile`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${MACHINE_API_KEY}`,
+      },
+    });
+    if (!res.ok) return hinted;
+    const data = await res.json();
+    if (typeof data?.isHostAgent === 'boolean') return data.isHostAgent;
+    return hinted;
+  } catch {
+    return hinted;
+  }
+}
+
+const IS_HOST_AGENT = await resolveHostAgentFlag();
+
 const server = new McpServer({ name: 'chat', version: '0.1.0' });
 
 // ── check_messages ────────────────────────────────────────────────────────────
@@ -921,6 +1017,106 @@ server.tool('upload_image',
   }
 );
 
+// ── update_goal_field ─────────────────────────────────────────────────────────
+server.tool('update_goal_field',
+  'Incrementally update one goal field in workspace context. Use this during IM dialogue to capture user intent continuously, instead of waiting for a full goal form.',
+  {
+    field_path: z.string().describe('Dot path under goal context, e.g. "brand_positioning.voice" or "audience.primary".'),
+    value: z.any().describe('Field value (string/number/object/array).'),
+    confidence: z.number().min(0).max(1).optional().describe('Confidence in [0,1].'),
+    status: z.enum(['candidate', 'user_confirmed']).optional().describe('candidate=tentative, user_confirmed=explicitly confirmed by user.'),
+    source_turn_id: z.string().optional().describe('Optional conversation turn id for traceability.'),
+  },
+  async ({ field_path, value, confidence, status, source_turn_id }) => {
+    if (!currentWorkspaceId) {
+      return { isError: true, content: [{ type: 'text', text: 'No workspace context. Call check_messages first or specify workspace context in the current conversation.' }] };
+    }
+    const data = await api('POST', '/goal-fields/update', {
+      workspace_id: currentWorkspaceId,
+      field_path,
+      value,
+      confidence,
+      status,
+      source_turn_id,
+    });
+    return {
+      content: [{
+        type: 'text',
+        text:
+          `Goal field updated.\n` +
+          `workspace=${data.workspaceId ?? currentWorkspaceId}\n` +
+          `field_path=${data.fieldPath ?? field_path}\n` +
+          `status=${data.status ?? status ?? 'candidate'}\n` +
+          `context_item_id=${data.contextItemId ?? 'unknown'} version=${data.contextItemVersion ?? 'unknown'}`,
+      }],
+    };
+  }
+);
+
+// ── supersede_goal_field ──────────────────────────────────────────────────────
+server.tool('supersede_goal_field',
+  'Mark an existing goal field value as superseded when the user explicitly changes their mind.',
+  {
+    field_path: z.string().describe('Dot path to supersede, e.g. "audience.primary".'),
+    reason: z.string().optional().describe('Why this field is superseded (optional).'),
+    source_turn_id: z.string().optional().describe('Optional conversation turn id for traceability.'),
+  },
+  async ({ field_path, reason, source_turn_id }) => {
+    if (!currentWorkspaceId) {
+      return { isError: true, content: [{ type: 'text', text: 'No workspace context. Call check_messages first or specify workspace context in the current conversation.' }] };
+    }
+    const data = await api('POST', '/goal-fields/supersede', {
+      workspace_id: currentWorkspaceId,
+      field_path,
+      reason,
+      source_turn_id,
+    });
+    return {
+      content: [{
+        type: 'text',
+        text:
+          `Goal field superseded.\n` +
+          `workspace=${data.workspaceId ?? currentWorkspaceId}\n` +
+          `field_path=${data.fieldPath ?? field_path}\n` +
+          `context_item_id=${data.contextItemId ?? 'unknown'} version=${data.contextItemVersion ?? 'unknown'}`,
+      }],
+    };
+  }
+);
+
+// ── request_credential_auth ───────────────────────────────────────────────────
+server.tool('request_credential_auth',
+  'Request just-in-time credential authorization for a platform. Returns a one-time OAuth URL that should be sent to the user as a clickable IM message.',
+  {
+    platform: z.string().describe('Target platform, e.g. "x".'),
+    reason: z.string().describe('Human-readable reason why this credential is needed right now.'),
+    source_turn_id: z.string().optional().describe('Optional conversation turn id for traceability.'),
+  },
+  async ({ platform, reason, source_turn_id }) => {
+    if (!currentWorkspaceId) {
+      return { isError: true, content: [{ type: 'text', text: 'No workspace context. Call check_messages first or specify workspace context in the current conversation.' }] };
+    }
+    const data = await api('POST', '/credential-auth/request', {
+      workspace_id: currentWorkspaceId,
+      platform,
+      reason,
+      source_turn_id,
+    });
+    return {
+      content: [{
+        type: 'text',
+        text:
+          `Credential auth requested.\n` +
+          `platform=${data.platform ?? platform}\n` +
+          `expires_at=${data.expiresAt ?? 'unknown'}\n` +
+          `auth_url=${data.authUrl}\n` +
+          `im_message_id=${data.messageId ?? 'unknown'}\n\n` +
+          `A structured credential auth message has been posted to IM. Ask the user to click the authorization button there.`,
+      }],
+    };
+  }
+);
+
 // ── request_approval ──────────────────────────────────────────────────────────
 server.tool('request_approval',
   'Request human approval before executing a sensitive platform action (posting, sending, publishing). Returns an action_id. After the human approves, call execute_approved_action with that ID.',
@@ -1122,7 +1318,424 @@ server.tool('complete_orchestrate_trigger',
   }
 );
 
+function hostJsonResult(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+
+function hostErrorResult(err) {
+  return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+}
+
+function buildQuery(params = {}) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value == null) continue;
+    if (typeof value === 'string' && !value.trim()) continue;
+    query.set(key, String(value));
+  }
+  const text = query.toString();
+  return text ? `?${text}` : '';
+}
+
+if (IS_HOST_AGENT) {
+  server.tool('search_scenarios',
+    'Search scenario candidates by user intent for host routing decisions.',
+    {
+      intent_text: z.string().describe('User intent text to match against scenario catalog.'),
+      category: z.string().optional().describe('Optional category filter.'),
+      visibility: z.string().optional().describe('Optional visibility filter (public/system/user_private/org_shared).'),
+      status: z.string().optional().describe('Optional status filter (draft/published/active/deprecated/archived).'),
+      limit: z.number().int().min(1).max(20).optional().describe('Maximum number of returned scenarios.'),
+    },
+    async ({ intent_text, category, visibility, status, limit }) => {
+      try {
+        const query = buildQuery({ intent_text, category, visibility, status, limit });
+        const data = await api('GET', `/host/scenarios/search${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('get_scenario',
+    'Get full scenario details (manifest + roles) for host explanation.',
+    {
+      scenario_id: z.string().describe('Scenario ID to inspect.'),
+    },
+    async ({ scenario_id }) => {
+      try {
+        const data = await api('GET', `/host/scenarios/${encodeURIComponent(scenario_id)}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('list_scenarios',
+    'List scenarios visible to host agent (public/system + owner-accessible).',
+    {
+      visibility: z.string().optional().describe('Optional visibility filter.'),
+      category: z.string().optional().describe('Optional category filter.'),
+      status: z.string().optional().describe('Optional status filter.'),
+      include_archived: z.boolean().optional().describe('Include archived scenarios when true.'),
+      limit: z.number().int().min(1).max(200).optional().describe('Maximum rows to return.'),
+    },
+    async ({ visibility, category, status, include_archived, limit }) => {
+      try {
+        const query = buildQuery({
+          visibility,
+          category,
+          status,
+          includeArchived: include_archived,
+          limit,
+        });
+        const data = await api('GET', `/host/scenarios${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('bind_workspace_scenario',
+    'Bind a scenario to an existing workspace and ensure a primary agent.',
+    {
+      workspace_id: z.string().describe('Workspace ID to bind.'),
+      scenario_id: z.string().describe('Scenario ID to bind.'),
+      role_id: z.string().optional().describe('Optional preferred role id/name for primary agent binding.'),
+      repair_role_binding: z.boolean().optional().describe('When true, ignore existing workspace role binding once and re-resolve primary agent for cleanup.'),
+    },
+    async ({ workspace_id, scenario_id, role_id, repair_role_binding }) => {
+      try {
+        const data = await api('POST', '/host/workspaces/bind-scenario', {
+          workspace_id,
+          scenario_id,
+          role_id,
+          repair_role_binding,
+        });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('recommend_scenario',
+    'Recommend best-fit scenarios for a given user intent.',
+    {
+      user_intent: z.string().describe('Natural-language user intent.'),
+    },
+    async ({ user_intent }) => {
+      try {
+        const data = await api('POST', '/host/scenarios/recommend', { user_intent });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('list_workspaces',
+    'List all owner workspaces with scenario/mode/last activity for host overview.',
+    {
+      owner_id: z.string().optional().describe('Optional owner id (must match current host owner).'),
+      limit: z.number().int().min(1).max(300).optional().describe('Maximum rows to return.'),
+    },
+    async ({ owner_id, limit }) => {
+      try {
+        const query = buildQuery({ owner_id, limit });
+        const data = await api('GET', `/host/workspaces${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('create_workspace',
+    'Create a workspace and optionally bind scenario + primary role.',
+    {
+      name: z.string().optional().describe('Optional workspace name.'),
+      description: z.string().optional().describe('Optional workspace description.'),
+      scenario_id: z.string().optional().describe('Optional scenario id to bind immediately.'),
+      role_id: z.string().optional().describe('Optional preferred role id/name when scenario is bound.'),
+    },
+    async ({ name, description, scenario_id, role_id }) => {
+      try {
+        const data = await api('POST', '/host/workspaces', {
+          name,
+          description,
+          scenario_id,
+          role_id,
+        });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('rename_workspace',
+    'Rename an existing workspace.',
+    {
+      workspace_id: z.string().describe('Workspace ID to rename.'),
+      new_name: z.string().describe('New workspace name.'),
+    },
+    async ({ workspace_id, new_name }) => {
+      try {
+        const data = await api('PATCH', `/host/workspaces/${encodeURIComponent(workspace_id)}`, {
+          new_name,
+        });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('delete_workspace',
+    'Delete (soft-delete) a workspace owned by the current user.',
+    {
+      workspace_id: z.string().describe('Workspace ID to delete.'),
+      confirm: z.boolean().describe('Must be true to confirm deletion.'),
+    },
+    async ({ workspace_id, confirm }) => {
+      try {
+        const query = buildQuery({ confirm });
+        const data = await api('DELETE', `/host/workspaces/${encodeURIComponent(workspace_id)}${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('get_workspace_summary',
+    'Get summary of workspace scenario, active agents, recent messages and publish stats.',
+    {
+      workspace_id: z.string().describe('Workspace ID to summarize.'),
+    },
+    async ({ workspace_id }) => {
+      try {
+        const data = await api('GET', `/host/workspaces/${encodeURIComponent(workspace_id)}/summary`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('query_user_history',
+    'Search user history across owner workspaces for prior activities/messages.',
+    {
+      topic: z.string().describe('Topic keyword to search across workspaces.'),
+      limit: z.number().int().min(1).max(50).optional().describe('Maximum number of results.'),
+    },
+    async ({ topic, limit }) => {
+      try {
+        const query = buildQuery({ topic, limit });
+        const data = await api('GET', `/host/history${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('list_accounts',
+    'List platform accounts owned by the current user.',
+    {
+      owner_id: z.string().optional().describe('Optional owner id (must match current owner).'),
+      workspace_id: z.string().optional().describe('Optional workspace filter; pass "null" for unbound accounts.'),
+      platform: z.string().optional().describe('Optional platform filter.'),
+      status: z.string().optional().describe('Optional status filter.'),
+      include_archived: z.boolean().optional().describe('Include archived accounts.'),
+    },
+    async ({ owner_id, workspace_id, platform, status, include_archived }) => {
+      try {
+        const query = buildQuery({
+          owner_id,
+          workspace_id,
+          platform,
+          status,
+          include_archived,
+        });
+        const data = await api('GET', `/host/accounts${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('list_credentials',
+    'List credentials as masked metadata (no plaintext).',
+    {
+      owner_id: z.string().optional().describe('Optional owner id (must match current owner).'),
+    },
+    async ({ owner_id }) => {
+      try {
+        const query = buildQuery({ owner_id });
+        const data = await api('GET', `/host/credentials${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('revoke_credential',
+    'Revoke a credential with explicit confirmation.',
+    {
+      credential_id: z.string().describe('Credential ID to revoke.'),
+      confirm: z.boolean().describe('Must be true to confirm revocation.'),
+    },
+    async ({ credential_id, confirm }) => {
+      try {
+        const data = await api('POST', `/host/credentials/${encodeURIComponent(credential_id)}/revoke`, {
+          confirm,
+        });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('get_data_locations',
+    'Describe where user/platform data is stored.',
+    {},
+    async () => {
+      try {
+        const data = await api('GET', '/host/data-locations');
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('explain_concept',
+    'Explain a product concept from docs corpus.',
+    {
+      topic: z.string().describe('Concept/topic text to explain.'),
+    },
+    async ({ topic }) => {
+      try {
+        const query = buildQuery({ topic });
+        const data = await api('GET', `/host/docs/explain${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('get_release_notes',
+    'Get release notes/events since a specified timestamp.',
+    {
+      since: z.string().optional().describe('Optional ISO timestamp (default: last 30 days).'),
+    },
+    async ({ since }) => {
+      try {
+        const query = buildQuery({ since });
+        const data = await api('GET', `/host/docs/release-notes${query}`);
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('get_known_issues',
+    'Get current known issues and limitations.',
+    {},
+    async () => {
+      try {
+        const data = await api('GET', '/host/docs/known-issues');
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('submit_feedback',
+    'Submit user feedback into internal backlog workflow.',
+    {
+      category: z.enum(['bug', 'feature', 'ux', 'performance', 'security', 'other']).describe('Feedback category.'),
+      content: z.string().describe('Feedback content.'),
+      workspace_id: z.string().optional().describe('Optional workspace context for this feedback.'),
+    },
+    async ({ category, content, workspace_id }) => {
+      try {
+        const data = await api('POST', '/host/feedback', {
+          category,
+          content,
+          workspace_id,
+        });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('escalate_to_human',
+    'Escalate severe issue to human operators.',
+    {
+      issue: z.string().describe('Issue details to escalate.'),
+      priority: z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Escalation priority.'),
+      workspace_id: z.string().optional().describe('Optional workspace context for escalation.'),
+    },
+    async ({ issue, priority, workspace_id }) => {
+      try {
+        const data = await api('POST', '/host/escalate', {
+          issue,
+          priority,
+          workspace_id,
+        });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('navigate_to_workspace',
+    'Emit navigation intent for UI to open a target workspace.',
+    {
+      workspace_id: z.string().describe('Target workspace ID.'),
+    },
+    async ({ workspace_id }) => {
+      try {
+        const data = await api('POST', '/host/navigation/workspace', { workspace_id });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+
+  server.tool('navigate_to_settings',
+    'Emit navigation intent for UI to open a settings section.',
+    {
+      section: z.string().describe('Settings section key, e.g. "credentials", "profile", "workspace".'),
+    },
+    async ({ section }) => {
+      try {
+        const data = await api('POST', '/host/navigation/settings', { section });
+        return hostJsonResult(data);
+      } catch (err) {
+        return hostErrorResult(err);
+      }
+    }
+  );
+}
+
 // ── start ─────────────────────────────────────────────────────────────────────
 const transport = new StdioServerTransport();
 await server.connect(transport);
-console.error(`[chat-bridge] MCP Server started (agentId=${AGENT_ID})`);
+console.error(`[chat-bridge] MCP Server started (agentId=${AGENT_ID}, host=${IS_HOST_AGENT ? 'true' : 'false'})`);