@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/core/api.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// We test apiFetch which uses global fetch — mock it
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+import { apiFetch, ApiError } from '@/lib/api';
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  mockFetch.mockReset();
+});
+
+describe('ApiError', () => {
+  it('has correct name and status', () => {
+    const err = new ApiError('Not Found', 404);
+    expect(err.name).toBe('ApiError');
+    expect(err.message).toBe('Not Found');
+    expect(err.status).toBe(404);
+    expect(err).toBeInstanceOf(Error);
+  });
+});
+
+describe('apiFetch', () => {
+  it('returns parsed JSON on success', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: 'hello' }),
+    });
+    const result = await apiFetch<{ data: string }>('/api/test');
+    expect(result).toEqual({ data: 'hello' });
+    expect(mockFetch).toHaveBeenCalledOnce();
+  });
+
+  it('throws ApiError with error body on non-2xx response', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      json: async () => ({ error: 'Forbidden resource' }),
+    });
+    await expect(apiFetch('/api/test')).rejects.toThrow(ApiError);
+    try {
+      await apiFetch('/api/test');
+    } catch (e) {
+      // mockFetch already consumed, re-mock for second call
+    }
+    // Re-test with fresh mock
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      json: async () => ({ error: 'Forbidden resource' }),
+    });
+    try {
+      await apiFetch('/api/test');
+      expect.unreachable();
+    } catch (e) {
+      expect(e).toBeInstanceOf(ApiError);
+      expect((e as ApiError).status).toBe(403);
+      expect((e as ApiError).message).toBe('Forbidden resource');
+    }
+  });
+
+  it('throws ApiError with generic message when error body is not JSON', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      json: async () => { throw new Error('not json'); },
+    });
+    try {
+      await apiFetch('/api/test');
+      expect.unreachable();
+    } catch (e) {
+      expect(e).toBeInstanceOf(ApiError);
+      expect((e as ApiError).status).toBe(500);
+      expect((e as ApiError).message).toContain('500');
+    }
+  });
+
+  it('throws ApiError with generic message when error body has no error field', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 422,
+      json: async () => ({ detail: 'something' }),
+    });
+    try {
+      await apiFetch('/api/test');
+      expect.unreachable();
+    } catch (e) {
+      expect(e).toBeInstanceOf(ApiError);
+      expect((e as ApiError).message).toContain('422');
+    }
+  });
+
+  it('passes fetch options through', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({}),
+    });
+    await apiFetch('/api/test', {
+      method: 'POST',
+      headers: { 'X-Custom': 'value' },
+      body: JSON.stringify({ key: 'val' }),
+    });
+    const [url, opts] = mockFetch.mock.calls[0];
+    expect(url).toBe('/api/test');
+    expect(opts.method).toBe('POST');
+    expect(opts.headers).toEqual({ 'X-Custom': 'value' });
+  });
+
+  it('works with timeout disabled (timeout=0)', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ ok: true }),
+    });
+    const result = await apiFetch('/api/test', { timeout: 0 });
+    expect(result).toEqual({ ok: true });
+    // signal should be undefined when timeout=0 and no external signal
+    const [, opts] = mockFetch.mock.calls[0];
+    expect(opts.signal).toBeUndefined();
+  });
+
+  it('passes external signal when provided', async () => {
+    const controller = new AbortController();
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ ok: true }),
+    });
+    await apiFetch('/api/test', { timeout: 0, signal: controller.signal });
+    const [, opts] = mockFetch.mock.calls[0];
+    // With signal bridging, fetch receives a new controller's signal (not the original)
+    // but aborting the original should propagate — verify signal exists
+    expect(opts.signal).toBeDefined();
+    expect(opts.signal).toBeInstanceOf(AbortSignal);
+  });
+});

