kiku-agent 1.0.6 → 1.0.8

package/server/agent/config.js

@@ -1,4 +1,31 @@
-export const CLOUD_PROVIDERS = {
+const PROVIDER_MODEL_ALIASES = {
+  openai: {
+    'o1-mini': 'gpt-5.6-luna',
+    'o3-mini': 'gpt-5.6-luna',
+  },
+  openrouter: {
+    auto: 'openrouter/auto',
+  },
+  groq: {
+    'gpt-oss-120b': 'openai/gpt-oss-120b',
+    'gpt-oss-20b': 'openai/gpt-oss-20b',
+  },
+  deepseek: {
+    'deepseek-chat': 'deepseek-v4-flash',
+    'deepseek-reasoner': 'deepseek-v4-flash',
+  },
+  gemini: {
+    'gemini-3.1-pro': 'gemini-3.1-pro-preview',
+  },
+};
+
+export function normalizeProviderModel(providerId, modelId) {
+  const normalizedProvider = String(providerId || '').toLowerCase().trim();
+  const normalizedModel = String(modelId || '').trim();
+  return PROVIDER_MODEL_ALIASES[normalizedProvider]?.[normalizedModel] || normalizedModel;
+}
+
+export const CLOUD_PROVIDERS = {
   lmstudio: {
     id: 'lmstudio',
     name: 'LM Studio (Local)',
@@ -23,18 +50,17 @@ export const CLOUD_PROVIDERS = {
     name: 'OpenAI Cloud',
     baseUrl: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1',
     apiKey: process.env.OPENAI_API_KEY || '',
-    defaultModel: process.env.OPENAI_MODEL || 'gpt-4o-mini',
+    defaultModel: normalizeProviderModel('openai', process.env.OPENAI_MODEL || 'gpt-5.6-luna'),
     isLocal: false,
     envKey: 'OPENAI_API_KEY',
-    docUrl: 'https://platform.openai.com/docs',
-    apiRefUrl: 'https://platform.openai.com/docs/api-reference',
-    pricingSummary: 'Pay-per-token (gpt-4o-mini: ~$0.15/1M in, $0.60/1M out)',
+    docUrl: 'https://developers.openai.com/api/docs/models',
+    apiRefUrl: 'https://developers.openai.com/api/reference',
+    pricingSummary: 'GPT-5.6 Luna: $0.20/1M in, $1.20/1M out; Terra/Sol available for higher capability',
     features: ['tools', 'streaming', 'vision', 'reasoning', 'system-prompt'],
     recommendedModels: [
-      { id: 'gpt-4o-mini', name: 'GPT-4o Mini', tier: 'ultra-cheap', cost: '$0.15 / 1M in', context: '128k', hasTools: true, description: 'Recommended default. Fast, intelligent, and highly cost-effective with tool use.' },
-      { id: 'gpt-4o', name: 'GPT-4o', tier: 'flagship', cost: '$2.50 / 1M in', context: '128k', hasTools: true, description: 'OpenAI flagship multimodal model for complex multimodal & reasoning tasks.' },
-      { id: 'o3-mini', name: 'o3 Mini', tier: 'reasoning', cost: '$1.10 / 1M in', context: '200k', hasTools: true, description: 'Fast, cost-efficient reasoning model with function calling capabilities.' },
-      { id: 'o1-mini', name: 'o1 Mini', tier: 'reasoning', cost: '$1.10 / 1M in', context: '128k', hasTools: true, description: 'Reasoning model specialized for complex STEM logic and coding.' },
+      { id: 'gpt-5.6-luna', name: 'GPT-5.6 Luna', tier: 'cost-sensitive', cost: '$0.20 / 1M in', context: '1.05M', hasTools: true, description: 'Recommended default for efficient, high-volume multilingual agent workloads.' },
+      { id: 'gpt-5.6-terra', name: 'GPT-5.6 Terra', tier: 'balanced', cost: '$2.00 / 1M in', context: '1.05M', hasTools: true, description: 'Balances intelligence and cost for production reasoning and tool use.' },
+      { id: 'gpt-5.6-sol', name: 'GPT-5.6 Sol', tier: 'flagship', cost: '$4.00 / 1M in', context: '1.05M', hasTools: true, description: 'Flagship model for complex professional reasoning and coding.' },
     ],
   },
   openrouter: {
@@ -42,62 +68,53 @@ export const CLOUD_PROVIDERS = {
     name: 'OpenRouter Cloud',
     baseUrl: process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api/v1',
     apiKey: process.env.OPENROUTER_API_KEY || '',
-    defaultModel: process.env.OPENROUTER_MODEL || 'google/gemini-2.5-flash',
-    extraHeaders: {
-      'HTTP-Referer': 'https://jujingyi-kikuuu.vercel.app/',
-      'X-Title': 'Kiku Agent',
-    },
+    defaultModel: normalizeProviderModel('openrouter', process.env.OPENROUTER_MODEL || 'openrouter/auto'),
+    extraHeaders: {
+      'HTTP-Referer': 'https://jujingyi-kikuuu.vercel.app/',
+      'X-OpenRouter-Title': 'Kiku Agent',
+    },
     isLocal: false,
     envKey: 'OPENROUTER_API_KEY',
-    docUrl: 'https://openrouter.ai/docs/quick-start',
-    apiRefUrl: 'https://openrouter.ai/docs/api_reference/overview',
-    pricingSummary: 'Universal aggregator with free tiers & flexible pay-as-you-go',
+    docUrl: 'https://openrouter.ai/docs/guides/routing/routers/auto-router',
+    apiRefUrl: 'https://openrouter.ai/docs/api/reference/overview',
+    pricingSummary: 'Auto Router selects a current model dynamically; usage is billed at the routed model rate',
     features: ['universal-routing', 'tools', 'streaming', 'free-tier', 'fallback'],
     recommendedModels: [
-      { id: 'google/gemini-2.5-flash', name: 'Gemini 2.5 Flash', tier: 'ultra-cheap', cost: '$0.10 / 1M in', context: '1M', hasTools: true, description: 'Super fast with huge 1M context window and native function calling.' },
-      { id: 'deepseek/deepseek-chat', name: 'DeepSeek Chat (V3)', tier: 'ultra-cheap', cost: '$0.14 / 1M in', context: '64k', hasTools: true, description: 'DeepSeek-V3 671B MoE via OpenRouter at ultra-low price.' },
-      { id: 'deepseek/deepseek-r1', name: 'DeepSeek Reasoner (R1)', tier: 'reasoning', cost: '$0.55 / 1M in', context: '64k', hasTools: false, description: 'Full DeepSeek-R1 reasoning with Chain-of-Thought output.' },
-      { id: 'meta-llama/llama-3.3-70b-instruct', name: 'Llama 3.3 70B Instruct', tier: 'balanced', cost: '$0.40 / 1M in', context: '128k', hasTools: true, description: 'State-of-the-art open-weights flagship model.' },
-      { id: 'openai/gpt-4o-mini', name: 'GPT-4o Mini', tier: 'ultra-cheap', cost: '$0.15 / 1M in', context: '128k', hasTools: true, description: 'OpenAI mini model routed via OpenRouter.' },
-      { id: 'qwen/qwen-2.5-72b-instruct', name: 'Qwen 2.5 72B Instruct', tier: 'balanced', cost: '$0.35 / 1M in', context: '128k', hasTools: true, description: 'Top-tier open-weights multilingual and coding model.' },
-      { id: 'meta-llama/llama-3.1-8b-instruct:free', name: 'Llama 3.1 8B (Free)', tier: 'free', cost: '$0.00', context: '128k', hasTools: true, description: 'Free tier Llama 3.1 8B on OpenRouter.' },
+      { id: 'openrouter/auto', name: 'OpenRouter Auto Router', tier: 'dynamic', cost: 'Routed model rate', context: 'Model-dependent', hasTools: true, description: 'Recommended default. Chooses from the current catalog so a retired third-party model does not break startup.' },
     ],
   },
-  groq: {
+  groq: {
     id: 'groq',
     name: 'Groq Cloud',
     baseUrl: process.env.GROQ_BASE_URL || 'https://api.groq.com/openai/v1',
     apiKey: process.env.GROQ_API_KEY || '',
-    defaultModel: process.env.GROQ_MODEL || 'llama-3.3-70b-versatile',
+    defaultModel: normalizeProviderModel('groq', process.env.GROQ_MODEL || 'openai/gpt-oss-120b'),
     isLocal: false,
     envKey: 'GROQ_API_KEY',
     docUrl: 'https://console.groq.com/docs/quickstart',
     apiRefUrl: 'https://console.groq.com/docs/api-reference',
-    pricingSummary: 'Ultra-fast LPU inference (llama-3.1-8b: $0.05/1M, llama-3.3-70b: $0.59/1M)',
+    pricingSummary: 'Ultra-fast LPU inference (GPT-OSS 20B: $0.075/1M in, GPT-OSS 120B: $0.15/1M in)',
     features: ['lpu-speed', 'tools', 'streaming', 'openai-compatible'],
-    recommendedModels: [
-      { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B Versatile', tier: 'balanced', cost: '$0.59 / 1M in', context: '128k', hasTools: true, description: 'Recommended default. 70B flagship quality with fast LPU speed and tool use.' },
-      { id: 'llama-3.1-8b-instant', name: 'Llama 3.1 8B Instant', tier: 'ultra-cheap', cost: '$0.05 / 1M in', context: '128k', hasTools: true, description: 'Blazing fast (~800 tokens/s) and ultra-low cost for quick inquiries.' },
-      { id: 'gpt-oss-120b', name: 'GPT-OSS 120B', tier: 'balanced', cost: '$0.59 / 1M in', context: '128k', hasTools: true, description: 'Open-weights 120B flagship model running with ultra-fast Groq LPU inference.' },
-      { id: 'mixtral-8x7b-32768', name: 'Mixtral 8x7B', tier: 'cheap', cost: '$0.24 / 1M in', context: '32k', hasTools: true, description: 'Mistral MoE architecture with 32k context.' },
-      { id: 'gemma2-9b-it', name: 'Gemma 2 9B IT', tier: 'cheap', cost: '$0.20 / 1M in', context: '8k', hasTools: true, description: 'Google Gemma 2 on Groq LPU hardware.' },
-    ],
+    recommendedModels: [
+      { id: 'openai/gpt-oss-120b', name: 'GPT-OSS 120B', tier: 'flagship', cost: '$0.15 / 1M in', context: '131k', hasTools: true, description: 'Recommended default. Production-grade 120B reasoning model with tool use on Groq.' },
+      { id: 'openai/gpt-oss-20b', name: 'GPT-OSS 20B', tier: 'ultra-cheap', cost: '$0.075 / 1M in', context: '131k', hasTools: true, description: 'Fast production model for lower-cost, high-volume requests.' },
+    ],
   },
   deepseek: {
     id: 'deepseek',
     name: 'DeepSeek Cloud',
-    baseUrl: process.env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com/v1',
+    baseUrl: process.env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com',
     apiKey: process.env.DEEPSEEK_API_KEY || '',
-    defaultModel: process.env.DEEPSEEK_MODEL || 'deepseek-chat',
+    defaultModel: normalizeProviderModel('deepseek', process.env.DEEPSEEK_MODEL || 'deepseek-v4-flash'),
     isLocal: false,
     envKey: 'DEEPSEEK_API_KEY',
     docUrl: 'https://api-docs.deepseek.com',
     apiRefUrl: 'https://api-docs.deepseek.com/api/create-chat-completion',
-    pricingSummary: 'Ultra-low cost (deepseek-chat: $0.14 cached / $0.27 uncached / 1M)',
-    features: ['deepseek-v3', 'deepseek-r1-reasoning', 'tools', 'streaming', 'context-cache'],
+    pricingSummary: 'V4 Flash: $0.22-$0.44/1M uncached input; V4 Pro: $0.66-$1.32/1M (off-peak/peak)',
+    features: ['deepseek-v4', 'thinking', 'tools', 'streaming', 'context-cache', '1m-context'],
     recommendedModels: [
-      { id: 'deepseek-chat', name: 'DeepSeek Chat (V3)', tier: 'ultra-cheap', cost: '$0.14-$0.27 / 1M in', context: '64k', hasTools: true, description: 'Recommended default. DeepSeek-V3 671B MoE, top-tier reasoning, tool calling, fast & ultra-cheap.' },
-      { id: 'deepseek-reasoner', name: 'DeepSeek Reasoner (R1)', tier: 'reasoning', cost: '$0.55 / 1M in', context: '64k', hasTools: false, description: 'DeepSeek-R1 full Chain-of-Thought reasoning with native thinking output.' },
+      { id: 'deepseek-v4-flash', name: 'DeepSeek V4 Flash', tier: 'balanced', cost: '$0.22-$0.44 / 1M uncached in', context: '1M', hasTools: true, description: 'Recommended default. Current V4 model with tool calls and thinking/non-thinking modes.' },
+      { id: 'deepseek-v4-pro', name: 'DeepSeek V4 Pro', tier: 'flagship', cost: '$0.66-$1.32 / 1M uncached in', context: '1M', hasTools: true, description: 'Higher-capability V4 model with tool calls and thinking mode.' },
     ],
   },
   gemini: {
@@ -105,18 +122,17 @@ export const CLOUD_PROVIDERS = {
     name: 'Google Gemini Cloud',
     baseUrl: process.env.GEMINI_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta/openai/',
     apiKey: process.env.GEMINI_API_KEY || '',
-    defaultModel: process.env.GEMINI_MODEL || 'gemini-2.5-flash',
+    defaultModel: normalizeProviderModel('gemini', process.env.GEMINI_MODEL || 'gemini-3.7-flash'),
     isLocal: false,
     envKey: 'GEMINI_API_KEY',
-    docUrl: 'https://ai.google.dev/docs',
-    apiRefUrl: 'https://ai.google.dev/api',
-    pricingSummary: 'Ultra-cheap (gemini-2.5-flash: $0.10/1M in, $0.40/1M out)',
+    docUrl: 'https://ai.google.dev/gemini-api/docs',
+    apiRefUrl: 'https://ai.google.dev/api/generate-content',
+    pricingSummary: 'Gemini 3.7 Flash: free tier available; paid standard $0.75/1M input through 2026',
     features: ['1m-context', 'multimodal', 'tools', 'streaming', 'thinking'],
     recommendedModels: [
-      { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', tier: 'ultra-cheap', cost: '$0.10 / 1M in', context: '1M', hasTools: true, description: 'Recommended default. Advanced reasoning and thinking capabilities with 1M context.' },
-      { id: 'gemini-2.5-flash-lite', name: 'Gemini 2.5 Flash Lite', tier: 'lowest-cost', cost: '$0.075 / 1M in', context: '1M', hasTools: true, description: 'Cost-optimized 2.5 lightweight model for high volume queries.' },
-      { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', tier: 'flagship', cost: '$1.25 / 1M in', context: '2M', hasTools: true, description: 'Deep reasoning and 2M context for complex multimodal analysis.' },
-      { id: 'gemini-3.1-pro', name: 'Gemini 3.1 Pro', tier: 'flagship', cost: '$1.50 / 1M in', context: '2M', hasTools: true, description: 'Next-gen Gemini 3.1 flagship with state-of-the-art coding and multimodal reasoning.' },
+      { id: 'gemini-3.7-flash', name: 'Gemini 3.7 Flash', tier: 'latest-stable', cost: '$0.75 / 1M in (2026)', context: '1M', hasTools: true, description: 'Recommended default. Latest stable Flash model for agentic workflows and multimodal reasoning.' },
+      { id: 'gemini-3.5-flash-lite', name: 'Gemini 3.5 Flash-Lite', tier: 'lowest-cost', cost: '$0.30 / 1M in', context: '1M', hasTools: true, description: 'Stable, cost-efficient model for high-volume translation and simple processing.' },
+      { id: 'gemini-3.6-flash', name: 'Gemini 3.6 Flash', tier: 'stable', cost: '$0.75 / 1M in (2026)', context: '1M', hasTools: true, description: 'Stable previous-generation Flash fallback with function calling and thinking.' },
     ],
   },
   custom: {

package/server/agent/jobManager.js

@@ -0,0 +1,96 @@
+function errorMessage(error) {
+  return error?.message || String(error || 'Unknown error');
+}
+
+export class AgentJobManager {
+  constructor(limit = 50) {
+    this.limit = limit;
+    this.jobs = [];
+  }
+
+  create(type, label) {
+    const controller = new AbortController();
+    const job = {
+      id: `job_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+      type: String(type || 'task'),
+      label: String(label || type || 'Task').slice(0, 200),
+      state: 'running',
+      createdAt: new Date().toISOString(),
+      startedAt: new Date().toISOString(),
+      completedAt: null,
+      error: null,
+      result: null,
+      controller,
+    };
+    this.jobs.unshift(job);
+    this.jobs = this.jobs.slice(0, this.limit);
+    return job;
+  }
+
+  async run(type, label, runner, options = {}) {
+    const job = this.create(type, label);
+    const abortParent = () => job.controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', abortParent, { once: true });
+    options.onJob?.(this.publicJob(job));
+    try {
+      const result = await runner({ signal: job.controller.signal, job: this.publicJob(job) });
+      job.state = job.controller.signal.aborted ? 'cancelled' : 'completed';
+      job.result = result;
+      job.completedAt = new Date().toISOString();
+      return result;
+    } catch (error) {
+      job.state = job.controller.signal.aborted || error?.name === 'AbortError' ? 'cancelled' : 'failed';
+      job.error = errorMessage(error);
+      job.completedAt = new Date().toISOString();
+      throw error;
+    } finally {
+      options.signal?.removeEventListener('abort', abortParent);
+    }
+  }
+
+  list() {
+    return this.jobs.map(job => this.publicJob(job));
+  }
+
+  get(id) {
+    const job = this.jobs.find(item => item.id === id);
+    return job ? this.publicJob(job) : null;
+  }
+
+  cancel(id) {
+    const job = this.jobs.find(item => item.id === id);
+    if (!job || job.state !== 'running') return false;
+    job.state = 'cancelled';
+    job.completedAt = new Date().toISOString();
+    job.controller.abort(new DOMException('Cancelled by user', 'AbortError'));
+    return true;
+  }
+
+  cancelType(type) {
+    let cancelled = false;
+    for (const job of this.jobs) {
+      if (job.type === type && job.state === 'running') cancelled = this.cancel(job.id) || cancelled;
+    }
+    return cancelled;
+  }
+
+  clear() {
+    const before = this.jobs.length;
+    this.jobs = this.jobs.filter(job => job.state === 'running');
+    return before - this.jobs.length;
+  }
+
+  publicJob(job) {
+    return {
+      id: job.id,
+      type: job.type,
+      label: job.label,
+      state: job.state,
+      createdAt: job.createdAt,
+      startedAt: job.startedAt,
+      completedAt: job.completedAt,
+      error: job.error,
+      result: job.result,
+    };
+  }
+}

package/server/agent/llmClient.js

@@ -1,9 +1,12 @@
-import { config, CLOUD_PROVIDERS } from './config.js';
+import { config, CLOUD_PROVIDERS, normalizeProviderModel } from './config.js';
 
 export class LLMClient {
   constructor(options = {}) {
-    const providerId = (options.provider || config.activeProvider || 'lmstudio').toLowerCase();
-    const providerDef = CLOUD_PROVIDERS[providerId] || CLOUD_PROVIDERS.lmstudio;
+    const providerId = (options.provider || config.activeProvider || 'lmstudio').toLowerCase();
+    const providerDef = CLOUD_PROVIDERS[providerId];
+    if (!providerDef) {
+      throw new Error(`Unknown provider "${providerId}". Supported: ${Object.keys(CLOUD_PROVIDERS).join(', ')}`);
+    }
 
     this.provider = providerId;
     this.providerName = providerDef.name || providerId;
@@ -11,7 +14,10 @@ export class LLMClient {
     this.apiKey = options.apiKey !== undefined
       ? options.apiKey
       : (providerDef.apiKey !== undefined ? providerDef.apiKey : (providerDef.isLocal ? (config.lmStudio.apiKey || 'lm-studio') : ''));
-    this.model = options.model || providerDef.defaultModel || config.lmStudio.model || 'google/gemma-4-e4b';
+    this.model = normalizeProviderModel(
+      providerId,
+      options.model || providerDef.defaultModel || config.lmStudio.model || 'google/gemma-4-e4b'
+    );
     this.timeout = options.timeout || config.lmStudio.requestTimeoutMs || 180000;
     this.extraHeaders = { ...(providerDef.extraHeaders || {}), ...(options.extraHeaders || {}) };
   }
@@ -27,7 +33,7 @@ export class LLMClient {
     this.providerName = providerDef.name || pId;
     this.baseUrl = (options.baseUrl || providerDef.baseUrl).replace(/\/+$/, '');
     this.apiKey = options.apiKey !== undefined ? options.apiKey : (providerDef.apiKey || '');
-    this.model = options.model || providerDef.defaultModel;
+    this.model = normalizeProviderModel(pId, options.model || providerDef.defaultModel);
     this.extraHeaders = { ...(providerDef.extraHeaders || {}), ...(options.extraHeaders || {}) };
     return this.getProviderInfo();
   }
@@ -40,7 +46,7 @@ export class LLMClient {
   setModel(model) {
     const trimmed = String(model || '').trim();
     if (!trimmed) throw new Error('A model ID is required.');
-    this.model = trimmed;
+    this.model = normalizeProviderModel(this.provider, trimmed);
     return this.model;
   }
 
@@ -187,8 +193,9 @@ export class LLMClient {
     onToken = null,
     onThought = null
   }) {
-    const isReasoningModel = /^(o1|o3|deepseek-reasoner)/i.test(this.model) || this.model.includes('reasoner');
-    const isO1OrO3 = /^(o1|o3)/i.test(this.model);
+    const isLegacyReasoningModel = /^(o1|o3|deepseek-reasoner)/i.test(this.model) || this.model.includes('reasoner');
+    const usesCompletionTokenLimit = /^(o1|o3|gpt-5(?:\.|-|$))/i.test(this.model);
+    const rejectsTemperature = /^(o1|o3|gpt-5(?:\.|-|$))/i.test(this.model);
 
     const buildPayload = (includeTools = true, includeTemp = true) => {
       const p = {
@@ -197,17 +204,17 @@ export class LLMClient {
         stream
       };
 
-      if (!isO1OrO3 && includeTemp && temperature !== undefined && temperature !== null) {
-        p.temperature = temperature;
-      }
-
-      if (isO1OrO3) {
-        p.max_completion_tokens = maxTokens;
-      } else {
-        p.max_tokens = maxTokens;
-      }
-
-      if (includeTools && tools && Array.isArray(tools) && tools.length > 0 && !isReasoningModel) {
+      if (!rejectsTemperature && includeTemp && temperature !== undefined && temperature !== null) {
+        p.temperature = temperature;
+      }
+
+      if (usesCompletionTokenLimit) {
+        p.max_completion_tokens = maxTokens;
+      } else {
+        p.max_tokens = maxTokens;
+      }
+
+      if (includeTools && tools && Array.isArray(tools) && tools.length > 0 && !isLegacyReasoningModel) {
         p.tools = tools;
         p.tool_choice = "auto";
       }

package/server/agent/mcpClient.js

@@ -11,11 +11,53 @@ export class McpClientManager {
   constructor(options = {}) {
     this.clientInfo = options.clientInfo || { name: 'kiku-agent', version: PACKAGE_VERSION };
     this.autoLoad = options.autoLoad !== false;
+    this.globalConfigPath = options.globalConfigPath || path.join(KIKU_DATA_DIR, 'mcp_servers.json');
+    this.configPaths = options.configPaths || [
+      this.globalConfigPath,
+      path.join(process.cwd(), 'opencode.json'),
+      path.join(process.cwd(), '.mcp.json'),
+      path.join(process.cwd(), 'mcp.json'),
+    ];
     this.servers = new Map();
     this.persistedConfigs = new Map();
+    this.configSources = new Map();
     this.toolRegistry = new Map();
   }
 
+  _trackConfigSource(serverName, filePath) {
+    const name = String(serverName || '').trim();
+    if (!name || !filePath) return;
+    const resolvedPath = path.resolve(filePath);
+    const sources = this.configSources.get(name) || new Set();
+    sources.add(resolvedPath);
+    this.configSources.set(name, sources);
+  }
+
+  async _removeFromConfigFile(filePath, serverName) {
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch (error) {
+      if (error?.code === 'ENOENT') return false;
+      throw error;
+    }
+
+    const parsed = JSON.parse(content);
+    let changed = false;
+    for (const key of ['mcpServers', 'mcp']) {
+      const servers = parsed[key];
+      if (servers && typeof servers === 'object' && Object.hasOwn(servers, serverName)) {
+        delete servers[serverName];
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      await fs.writeFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+    }
+    return changed;
+  }
+
   async connect(serverName, serverConfig = {}, { persist = true } = {}) {
     const name = String(serverName || '').trim();
     if (!name) throw new Error('Server name is required to connect to MCP.');
@@ -107,7 +149,8 @@ export class McpClientManager {
       this._rebuildToolRegistry();
 
       if (persist) {
-        await this.savePersistedConfig().catch(() => {});
+        const saveResult = await this.savePersistedConfig().catch(() => null);
+        if (saveResult?.success) this._trackConfigSource(name, saveResult.filePath);
       }
 
       return {
@@ -153,12 +196,25 @@ export class McpClientManager {
   }
 
   async remove(serverName, { persist = true } = {}) {
+    const wasConnected = this.servers.has(serverName);
     await this.disconnect(serverName, { persist: false });
     const hadPersisted = this.persistedConfigs.delete(serverName);
+    const sources = [...(this.configSources.get(serverName) || [])];
+    let removedFromSource = false;
+
     if (persist) {
-      await this.savePersistedConfig().catch(() => {});
+      for (const sourcePath of sources) {
+        const removed = await this._removeFromConfigFile(sourcePath, serverName);
+        removedFromSource = removedFromSource || removed;
+      }
+
+      const saveResult = await this.savePersistedConfig();
+      if (!saveResult.success) {
+        throw new Error(`Failed to update global MCP configuration: ${saveResult.error}`);
+      }
     }
-    return hadPersisted;
+    this.configSources.delete(serverName);
+    return wasConnected || hadPersisted || removedFromSource;
   }
 
   async disconnectAll() {
@@ -325,6 +381,7 @@ export class McpClientManager {
         resourcesCount: server.resources.length,
         promptsCount: server.prompts.length,
         connectedAt: server.connectedAt,
+        sources: [...(this.configSources.get(name) || [])],
         config: server.config,
       });
     }
@@ -339,6 +396,7 @@ export class McpClientManager {
         resourcesCount: 0,
         promptsCount: 0,
         error: cfg.lastError || null,
+        sources: [...(this.configSources.get(name) || [])],
         config: cfg,
       });
     }
@@ -353,7 +411,7 @@ export class McpClientManager {
 
   async savePersistedConfig(customPath) {
     try {
-      const filePath = customPath || path.join(KIKU_DATA_DIR, 'mcp_servers.json');
+      const filePath = customPath || this.globalConfigPath;
       await fs.mkdir(path.dirname(filePath), { recursive: true });
 
       const serversObj = {};
@@ -369,6 +427,9 @@ export class McpClientManager {
       }
 
       await fs.writeFile(filePath, JSON.stringify({ mcpServers: serversObj }, null, 2), 'utf8');
+      for (const name of Object.keys(serversObj)) {
+        this._trackConfigSource(name, filePath);
+      }
       return { success: true, filePath, count: Object.keys(serversObj).length };
     } catch (err) {
       return { success: false, error: err.message };
@@ -383,20 +444,15 @@ export class McpClientManager {
   async loadPersistedServers() {
     if (this.autoLoad === false) return [];
     const results = [];
-    const candidates = [
-      path.join(KIKU_DATA_DIR, 'mcp_servers.json'),
-      path.join(process.cwd(), 'opencode.json'),
-      path.join(process.cwd(), '.mcp.json'),
-      path.join(process.cwd(), 'mcp.json'),
-    ];
 
-    for (const filePath of candidates) {
+    for (const filePath of this.configPaths) {
       try {
         const content = await fs.readFile(filePath, 'utf8');
         const parsed = JSON.parse(content);
         const serversObj = parsed.mcpServers || parsed.mcp || {};
         for (const [name, cfg] of Object.entries(serversObj)) {
           this.persistedConfigs.set(name, cfg);
+          this._trackConfigSource(name, filePath);
           if (cfg.enabled === false || cfg.disabled === true) continue;
           if (this.servers.has(name)) continue;
           try {
@@ -422,6 +478,7 @@ export class McpClientManager {
 
     for (const [name, cfg] of Object.entries(serversObj)) {
       this.persistedConfigs.set(name, cfg);
+      this._trackConfigSource(name, resolvedPath);
       if (cfg.enabled === false || cfg.disabled === true) continue;
       try {
         const res = await this.connect(name, cfg);

package/server/agent/memory.js

@@ -13,9 +13,10 @@ export class AgentMemory {
     this.preferences = {
       language: null,          
       topicsOfInterest: [],    
-      responseStyle: 'default', 
-      userSkills: [],
-      skillsEnabled: true,
+      responseStyle: 'default', 
+      userSkills: [],
+      skillsEnabled: true,
+      favorites: [],
     };
     this.sessions = [];         
     this.summaries = [];       
@@ -68,9 +69,10 @@ export class AgentMemory {
       const loadedPrefs = parsed.preferences || {};
       this.preferences = {
         ...this.preferences,
-        ...loadedPrefs,
-        userSkills: Array.isArray(loadedPrefs.userSkills) ? loadedPrefs.userSkills : [],
-        topicsOfInterest: (loadedPrefs.topicsOfInterest || []).map(t => ({
+        ...loadedPrefs,
+        userSkills: Array.isArray(loadedPrefs.userSkills) ? loadedPrefs.userSkills : [],
+        favorites: Array.isArray(loadedPrefs.favorites) ? loadedPrefs.favorites : [],
+        topicsOfInterest: (loadedPrefs.topicsOfInterest || []).map(t => ({
           ...t,
           lastSeen: t.lastSeen ? new Date(t.lastSeen) : new Date()
         }))
@@ -238,10 +240,78 @@ export class AgentMemory {
     return grouped;
   }
 
-  setPreference(key, value) {
-    this.preferences[key] = value;
-    this.save().catch(() => {});
-  }
+  setPreference(key, value) {
+    this.preferences[key] = value;
+    this.save().catch(() => {});
+  }
+
+  addFavorite(entity = {}) {
+    const allowedTypes = ['work', 'song', 'role', 'brand', 'award', 'photo', 'stage'];
+    const type = String(entity.type || '').toLowerCase();
+    const title = String(entity.title || '').replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 200);
+    const entityId = String(entity.entityId || title).replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 200);
+    if (!allowedTypes.includes(type)) throw new Error(`Favorite type must be one of: ${allowedTypes.join(', ')}.`);
+    if (!title || !entityId) throw new Error('Favorite title and entity ID are required.');
+    if (!Array.isArray(this.preferences.favorites)) this.preferences.favorites = [];
+    const duplicate = this.preferences.favorites.find(item => item.type === type && item.entityId.toLowerCase() === entityId.toLowerCase());
+    if (duplicate) return { favorite: duplicate, created: false };
+    const favorite = {
+      id: `fav_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+      type,
+      entityId,
+      title,
+      year: Number.isInteger(Number(entity.year)) ? Number(entity.year) : null,
+      detail: String(entity.detail || '').replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 300),
+      url: /^https?:\/\//i.test(String(entity.url || '')) ? String(entity.url).slice(0, 1000) : null,
+      createdAt: new Date().toISOString(),
+    };
+    this.preferences.favorites.unshift(favorite);
+    this.preferences.favorites = this.preferences.favorites.slice(0, 200);
+    this.save().catch(() => {});
+    return { favorite, created: true };
+  }
+
+  getFavorites(type) {
+    const favorites = Array.isArray(this.preferences.favorites) ? this.preferences.favorites : [];
+    if (!type || type === 'all') return [...favorites];
+    return favorites.filter(item => item.type === String(type).toLowerCase());
+  }
+
+  removeFavorite(id) {
+    if (!/^fav_[a-zA-Z0-9_]+$/.test(String(id || ''))) return false;
+    const favorites = Array.isArray(this.preferences.favorites) ? this.preferences.favorites : [];
+    const before = favorites.length;
+    this.preferences.favorites = favorites.filter(item => item.id !== id);
+    if (this.preferences.favorites.length === before) return false;
+    this.save().catch(() => {});
+    return true;
+  }
+
+  async exportFavorites(format = 'json') {
+    const normalized = String(format || 'json').toLowerCase();
+    if (!['json', 'markdown'].includes(normalized)) throw new Error('Favorite export format must be json or markdown.');
+    await fs.mkdir(EXPORT_DIR, { recursive: true });
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const extension = normalized === 'markdown' ? 'md' : 'json';
+    const filename = `kiku-favorites-${timestamp}.${extension}`;
+    const filePath = path.join(EXPORT_DIR, filename);
+    const favorites = this.getFavorites();
+    const content = normalized === 'json'
+      ? JSON.stringify({ exportedAt: now.toISOString(), count: favorites.length, favorites }, null, 2)
+      : [
+          '# Kiku Agent Favorites',
+          '',
+          `Exported: ${now.toISOString()}`,
+          '',
+          '| ID | Type | Title | Year | Detail |',
+          '|---|---|---|---:|---|',
+          ...favorites.map(item => `| ${item.id} | ${item.type} | ${String(item.title).replace(/\|/g, '\\|')} | ${item.year || ''} | ${String(item.detail || '').replace(/\|/g, '\\|')} |`),
+          '',
+        ].join('\n');
+    await fs.writeFile(filePath, content, 'utf-8');
+    return { filePath, filename, count: favorites.length, size: (await fs.stat(filePath)).size };
+  }
 
   addUserSkill(instruction) {
     const value = String(instruction || '').replace(/\s+/g, ' ').trim();
@@ -633,10 +703,13 @@ export class AgentMemory {
 
   async clearAll() {
     this.facts = [];
-    this.preferences = {
-      language: null,
-      topicsOfInterest: [],
-      responseStyle: 'default'
+    this.preferences = {
+      language: null,
+      topicsOfInterest: [],
+      responseStyle: 'default',
+      userSkills: [],
+      skillsEnabled: true,
+      favorites: [],
     };
     this.sessions = [];
     this.summaries = [];