@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/core/helpers.ts

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+/**
+ * Creates a temporary directory to use as MIND_ROOT for testing.
+ * Returns the absolute path.
+ */
+export function mkTempMindRoot(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-test-'));
+}
+
+/**
+ * Removes a temporary MIND_ROOT directory and all its contents.
+ */
+export function cleanupMindRoot(mindRoot: string): void {
+  fs.rmSync(mindRoot, { recursive: true, force: true });
+}
+
+/**
+ * Creates a file within the temporary mindRoot with the given content.
+ * Creates parent directories as needed.
+ */
+export function seedFile(mindRoot: string, relativePath: string, content: string): void {
+  const abs = path.join(mindRoot, relativePath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf-8');
+}
+
+/**
+ * Reads a file from the temporary mindRoot.
+ */
+export function readSeeded(mindRoot: string, relativePath: string): string {
+  return fs.readFileSync(path.join(mindRoot, relativePath), 'utf-8');
+}

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

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// ── Test the cosine similarity math ──
+import { cosineSimilarity } from '@/lib/core/embedding-index';
+
+describe('cosineSimilarity', () => {
+  it('returns 1 for identical vectors', () => {
+    const a = new Float32Array([1, 2, 3]);
+    expect(cosineSimilarity(a, a)).toBeCloseTo(1, 5);
+  });
+
+  it('returns 0 for orthogonal vectors', () => {
+    const a = new Float32Array([1, 0, 0]);
+    const b = new Float32Array([0, 1, 0]);
+    expect(cosineSimilarity(a, b)).toBeCloseTo(0, 5);
+  });
+
+  it('returns close to 1 for similar vectors', () => {
+    const a = new Float32Array([1, 2, 3]);
+    const b = new Float32Array([1.1, 2.1, 3.1]);
+    expect(cosineSimilarity(a, b)).toBeGreaterThan(0.99);
+  });
+
+  it('returns 0 for zero vectors', () => {
+    const a = new Float32Array([0, 0, 0]);
+    const b = new Float32Array([1, 2, 3]);
+    expect(cosineSimilarity(a, b)).toBe(0);
+  });
+
+  it('returns 0 for mismatched dimensions', () => {
+    const a = new Float32Array([1, 2]);
+    const b = new Float32Array([1, 2, 3]);
+    expect(cosineSimilarity(a, b)).toBe(0);
+  });
+
+  it('returns 0 for empty vectors', () => {
+    const a = new Float32Array([]);
+    const b = new Float32Array([]);
+    expect(cosineSimilarity(a, b)).toBe(0);
+  });
+
+  it('clamps result to [0,1]', () => {
+    // Normalized embedding vectors should naturally stay in [0,1]
+    const a = new Float32Array([0.5, 0.5, 0.5]);
+    const b = new Float32Array([0.5, 0.5, 0.5]);
+    const sim = cosineSimilarity(a, b);
+    expect(sim).toBeGreaterThanOrEqual(0);
+    expect(sim).toBeLessThanOrEqual(1);
+  });
+});
+
+// ── Test hybrid search fallback behavior ──
+// We mock the dependencies to test the RRF merge logic and fallback paths
+
+describe('hybridSearch', () => {
+  // Reset modules between tests to clear singleton state
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it('falls back to pure BM25 when embedding is disabled', async () => {
+    // Mock settings to have embedding disabled
+    vi.doMock('@/lib/settings', () => ({
+      readSettings: () => ({
+        ai: { activeProvider: '', providers: [] },
+        embedding: undefined,
+        mindRoot: '/tmp/test-mind',
+      }),
+      effectiveSopRoot: () => '/tmp/test-mind',
+    }));
+
+    // Mock BM25 search
+    vi.doMock('@/lib/core/search', () => ({
+      searchFiles: () => [
+        { path: 'test.md', snippet: 'test content', score: 10, occurrences: 1 },
+      ],
+    }));
+
+    const { hybridSearch } = await import('@/lib/core/hybrid-search');
+    const results = await hybridSearch('/tmp/test-mind', 'test query');
+    expect(results).toHaveLength(1);
+    expect(results[0].path).toBe('test.md');
+  });
+});
+
+describe('EmbeddingIndex', () => {
+  it('can be instantiated without errors', async () => {
+    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
+    const index = new EmbeddingIndex();
+    expect(index.isReady()).toBe(false);
+    expect(index.isBuilding()).toBe(false);
+    expect(index.getDocCount()).toBe(0);
+  });
+
+  it('searchByVector returns empty when not ready', async () => {
+    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
+    const index = new EmbeddingIndex();
+    const results = index.searchByVector(new Float32Array([1, 2, 3]));
+    expect(results).toEqual([]);
+  });
+
+  it('invalidate clears state', async () => {
+    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
+    const index = new EmbeddingIndex();
+    index.invalidate();
+    expect(index.isReady()).toBe(false);
+    expect(index.getDocCount()).toBe(0);
+  });
+});

package/_standalone/__tests__/core/inbox-url-utils.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { looksLikeUrl } from '@/lib/inbox-upload';
+
+describe('looksLikeUrl', () => {
+  it('accepts valid http URLs', () => {
+    expect(looksLikeUrl('http://example.com')).toBe(true);
+    expect(looksLikeUrl('http://example.com/path?q=1&a=2')).toBe(true);
+  });
+
+  it('accepts valid https URLs', () => {
+    expect(looksLikeUrl('https://example.com')).toBe(true);
+    expect(looksLikeUrl('https://sub.example.com/long/path#anchor')).toBe(true);
+  });
+
+  it('accepts URLs with leading/trailing whitespace', () => {
+    expect(looksLikeUrl('  https://example.com  ')).toBe(true);
+    expect(looksLikeUrl('\nhttps://example.com\n')).toBe(true);
+  });
+
+  it('rejects non-http schemes', () => {
+    expect(looksLikeUrl('ftp://example.com')).toBe(false);
+    expect(looksLikeUrl('file:///etc/passwd')).toBe(false);
+    expect(looksLikeUrl('javascript:alert(1)')).toBe(false);
+  });
+
+  it('rejects plain text', () => {
+    expect(looksLikeUrl('hello world')).toBe(false);
+    expect(looksLikeUrl('example.com')).toBe(false);
+    expect(looksLikeUrl('')).toBe(false);
+    expect(looksLikeUrl('   ')).toBe(false);
+  });
+
+  it('rejects strings that start with http but are invalid', () => {
+    expect(looksLikeUrl('http://')).toBe(false);
+    expect(looksLikeUrl('https://')).toBe(false);
+  });
+});

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

@@ -0,0 +1,418 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { mkTempMindRoot, cleanupMindRoot, seedFile, readSeeded } from './helpers';
+import {
+  INBOX_DIR,
+  ensureInboxSpace,
+  listInboxFiles,
+  saveToInbox,
+  deleteFromInbox,
+  archiveFromInbox,
+  listProcessedFiles,
+} from '@/lib/core/inbox';
+
+describe('ensureInboxSpace', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('creates Inbox directory with INSTRUCTION.md and README.md', () => {
+    const result = ensureInboxSpace(mindRoot);
+    expect(result).toBe(path.resolve(mindRoot, INBOX_DIR));
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'README.md'))).toBe(true);
+  });
+
+  it('is idempotent — calling twice does not overwrite existing files', () => {
+    ensureInboxSpace(mindRoot);
+    const original = readSeeded(mindRoot, `${INBOX_DIR}/INSTRUCTION.md`);
+    seedFile(mindRoot, `${INBOX_DIR}/custom.md`, 'user content');
+    ensureInboxSpace(mindRoot);
+    expect(readSeeded(mindRoot, `${INBOX_DIR}/INSTRUCTION.md`)).toBe(original);
+    expect(readSeeded(mindRoot, `${INBOX_DIR}/custom.md`)).toBe('user content');
+  });
+
+  it('recreates Inbox after user deletes it', () => {
+    ensureInboxSpace(mindRoot);
+    fs.rmSync(path.join(mindRoot, INBOX_DIR), { recursive: true, force: true });
+    ensureInboxSpace(mindRoot);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+  });
+});
+
+describe('listInboxFiles', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('returns empty array when Inbox does not exist', () => {
+    expect(listInboxFiles(mindRoot)).toEqual([]);
+  });
+
+  it('returns empty array when Inbox exists but is empty (only system files)', () => {
+    ensureInboxSpace(mindRoot);
+    expect(listInboxFiles(mindRoot)).toEqual([]);
+  });
+
+  it('lists non-system files with metadata', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/notes.md`, '# Notes');
+    seedFile(mindRoot, `${INBOX_DIR}/data.csv`, 'a,b,c');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files).toHaveLength(2);
+    expect(files.map(f => f.name).sort()).toEqual(['data.csv', 'notes.md']);
+    expect(files[0].size).toBeGreaterThan(0);
+    expect(files[0].modifiedAt).toBeTruthy();
+    expect(typeof files[0].isAging).toBe('boolean');
+  });
+
+  it('excludes system files (INSTRUCTION.md, README.md, dotfiles)', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/.hidden`, 'hidden');
+    seedFile(mindRoot, `${INBOX_DIR}/visible.md`, 'ok');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files).toHaveLength(1);
+    expect(files[0].name).toBe('visible.md');
+  });
+
+  it('sorts by modification time (newest first)', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/old.md`, 'old');
+    const oldPath = path.join(mindRoot, INBOX_DIR, 'old.md');
+    const pastTime = new Date(Date.now() - 86400000);
+    fs.utimesSync(oldPath, pastTime, pastTime);
+
+    seedFile(mindRoot, `${INBOX_DIR}/new.md`, 'new');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files[0].name).toBe('new.md');
+    expect(files[1].name).toBe('old.md');
+  });
+
+  it('marks files older than 7 days as aging', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/aged.md`, 'old content');
+    const filePath = path.join(mindRoot, INBOX_DIR, 'aged.md');
+    const eightDaysAgo = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000);
+    fs.utimesSync(filePath, eightDaysAgo, eightDaysAgo);
+
+    seedFile(mindRoot, `${INBOX_DIR}/fresh.md`, 'new content');
+
+    const files = listInboxFiles(mindRoot);
+    const aged = files.find(f => f.name === 'aged.md');
+    const fresh = files.find(f => f.name === 'fresh.md');
+    expect(aged?.isAging).toBe(true);
+    expect(fresh?.isAging).toBe(false);
+  });
+
+  it('skips subdirectories', () => {
+    ensureInboxSpace(mindRoot);
+    fs.mkdirSync(path.join(mindRoot, INBOX_DIR, 'subdir'), { recursive: true });
+    seedFile(mindRoot, `${INBOX_DIR}/subdir/nested.md`, 'nested');
+    seedFile(mindRoot, `${INBOX_DIR}/top.md`, 'top');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files).toHaveLength(1);
+    expect(files[0].name).toBe('top.md');
+  });
+});
+
+describe('saveToInbox', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('saves a markdown file to Inbox', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'notes.md', content: '# My Notes\n\nSome content' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.saved[0].original).toBe('notes.md');
+    expect(result.saved[0].path).toBe('Inbox/notes.md');
+    expect(result.skipped).toHaveLength(0);
+
+    const content = readSeeded(mindRoot, 'Inbox/notes.md');
+    expect(content).toContain('My Notes');
+  });
+
+  it('converts .txt to .md with title heading', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'todo.txt', content: 'Buy milk\nFix bug' },
+    ]);
+
+    expect(result.saved[0].path).toBe('Inbox/todo.md');
+    const content = readSeeded(mindRoot, 'Inbox/todo.md');
+    expect(content).toContain('# Todo');
+    expect(content).toContain('Buy milk');
+  });
+
+  it('handles multiple files at once', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'a.md', content: 'aaa' },
+      { name: 'b.md', content: 'bbb' },
+      { name: 'c.md', content: 'ccc' },
+    ]);
+
+    expect(result.saved).toHaveLength(3);
+    expect(fs.readdirSync(path.join(mindRoot, INBOX_DIR))).toContain('a.md');
+    expect(fs.readdirSync(path.join(mindRoot, INBOX_DIR))).toContain('b.md');
+    expect(fs.readdirSync(path.join(mindRoot, INBOX_DIR))).toContain('c.md');
+  });
+
+  it('deduplicates with -1 suffix on name collision', () => {
+    saveToInbox(mindRoot, [{ name: 'notes.md', content: 'first' }]);
+    const result = saveToInbox(mindRoot, [{ name: 'notes.md', content: 'second' }]);
+
+    expect(result.saved[0].path).toBe('Inbox/notes-1.md');
+    expect(readSeeded(mindRoot, 'Inbox/notes.md')).toContain('first');
+    expect(readSeeded(mindRoot, 'Inbox/notes-1.md')).toContain('second');
+  });
+
+  it('skips unsupported file formats', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'script.exe', content: 'binary' },
+      { name: 'notes.md', content: 'ok' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.skipped).toHaveLength(1);
+    expect(result.skipped[0].name).toBe('script.exe');
+    expect(result.skipped[0].reason).toContain('Unsupported');
+  });
+
+  it('skips files with empty or invalid names', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: '', content: 'no name' },
+      { name: 'valid.md', content: 'ok' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.skipped).toHaveLength(1);
+  });
+
+  it('skips files with missing or null content', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'no-content.md', content: undefined as unknown as string },
+      { name: 'null-content.md', content: null as unknown as string },
+      { name: 'valid.md', content: 'ok' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.skipped).toHaveLength(2);
+    expect(result.skipped[0].reason).toContain('Missing');
+    expect(result.skipped[1].reason).toContain('Missing');
+  });
+
+  it('auto-creates Inbox directory if it was deleted', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'rescued.md', content: 'saved!' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+    expect(readSeeded(mindRoot, 'Inbox/rescued.md')).toContain('saved!');
+  });
+
+  it('preserves CSV and JSON files as-is (no markdown conversion)', () => {
+    saveToInbox(mindRoot, [
+      { name: 'data.csv', content: 'a,b,c\n1,2,3' },
+      { name: 'config.json', content: '{"key":"value"}' },
+    ]);
+
+    expect(readSeeded(mindRoot, 'Inbox/data.csv')).toBe('a,b,c\n1,2,3');
+    expect(readSeeded(mindRoot, 'Inbox/config.json')).toBe('{"key":"value"}');
+  });
+
+  it('sanitizes dangerous file names', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: '../../../etc/passwd.md', content: 'hack attempt' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.saved[0].path).toContain('Inbox/');
+    expect(result.saved[0].path).not.toContain('..');
+  });
+
+  it('handles base64 encoded content', () => {
+    const originalContent = 'Hello from base64!';
+    const base64 = Buffer.from(originalContent).toString('base64');
+    const result = saveToInbox(mindRoot, [
+      { name: 'encoded.md', content: base64, encoding: 'base64' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(readSeeded(mindRoot, 'Inbox/encoded.md')).toContain('Hello from base64!');
+  });
+});
+
+describe('deleteFromInbox', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('deletes existing files by name', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/a.md`, 'aaa');
+    seedFile(mindRoot, `${INBOX_DIR}/b.md`, 'bbb');
+
+    const result = deleteFromInbox(mindRoot, ['a.md', 'b.md']);
+    expect(result.deleted).toEqual(['a.md', 'b.md']);
+    expect(result.notFound).toEqual([]);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'a.md'))).toBe(false);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'b.md'))).toBe(false);
+  });
+
+  it('reports not-found for missing files', () => {
+    ensureInboxSpace(mindRoot);
+    const result = deleteFromInbox(mindRoot, ['nonexistent.md']);
+    expect(result.deleted).toEqual([]);
+    expect(result.notFound).toEqual(['nonexistent.md']);
+  });
+
+  it('refuses to delete system files', () => {
+    ensureInboxSpace(mindRoot);
+    const result = deleteFromInbox(mindRoot, ['INSTRUCTION.md', 'README.md']);
+    expect(result.deleted).toEqual([]);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'README.md'))).toBe(true);
+  });
+
+  it('handles mixed existing and missing files', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/real.md`, 'content');
+
+    const result = deleteFromInbox(mindRoot, ['real.md', 'fake.md']);
+    expect(result.deleted).toEqual(['real.md']);
+    expect(result.notFound).toEqual(['fake.md']);
+  });
+
+  it('ignores empty or invalid names', () => {
+    ensureInboxSpace(mindRoot);
+    const result = deleteFromInbox(mindRoot, ['', null as unknown as string]);
+    expect(result.deleted).toEqual([]);
+    expect(result.notFound).toEqual([]);
+  });
+
+  it('prevents path traversal attempts', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, 'outside.md', 'should not be deleted');
+
+    const result = deleteFromInbox(mindRoot, ['../outside.md']);
+    expect(result.notFound).toEqual(['../outside.md']);
+    expect(fs.existsSync(path.join(mindRoot, 'outside.md'))).toBe(true);
+  });
+});
+
+describe('archiveFromInbox', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('moves files to .processed/ with timestamp prefix', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/notes.md`, '# Notes');
+
+    const result = archiveFromInbox(mindRoot, ['notes.md']);
+    expect(result.archived).toHaveLength(1);
+    expect(result.archived[0].original).toBe('notes.md');
+    expect(result.archived[0].archivedPath).toMatch(/^Inbox\/\.processed\/\d{8}-\d{6}_notes\.md$/);
+    expect(result.notFound).toEqual([]);
+
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'notes.md'))).toBe(false);
+
+    const processedDir = path.join(mindRoot, INBOX_DIR, '.processed');
+    const processedFiles = fs.readdirSync(processedDir);
+    expect(processedFiles).toHaveLength(1);
+    expect(processedFiles[0]).toMatch(/^\d{8}-\d{6}_notes\.md$/);
+
+    const content = fs.readFileSync(path.join(processedDir, processedFiles[0]), 'utf-8');
+    expect(content).toBe('# Notes');
+  });
+
+  it('reports not-found for missing files', () => {
+    ensureInboxSpace(mindRoot);
+    const result = archiveFromInbox(mindRoot, ['nonexistent.md']);
+    expect(result.archived).toEqual([]);
+    expect(result.notFound).toEqual(['nonexistent.md']);
+  });
+
+  it('refuses to archive system files', () => {
+    ensureInboxSpace(mindRoot);
+    const result = archiveFromInbox(mindRoot, ['INSTRUCTION.md', 'README.md']);
+    expect(result.archived).toEqual([]);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'README.md'))).toBe(true);
+  });
+
+  it('handles mixed existing and missing files', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/real.md`, 'content');
+
+    const result = archiveFromInbox(mindRoot, ['real.md', 'fake.md']);
+    expect(result.archived).toHaveLength(1);
+    expect(result.notFound).toEqual(['fake.md']);
+  });
+
+  it('creates .processed/ directory if it does not exist', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/a.md`, 'aaa');
+
+    const processedDir = path.join(mindRoot, INBOX_DIR, '.processed');
+    expect(fs.existsSync(processedDir)).toBe(false);
+
+    archiveFromInbox(mindRoot, ['a.md']);
+    expect(fs.existsSync(processedDir)).toBe(true);
+  });
+
+  it('archived files are hidden from listInboxFiles', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/visible.md`, 'visible');
+
+    expect(listInboxFiles(mindRoot)).toHaveLength(1);
+
+    archiveFromInbox(mindRoot, ['visible.md']);
+
+    expect(listInboxFiles(mindRoot)).toHaveLength(0);
+  });
+});
+
+describe('listProcessedFiles', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('returns empty array when .processed/ does not exist', () => {
+    expect(listProcessedFiles(mindRoot)).toEqual([]);
+  });
+
+  it('lists archived files sorted by date', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/a.md`, 'a');
+    seedFile(mindRoot, `${INBOX_DIR}/b.md`, 'b');
+    archiveFromInbox(mindRoot, ['a.md', 'b.md']);
+
+    const files = listProcessedFiles(mindRoot);
+    expect(files).toHaveLength(2);
+    expect(files[0].originalName).toMatch(/\.(md|csv|json)$/);
+    expect(files[0].path).toContain('.processed/');
+  });
+
+  it('extracts original name by stripping timestamp prefix', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/report.md`, 'content');
+    archiveFromInbox(mindRoot, ['report.md']);
+
+    const files = listProcessedFiles(mindRoot);
+    expect(files[0].originalName).toBe('report.md');
+  });
+});

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

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { signJwt, verifyJwt } from '@/lib/jwt';
+
+describe('signJwt + verifyJwt', () => {
+  const secret = 'test-secret-key-1234';
+
+  it('signs and verifies a simple payload', async () => {
+    const payload = { sub: 'user-123', role: 'admin' };
+    const token = await signJwt(payload, secret);
+
+    expect(typeof token).toBe('string');
+    expect(token.split('.')).toHaveLength(3);
+
+    const verified = await verifyJwt(token, secret);
+    expect(verified).not.toBeNull();
+    expect(verified!.sub).toBe('user-123');
+    expect(verified!.role).toBe('admin');
+  });
+
+  it('returns null for invalid token format', async () => {
+    expect(await verifyJwt('not-a-jwt', secret)).toBeNull();
+    expect(await verifyJwt('a.b', secret)).toBeNull();
+    expect(await verifyJwt('', secret)).toBeNull();
+  });
+
+  it('returns null for wrong secret', async () => {
+    const token = await signJwt({ sub: 'test' }, secret);
+    const verified = await verifyJwt(token, 'wrong-secret');
+    expect(verified).toBeNull();
+  });
+
+  it('returns null for expired token', async () => {
+    const payload = { sub: 'test', exp: Math.floor(Date.now() / 1000) - 3600 };
+    const token = await signJwt(payload, secret);
+    const verified = await verifyJwt(token, secret);
+    expect(verified).toBeNull();
+  });
+
+  it('accepts non-expired token', async () => {
+    const payload = { sub: 'test', exp: Math.floor(Date.now() / 1000) + 3600 };
+    const token = await signJwt(payload, secret);
+    const verified = await verifyJwt(token, secret);
+    expect(verified).not.toBeNull();
+    expect(verified!.sub).toBe('test');
+  });
+
+  it('handles payload with special characters', async () => {
+    const payload = { name: '日本語テスト 🎉', path: '/a/b/c' };
+    const token = await signJwt(payload, secret);
+    const verified = await verifyJwt(token, secret);
+    expect(verified).not.toBeNull();
+    expect(verified!.name).toBe('日本語テスト 🎉');
+    expect(verified!.path).toBe('/a/b/c');
+  });
+
+  it('handles empty payload', async () => {
+    const token = await signJwt({}, secret);
+    const verified = await verifyJwt(token, secret);
+    expect(verified).not.toBeNull();
+    expect(verified).toEqual({});
+  });
+});