package/_standalone/__tests__/core/atomic-append.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
+import { appendToFile } from '@/lib/core/lines';
+import { readFile } from '@/lib/core/fs-ops';
+
+describe('appendToFile (atomic append)', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('appends to non-empty file with newline separator', () => {
+    seedFile(mindRoot, 'a.md', 'line1');
+    appendToFile(mindRoot, 'a.md', 'line2');
+    expect(readFile(mindRoot, 'a.md')).toBe('line1\nline2');
+  });
+
+  it('appends to file already ending with double newline', () => {
+    seedFile(mindRoot, 'a.md', 'line1\n\n');
+    appendToFile(mindRoot, 'a.md', 'line2');
+    expect(readFile(mindRoot, 'a.md')).toBe('line1\n\nline2');
+  });
+
+  it('appends to empty file without separator', () => {
+    seedFile(mindRoot, 'a.md', '');
+    appendToFile(mindRoot, 'a.md', 'first line');
+    expect(readFile(mindRoot, 'a.md')).toBe('first line');
+  });
+
+  it('handles multiple appends', () => {
+    seedFile(mindRoot, 'a.md', 'A');
+    appendToFile(mindRoot, 'a.md', 'B');
+    appendToFile(mindRoot, 'a.md', 'C');
+    const content = readFile(mindRoot, 'a.md');
+    expect(content).toContain('A');
+    expect(content).toContain('B');
+    expect(content).toContain('C');
+  });
+
+  it('handles CJK content', () => {
+    seedFile(mindRoot, 'a.md', '# 知识库');
+    appendToFile(mindRoot, 'a.md', '新的内容');
+    const content = readFile(mindRoot, 'a.md');
+    expect(content).toContain('知识库');
+    expect(content).toContain('新的内容');
+  });
+});

package/_standalone/__tests__/core/backlinks.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
+import { findBacklinks } from '@/lib/core/backlinks';
+
+describe('backlinks', () => {
+  let mindRoot: string;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+  });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('finds wikilink [[target]] references', () => {
+    seedFile(mindRoot, 'target.md', '# Target');
+    seedFile(mindRoot, 'source.md', 'See [[target]] for details.');
+    const results = findBacklinks(mindRoot, 'target.md');
+    expect(results).toHaveLength(1);
+    expect(results[0].source).toBe('source.md');
+    expect(results[0].context).toContain('[[target]]');
+  });
+
+  it('finds markdown link (target.md) references', () => {
+    seedFile(mindRoot, 'Profile/Identity.md', '# Identity');
+    seedFile(mindRoot, 'index.md', 'Read [my profile](Profile/Identity.md) here.');
+    const results = findBacklinks(mindRoot, 'Profile/Identity.md');
+    expect(results).toHaveLength(1);
+    expect(results[0].source).toBe('index.md');
+  });
+
+  it('finds wikilink with display text [[target|Display]]', () => {
+    seedFile(mindRoot, 'target.md', '# Target');
+    seedFile(mindRoot, 'source.md', 'See [[target|My Target]] for more.');
+    const results = findBacklinks(mindRoot, 'target.md');
+    expect(results).toHaveLength(1);
+  });
+
+  it('finds backtick references', () => {
+    seedFile(mindRoot, 'docs/setup.md', '# Setup');
+    seedFile(mindRoot, 'notes.md', 'Check `docs/setup.md` for instructions.');
+    const results = findBacklinks(mindRoot, 'docs/setup.md');
+    expect(results).toHaveLength(1);
+    expect(results[0].source).toBe('notes.md');
+  });
+
+  it('does not include self-references', () => {
+    seedFile(mindRoot, 'self.md', 'This file references [[self]] itself.');
+    const results = findBacklinks(mindRoot, 'self.md');
+    expect(results).toHaveLength(0);
+  });
+
+  it('returns empty when no backlinks exist', () => {
+    seedFile(mindRoot, 'target.md', '# Target');
+    seedFile(mindRoot, 'other.md', 'No references here.');
+    const results = findBacklinks(mindRoot, 'target.md');
+    expect(results).toHaveLength(0);
+  });
+
+  it('only scans .md files', () => {
+    seedFile(mindRoot, 'target.md', '# Target');
+    seedFile(mindRoot, 'data.csv', 'target,value');
+    const results = findBacklinks(mindRoot, 'target.md');
+    expect(results).toHaveLength(0);
+  });
+
+  it('reports line number and context', () => {
+    seedFile(mindRoot, 'target.md', '# Target');
+    seedFile(mindRoot, 'source.md', 'Line 1\nLine 2 with [[target]]\nLine 3');
+    const results = findBacklinks(mindRoot, 'target.md');
+    expect(results[0].line).toBe(2);
+    expect(results[0].context).toContain('Line 2');
+  });
+});

