tachibot-mcp 2.23.1 → 2.23.3

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to TachiBot MCP will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.23.3] - 2026-06-17
+
+### Changed
+- **GLM-5.1 → GLM-5.2** (`z-ai/glm-5.2`, released Jun 13 on OpenRouter, verified via grok_search + web): Zhipu's open-weights flagship for long-horizon tasks — usable 1M-token context (up from agentic-tier 5.1), two thinking-effort levels (High/Max). SWE-Bench Pro 62.1 (up from 58.4), Terminal-Bench 2.1 81.0 (up from 62.0); beats GPT-5.5 on several long-horizon coding benchmarks at ~1/6 the cost. List price $1.40/$4.40 per M (262K max output). Powers `glm_reason` and the `glm` juror. GLM-5.1 kept as quota fallback via `MODEL_FALLBACKS` (GLM-5.2 → GLM-5.1 → GLM-5); the `glm` substring already routes 5.2 to the 600s reasoning timeout.
+
+## [2.23.2] - 2026-06-15
+
+### Changed
+- **Kimi K2.6 → K2.7-Code** (`moonshotai/kimi-k2.7-code`, released Jun 12 on OpenRouter, verified via grok_search): coding-specialized variant built on K2.6 — +21.8% on Kimi Code Bench v2 with lower token use, 262K context, native multimodal, always-thinking mode. List price $0.75/$3.50 per M. Now powers all Kimi tools — `kimi_thinking`, `kimi_code`, `kimi_decompose`, `kimi_long_context` (`openrouter-tools.ts`) and the `kimi` juror (`jury-tool.ts`). K2.6 kept as quota fallback via `MODEL_FALLBACKS` (K2.7-Code → K2.6 → K2-Thinking); the `kimi` substring already routes K2.7-Code to the 600s reasoning timeout (regression test added).
+
+### Notes
+- No general-purpose Kimi K2.7 exists yet — K2.7-Code is the only post-K2.6 release. The coding-tuned model now also serves the reasoning/long-context tools and the kimi juror.
+
 ## [2.23.1] - 2026-06-11
 
 ### Changed

package/README.md

@@ -4,7 +4,7 @@
 
 ### Multi-Model AI Orchestration Platform
 
