@geminilight/mindos 0.6.73 → 0.6.74

package/_standalone/__tests__/agent/chat-mode.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getChatTools, knowledgeBaseTools, WRITE_TOOLS } from '@/lib/agent/tools';
-import { CHAT_SYSTEM_PROMPT, AGENT_SYSTEM_PROMPT } from '@/lib/agent/prompt';
-
-// ---------------------------------------------------------------------------
-// getChatTools — tool set correctness
-// ---------------------------------------------------------------------------
-
-describe('getChatTools', () => {
-  const chatTools = getChatTools();
-  const chatToolNames = chatTools.map(t => t.name);
-
-  it('returns a non-empty array of tools', () => {
-    expect(chatTools.length).toBeGreaterThan(0);
-  });
-
-  it('returns exactly the 8 approved read-only tools', () => {
-    const expected = [
-      'list_files', 'read_file', 'read_file_chunk',
-      'search', 'get_recent', 'get_backlinks',
-      'web_search', 'web_fetch',
-    ];
-    expect(new Set(chatToolNames)).toEqual(new Set(expected));
-  });
-
-  it('is a strict subset of knowledgeBaseTools', () => {
-    const allNames = new Set(knowledgeBaseTools.map(t => t.name));
-    for (const name of chatToolNames) {
-      expect(allNames.has(name)).toBe(true);
-    }
-  });
-
-  it('contains zero write tools', () => {
-    for (const name of chatToolNames) {
-      expect(WRITE_TOOLS.has(name)).toBe(false);
-    }
-  });
-
-  it('is significantly smaller than full tool set', () => {
-    expect(chatTools.length).toBeLessThan(knowledgeBaseTools.length);
-  });
-
-  it('each tool has a valid execute function', () => {
-    for (const tool of chatTools) {
-      expect(typeof tool.execute).toBe('function');
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// CHAT_SYSTEM_PROMPT — content correctness
-// ---------------------------------------------------------------------------
-
-describe('CHAT_SYSTEM_PROMPT', () => {
-  it('exists and is a non-empty string', () => {
-    expect(typeof CHAT_SYSTEM_PROMPT).toBe('string');
-    expect(CHAT_SYSTEM_PROMPT.length).toBeGreaterThan(100);
-  });
-
-  it('mentions Chat (Read-Only) mode', () => {
-    expect(CHAT_SYSTEM_PROMPT).toContain('Chat');
-    expect(CHAT_SYSTEM_PROMPT).toContain('Read-Only');
-  });
-
-  it('contains anti-hallucination directive', () => {
-    expect(CHAT_SYSTEM_PROMPT).toContain('Anti-Hallucination');
-  });
-
-  it('contains cite-sources directive', () => {
-    expect(CHAT_SYSTEM_PROMPT).toContain('Cite Sources');
-  });
-
-  it('instructs to suggest switching to Agent mode for writes', () => {
-    expect(CHAT_SYSTEM_PROMPT).toContain('Agent mode');
-  });
-
-  it('is significantly shorter than AGENT_SYSTEM_PROMPT', () => {
-    expect(CHAT_SYSTEM_PROMPT.length).toBeLessThan(AGENT_SYSTEM_PROMPT.length);
-  });
-
-  it('does not contain write-related directives', () => {
-    expect(CHAT_SYSTEM_PROMPT).not.toContain('Read-Before-Write');
-    expect(CHAT_SYSTEM_PROMPT).not.toContain('write_file');
-    expect(CHAT_SYSTEM_PROMPT).not.toContain('create_file');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// AskMode type — compile-time type check
-// ---------------------------------------------------------------------------
-
-describe('AskMode type', () => {
-  it('accepts valid mode values', async () => {
-    const { AskMode } = await import('@/lib/types') as any;
-    const validModes: Array<import('@/lib/types').AskMode> = ['chat', 'agent'];
-    expect(validModes).toHaveLength(2);
-  });
-
-  it('AskModeApi includes organize', async () => {
-    const validModes: Array<import('@/lib/types').AskModeApi> = ['chat', 'agent', 'organize'];
-    expect(validModes).toHaveLength(3);
-  });
-});

package/_standalone/__tests__/agent/loop-detection.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { detectLoop, type StepEntry } from '@/lib/agent/loop-detection';
-
-function step(tool: string, input = ''): StepEntry {
-  return { tool, input };
-}
-
-describe('detectLoop', () => {
-  describe('identical repetition', () => {
-    it('detects 3 identical calls in a row', () => {
-      const history = [step('readFile', 'a.md'), step('readFile', 'a.md'), step('readFile', 'a.md')];
-      expect(detectLoop(history)).toBe(true);
-    });
-
-    it('does not trigger with only 2 identical calls', () => {
-      const history = [step('readFile', 'a.md'), step('readFile', 'a.md')];
-      expect(detectLoop(history)).toBe(false);
-    });
-
-    it('does not trigger with different args', () => {
-      const history = [step('readFile', 'a.md'), step('readFile', 'b.md'), step('readFile', 'c.md')];
-      expect(detectLoop(history)).toBe(false);
-    });
-  });
-
-  describe('pattern cycle detection', () => {
-    it('detects A→B→A→B cycle', () => {
-      const history = [step('readFile'), step('writeFile'), step('readFile'), step('writeFile')];
-      expect(detectLoop(history)).toBe(true);
-    });
-
-    it('detects A→B→C→A→B→C cycle', () => {
-      const history = [
-        step('read'), step('search'), step('write'),
-        step('read'), step('search'), step('write'),
-      ];
-      expect(detectLoop(history)).toBe(true);
-    });
-
-    it('does not trigger for non-repeating sequence', () => {
-      const history = [step('read'), step('search'), step('write'), step('commit')];
-      expect(detectLoop(history)).toBe(false);
-    });
-
-    it('detects cycle even with earlier non-repeating history', () => {
-      const history = [
-        step('init'), step('config'), // noise
-        step('read'), step('write'), step('read'), step('write'), // cycle
-      ];
-      expect(detectLoop(history)).toBe(true);
-    });
-
-    it('does not false-positive on same tool names with all different args', () => {
-      // Agent reads different files in alternation — not a loop
-      const history = [
-        step('readFile', 'a.md'), step('writeFile', 'x.md'),
-        step('readFile', 'b.md'), step('writeFile', 'y.md'),
-      ];
-      expect(detectLoop(history)).toBe(false);
-    });
-
-    it('detects cycle when at least one arg pair matches', () => {
-      // read same file, write to different targets — still a loop
-      const history = [
-        step('readFile', 'a.md'), step('writeFile', 'x.md'),
-        step('readFile', 'a.md'), step('writeFile', 'z.md'),
-      ];
-      expect(detectLoop(history)).toBe(true);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('returns false for empty history', () => {
-      expect(detectLoop([])).toBe(false);
-    });
-
-    it('returns false for single entry', () => {
-      expect(detectLoop([step('read')])).toBe(false);
-    });
-
-    it('returns false for short non-repeating history', () => {
-      expect(detectLoop([step('a'), step('b'), step('c')])).toBe(false);
-    });
-  });
-});

package/_standalone/__tests__/agent/paragraph-extract.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractRelevantContent, splitParagraphs } from '@/lib/agent/paragraph-extract';
-
-describe('splitParagraphs', () => {
-  it('splits on double newlines', () => {
-    const text = 'Paragraph 1\n\nParagraph 2\n\nParagraph 3';
-    expect(splitParagraphs(text)).toEqual(['Paragraph 1', 'Paragraph 2', 'Paragraph 3']);
-  });
-
-  it('handles empty string', () => {
-    expect(splitParagraphs('')).toEqual([]);
-  });
-
-  it('handles single paragraph', () => {
-    expect(splitParagraphs('Hello world')).toEqual(['Hello world']);
-  });
-});
-
-describe('extractRelevantContent', () => {
-  it('returns content unchanged if within limit', () => {
-    const content = 'Short content';
-    const { result, truncated } = extractRelevantContent(content, 1000);
-    expect(result).toBe(content);
-    expect(truncated).toBe(false);
-  });
-
-  it('truncates at paragraph boundary without query', () => {
-    const content = 'A'.repeat(100) + '\n\n' + 'B'.repeat(100);
-    const { result, truncated } = extractRelevantContent(content, 150);
-    expect(truncated).toBe(true);
-    expect(result).toContain('A'.repeat(100));
-    expect(result).not.toContain('B'.repeat(100));
-  });
-
-  it('extracts query-relevant paragraphs', () => {
-    const paragraphs = [
-      '# Title\n\nThis is the intro.',
-      'Paragraph about cats and dogs.',
-      'Paragraph about deployment and servers.',
-      'Another paragraph about cats playing.',
-      'Final paragraph about nothing.',
-    ];
-    const content = paragraphs.join('\n\n');
-    const { result } = extractRelevantContent(content, 200, 'cats');
-    // Should include title (always) + cat paragraphs
-    expect(result).toContain('Title');
-    expect(result).toContain('cats');
-  });
-
-  it('preserves original order of extracted paragraphs', () => {
-    const content = 'P1 intro\n\nP2 query match\n\nP3 filler\n\nP4 query match again';
-    const { result } = extractRelevantContent(content, 100, 'query');
-    const idx1 = result.indexOf('P1');
-    const idx2 = result.indexOf('P2');
-    if (idx1 !== -1 && idx2 !== -1) {
-      expect(idx1).toBeLessThan(idx2);
-    }
-  });
-
-  it('handles very long content with CJK query', () => {
-    const intro = '# 知识管理系统';
-    const filler = Array.from({ length: 50 }, (_, i) => `段落 ${i}: 一些无关的内容。`).join('\n\n');
-    const target = '这是关于部署的重要段落。包含了服务器配置信息。';
-    const content = intro + '\n\n' + filler + '\n\n' + target;
-    const { result, truncated } = extractRelevantContent(content, 500, '部署');
-    expect(truncated).toBe(true);
-    expect(result).toContain('部署');
-    expect(result).toContain('知识管理');
-  });
-
-  it('returns truncated flag when paragraphs are dropped', () => {
-    const content = 'Short\n\n' + 'X'.repeat(200);
-    const { truncated } = extractRelevantContent(content, 50, 'Short');
-    expect(truncated).toBe(true);
-  });
-});

package/_standalone/__tests__/agent/prompt.test.ts

@@ -1,21 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { AGENT_SYSTEM_PROMPT, CHAT_SYSTEM_PROMPT } from '@/lib/agent/prompt';
-
-describe('agent prompt self-introduction rules', () => {
-  it('uses the MindOS identity without slogan wording in agent mode', () => {
-    expect(AGENT_SYSTEM_PROMPT).toContain('You are MindOS — the user\'s local knowledge assistant.');
-    expect(AGENT_SYSTEM_PROMPT).not.toContain('this appears to be their first message in a new conversation');
-    expect(AGENT_SYSTEM_PROMPT).not.toContain('operator of the user\'s second brain');
-    expect(AGENT_SYSTEM_PROMPT).not.toContain('You are MindOS Agent');
-    expect(AGENT_SYSTEM_PROMPT).toContain('If the user\'s message already contains a concrete task');
-    expect(AGENT_SYSTEM_PROMPT).toContain('skip the self-introduction and do the task directly');
-  });
-
-  it('applies the same concrete-task rule and identity in chat mode', () => {
-    expect(CHAT_SYSTEM_PROMPT).toContain('You are MindOS — the user\'s local knowledge assistant.');
-    expect(CHAT_SYSTEM_PROMPT).not.toContain('operator of the user\'s second brain');
-    expect(CHAT_SYSTEM_PROMPT).not.toContain('You are MindOS Agent');
-    expect(CHAT_SYSTEM_PROMPT).toContain('If the same message also includes a concrete task');
-    expect(CHAT_SYSTEM_PROMPT).toContain('skip the introduction and do the task');
-  });
-});

package/_standalone/__tests__/agent/provider-endpoints.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildCompatEndpointCandidates, getProviderApiType } from '@/lib/agent/providers';
-
-
-describe('buildCompatEndpointCandidates', () => {
-  it('keeps OpenAI-compatible custom path and adds v1 fallback', () => {
-    const endpoints = buildCompatEndpointCandidates(
-      'https://proxy.example.com/custom',
-      '/chat/completions',
-      'openai-completions',
-    );
-
-    expect(endpoints).toEqual([
-      'https://proxy.example.com/custom/chat/completions',
-      'https://proxy.example.com/custom/v1/chat/completions',
-    ]);
-  });
-
-  it('keeps existing version prefix without adding another v1', () => {
-    const endpoints = buildCompatEndpointCandidates(
-      'https://api.openai.com/v1',
-      '/chat/completions',
-      'openai-completions',
-    );
-
-    expect(endpoints).toEqual([
-      'https://api.openai.com/v1/chat/completions',
-    ]);
-  });
-
-  it('preserves GLM path prefix without injecting an extra v1 after /v4', () => {
-    const endpoints = buildCompatEndpointCandidates(
-      'https://api.z.ai/api/coding/paas/v4',
-      '/models',
-      'openai-completions',
-    );
-
-    expect(endpoints).toEqual([
-      'https://api.z.ai/api/coding/paas/v4/models',
-    ]);
-  });
-
-  it('preserves Anthropic-compatible path prefixes for Kimi/MiniMax style gateways', () => {
-    const endpoints = buildCompatEndpointCandidates(
-      'https://api.kimi.com/coding',
-      '/models',
-      'anthropic-messages',
-    );
-
-    expect(endpoints).toEqual([
-      'https://api.kimi.com/coding/models',
-      'https://api.kimi.com/coding/v1/models',
-    ]);
-  });
-});
-
-
-describe('getProviderApiType', () => {
-  it('reports GLM as openai-completions', () => {
-    expect(getProviderApiType('zai')).toBe('openai-completions');
-  });
-
-  it('reports MiniMax CN as anthropic-messages', () => {
-    expect(getProviderApiType('minimax-cn')).toBe('anthropic-messages');
-  });
-
-  it('reports Kimi Coding as anthropic-messages', () => {
-    expect(getProviderApiType('kimi-coding')).toBe('anthropic-messages');
-  });
-});

package/_standalone/__tests__/agent/retry-reconnect.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isRetryableError, retryDelay, sleep } from '@/lib/agent/reconnect';
-
-// ── isRetryableError ──────────────────────────────────────────────────────────
-
-describe('isRetryableError', () => {
-  describe('non-retryable: AbortError', () => {
-    it('returns false for DOMException AbortError', () => {
-      const err = new DOMException('The user aborted the request.', 'AbortError');
-      expect(isRetryableError(err)).toBe(false);
-    });
-  });
-
-  describe('non-retryable: auth / forbidden HTTP status', () => {
-    it('returns false for HTTP 401', () => {
-      expect(isRetryableError(new Error('Unauthorized'), 401)).toBe(false);
-    });
-
-    it('returns false for HTTP 403', () => {
-      expect(isRetryableError(new Error('Forbidden'), 403)).toBe(false);
-    });
-
-    it('returns false for error message containing "api key"', () => {
-      expect(isRetryableError(new Error('Invalid api key provided'))).toBe(false);
-    });
-
-    it('returns false for error message containing "authentication"', () => {
-      expect(isRetryableError(new Error('Authentication failed'))).toBe(false);
-    });
-
-    it('returns false for "model not found" errors', () => {
-      expect(isRetryableError(new Error('The model gpt-99 was not found'))).toBe(false);
-    });
-  });
-
-  describe('retryable: transient network / server errors', () => {
-    it('returns true for generic network error (no httpStatus)', () => {
-      expect(isRetryableError(new Error('fetch failed'))).toBe(true);
-    });
-
-    it('returns true for HTTP 500', () => {
-      expect(isRetryableError(new Error('Internal Server Error'), 500)).toBe(true);
-    });
-
-    it('returns true for HTTP 503', () => {
-      expect(isRetryableError(new Error('Service Unavailable'), 503)).toBe(true);
-    });
-
-    it('returns true for connection reset', () => {
-      expect(isRetryableError(new Error('ECONNRESET'))).toBe(true);
-    });
-  });
-
-  describe('retryable: rate limit (429)', () => {
-    it('returns false for HTTP 429 (rate limit — caller handles this specially)', () => {
-      // reconnect.ts lists 429 as NON_RETRYABLE_STATUS.
-      // The frontend retry loop decides not to retry 429 at HTTP level;
-      // the backend should handle 429 via its own LLM-layer retry.
-      expect(isRetryableError(new Error('Too Many Requests'), 429)).toBe(false);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('returns true for non-Error values (unknown errors)', () => {
-      expect(isRetryableError('some string error')).toBe(true);
-      expect(isRetryableError(null)).toBe(true);
-      expect(isRetryableError(undefined)).toBe(true);
-    });
-  });
-});
-
-// ── retryDelay ────────────────────────────────────────────────────────────────
-
-describe('retryDelay', () => {
-  it('returns 2000ms for attempt 1 (first retry)', () => {
-    expect(retryDelay(1)).toBe(2000);
-  });
-
-  it('returns 4000ms for attempt 2', () => {
-    expect(retryDelay(2)).toBe(4000);
-  });
-
-  it('returns 8000ms for attempt 3', () => {
-    expect(retryDelay(3)).toBe(8000);
-  });
-
-  it('caps at 10000ms regardless of attempt number', () => {
-    expect(retryDelay(10)).toBe(10000);
-    expect(retryDelay(100)).toBe(10000);
-  });
-
-  it('returns 1000ms for attempt 0 (base case)', () => {
-    expect(retryDelay(0)).toBe(1000);
-  });
-});
-
-// ── sleep ─────────────────────────────────────────────────────────────────────
-
-describe('sleep', () => {
-  it('resolves after specified delay', async () => {
-    const start = Date.now();
-    await sleep(50);
-    expect(Date.now() - start).toBeGreaterThanOrEqual(40);
-  });
-
-  it('rejects immediately when signal is already aborted', async () => {
-    const controller = new AbortController();
-    controller.abort();
-    await expect(sleep(1000, controller.signal)).rejects.toThrow();
-  });
-
-  it('rejects early when signal is aborted during sleep', async () => {
-    const controller = new AbortController();
-    const start = Date.now();
-    setTimeout(() => controller.abort(), 30);
-    await expect(sleep(2000, controller.signal)).rejects.toThrow();
-    // Should abort well before the full 2000ms
-    expect(Date.now() - start).toBeLessThan(500);
-  });
-});

package/_standalone/__tests__/agent/stream-consumer-status.test.ts

@@ -1,103 +0,0 @@
-/**
- * Tests for consumeUIMessageStream handling of 'status' SSE events.
- *
- * Status events are sent by the backend during retry attempts to inform
- * the frontend about the retry state. Previously, these were silently
- * ignored. After the fix, they should surface as text in the message.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { consumeUIMessageStream } from '@/lib/agent/stream-consumer';
-import type { ToolCallPart } from '@/lib/types';
-
-/** Helper: encode SSE events into a ReadableStream */
-function makeStream(...events: object[]): ReadableStream<Uint8Array> {
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    start(controller) {
-      for (const evt of events) {
-        controller.enqueue(encoder.encode(`data:${JSON.stringify(evt)}\n\n`));
-      }
-      controller.close();
-    },
-  });
-}
-
-describe('consumeUIMessageStream — status event handling', () => {
-  it('ignores status events when no text has been emitted yet (silent reconnect)', async () => {
-    // Status-only stream (no text_delta, no done) — after the fix,
-    // status events should NOT appear as visible text in the message
-    // because they are transient UI state, not conversation content.
-    // The frontend AskContent handles reconnect UI via loadingPhase state.
-    const stream = makeStream(
-      { type: 'status', message: 'Request failed, retrying (1/3)...' },
-      { type: 'done' },
-    );
-    const updates: string[] = [];
-    const result = await consumeUIMessageStream(stream, (msg) => {
-      updates.push(msg.content);
-    });
-    // Status messages should NOT appear in the conversation content
-    expect(result.content).toBe('');
-    expect(result.parts).toEqual([]);
-  });
-
-  it('processes text_delta events normally', async () => {
-    const stream = makeStream(
-      { type: 'text_delta', delta: 'Hello, ' },
-      { type: 'text_delta', delta: 'world!' },
-      { type: 'done' },
-    );
-    const result = await consumeUIMessageStream(stream, vi.fn());
-    expect(result.content).toBe('Hello, world!');
-  });
-
-  it('handles stream with status event followed by successful text', async () => {
-    const stream = makeStream(
-      { type: 'status', message: 'Request failed, retrying (1/3)...' },
-      { type: 'text_delta', delta: 'Response after retry' },
-      { type: 'done' },
-    );
-    const result = await consumeUIMessageStream(stream, vi.fn());
-    // Status should not appear, only the actual response text
-    expect(result.content).toBe('Response after retry');
-  });
-
-  it('handles error event by adding error text to message', async () => {
-    const stream = makeStream(
-      { type: 'error', message: 'LLM API unavailable' },
-    );
-    const result = await consumeUIMessageStream(stream, vi.fn());
-    expect(result.content).toContain('LLM API unavailable');
-  });
-
-  it('handles malformed SSE lines gracefully', async () => {
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream<Uint8Array>({
-      start(controller) {
-        controller.enqueue(encoder.encode('data:{bad json}\n\n'));
-        controller.enqueue(encoder.encode(`data:${JSON.stringify({ type: 'text_delta', delta: 'ok' })}\n\n`));
-        controller.enqueue(encoder.encode(`data:${JSON.stringify({ type: 'done' })}\n\n`));
-        controller.close();
-      },
-    });
-    const result = await consumeUIMessageStream(stream, vi.fn());
-    expect(result.content).toBe('ok');
-  });
-
-  it('finalizes pending tool calls when stream ends unexpectedly', async () => {
-    const stream = makeStream(
-      { type: 'tool_start', toolCallId: 'tc1', toolName: 'read_file', args: { path: 'a.md' } },
-      // stream ends without tool_end or done
-    );
-    const updates: Array<{ parts?: unknown[] }> = [];
-    const result = await consumeUIMessageStream(stream, (msg) => { updates.push(msg as { parts?: unknown[] }); });
-    // After unexpected stream end, the tool call part should be finalized to 'error' state.
-    // Check both the last onUpdate emission and the final returned message.
-    const allParts = [
-      ...(updates[updates.length - 1]?.parts ?? []),
-      ...(result.parts ?? []),
-    ];
-    const toolPart = allParts.find((p): p is ToolCallPart => (p as ToolCallPart).type === 'tool-call');
-    expect(toolPart?.state).toBe('error');
-  });
-});

package/_standalone/__tests__/agent/token-estimation.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { estimateStringTokens } from '@/lib/agent/context';
-
-describe('estimateStringTokens', () => {
-  it('estimates pure ASCII at ~4 chars per token', () => {
-    const text = 'Hello world, this is a test sentence.';
-    const tokens = estimateStringTokens(text);
-    // 37 chars / 4 = 9.25 → ceil = 10 tokens
-    expect(tokens).toBe(10);
-  });
-
-  it('estimates pure CJK at ~1.5 tokens per char', () => {
-    const text = '知识管理系统';
-    const tokens = estimateStringTokens(text);
-    // 6 CJK chars * 1.5 = 9 tokens
-    expect(tokens).toBe(9);
-  });
-
-  it('handles mixed CJK and ASCII correctly', () => {
-    const text = 'MindOS 知识管理';
-    const tokens = estimateStringTokens(text);
-    // "MindOS " = 7 ASCII chars → 7/4 = 1.75
-    // "知识管理" = 4 CJK chars → 4 * 1.5 = 6
-    // total = ceil(1.75 + 6) = 8
-    expect(tokens).toBe(8);
-  });
-
-  it('returns 0 for empty string', () => {
-    expect(estimateStringTokens('')).toBe(0);
-  });
-
-  it('estimates Japanese Hiragana as CJK', () => {
-    const text = 'こんにちは';
-    const tokens = estimateStringTokens(text);
-    // 5 chars * 1.5 = 7.5 → ceil = 8
-    expect(tokens).toBe(8);
-  });
-
-  it('estimates Korean Hangul as CJK', () => {
-    const text = '안녕하세요';
-    const tokens = estimateStringTokens(text);
-    // 5 chars * 1.5 = 7.5 → ceil = 8
-    expect(tokens).toBe(8);
-  });
-
-  it('is more accurate than naive length/4 for Chinese text', () => {
-    const chineseText = '这是一个关于人工智能的知识库管理系统';
-    const accurate = estimateStringTokens(chineseText);
-    const naive = Math.ceil(chineseText.length / 4);
-    // Naive: 17/4 = 5, Accurate: 17*1.5 = 26
-    // Accurate should be much higher for pure CJK
-    expect(accurate).toBeGreaterThan(naive * 3);
-  });
-});