package/_standalone/__tests__/core/bm25-search.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
+import { searchFiles } from '@/lib/core/search';
+
+describe('BM25 search scoring', () => {
+  let mindRoot: string;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+  });
+
+  afterEach(() => {
+    cleanupMindRoot(mindRoot);
+  });
+
+  it('ranks rare terms higher than common terms', () => {
+    // "search" appears in all 3 files → low IDF
+    // "CRDT" appears in only 1 file → high IDF
+    seedFile(mindRoot, 'Notes/common.md', 'search is a common search feature for search');
+    seedFile(mindRoot, 'Notes/also-common.md', 'we also implement search functionality');
+    seedFile(mindRoot, 'Notes/rare.md', 'search and CRDT algorithms are interesting');
+
+    const results = searchFiles(mindRoot, 'CRDT');
+    expect(results).toHaveLength(1);
+    expect(results[0].path).toBe('Notes/rare.md');
+  });
+
+  it('scores shorter documents higher when term frequency is equal', () => {
+    // Both have "algorithm" once, but short.md is much shorter → higher density
+    seedFile(mindRoot, 'Notes/short.md', 'The algorithm works well.');
+    seedFile(mindRoot, 'Notes/long.md', 'The algorithm ' + 'uses many words to describe things. '.repeat(50));
+
+    const results = searchFiles(mindRoot, 'algorithm');
+    expect(results.length).toBe(2);
+    expect(results[0].path).toBe('Notes/short.md');
+  });
+
+  it('handles multi-word queries by summing per-term BM25 scores', () => {
+    // "search" is common (in all), "vector" is rare (in 1)
+    seedFile(mindRoot, 'Notes/a.md', 'search for things');
+    seedFile(mindRoot, 'Notes/b.md', 'search with vector embeddings');
+    seedFile(mindRoot, 'Notes/c.md', 'search the knowledge base');
+
+    const results = searchFiles(mindRoot, 'vector search');
+    // b.md should rank first because it has the rare word "vector"
+    expect(results[0].path).toBe('Notes/b.md');
+  });
+
+  it('diminishes returns for repeated terms (saturation)', () => {
+    // File with "search" 20 times should NOT score 20x more than file with it 5 times
+    seedFile(mindRoot, 'Notes/moderate.md', ('search feature. ').repeat(5));
+    seedFile(mindRoot, 'Notes/spammy.md', ('search ').repeat(20));
+    seedFile(mindRoot, 'Notes/filler.md', 'nothing relevant here about databases');
+
+    const results = searchFiles(mindRoot, 'search');
+    expect(results.length).toBe(2);
+    // Both should appear but the spammy one shouldn't dominate excessively
+    const scores = results.map(r => r.score);
+    // Spammy has 4x the occurrences but BM25 saturation means score ratio < 4x
+    if (results[0].path === 'Notes/spammy.md') {
+      expect(scores[0] / scores[1]).toBeLessThan(4);
+    }
+  });
+
+  it('returns zero-score results when IDF is near zero (term in all docs)', () => {
+    // When a term appears in every document, IDF approaches 0
+    // BM25 should still return results but with low scores
+    seedFile(mindRoot, 'Notes/a.md', 'common word here');
+    seedFile(mindRoot, 'Notes/b.md', 'common word there');
+
+    const results = searchFiles(mindRoot, 'common');
+    expect(results.length).toBe(2);
+    // Scores should be very low but not negative
+    for (const r of results) {
+      expect(r.score).toBeGreaterThanOrEqual(0);
+    }
+  });
+});