-[![Version](https://img.shields.io/badge/version-2.15.2-blue.svg)](https://www.npmjs.com/package/tachibot-mcp)
+[![Version](https://img.shields.io/badge/version-2.23.2-blue.svg)](https://www.npmjs.com/package/tachibot-mcp)
 [![Tools](https://img.shields.io/badge/tools-57_active-brightgreen.svg)](#-tool-ecosystem-57-tools)
 [![License](https://img.shields.io/badge/license-AGPL--3.0-green.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
@@ -12,7 +12,7 @@
 
 **57 AI tools. 12 providers. One protocol.**
 
-Orchestrate Perplexity, Grok, GPT-5.5, Gemini, Qwen, Kimi K2.6, and MiniMax M3
+Orchestrate Perplexity, Grok, GPT-5.5, Gemini, Qwen, Kimi K2.7-Code, and MiniMax M3
 from Claude Code, Claude Desktop, Cursor, or any MCP client.
 
 [Get Started](#-quick-start) · [View Tools](#-tool-ecosystem-57-tools) · [Documentation](https://tachibot.com/docs)

package/dist/src/config/model-constants.js

@@ -87,12 +87,14 @@ export const GROK_MODELS = {
     _3: "grok-3", // Legacy with search: 256K→2M
 };
 // Kimi Models (Moonshot AI via OpenRouter)
-// K2.6 released Apr 20, 2026 - 1T MoE, leads SWE-bench Pro for long-horizon coding
-// K2.5 released Jan 27, 2026 - kept as fallback
+// K2.7-Code released Jun 12, 2026 - coding-specialized (built on K2.6), +21.8% on Kimi Code Bench v2, lower token use, 262K ctx, multimodal, always-thinking
+// K2.6 released Apr 20, 2026 - 1T MoE, leads SWE-bench Pro for long-horizon coding (fallback)
+// K2.5 released Jan 27, 2026 - kept as legacy
 export const KIMI_MODELS = {
     K2_THINKING: "moonshotai/kimi-k2-thinking", // 1T MoE, 32B active - agentic reasoning (256k context)
-    K2_6: "moonshotai/kimi-k2.6", // CURRENT: 1T MoE, SWE-Pro leader, ~$0.74/$4.65
-    K2_5: "moonshotai/kimi-k2.5", // Previous: multimodal + agent swarm (fallback)
+    K2_7_CODE: "moonshotai/kimi-k2.7-code", // CURRENT (Jun 12, 2026): coding-specialized, +21.8% Code Bench v2, 262K ctx, $0.75/$3.50
+    K2_6: "moonshotai/kimi-k2.6", // Previous (Apr 2026): 1T MoE, SWE-Pro leader (fallback)
+    K2_5: "moonshotai/kimi-k2.5", // Legacy: multimodal + agent swarm
 };
 // MiniMax Models (MiniMax via OpenRouter)
 // M3 released May 31, 2026 - 1M ctx, MSA sparse attention (~1/20 compute at 1M), native multimodal
@@ -186,7 +188,7 @@ export const CURRENT_MODELS = {
         reason: PERPLEXITY_MODELS.SONAR_REASONING, // sonar-reasoning-pro $2/$8 per M
     },
     openrouter: {
-        kimi: KIMI_MODELS.K2_6, // K2.6 (Apr 2026): 1T MoE, SWE-bench Pro leader
+        kimi: KIMI_MODELS.K2_7_CODE, // K2.7-Code (Jun 2026): coding-specialized, built on K2.6
         qwen: QWEN_MODELS.CODER_NEXT, // Qwen3-Coder-Next: 80B/3B MoE, 262K ctx, SWE >70% (no 3.6-coder yet)
         qwen_reason: QWEN_MODELS.MAX_THINKING, // 235B MoE thinking mode (HMMT 98%) — still best for reasoning
         minimax: MINIMAX_MODELS.M3, // M3: 1M ctx, MSA sparse attention, agentic/coding
@@ -304,7 +306,7 @@ export const TOOL_DEFAULTS = {
         temperature: 0.3, // Lower for precise reasoning
     },
     kimi_thinking: {
-        model: KIMI_MODELS.K2_6, // K2.6 (Apr 2026): 1T MoE, SWE-bench Pro leader
+        model: KIMI_MODELS.K2_7_CODE, // K2.7-Code (Jun 2026): coding-specialized, built on K2.6
         maxTokens: 16000,
         temperature: 0.7,
     },
@@ -370,6 +372,7 @@ export const MODEL_DISPLAY_NAMES = {
     "sonar-reasoning-pro": "perplexity-reason",
     // Kimi (Moonshot)
     "moonshotai/kimi-k2-thinking": "kimi-k2",
+    "moonshotai/kimi-k2.7-code": "kimi-k2.7-code",
     "moonshotai/kimi-k2.6": "kimi-k2.6",
     "moonshotai/kimi-k2.5": "kimi-k2.5",
     "moonshotai/kimi-k2.5-thinking": "kimi-k2.5",
@@ -424,6 +427,7 @@ export const MODEL_PRICING = {
     "sonar-reasoning-pro": 0.006, // avoid - expensive reasoning tokens
     // OpenRouter models - Kimi
     "moonshotai/kimi-k2-thinking": 0.002,
+    "moonshotai/kimi-k2.7-code": 0.002125, // ($0.75 + $3.50) / 2 / 1000 (Jun 12, 2026)
     "moonshotai/kimi-k2.6": 0.0027, // ($0.74 + $4.65) / 2 / 1000 (Apr 2026)
     "moonshotai/kimi-k2.5": 0.003,
     "moonshotai/kimi-k2.5-thinking": 0.003,

package/dist/src/config/model-defaults.js

@@ -28,7 +28,7 @@ const MODELS = {
     // OpenRouter
     QWEN: QWEN_MODELS.CODER_NEXT, // qwen/qwen3-coder-next (80B/3B MoE, 262K ctx)
     QWEN_REASON: QWEN_MODELS.MAX_THINKING, // qwen/qwen3-235b-a22b-thinking (235B MoE)
-    KIMI: KIMI_MODELS.K2_6, // moonshotai/kimi-k2.6 (Apr 2026 - SWE-bench Pro leader)
+    KIMI: KIMI_MODELS.K2_7_CODE, // moonshotai/kimi-k2.7-code (Jun 2026 - coding-specialized, built on K2.6)
     MINIMAX: MINIMAX_MODELS.M3, // minimax/minimax-m3 (May 2026 - 1M ctx, MSA sparse attention)
 };
 /**

package/dist/src/config/timeout-config.js

@@ -36,8 +36,8 @@ export function getTimeoutConfig() {
  * Thinking/reasoning/swarm models get extended timeout (600s default).
  * Standard models get 180s default.
  *
- * NOTE: All Kimi K2 variants (incl. 'moonshotai/kimi-k2.6') run the Agent Swarm
- * and need the extended timeout — but their model IDs don't contain 'thinking',
+ * NOTE: All Kimi K2 variants (incl. 'moonshotai/kimi-k2.7-code', which is always in
+ * thinking mode) need the extended timeout — but their model IDs don't contain 'thinking',
  * so we match 'kimi' explicitly. Same applies to DeepSeek V4 and Zhipu GLM, whose
  * reasoning passes are slow but whose IDs lack the 'thinking'/'reasoning' marker.
  * This keeps primary and fallback consistent and lets these tools inherit 600s

package/dist/src/memory/index.js

@@ -9,7 +9,7 @@ export * from './memory-manager.js';
 // Provider exports
 export * from './providers/local-provider.js';
 export * from './providers/mem0-provider.js';
-// export * from './providers/dokoro-provider.js';
+export * from './providers/dokoro-provider.js';
 // export * from './providers/hybrid-provider.js';
 // Main API
 export { getMemoryManager, resetMemoryManager, HierarchicalMemoryManager } from './memory-manager.js';

package/dist/src/memory/memory-config.js

@@ -109,9 +109,8 @@ export function validateMemoryConfig(config) {
     if (config.provider === 'mem0' && !config.mem0?.apiKey && !process.env.MEM0_API_KEY) {
         errors.push('Mem0 provider requires API key (MEM0_API_KEY or config.mem0.apiKey)');
     }
-    if (config.provider === 'dokoro' && !config.dokoro?.connectionString && !process.env.DOKORO_CONNECTION) {
-        errors.push('Dokoro provider requires connection string');
-    }
+    // Dokoro is file-backed: connectionString is optional (falls back to
+    // DOKORO_PATH env or {cwd}/dokoro), so no validation needed here.
     if (config.provider === 'local' && !config.local?.path) {
         errors.push('Local provider requires storage path');
     }

package/dist/src/memory/memory-manager.js

@@ -6,7 +6,7 @@ import { mergeMemoryConfig, validateMemoryConfig } from './memory-config.js';
 import { LocalProvider } from './providers/local-provider.js';
 import { Mem0Provider } from './providers/mem0-provider.js';
 import { randomBytes } from 'crypto';
-// import { DokoroProvider } from './providers/dokoro-provider.js';
+import { DokoroProvider } from './providers/dokoro-provider.js';
 // import { HybridProvider } from './providers/hybrid-provider.js';
 /**
  * Main memory manager that coordinates all providers
@@ -245,9 +245,15 @@ export class HierarchicalMemoryManager {
                     return null;
                 }
             case 'dokoro':
-                // TODO: Implement Dokoro provider
-                console.warn('Dokoro provider not yet implemented');
-                return null;
+                try {
+                    const provider = new DokoroProvider(this.config.dokoro || {});
+                    await provider.initialize();
+                    return provider;
+                }
+                catch (error) {
+                    console.error('Failed to create Dokoro provider:', error);
+                    return null;
+                }
             case 'local':
                 return await this.createLocalProvider();
             case 'hybrid':

package/dist/src/memory/providers/dokoro-provider.js

@@ -1,185 +1,169 @@
 /**
  * Dokoro Memory Provider
- * Integration with Dokoro for development logging and memory persistence
+ *
+ * File-backed integration with a dokoro workspace. dokoro is a local-first,
+ * per-project agent-memory system: there is no client library and no network
+ * endpoint — its workspace is a folder of markdown files with YAML frontmatter.
+ *
+ * Resolution convention (same as planner-tools.ts):
+ *   connectionString (treated as DOKORO_PATH override)
+ *   || process.env.DOKORO_PATH
+ *   || {cwd}/dokoro
+ *
+ * Memories are written to <dokoroPath>/sessions/ as markdown files; reads
+ * cover both <dokoroPath>/sessions/ and <dokoroPath>/daily/.
+ *
+ * If the workspace folder cannot be created/written, the provider degrades
+ * to an in-memory store (never throws out of the provider for storage issues).
  */
 import { BaseMemoryProvider } from '../memory-interface.js';
+import * as fs from 'fs/promises';
+import { constants as fsConstants } from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+const MEMORY_TIERS = ['session', 'working', 'project', 'team', 'global'];
 /**
- * Dokoro provider implementation
+ * Dokoro provider implementation (file-backed)
  */
 export class DokoroProvider extends BaseMemoryProvider {
     constructor(config) {
         super();
         this.name = 'dokoro';
-        this.client = null;
-        this.isConnected = false;
+        this.fileBacked = false;
+        this.fallbackStore = new Map();
+        // Spread first, then resolve defaults — explicit-undefined fields in the
+        // caller's config must not clobber env/default resolution.
         this.config = {
-            connectionString: config.connectionString || process.env.DOKORO_CONNECTION,
-            workspace: config.workspace || process.env.DOKORO_WORKSPACE || 'default',
-            projectId: config.projectId || process.env.DOKORO_PROJECT,
-            enableSync: config.enableSync !== false,
-            ...config
+            ...config,
+            connectionString: config.connectionString ?? process.env.DOKORO_CONNECTION,
+            workspace: config.workspace ?? process.env.DOKORO_WORKSPACE ?? 'default',
+            projectId: config.projectId ?? process.env.DOKORO_PROJECT,
+            enableSync: config.enableSync !== false
         };
+        // connectionString acts as a DOKORO_PATH override; same resolution
+        // convention as planner-tools.ts getDokoroDailyDir().
+        this.dokoroPath = path.resolve(this.config.connectionString ||
+            process.env.DOKORO_PATH ||
+            path.join(process.cwd(), 'dokoro'));
+        this.sessionsDir = path.join(this.dokoroPath, 'sessions');
+        this.dailyDir = path.join(this.dokoroPath, 'daily');
     }
     async doInitialize() {
         try {
-            // Try to load Dokoro client dynamically
-            const dokoroModule = await this.loadDokoroModule();
-            if (!dokoroModule) {
-                // Create a mock/local implementation if Dokoro is not available
-                this.client = this.createLocalDokoro();
-            }
-            else {
-                // Use actual Dokoro client
-                this.client = new dokoroModule.DokoroClient({
-                    connectionString: this.config.connectionString,
-                    workspace: this.config.workspace
-                });
-            }
-            // Connect to Dokoro
-            if (this.client) {
-                await this.client.connect();
-                this.isConnected = true;
-            }
-            console.error(`Dokoro provider initialized for workspace: ${this.config.workspace}`);
+            await fs.mkdir(this.sessionsDir, { recursive: true });
+            await fs.access(this.sessionsDir, fsConstants.W_OK);
+            this.fileBacked = true;
+            console.error(`Dokoro provider: file-backed at ${this.dokoroPath}`);
         }
         catch (error) {
-            console.error('Failed to initialize Dokoro provider:', error);
-            // Fall back to local implementation
-            this.client = this.createLocalDokoro();
-            await this.client.connect();
-            this.isConnected = true;
+            this.fileBacked = false;
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Dokoro provider: workspace unavailable at ${this.dokoroPath}, using in-memory fallback (${message})`);
         }
     }
     async store(item) {
-        if (!this.isConnected || !this.client) {
-            throw new Error('Dokoro provider not initialized');
+        if (!item.id) {
+            item.id = this.generateId();
         }
-        try {
-            // Convert MemoryItem to Dokoro entry
-            const entry = {
-                type: `memory_${item.tier}`,
-                content: item.content,
-                metadata: {
-                    ...item.metadata,
-                    memoryId: item.id,
-                    tier: item.tier,
-                    teamId: item.teamId,
-                    ttl: item.ttl,
-                    accessCount: item.accessCount
-                },
-                workspace: this.config.workspace,
-                project: item.projectId || this.config.projectId,
-                user: item.userId,
-                tags: item.tags,
-                timestamp: item.timestamp
-            };
-            // Store in Dokoro
-            const id = await this.client.log(entry);
-            // Update metrics
-            this.metrics.totalItems++;
-            this.metrics.itemsByTier[item.tier]++;
-            return id || item.id;
-        }
-        catch (error) {
-            console.error('Failed to store in Dokoro:', error);
-            throw error;
+        if (!item.timestamp) {
+            item.timestamp = new Date();
         }
-    }
-    async retrieve(query) {
-        if (!this.isConnected || !this.client) {
-            throw new Error('Dokoro provider not initialized');
-        }
-        try {
-            const startTime = Date.now();
-            // Build Dokoro query
-            const dokoroQuery = {
-                workspace: this.config.workspace,
-                project: query.projectId || this.config.projectId,
-                search: query.text,
-                tags: query.tags,
-                startDate: query.startDate,
-                endDate: query.endDate,
-                limit: query.limit,
-                offset: query.offset
-            };
-            // Add tier filtering
-            if (query.tiers && query.tiers.length > 0) {
-                dokoroQuery.type = query.tiers.map(tier => `memory_${tier}`).join(',');
+        if (this.fileBacked) {
+            try {
+                const filePath = await this.writeMemoryFile(item);
+                this.metrics.totalItems++;
+                this.metrics.itemsByTier[item.tier]++;
+                // The file basename (without .md) is the durable id for file-backed
+                // items. Sync it back onto the caller's item so code holding the
+                // pre-store id via item.id can still update()/delete() later.
+                item.id = path.basename(filePath, '.md');
+                return item.id;
             }
-            // Query Dokoro
-            const entries = await this.client.query(dokoroQuery);
-            // Convert to MemoryItems
-            const items = this.convertDokoroEntries(entries);
-            // Filter by userId if specified
-            let filteredItems = items;
-            if (query.userId) {
-                filteredItems = items.filter(item => item.userId === query.userId);
+            catch (error) {
+                // Flip to in-memory mode so store/retrieve/update/delete switch
+                // together — leaving fileBacked true would strand this item in the
+                // fallback store where retrieve() (file scan) never sees it.
+                this.fileBacked = false;
+                console.error('Dokoro provider: failed to write memory file, switching to in-memory fallback for this session:', error);
             }
-            // Update metrics
-            const retrievalTime = Date.now() - startTime;
-            this.metrics.avgRetrievalTime =
-                (this.metrics.avgRetrievalTime + retrievalTime) / 2;
-            // Update access counts
-            filteredItems.forEach(item => {
-                item.accessCount = (item.accessCount || 0) + 1;
-                item.lastAccessed = new Date();
-            });
-            return filteredItems;
-        }
-        catch (error) {
-            console.error('Failed to retrieve from Dokoro:', error);
-            throw error;
         }
+        this.fallbackStore.set(item.id, item);
+        this.metrics.totalItems++;
+        this.metrics.itemsByTier[item.tier]++;
+        return item.id;
+    }
+    async retrieve(query) {
+        const startTime = Date.now();
+        const items = this.fileBacked
+            ? await this.readAllMemoryFiles()
+            : Array.from(this.fallbackStore.values());
+        const results = this.applyQuery(items, query);
+        // Update metrics
+        const retrievalTime = Date.now() - startTime;
+        this.metrics.avgRetrievalTime =
+            (this.metrics.avgRetrievalTime + retrievalTime) / 2;
+        // Update access counts (in-memory only; not persisted back to files)
+        results.forEach(item => {
+            item.accessCount = (item.accessCount || 0) + 1;
+            item.lastAccessed = new Date();
+        });
+        return results;
     }
     async update(id, updates) {
-        if (!this.isConnected || !this.client) {
-            throw new Error('Dokoro provider not initialized');
+        if (!this.fileBacked) {
+            const item = this.fallbackStore.get(id);
+            if (!item)
+                return false;
+            Object.assign(item, updates, { id: item.id });
+            return true;
         }
         try {
-            // Convert updates to Dokoro format
-            const dokoroUpdates = {
-                content: updates.content,
-                metadata: updates.metadata,
-                tags: updates.tags
-            };
-            // Update tier in metadata if changed
-            if (updates.tier) {
-                dokoroUpdates.type = `memory_${updates.tier}`;
-                dokoroUpdates.metadata = {
-                    ...dokoroUpdates.metadata,
-                    tier: updates.tier
-                };
-            }
-            return await this.client.update(id, dokoroUpdates);
+            const filePath = await this.findFileById(id);
+            if (!filePath)
+                return false;
+            const item = await this.parseMemoryFile(filePath);
+            if (!item)
+                return false;
+            Object.assign(item, updates, { id: item.id });
+            await this.writeMemoryFile(item, filePath);
+            return true;
         }
         catch (error) {
-            console.error('Failed to update in Dokoro:', error);
+            console.error('Dokoro provider: failed to update memory file:', error);
             return false;
         }
     }
     async delete(id) {
-        if (!this.isConnected || !this.client) {
-            throw new Error('Dokoro provider not initialized');
+        if (!this.fileBacked) {
+            const item = this.fallbackStore.get(id);
+            if (!item)
+                return false;
+            this.fallbackStore.delete(id);
+            this.metrics.totalItems--;
+            this.metrics.itemsByTier[item.tier]--;
+            return true;
         }
         try {
-            const result = await this.client.delete(id);
-            if (result) {
-                this.metrics.totalItems--;
+            const filePath = await this.findFileById(id);
+            if (!filePath)
+                return false;
+            const item = await this.parseMemoryFile(filePath);
+            await fs.unlink(filePath);
+            this.metrics.totalItems--;
+            if (item) {
+                this.metrics.itemsByTier[item.tier]--;
             }
-            return result;
+            return true;
         }
         catch (error) {
-            console.error('Failed to delete from Dokoro:', error);
+            console.error('Dokoro provider: failed to delete memory file:', error);
             return false;
         }
     }
     async cleanup() {
         const now = Date.now();
         let cleaned = 0;
-        // Query for expired items
-        const items = await this.retrieve({
-            endDate: new Date(now - 24 * 60 * 60 * 1000) // Items older than 24 hours
-        });
+        const items = await this.export();
         for (const item of items) {
             if (item.ttl && item.ttl > 0) {
                 const expiryTime = item.timestamp.getTime() + (item.ttl * 60 * 1000);
@@ -193,22 +177,10 @@ export class DokoroProvider extends BaseMemoryProvider {
         return cleaned;
     }
     async export() {
-        if (!this.isConnected || !this.client) {
-            throw new Error('Dokoro provider not initialized');
-        }
-        try {
-            const entries = await this.client.query({
-                workspace: this.config.workspace,
-                project: this.config.projectId,
-                type: 'memory_', // Prefix match for all memory types
-                limit: 100000 // Large limit to get all
-            });
-            return this.convertDokoroEntries(entries);
-        }
-        catch (error) {
-            console.error('Failed to export from Dokoro:', error);
-            throw error;
+        if (this.fileBacked) {
+            return await this.readAllMemoryFiles();
         }
+        return Array.from(this.fallbackStore.values());
     }
     async import(items) {
         let imported = 0;
@@ -224,149 +196,281 @@ export class DokoroProvider extends BaseMemoryProvider {
         return imported;
     }
     async isAvailable() {
-        if (!this.isConnected || !this.client)
-            return false;
+        return this.initialized;
+    }
+    async close() {
+        this.fallbackStore.clear();
+        await super.close();
+    }
+    /**
+     * File helpers
+     */
+    /**
+     * Write a MemoryItem as a dokoro markdown file (YAML frontmatter + body).
+     * If targetPath is given, overwrites that file (update); otherwise a new
+     * file is created in sessions/ with a collision-safe name.
+     */
+    async writeMemoryFile(item, targetPath) {
+        const filePath = targetPath || await this.nextAvailablePath(item);
+        const tags = Array.from(new Set(['tachibot', ...(item.tags || [])]));
+        const frontmatter = {
+            title: this.titleFor(item),
+            date: item.timestamp.toISOString(),
+            type: item.metadata?.kind || 'memory',
+            status: 'active',
+            provider: 'tachibot',
+            tier: item.tier,
+            memoryId: item.id,
+            tags
+        };
+        if (item.userId)
+            frontmatter.userId = item.userId;
+        if (item.projectId || this.config.projectId) {
+            frontmatter.projectId = item.projectId || this.config.projectId;
+        }
+        if (item.teamId)
+            frontmatter.teamId = item.teamId;
+        if (item.ttl !== undefined)
+            frontmatter.ttl = item.ttl;
+        if (item.accessCount !== undefined)
+            frontmatter.accessCount = item.accessCount;
+        if (item.metadata && Object.keys(item.metadata).length > 0) {
+            frontmatter.metadata = item.metadata;
+        }
+        const content = `---\n${yaml.stringify(frontmatter)}---\n\n${item.content}\n`;
+        // Write to temp file then rename (atomic, mirrors local-provider.ts)
+        const tempPath = `${filePath}.tmp`;
+        await fs.writeFile(tempPath, content, 'utf-8');
+        await fs.rename(tempPath, filePath);
+        return filePath;
+    }
+    /**
+     * Build a collision-safe sessions/ path:
+     * YYYY-MM-DD-HHhMMm-dayname-memory-<slug>.md (dokoro naming convention,
+     * same pattern as planner-tools.ts generatePlanFilename).
+     */
+    async nextAvailablePath(item) {
+        const ts = item.timestamp;
+        const year = ts.getFullYear();
+        const month = String(ts.getMonth() + 1).padStart(2, '0');
+        const day = String(ts.getDate()).padStart(2, '0');
+        const hours = String(ts.getHours()).padStart(2, '0');
+        const minutes = String(ts.getMinutes()).padStart(2, '0');
+        const dayName = ts.toLocaleDateString('en-US', { weekday: 'long' }).toLowerCase();
+        const slug = this.slugify(item.metadata?.title ||
+            item.metadata?.kind ||
+            item.content ||
+            item.tier);
+        const base = `${year}-${month}-${day}-${hours}h${minutes}m-${dayName}-memory-${slug}`;
+        let candidate = path.join(this.sessionsDir, `${base}.md`);
+        let counter = 2;
+        while (await this.fileExists(candidate)) {
+            candidate = path.join(this.sessionsDir, `${base}-${counter}.md`);
+            counter++;
+        }
+        return candidate;
+    }
+    slugify(text) {
+        return (text
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '')
+            .substring(0, 40) || 'item');
+    }
+    titleFor(item) {
+        if (item.metadata?.title)
+            return String(item.metadata.title);
+        const firstLine = item.content.split('\n')[0].trim();
+        if (firstLine) {
+            return firstLine.length > 80 ? `${firstLine.substring(0, 77)}...` : firstLine;
+        }
+        return `Memory (${item.tier})`;
+    }
+    async fileExists(filePath) {
         try {
-            // Check connection by getting stats
-            await this.client.getStats();
+            await fs.access(filePath);
             return true;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
-    async close() {
-        if (this.client) {
-            await this.client.disconnect();
-            this.client = null;
+    /**
+     * List all markdown files in sessions/ and daily/.
+     */
+    async listMemoryFiles() {
+        const files = [];
+        for (const dir of [this.sessionsDir, this.dailyDir]) {
+            try {
+                const entries = await fs.readdir(dir);
+                for (const entry of entries) {
+                    if (entry.endsWith('.md')) {
+                        files.push(path.join(dir, entry));
+                    }
+                }
+            }
+            catch {
+                // Directory missing (e.g. no daily/ yet) — skip silently
+            }
         }
-        this.isConnected = false;
-        await super.close();
+        return files;
+    }
+    async readAllMemoryFiles() {
+        const files = await this.listMemoryFiles();
+        const items = [];
+        for (const filePath of files) {
+            const item = await this.parseMemoryFile(filePath);
+            if (item) {
+                items.push(item);
+            }
+        }
+        return items;
     }
     /**
-     * Helper methods
+     * Resolve a stored id (file basename without .md) back to its path.
      */
-    async loadDokoroModule() {
-        try {
-            // Try to dynamically import dokoro package
-            // @ts-ignore - Optional dependency
-            const dokoro = await import('dokoro');
-            return dokoro;
-        }
-        catch (error) {
-            // Dokoro package not installed
-            console.warn('Dokoro package not installed. Using local implementation.');
-            return null;
+    async findFileById(id) {
+        const fileName = `${id}.md`;
+        for (const dir of [this.sessionsDir, this.dailyDir]) {
+            const candidate = path.join(dir, fileName);
+            if (await this.fileExists(candidate)) {
+                return candidate;
+            }
         }
+        return null;
     }
-    createLocalDokoro() {
-        // Local implementation that mimics Dokoro API
-        const localStore = new Map();
-        let nextId = 1;
-        return {
-            async connect() {
-                console.error('Using local Dokoro implementation');
-            },
-            async disconnect() {
-                localStore.clear();
-            },
-            async log(entry) {
-                const id = entry.id || `dokoro_${nextId++}`;
-                entry.id = id;
-                entry.timestamp = entry.timestamp || new Date();
-                localStore.set(id, entry);
-                return id;
-            },
-            async query(params) {
-                let results = Array.from(localStore.values());
-                // Filter by type
-                if (params.type) {
-                    const types = params.type.split(',');
-                    results = results.filter(e => types.some(t => e.type.startsWith(t)));
-                }
-                // Filter by workspace
-                if (params.workspace) {
-                    results = results.filter(e => e.workspace === params.workspace);
-                }
-                // Filter by project
-                if (params.project) {
-                    results = results.filter(e => e.project === params.project);
-                }
-                // Text search
-                if (params.search) {
-                    const searchLower = params.search.toLowerCase();
-                    results = results.filter(e => e.content.toLowerCase().includes(searchLower));
-                }
-                // Filter by tags
-                if (params.tags && params.tags.length > 0) {
-                    results = results.filter(e => e.tags && params.tags.some(tag => e.tags.includes(tag)));
-                }
-                // Date filtering
-                if (params.startDate) {
-                    results = results.filter(e => e.timestamp && e.timestamp >= params.startDate);
-                }
-                if (params.endDate) {
-                    results = results.filter(e => e.timestamp && e.timestamp <= params.endDate);
-                }
-                // Sort by timestamp (newest first)
-                results.sort((a, b) => {
-                    const timeA = a.timestamp?.getTime() || 0;
-                    const timeB = b.timestamp?.getTime() || 0;
-                    return timeB - timeA;
-                });
-                // Apply offset and limit
-                if (params.offset) {
-                    results = results.slice(params.offset);
+    /**
+     * Parse a dokoro markdown file (YAML frontmatter + body) into a MemoryItem.
+     * Files without frontmatter are treated as plain content.
+     */
+    async parseMemoryFile(filePath) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            let frontmatter = {};
+            let body = raw;
+            const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+            if (match) {
+                try {
+                    frontmatter = yaml.parse(match[1]) || {};
                 }
-                if (params.limit) {
-                    results = results.slice(0, params.limit);
+                catch {
+                    frontmatter = {};
                 }
-                return results;
-            },
-            async update(id, updates) {
-                const entry = localStore.get(id);
-                if (!entry)
-                    return false;
-                Object.assign(entry, updates);
-                localStore.set(id, entry);
-                return true;
-            },
-            async delete(id) {
-                return localStore.delete(id);
-            },
-            async getStats() {
-                const entriesByType = {};
-                localStore.forEach(entry => {
-                    entriesByType[entry.type] = (entriesByType[entry.type] || 0) + 1;
-                });
-                return {
-                    totalEntries: localStore.size,
-                    entriesByType,
-                    storageUsedMB: localStore.size * 0.001 // Rough estimate
-                };
+                body = raw.slice(match[0].length);
             }
-        };
-    }
-    convertDokoroEntries(entries) {
-        return entries.map(entry => {
-            // Extract tier from type (e.g., "memory_session" -> "session")
-            const tier = (entry.type.replace('memory_', '') || 'session');
+            const tier = MEMORY_TIERS.includes(frontmatter.tier)
+                ? frontmatter.tier
+                : 'session';
+            let timestamp;
+            if (frontmatter.date && !isNaN(Date.parse(frontmatter.date))) {
+                timestamp = new Date(frontmatter.date);
+            }
+            else {
+                const stats = await fs.stat(filePath);
+                timestamp = stats.mtime;
+            }
+            const metadata = {
+                ...(typeof frontmatter.metadata === 'object' && frontmatter.metadata !== null
+                    ? frontmatter.metadata
+                    : {}),
+                sourceFile: filePath
+            };
+            if (frontmatter.title && metadata.title === undefined) {
+                metadata.title = frontmatter.title;
+            }
+            if (frontmatter.type)
+                metadata.kind = frontmatter.type;
             return {
-                id: entry.id || this.generateId(),
-                content: entry.content,
+                id: path.basename(filePath, '.md'),
+                content: body.trim(),
                 tier,
-                userId: entry.user,
-                projectId: entry.project || this.config.projectId,
-                teamId: entry.metadata?.teamId,
-                timestamp: entry.timestamp || new Date(),
-                metadata: entry.metadata || {},
-                tags: entry.tags,
-                ttl: entry.metadata?.ttl,
-                accessCount: entry.metadata?.accessCount || 0,
-                lastAccessed: entry.metadata?.lastAccessed ?
-                    new Date(entry.metadata.lastAccessed) : new Date()
+                userId: frontmatter.userId,
+                projectId: frontmatter.projectId || this.config.projectId,
+                teamId: frontmatter.teamId,
+                timestamp,
+                metadata,
+                tags: this.normalizeTags(frontmatter.tags),
+                ttl: typeof frontmatter.ttl === 'number' ? frontmatter.ttl : undefined,
+                accessCount: typeof frontmatter.accessCount === 'number' ? frontmatter.accessCount : 0,
+                lastAccessed: undefined
             };
-        });
+        }
+        catch (error) {
+            console.error(`Dokoro provider: failed to parse ${filePath}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Tags in dokoro files may be a YAML list or a map (e.g. plans use
+     * `tags:\n  type: plan`). Normalize both to string arrays.
+     */
+    normalizeTags(tags) {
+        if (Array.isArray(tags)) {
+            return tags.map(t => String(t));
+        }
+        if (tags && typeof tags === 'object') {
+            return Object.entries(tags).map(([key, value]) => `${key}:${value}`);
+        }
+        return undefined;
+    }
+    /**
+     * Query filtering shared by file-backed and fallback modes.
+     * Field filters (project/user/team) are lenient: items without the field
+     * (e.g. plans in daily/ not written by tachibot) are not excluded.
+     */
+    applyQuery(items, query) {
+        let results = items;
+        if (query.tiers && query.tiers.length > 0) {
+            results = results.filter(item => query.tiers.includes(item.tier));
+        }
+        if (query.projectId) {
+            if (this.config.strictProjectFilter) {
+                results = results.filter(item => item.projectId === query.projectId);
+            }
+            else {
+                // Deliberately lenient default: dokoro daily/ files (plans, work
+                // records) carry no projectId in their frontmatter, so exact-match
+                // filtering would hide the entire dokoro workspace whenever the
+                // memory manager injects its default projectId into queries. The
+                // tradeoff is that untagged files from other projects sharing the
+                // same workspace leak into results. Set strictProjectFilter: true
+                // in DokoroConfig for exact-match project isolation.
+                results = results.filter(item => !item.projectId || item.projectId === query.projectId);
+            }
+        }
+        if (query.userId) {
+            results = results.filter(item => !item.userId || item.userId === query.userId);
+        }
+        if (query.teamId) {
+            results = results.filter(item => !item.teamId || item.teamId === query.teamId);
+        }
+        if (query.tags && query.tags.length > 0) {
+            results = results.filter(item => item.tags && query.tags.some(tag => item.tags.includes(tag)));
+        }
+        if (query.startDate) {
+            results = results.filter(item => item.timestamp >= query.startDate);
+        }
+        if (query.endDate) {
+            results = results.filter(item => item.timestamp <= query.endDate);
+        }
+        // Case-insensitive substring match over title + body
+        if (query.text) {
+            const searchText = query.text.toLowerCase();
+            results = results.filter(item => {
+                const title = String(item.metadata?.title || '').toLowerCase();
+                return (item.content.toLowerCase().includes(searchText) ||
+                    title.includes(searchText));
+            });
+        }
+        // Sort by timestamp (newest first)
+        results.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        if (query.offset) {
+            results = results.slice(query.offset);
+        }
+        if (query.limit) {
+            results = results.slice(0, query.limit);
+        }
+        return results;
     }
 }
 /**

package/dist/src/tools/jury-tool.js

@@ -54,9 +54,9 @@ export const JUROR_REGISTRY = {
         label: "Kimi (Step-by-Step)",
         role: "Think step-by-step. Decompose the problem. Find edge cases others miss.",
         call: async (q) => callOpenRouter([
-            { role: "system", content: `You are Kimi K2.6. Think step-by-step. Decompose problems. Find edge cases. ${FORMAT_INSTRUCTION}` },
+            { role: "system", content: `You are Kimi K2.7-Code. Think step-by-step. Decompose problems. Find edge cases. ${FORMAT_INSTRUCTION}` },
             { role: "user", content: q }
-        ], OpenRouterModel.KIMI_K2_6, 0.4, 3000, { top_p: 0.9 }, 240000),
+        ], OpenRouterModel.KIMI_K2_7_CODE, 0.4, 3000, { top_p: 0.9 }, 240000),
     },
     perplexity: {
         label: "Perplexity (Research)",
@@ -86,12 +86,12 @@ export const JUROR_REGISTRY = {
         ], OpenRouterModel.DEEPSEEK_V4_PRO, 0.3, 4000),
     },
     glm: {
-        label: "GLM-5.1 (Agentic)",
+        label: "GLM-5.2 (Agentic)",
         role: "Reason as an agent: plan, anticipate failure modes, decide. Strong on tool-use and SWE.",
         call: async (q) => callOpenRouter([
-            { role: "system", content: `You are Zhipu GLM-5.1, a SWE-Bench Pro leader. Plan, reason through tool-use/steps, then give a decisive verdict. ${FORMAT_INSTRUCTION}` },
+            { role: "system", content: `You are Zhipu GLM-5.2, a frontier open-weights agentic model (1M ctx, top long-horizon coding). Plan, reason through tool-use/steps, then give a decisive verdict. ${FORMAT_INSTRUCTION}` },
             { role: "user", content: q }
-        ], OpenRouterModel.GLM_5_1, 0.3, 4000),
+        ], OpenRouterModel.GLM_5_2, 0.3, 4000),
     },
     stepfun: {
         label: "StepFun 3.7 (Efficient Reasoning)",

package/dist/src/tools/openrouter-tools.js

@@ -29,6 +29,7 @@ export var OpenRouterModel;
     OpenRouterModel["QWEN3_MAX_THINKING"] = "qwen/qwen3-235b-a22b-thinking-2507";
     // Moonshot AI models (Kimi)
     OpenRouterModel["KIMI_K2_THINKING"] = "moonshotai/kimi-k2-thinking";
+    OpenRouterModel["KIMI_K2_7_CODE"] = "moonshotai/kimi-k2.7-code";
     OpenRouterModel["KIMI_K2_6"] = "moonshotai/kimi-k2.6";
     OpenRouterModel["KIMI_K2_5"] = "moonshotai/kimi-k2.5";
     // MiniMax models - VERY CHEAP, #1 AI Intelligence Index
@@ -40,7 +41,8 @@ export var OpenRouterModel;
     OpenRouterModel["DEEPSEEK_V4_PRO"] = "deepseek/deepseek-v4-pro";
     OpenRouterModel["DEEPSEEK_V4_FLASH"] = "deepseek/deepseek-v4-flash";
     OpenRouterModel["DEEPSEEK_R1_0528"] = "deepseek/deepseek-r1-0528";
-    // Zhipu GLM models - agentic / SWE-Bench Pro leader
+    // Zhipu GLM models - agentic / long-horizon coding (open-weights)
+    OpenRouterModel["GLM_5_2"] = "z-ai/glm-5.2";
     OpenRouterModel["GLM_5_1"] = "z-ai/glm-5.1";
     OpenRouterModel["GLM_5"] = "z-ai/glm-5";
     // StepFun models - efficient reasoning (196B, high AIME/SWE-Verified)
@@ -53,8 +55,10 @@ export var OpenRouterModel;
 const MODEL_FALLBACKS = {
     [OpenRouterModel.QWEN3_CODER_NEXT]: OpenRouterModel.QWEN3_CODER, // Fall back to 480B if Coder-Next fails
     [OpenRouterModel.QWEN3_CODER]: OpenRouterModel.QWEN3_CODER,
+    [OpenRouterModel.KIMI_K2_7_CODE]: OpenRouterModel.KIMI_K2_6, // Fall back to K2.6 if K2.7-Code fails
     [OpenRouterModel.KIMI_K2_6]: OpenRouterModel.KIMI_K2_THINKING, // Fall back to k2-thinking if K2.6 fails (k2.5 retired from OpenRouter)
     [OpenRouterModel.DEEPSEEK_V4_PRO]: OpenRouterModel.DEEPSEEK_V4_FLASH, // Fall back to V4 Flash if Pro is rate-limited
+    [OpenRouterModel.GLM_5_2]: OpenRouterModel.GLM_5_1, // Fall back to GLM-5.1 if 5.2 fails
     [OpenRouterModel.GLM_5_1]: OpenRouterModel.GLM_5, // Fall back to GLM-5 base if 5.1 fails
     [OpenRouterModel.STEPFUN_3_7]: OpenRouterModel.STEPFUN_3_5, // Fall back to 3.5 flash if 3.7 fails
     [OpenRouterModel.MINIMAX_M3]: OpenRouterModel.MINIMAX_M2_7, // Fall back to M2.7 if M3 fails
@@ -538,13 +542,13 @@ ${FORMAT_INSTRUCTION}`
     }
 });
 /**
- * Kimi K2.6 Thinking Tool
- * Multimodal model with Agent Swarm (100 sub-agents) and built-in reasoning
- * $0.60/$3.00 per M tokens, 262K context
+ * Kimi K2.7-Code Thinking Tool
+ * Coding-specialized multimodal model (built on K2.6), always-thinking mode
+ * $0.75/$3.50 per M tokens, 262K context
  */
 export const kimiThinkingTool = defineModelTool({
     name: "kimi_thinking",
-    description: "Kimi K2.6 multimodal reasoning with Agent Swarm. Put your PROBLEM in the 'problem' parameter.",
+    description: "Kimi K2.7-Code multimodal reasoning (always-thinking). Put your PROBLEM in the 'problem' parameter.",
     parameters: z.object({
         problem: z.string().describe("The problem to reason about (REQUIRED - put your question here)"),
         ...reasoningContextField,
@@ -568,7 +572,7 @@ export const kimiThinkingTool = defineModelTool({
         const messages = [
             {
                 role: "system",
-                content: `You are Kimi K2, an expert reasoning model. Be concise and direct.
+                content: `You are Kimi K2.7-Code, an expert reasoning model. Be concise and direct.
 ${approachPrompts[args.approach || 'step-by-step']}.
 Use ${args.maxSteps} reasoning steps max. ${args.context ? `Context: ${args.context}` : ''}
 ${FORMAT_INSTRUCTION}`
@@ -582,7 +586,7 @@ ${FORMAT_INSTRUCTION}`
         // Timeout inherited from getOpenRouterModelTimeout() — Kimi → 600s (Agent Swarm
         // needs the headroom; 180s/240s previously caused timeouts).
         const reportFn = reportProgress ?? (async () => { });
-        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_6, 0.4, 3000, {
+        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_7_CODE, 0.4, 3000, {
             top_p: 0.9,
             presence_penalty: 0.1,
             frequency_penalty: 0.2
@@ -591,12 +595,12 @@ ${FORMAT_INSTRUCTION}`
 });
 /**
  * Kimi Code Tool
- * SWE-focused code generation/fixing with Kimi K2.6 (SWE-Bench 76.8%)
+ * SWE-focused code generation/fixing with Kimi K2.7-Code (+21.8% on Kimi Code Bench v2 over K2.6)
  * Best for: code generation, bug fixing, refactoring, repo-level understanding
  */
 export const kimiCodeTool = defineModelTool({
     name: "kimi_code",
-    description: "SWE-focused code generation/fixing with Kimi K2.6 (SWE-Bench 76.8%). Put your REQUEST in the 'query' parameter.",
+    description: "SWE-focused code generation/fixing with Kimi K2.7-Code (coding-specialized). Put your REQUEST in the 'query' parameter.",
     parameters: z.object({
         query: z.string().describe("Your request or question (REQUIRED - put your main request here)"),
         task: z.enum(["generate", "fix", "review", "optimize", "debug", "refactor"])
@@ -616,7 +620,7 @@ export const kimiCodeTool = defineModelTool({
             debug: "Debug and identify root causes",
             refactor: "Refactor for better structure and maintainability"
         };
-        const systemPrompt = `You are Kimi K2.6, an expert SWE model (SWE-Bench 76.8%). You excel at repo-level code understanding and changes.
+        const systemPrompt = `You are Kimi K2.7-Code, a coding-specialized SWE model. You excel at repo-level code understanding and changes.
 Task: ${taskPrompts[args.task || "review"]}
 ${args.language ? `Language: ${args.language}` : ''}
 Focus: Clean code, correct solutions, minimal changes for fixes. Understand the full repo context when reviewing.
@@ -632,7 +636,7 @@ ${FORMAT_INSTRUCTION}`;
             { role: "user", content: userPrompt + fileContext }
         ];
         const reportFn = reportProgress ?? (async () => { });
-        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_6, 0.3, 4000), reportFn, 240000);
+        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_7_CODE, 0.3, 4000), reportFn, 240000);
     }
 });
 // kimi_decompose configuration
@@ -641,12 +645,12 @@ const DECOMPOSE_MAX_TOKENS = 4500;
 // Timeout inherited from getOpenRouterModelTimeout() — Kimi → 600s (Agent Swarm).
 /**
  * Kimi Decompose Tool
- * Structured task decomposition using Kimi K2.6's Agent Swarm reasoning
+ * Structured task decomposition using Kimi K2.7-Code's extended reasoning
  * Best for: breaking complex tasks into subtasks with dependencies and acceptance criteria
  */
 export const kimiDecomposeTool = defineModelTool({
     name: "kimi_decompose",
-    description: "Structured task decomposition with Kimi K2.6 Agent Swarm reasoning. Breaks tasks into subtasks with IDs, dependencies, and acceptance criteria.",
+    description: "Structured task decomposition with Kimi K2.7-Code extended reasoning. Breaks tasks into subtasks with IDs, dependencies, and acceptance criteria.",
     parameters: z.object({
         task: z.string().describe("The task to decompose (REQUIRED - describe the complex task)"),
         context: z.string().optional().describe("Additional context about the project, codebase, or constraints"),
@@ -755,7 +759,7 @@ TASK REQUIREMENTS (one block per task)
 RISKS
 - [risk] > Mitigation: [approach]`
         };
-        const systemPrompt = `You are Kimi K2.6, expert at structured task decomposition using Agent Swarm reasoning.
+        const systemPrompt = `You are Kimi K2.7-Code, expert at structured task decomposition using extended reasoning.
 
 Your job is to produce SMART decompositions — not mechanical ID/deps lists, but context-aware plans that a developer can act on immediately.
 
@@ -793,7 +797,7 @@ Wrap your final output in <output> tags. Everything outside <output> is discarde
             { role: "user", content: userPrompt }
         ];
         const reportFn = reportProgress ?? (async () => { });
-        const raw = await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_6, DECOMPOSE_TEMPERATURE, DECOMPOSE_MAX_TOKENS, {}), reportFn);
+        const raw = await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_7_CODE, DECOMPOSE_TEMPERATURE, DECOMPOSE_MAX_TOKENS, {}), reportFn);
         // Strip reasoning leak from Kimi K2.6 (dumps CoT into message.content)
         // Strategy: try <output> tags first, then find first section header
         const outputMatch = raw.match(/<output>([\s\S]*?)<\/output>/);
@@ -808,12 +812,12 @@ Wrap your final output in <output> tags. Everything outside <output> is discarde
 });
 /**
  * Kimi Long Context Tool
- * Long-context analysis leveraging Kimi K2.6's 256K context window
+ * Long-context analysis leveraging Kimi K2.7-Code's 262K context window
  * Best for: analyzing large documents, codebases, or text bodies
  */
 export const kimiLongContextTool = defineModelTool({
     name: "kimi_long_context",
-    description: "Long-context analysis with Kimi K2.6 (256K context window). Put CONTENT in the 'content' parameter.",
+    description: "Long-context analysis with Kimi K2.7-Code (262K context window). Put CONTENT in the 'content' parameter.",
     parameters: z.object({
         content: z.string().describe("The long text/document to analyze (REQUIRED - put your content here)"),
         task: z.enum(["summarize", "extract", "analyze", "compare", "find"])
@@ -838,7 +842,7 @@ export const kimiLongContextTool = defineModelTool({
             detailed: "Provide thorough analysis with supporting evidence and examples",
             structured: "Use clear sections with headers, bullet points, and structured formatting"
         };
-        const systemPrompt = `You are Kimi K2.6, expert at processing and analyzing large documents (best-effort 256K context window).
+        const systemPrompt = `You are Kimi K2.7-Code, expert at processing and analyzing large documents (best-effort 262K context window).
 Task: ${taskPrompts[args.task || "analyze"]}
 Format: ${formatPrompts[args.outputFormat || "detailed"]}
 ${args.query ? `Specific query: ${args.query}` : ''}
@@ -853,7 +857,7 @@ ${FORMAT_INSTRUCTION}`;
             { role: "user", content: args.content + fileContext }
         ];
         const reportFn = reportProgress ?? (async () => { });
-        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_6, 0.2, 8000), reportFn, 300000);
+        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_7_CODE, 0.2, 8000), reportFn, 300000);
     }
 });
 /**
@@ -1151,12 +1155,12 @@ ${FORMAT_INSTRUCTION}`;
 };
 /**
  * GLM Reason Tool
- * Agentic reasoning & tool-use planning with Zhipu GLM-5.1 (SWE-Bench Pro leader).
+ * Agentic reasoning & tool-use planning with Zhipu GLM-5.2 (1M ctx, long-horizon coding leader).
  * Best for: agentic task planning, tool-use strategy, software-engineering reasoning.
  */
 export const glmReasonTool = {
     name: "glm_reason",
-    description: "Agentic reasoning & tool-use planning with Zhipu GLM-5.1 (SWE-Bench Pro leader). Put your PROBLEM in the 'problem' parameter.",
+    description: "Agentic reasoning & tool-use planning with Zhipu GLM-5.2 (1M ctx, top open-weights for long-horizon coding). Put your PROBLEM in the 'problem' parameter.",
     parameters: z.object({
         problem: z.string().describe("The problem to reason about (REQUIRED - put your question here)"),
         context: z.string().optional().describe("Additional context for the reasoning task"),
@@ -1179,7 +1183,7 @@ export const glmReasonTool = {
         const messages = [
             {
                 role: "system",
-                content: `You are Zhipu GLM-5.1, a frontier agentic model and SWE-Bench Pro leader, strong at tool-use planning and software-engineering reasoning.
+                content: `You are Zhipu GLM-5.2, a frontier open-weights agentic model with a 1M-token context, strong at long-horizon coding, tool-use planning and software-engineering reasoning.
 ${approachPrompts[args.approach || 'agentic']}.
 State your plan, reason through it, then give a decisive conclusion. Flag assumptions and risks explicitly.
 ${args.context ? `Context: ${args.context}` : ''}
@@ -1191,7 +1195,7 @@ ${FORMAT_INSTRUCTION}`
             }
         ];
         const reportFn = reportProgress ?? (async () => { });
-        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.GLM_5_1, 0.3, 8000), reportFn);
+        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.GLM_5_2, 0.3, 8000), reportFn);
     }
 };
 /**
@@ -1308,7 +1312,7 @@ export function getAllOpenRouterTools() {
         // NEW tools (Jun 2026)
         deepseekReasonTool, // DeepSeek V4 Pro - frontier reasoning/math (open-weight)
         deepseekAlgoTool, // DeepSeek V4 Pro - algorithmic code review (top AIME/CodeElo)
-        glmReasonTool, // Zhipu GLM-5.1 - agentic reasoning (SWE-Bench Pro leader)
+        glmReasonTool, // Zhipu GLM-5.2 - agentic reasoning (1M ctx, long-horizon coding)
         stepfunReasonTool, // StepFun Step 3.7 Flash - efficient reasoning
         ernieReasonTool, // Baidu ERNIE 4.5 VL - broad-knowledge reasoning
     ];

package/package.json

@@ -2,7 +2,7 @@
   "name": "tachibot-mcp",
   "mcpName": "io.github.byPawel/tachibot-mcp",
   "displayName": "TachiBot MCP - Universal AI Orchestrator",
-  "version": "2.23.1",
+  "version": "2.23.3",
   "type": "module",
   "main": "dist/src/server.js",
   "bin": {