package/_standalone/__tests__/core/chinese-segmentation.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
+import { SearchIndex } from '@/lib/core/search-index';
+
+describe('Chinese word segmentation (Intl.Segmenter)', () => {
+  let mindRoot: string;
+  let index: SearchIndex;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+    index = new SearchIndex();
+  });
+
+  afterEach(() => {
+    cleanupMindRoot(mindRoot);
+  });
+
+  it('segments Chinese text into proper words, not bigrams', () => {
+    seedFile(mindRoot, 'notes/ai.md', '# 人工智能\n\n知识管理系统是一种工具。');
+    index.rebuild(mindRoot);
+
+    // "知识管理" should match because Intl.Segmenter produces ["知识", "管理"]
+    // and the file contains both tokens
+    const candidates = index.getCandidates('知识管理');
+    expect(candidates).toContain('notes/ai.md');
+  });
+
+  it('finds files by single Chinese word', () => {
+    seedFile(mindRoot, 'a.md', '人工智能的发展');
+    seedFile(mindRoot, 'b.md', '自然语言处理');
+    index.rebuild(mindRoot);
+
+    const candidates = index.getCandidates('智能');
+    expect(candidates).toContain('a.md');
+  });
+
+  it('finds files by multi-word Chinese query', () => {
+    seedFile(mindRoot, 'a.md', '深度学习是人工智能的重要分支');
+    seedFile(mindRoot, 'b.md', '机器学习算法');
+    index.rebuild(mindRoot);
+
+    // Both should match "学习"
+    const candidates = index.getCandidates('学习');
+    expect(candidates).toContain('a.md');
+    expect(candidates).toContain('b.md');
+  });
+
+  it('does not produce false bigram matches', () => {
+    // With bigrams, "识管" would be a token in "知识管理"
+    // With Intl.Segmenter, "识管" should NOT be a token
+    seedFile(mindRoot, 'a.md', '知识管理系统');
+    index.rebuild(mindRoot);
+
+    const candidates = index.getCandidates('识管');
+    // With proper segmentation, "识管" is not a word boundary,
+    // so it should NOT appear as an indexed token.
+    // However, the file may still be found via single-char unigrams.
+    // The key test is that segmentation improves precision.
+    expect(candidates.length).toBeLessThanOrEqual(1);
+  });
+
+  it('handles mixed Chinese and English', () => {
+    seedFile(mindRoot, 'a.md', 'MindOS 是一款知识管理工具');
+    index.rebuild(mindRoot);
+
+    expect(index.getCandidates('mindos')).toContain('a.md');
+    expect(index.getCandidates('知识')).toContain('a.md');
+  });
+});

package/_standalone/__tests__/core/config.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+/**
+ * Tests for config.js getStartMode() and isDaemonMode().
+ * Since these functions read from ~/.mindos/config.json,
+ * we test the underlying logic by directly exercising
+ * the config file parsing.
+ */
+
+let tmpDir: string;
+let configPath: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-config-test-'));
+  const mindosDir = path.join(tmpDir, '.mindos');
+  fs.mkdirSync(mindosDir, { recursive: true });
+  configPath = path.join(mindosDir, 'config.json');
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+/** Mimics getStartMode logic from bin/lib/config.js */
+function getStartMode(cfgPath: string): string {
+  try {
+    const mode = JSON.parse(fs.readFileSync(cfgPath, 'utf-8')).startMode || 'start';
+    return mode === 'daemon' ? 'start' : mode;
+  } catch {
+    return 'start';
+  }
+}
+
+/** Mimics isDaemonMode logic from bin/lib/config.js */
+function isDaemonMode(cfgPath: string): boolean {
+  try {
+    return JSON.parse(fs.readFileSync(cfgPath, 'utf-8')).startMode === 'daemon';
+  } catch {
+    return false;
+  }
+}
+
+describe('getStartMode', () => {
+  it('returns "start" when no config file exists', () => {
+    expect(getStartMode('/nonexistent/config.json')).toBe('start');
+  });
+
+  it('returns "start" when startMode is not set', () => {
+    fs.writeFileSync(configPath, JSON.stringify({ mindRoot: '/tmp' }));
+    expect(getStartMode(configPath)).toBe('start');
+  });
+
+  it('returns "start" when startMode is "start"', () => {
+    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'start' }));
+    expect(getStartMode(configPath)).toBe('start');
+  });
+
+  it('maps "daemon" to "start"', () => {
+    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'daemon' }));
+    expect(getStartMode(configPath)).toBe('start');
+  });
+
+  it('returns "dev" when startMode is "dev"', () => {
+    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'dev' }));
+    expect(getStartMode(configPath)).toBe('dev');
+  });
+
+  it('returns "start" when config is invalid JSON', () => {
+    fs.writeFileSync(configPath, 'not json');
+    expect(getStartMode(configPath)).toBe('start');
+  });
+});
+
+describe('isDaemonMode', () => {
+  it('returns false when no config exists', () => {
+    expect(isDaemonMode('/nonexistent/config.json')).toBe(false);
+  });
+
+  it('returns false when startMode is "start"', () => {
+    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'start' }));
+    expect(isDaemonMode(configPath)).toBe(false);
+  });
+
+  it('returns true when startMode is "daemon"', () => {
+    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'daemon' }));
+    expect(isDaemonMode(configPath)).toBe(true);
+  });
+
+  it('returns false when startMode is not set', () => {
+    fs.writeFileSync(configPath, JSON.stringify({}));
+    expect(isDaemonMode(configPath)).toBe(false);
+  });
+
+  it('returns false for invalid JSON', () => {
+    fs.writeFileSync(configPath, '{broken');
+    expect(isDaemonMode(configPath)).toBe(false);
+  });
+});

package/_standalone/__tests__/core/content-changes.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { testMindRoot } from '../setup';
+import {
+  appendContentChange,
+  listContentChanges,
+  getContentChangeSummary,
+  markContentChangesSeen,
+} from '../../lib/core/content-changes';
+
+function changeLogPath(root: string) {
+  return path.join(root, '.mindos', 'change-log.json');
+}
+
+describe('core/content-changes', () => {
+  it('creates .mindos/change-log.json on first append', () => {
+    appendContentChange(testMindRoot, {
+      op: 'save_file',
+      path: 'note.md',
+      source: 'user',
+      before: 'a',
+      after: 'b',
+      summary: 'updated file',
+    });
+
+    expect(fs.existsSync(changeLogPath(testMindRoot))).toBe(true);
+    const raw = fs.readFileSync(changeLogPath(testMindRoot), 'utf-8');
+    const json = JSON.parse(raw) as { events: unknown[] };
+    expect(Array.isArray(json.events)).toBe(true);
+    expect(json.events.length).toBe(1);
+  });
+
+  it('lists latest events first and supports path filter', () => {
+    appendContentChange(testMindRoot, {
+      op: 'save_file',
+      path: 'a.md',
+      source: 'user',
+      before: '1',
+      after: '2',
+      summary: 'a changed',
+    });
+    appendContentChange(testMindRoot, {
+      op: 'save_file',
+      path: 'b.md',
+      source: 'agent',
+      before: 'x',
+      after: 'y',
+      summary: 'b changed',
+    });
+
+    const all = listContentChanges(testMindRoot, { limit: 10 });
+    expect(all.length).toBeGreaterThanOrEqual(2);
+    expect(all[0].ts >= all[1].ts).toBe(true);
+
+    const onlyA = listContentChanges(testMindRoot, { path: 'a.md', limit: 10 });
+    expect(onlyA.every((e) => e.path === 'a.md')).toBe(true);
+  });
+
+  it('computes unread summary and mark seen resets unread', () => {
+    appendContentChange(testMindRoot, {
+      op: 'save_file',
+      path: 'summary.md',
+      source: 'agent',
+      before: '',
+      after: 'new',
+      summary: 'summary changed',
+    });
+    const beforeSeen = getContentChangeSummary(testMindRoot);
+    expect(beforeSeen.unreadCount).toBeGreaterThan(0);
+
+    markContentChangesSeen(testMindRoot);
+    const afterSeen = getContentChangeSummary(testMindRoot);
+    expect(afterSeen.unreadCount).toBe(0);
+  });
+
+  it('imports legacy Agent-Diff.md agent-diff blocks into change-log', () => {
+    const legacyPath = path.join(testMindRoot, 'Agent-Diff.md');
+    fs.writeFileSync(legacyPath, [
+      '# Agent Changes',
+      '```agent-diff',
+      JSON.stringify({
+        ts: '2025-01-15T10:30:00Z',
+        path: 'Profile/Identity.md',
+        tool: 'mindos_write_file',
+        before: '# Identity\n\nName: Alice',
+        after: '# Identity\n\nName: Alice\nRole: Engineer',
+      }, null, 2),
+      '```',
+    ].join('\n'), 'utf-8');
+
+    const events = listContentChanges(testMindRoot, { limit: 10 });
+    expect(events.length).toBe(1);
+    expect(events[0].op).toBe('legacy_agent_diff_import');
+    expect(events[0].path).toBe('Profile/Identity.md');
+    expect(events[0].source).toBe('agent');
+
+    const raw = JSON.parse(fs.readFileSync(changeLogPath(testMindRoot), 'utf-8')) as {
+      legacy?: { agentDiffImportedCount?: number };
+    };
+    expect(raw.legacy?.agentDiffImportedCount).toBe(1);
+    expect(fs.existsSync(legacyPath)).toBe(false);
+  });
+
+  it('imports only new legacy blocks on subsequent reads', () => {
+    const legacyPath = path.join(testMindRoot, 'Agent-Diff.md');
+    const makeBlock = (pathValue: string) => [
+      '```agent-diff',
+      JSON.stringify({
+        ts: '2025-01-15T10:30:00Z',
+        path: pathValue,
+        tool: 'mindos_update_lines',
+        before: 'a',
+        after: 'b',
+      }, null, 2),
+      '```',
+    ].join('\n');
+
+    fs.writeFileSync(legacyPath, `# Agent Changes\n\n${makeBlock('a.md')}\n`, 'utf-8');
+    const first = listContentChanges(testMindRoot, { limit: 10 });
+    expect(first.map((e) => e.path)).toContain('a.md');
+
+    // Re-create legacy file to simulate users adding it again manually.
+    fs.writeFileSync(legacyPath, `# Agent Changes\n\n${makeBlock('a.md')}\n${makeBlock('b.md')}\n`, 'utf-8');
+    const second = listContentChanges(testMindRoot, { limit: 10 });
+    const importedLegacy = second.filter((e) => e.op === 'legacy_agent_diff_import');
+    expect(importedLegacy.length).toBe(2);
+    expect(importedLegacy.map((e) => e.path)).toEqual(expect.arrayContaining(['a.md', 'b.md']));
+    expect(fs.existsSync(legacyPath)).toBe(false);
+  });
+});

package/_standalone/__tests__/core/context.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { estimateStringTokens } from '../../lib/agent/context';
+
+describe('Context estimation', () => {
+  describe('estimateStringTokens', () => {
+    it('estimates ASCII text tokens (~0.25 per char)', () => {
+      const text = 'Hello, this is a test sentence with some words.';
+      const tokens = estimateStringTokens(text);
+      // ~48 chars → ~12 tokens
+      expect(tokens).toBeGreaterThan(5);
+      expect(tokens).toBeLessThan(25);
+    });
+
+    it('estimates CJK text tokens (~1.5 per char)', () => {
+      const text = '你好世界这是测试';
+      const tokens = estimateStringTokens(text);
+      // 8 CJK chars → ~12 tokens
+      expect(tokens).toBeGreaterThan(8);
+      expect(tokens).toBeLessThan(20);
+    });
+
+    it('handles mixed CJK and ASCII', () => {
+      const text = 'Hello 你好 World 世界';
+      const tokens = estimateStringTokens(text);
+      expect(tokens).toBeGreaterThan(5);
+      expect(tokens).toBeLessThan(20);
+    });
+
+    it('returns 0 for empty string', () => {
+      expect(estimateStringTokens('')).toBe(0);
+    });
+
+    it('estimates a typical system prompt size', () => {
+      // Simulate a moderate system prompt
+      const prompt = 'You are a helpful assistant.\n'.repeat(100);
+      const tokens = estimateStringTokens(prompt);
+      // ~2800 chars → ~700 tokens
+      expect(tokens).toBeGreaterThan(500);
+      expect(tokens).toBeLessThan(1000);
+    });
+
+    it('estimates large content (20K chars) reasonably', () => {
+      const large = 'a'.repeat(20_000);
+      const tokens = estimateStringTokens(large);
+      // 20000 ASCII chars → ~5000 tokens
+      expect(tokens).toBeGreaterThanOrEqual(4000);
+      expect(tokens).toBeLessThanOrEqual(6000);
+    });
+  });
+});