@geminilight/mindos 0.6.40 → 0.6.41

package/_standalone/__tests__/api/mcp-install.test.ts

@@ -176,6 +176,29 @@ describe('POST /api/mcp/install', () => {
     expect(content).toContain('[mcp_servers.mindos]');
   });
 
+  it('handles empty config file gracefully (e.g. fresh VS Code mcp.json)', async () => {
+    const { POST } = await importInstallRoute();
+    // Pre-create an empty config file (common with VS Code)
+    const copilotDir = path.join(tempHome, '.config', 'Code', 'User');
+    fs.mkdirSync(copilotDir, { recursive: true });
+    fs.writeFileSync(path.join(copilotDir, 'mcp.json'), '', 'utf-8');
+
+    const req = new NextRequest('http://localhost/api/mcp/install', {
+      method: 'POST',
+      body: JSON.stringify({
+        agents: [{ key: 'github-copilot', scope: 'global' }],
+        transport: 'stdio',
+      }),
+      headers: { 'content-type': 'application/json' },
+    });
+    const res = await POST(req);
+    const body = await res.json();
+    expect(body.results[0].status).toBe('ok');
+
+    const config = JSON.parse(fs.readFileSync(path.join(copilotDir, 'mcp.json'), 'utf-8'));
+    expect(config.servers.mindos.type).toBe('stdio');
+  });
+
   it('installs github-copilot agent with servers key for global scope', async () => {
     const { POST } = await importInstallRoute();
     const req = new NextRequest('http://localhost/api/mcp/install', {

package/_standalone/__tests__/cli/agent-routing.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Tests for agent/ask CLI routing logic:
+ * - `-p` flag → non-interactive (print mode)
+ * - No `-p` + no args → interactive REPL
+ * - Management subcommands → direct execution
+ */
+
+import { describe, it, expect } from 'vitest';
+
+const MANAGEMENT_SUBCOMMANDS = new Set(['list', 'ls', 'info', 'stats', 'help']);
+
+type AgentRoute = 'interactive' | 'print' | 'management';
+
+function classifyAgentArgs(
+  args: string[],
+  flags: Record<string, unknown> = {},
+): AgentRoute {
+  const sub = args[0];
+
+  // Management subcommands always take priority
+  if (sub && MANAGEMENT_SUBCOMMANDS.has(sub)) return 'management';
+
+  // -p / --print → non-interactive print mode
+  if (flags.p || flags.print) return 'print';
+
+  // Has task text without -p → also print mode (backward compat: inline task)
+  if (sub) return 'print';
+
+  // No args, no -p → interactive REPL
+  return 'interactive';
+}
+
+function classifyAskArgs(
+  args: string[],
+  flags: Record<string, unknown> = {},
+): 'interactive' | 'print' {
+  if (flags.p || flags.print) return 'print';
+  if (args.length > 0) return 'print';
+  return 'interactive';
+}
+
+function buildAskBody(
+  content: string | string[],
+  mode: 'agent' | 'chat',
+  opts: { file?: string; maxSteps?: number } = {},
+) {
+  const messages = Array.isArray(content)
+    ? content.map((c, i) => ({
+        role: i % 2 === 0 ? 'user' : 'assistant',
+        content: c,
+        timestamp: Date.now(),
+      }))
+    : [{ role: 'user', content, timestamp: Date.now() }];
+
+  const body: Record<string, unknown> = { messages, mode };
+  if (opts.file) body.attachedFiles = [opts.file];
+  if (opts.maxSteps) body.maxSteps = opts.maxSteps;
+  return body;
+}
+
+// ── Agent routing ─────────────────────────────────────────────────────────────
+
+describe('Agent CLI routing', () => {
+  it('routes empty args (no -p) to interactive', () => {
+    expect(classifyAgentArgs([])).toBe('interactive');
+  });
+
+  it('routes -p flag with task to print mode', () => {
+    expect(classifyAgentArgs(['整理笔记'], { p: true })).toBe('print');
+  });
+
+  it('routes --print flag with task to print mode', () => {
+    expect(classifyAgentArgs(['do stuff'], { print: true })).toBe('print');
+  });
+
+  it('routes bare task (no -p) to print mode for backward compat', () => {
+    expect(classifyAgentArgs(['Summarize my notes'])).toBe('print');
+  });
+
+  it('routes "list" to management regardless of -p', () => {
+    expect(classifyAgentArgs(['list'])).toBe('management');
+    expect(classifyAgentArgs(['list'], { p: true })).toBe('management');
+  });
+
+  it('routes "ls" alias to management', () => {
+    expect(classifyAgentArgs(['ls'])).toBe('management');
+  });
+
+  it('routes "info" to management', () => {
+    expect(classifyAgentArgs(['info', 'cursor'])).toBe('management');
+  });
+
+  it('routes "stats" to management', () => {
+    expect(classifyAgentArgs(['stats'])).toBe('management');
+  });
+
+  it('routes "help" to management', () => {
+    expect(classifyAgentArgs(['help'])).toBe('management');
+  });
+
+  it('routes Chinese task text to print mode', () => {
+    expect(classifyAgentArgs(['整理我的笔记'])).toBe('print');
+  });
+
+  it('does not misroute words starting with subcommand prefix', () => {
+    expect(classifyAgentArgs(['listing', 'all', 'files'])).toBe('print');
+    expect(classifyAgentArgs(['information', 'about', 'RAG'])).toBe('print');
+  });
+
+  it('routes -p with no task text to print mode', () => {
+    expect(classifyAgentArgs([], { p: true })).toBe('print');
+  });
+});
+
+// ── Ask routing ───────────────────────────────────────────────────────────────
+
+describe('Ask CLI routing', () => {
+  it('routes empty args to interactive', () => {
+    expect(classifyAskArgs([])).toBe('interactive');
+  });
+
+  it('routes -p with question to print', () => {
+    expect(classifyAskArgs(['what is RAG'], { p: true })).toBe('print');
+  });
+
+  it('routes bare question (no -p) to print for backward compat', () => {
+    expect(classifyAskArgs(['what is RAG'])).toBe('print');
+  });
+
+  it('routes --print flag to print', () => {
+    expect(classifyAskArgs(['hello'], { print: true })).toBe('print');
+  });
+});
+
+// ── API body construction ─────────────────────────────────────────────────────
+
+describe('Ask API body construction', () => {
+  it('builds agent mode body with correct message format', () => {
+    const body = buildAskBody('do something', 'agent');
+    expect(body.mode).toBe('agent');
+    expect(body.messages).toHaveLength(1);
+    const msg = (body.messages as any[])[0];
+    expect(msg.role).toBe('user');
+    expect(msg.content).toBe('do something');
+    expect(msg.timestamp).toBeTypeOf('number');
+  });
+
+  it('builds chat mode body', () => {
+    const body = buildAskBody('what is RAG', 'chat');
+    expect(body.mode).toBe('chat');
+  });
+
+  it('builds multi-turn conversation body', () => {
+    const body = buildAskBody(['hello', 'hi there', 'how are you'], 'chat');
+    expect(body.messages).toHaveLength(3);
+    const msgs = body.messages as any[];
+    expect(msgs[0].role).toBe('user');
+    expect(msgs[1].role).toBe('assistant');
+    expect(msgs[2].role).toBe('user');
+  });
+
+  it('attaches file when provided', () => {
+    const body = buildAskBody('summarize', 'agent', { file: 'notes.md' });
+    expect(body.attachedFiles).toEqual(['notes.md']);
+  });
+
+  it('sets maxSteps when provided', () => {
+    const body = buildAskBody('do task', 'agent', { maxSteps: 10 });
+    expect(body.maxSteps).toBe(10);
+  });
+
+  it('omits attachedFiles and maxSteps when not provided', () => {
+    const body = buildAskBody('simple task', 'agent');
+    expect(body.attachedFiles).toBeUndefined();
+    expect(body.maxSteps).toBeUndefined();
+  });
+});
+
+describe('SSE event parsing', () => {
+  function parseSSELine(line: string): { type: string; [key: string]: unknown } | null {
+    if (!line.startsWith('data:')) return null;
+    const payload = line.slice(5);
+    if (!payload) return null;
+    try {
+      return JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+
+  it('parses text_delta event', () => {
+    const event = parseSSELine('data:{"type":"text_delta","text":"Hello"}');
+    expect(event).toEqual({ type: 'text_delta', text: 'Hello' });
+  });
+
+  it('parses tool_start event', () => {
+    const event = parseSSELine('data:{"type":"tool_start","name":"search_notes","input":{"query":"today"}}');
+    expect(event?.type).toBe('tool_start');
+    expect(event?.name).toBe('search_notes');
+  });
+
+  it('parses tool_end event', () => {
+    const event = parseSSELine('data:{"type":"tool_end","result":"found 3 notes"}');
+    expect(event?.type).toBe('tool_end');
+    expect(event?.result).toBe('found 3 notes');
+  });
+
+  it('parses error event', () => {
+    const event = parseSSELine('data:{"type":"error","message":"API key not configured"}');
+    expect(event?.type).toBe('error');
+    expect(event?.message).toBe('API key not configured');
+  });
+
+  it('parses done event', () => {
+    const event = parseSSELine('data:{"type":"done"}');
+    expect(event?.type).toBe('done');
+  });
+
+  it('returns null for non-data lines', () => {
+    expect(parseSSELine('event: message')).toBeNull();
+    expect(parseSSELine('')).toBeNull();
+    expect(parseSSELine('retry: 3000')).toBeNull();
+  });
+
+  it('returns null for empty data', () => {
+    expect(parseSSELine('data:')).toBeNull();
+  });
+
+  it('returns null for invalid JSON', () => {
+    expect(parseSSELine('data:{broken')).toBeNull();
+  });
+});

package/_standalone/__tests__/cli/file-subcommands.test.ts

@@ -0,0 +1,379 @@
+/**
+ * Tests for new `mindos file` subcommands:
+ * write, append, edit-section, insert-heading, append-csv, backlinks, recent, history
+ *
+ * Tests the pure-logic modules (markdown.js, csv.js) and integration via file.js helpers.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+
+function mkTmp(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-cli-file-'));
+}
+function cleanup(dir: string): void {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+function seed(root: string, rel: string, content: string): void {
+  const abs = path.join(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf-8');
+}
+function read(root: string, rel: string): string {
+  return fs.readFileSync(path.join(root, rel), 'utf-8');
+}
+
+// ── Markdown section logic (ported from app/lib/core/lines.ts) ──
+
+function findHeadingIndex(lines: string[], heading: string): number {
+  return lines.findIndex(l => {
+    const trimmed = l.trim();
+    return trimmed === heading || trimmed.replace(/^#+\s*/, '') === heading.replace(/^#+\s*/, '');
+  });
+}
+
+function replaceSection(content: string, heading: string, newBody: string): string {
+  const lines = content.split('\n');
+  const idx = findHeadingIndex(lines, heading);
+  if (idx === -1) return '';
+
+  const headingLevel = (lines[idx].match(/^#+/) ?? [''])[0].length;
+  let sectionEnd = lines.length - 1;
+  for (let i = idx + 1; i < lines.length; i++) {
+    const m = lines[i].match(/^(#+)\s/);
+    if (m && m[1].length <= headingLevel) {
+      sectionEnd = i - 1;
+      break;
+    }
+  }
+  while (sectionEnd > idx && lines[sectionEnd].trim() === '') sectionEnd--;
+
+  const before = lines.slice(0, idx + 1);
+  const after = lines.slice(sectionEnd + 1);
+  return [...before, '', newBody, ...after].join('\n');
+}
+
+function insertAfterHeading(content: string, heading: string, insertion: string): string {
+  const lines = content.split('\n');
+  const idx = findHeadingIndex(lines, heading);
+  if (idx === -1) return '';
+
+  let insertAt = idx + 1;
+  while (insertAt < lines.length && lines[insertAt].trim() === '') insertAt++;
+
+  const before = lines.slice(0, insertAt);
+  const after = lines.slice(insertAt);
+  return [...before, '', insertion, ...after].join('\n');
+}
+
+function escapeCsvRow(row: string[]): string {
+  return row.map(cell => {
+    if (cell.includes(',') || cell.includes('"') || cell.includes('\n')) {
+      return `"${cell.replace(/"/g, '""')}"`;
+    }
+    return cell;
+  }).join(',');
+}
+
+function listHeadings(content: string): string[] {
+  return content.split('\n')
+    .filter(l => /^#{1,6}\s/.test(l))
+    .map(l => l.trim());
+}
+
+// ── Markdown replaceSection tests ──
+
+describe('replaceSection', () => {
+  it('replaces section body between same-level headings', () => {
+    const input = '# Title\n\n## A\n\nOld A content\n\n## B\n\nB content';
+    const result = replaceSection(input, '## A', 'New A content');
+    expect(result).toContain('## A');
+    expect(result).toContain('New A content');
+    expect(result).not.toContain('Old A content');
+    expect(result).toContain('## B');
+    expect(result).toContain('B content');
+  });
+
+  it('replaces last section (no following heading)', () => {
+    const input = '# Title\n\n## A\n\nA content\n\n## B\n\nOld B';
+    const result = replaceSection(input, '## B', 'New B');
+    expect(result).toContain('New B');
+    expect(result).not.toContain('Old B');
+  });
+
+  it('returns empty string when heading not found', () => {
+    const input = '# Title\n\n## A\n\nContent';
+    expect(replaceSection(input, '## Missing', 'x')).toBe('');
+  });
+
+  it('handles heading with extra spaces', () => {
+    const input = '## Status \n\nOld status';
+    const result = replaceSection(input, '## Status', 'New status');
+    expect(result).toContain('New status');
+  });
+
+  it('stops at higher-level heading', () => {
+    const input = '# Title\n\n## A\n\nA stuff\n\n### Sub\n\nSub stuff\n\n## B\n\nB stuff';
+    const result = replaceSection(input, '## A', 'Replaced');
+    expect(result).toContain('Replaced');
+    expect(result).toContain('## B');
+    expect(result).toContain('B stuff');
+    expect(result).not.toContain('A stuff');
+    expect(result).not.toContain('Sub stuff');
+  });
+
+  it('replaces section with empty content', () => {
+    const input = '## A\n\nContent\n\n## B\n\nMore';
+    const result = replaceSection(input, '## A', '');
+    expect(result).toContain('## A');
+    expect(result).not.toContain('Content');
+  });
+});
+
+// ── insertAfterHeading tests ──
+
+describe('insertAfterHeading', () => {
+  it('inserts after heading, before existing content', () => {
+    const input = '## Notes\n\nExisting note';
+    const result = insertAfterHeading(input, '## Notes', 'New note');
+    expect(result).toContain('## Notes');
+    expect(result).toContain('New note');
+    expect(result).toContain('Existing note');
+    const lines = result.split('\n');
+    const notesIdx = lines.findIndex(l => l.includes('## Notes'));
+    const newIdx = lines.findIndex(l => l.includes('New note'));
+    const existIdx = lines.findIndex(l => l.includes('Existing note'));
+    expect(newIdx).toBeGreaterThan(notesIdx);
+    expect(newIdx).toBeLessThan(existIdx);
+  });
+
+  it('returns empty string when heading not found', () => {
+    expect(insertAfterHeading('# Title', '## Missing', 'x')).toBe('');
+  });
+
+  it('inserts at end if heading is last thing', () => {
+    const input = '## Notes';
+    const result = insertAfterHeading(input, '## Notes', 'Added');
+    expect(result).toContain('## Notes');
+    expect(result).toContain('Added');
+  });
+});
+
+// ── CSV escaping tests ──
+
+describe('escapeCsvRow', () => {
+  it('joins simple values', () => {
+    expect(escapeCsvRow(['a', 'b', 'c'])).toBe('a,b,c');
+  });
+
+  it('quotes values containing commas', () => {
+    expect(escapeCsvRow(['a,b', 'c'])).toBe('"a,b",c');
+  });
+
+  it('escapes double quotes', () => {
+    expect(escapeCsvRow(['say "hello"', 'x'])).toBe('"say ""hello""",x');
+  });
+
+  it('quotes values containing newlines', () => {
+    expect(escapeCsvRow(['line1\nline2', 'x'])).toBe('"line1\nline2",x');
+  });
+
+  it('handles empty strings', () => {
+    expect(escapeCsvRow(['', '', ''])).toBe(',,');
+  });
+
+  it('handles single value', () => {
+    expect(escapeCsvRow(['only'])).toBe('only');
+  });
+});
+
+// ── listHeadings tests ──
+
+describe('listHeadings', () => {
+  it('extracts all markdown headings', () => {
+    const input = '# Title\n\nSome text\n\n## A\n\nContent\n\n### Sub\n\n## B';
+    expect(listHeadings(input)).toEqual(['# Title', '## A', '### Sub', '## B']);
+  });
+
+  it('returns empty for no headings', () => {
+    expect(listHeadings('Just text\nMore text')).toEqual([]);
+  });
+
+  it('ignores lines that look like headings inside code blocks', () => {
+    expect(listHeadings('## Real\n\n```\n## Not a heading\n```')).toContain('## Real');
+  });
+});
+
+// ── Backlinks logic tests ──
+
+describe('findBacklinksLocal', () => {
+  let root: string;
+  beforeEach(() => { root = mkTmp(); });
+  afterEach(() => { cleanup(root); });
+
+  function findBacklinksLocal(mindRoot: string, targetPath: string): string[] {
+    const results: string[] = [];
+    const bname = path.basename(targetPath, '.md');
+    const escapedTarget = targetPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedBname = bname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    const patterns = [
+      new RegExp(`\\[\\[${escapedBname}(?:[|#][^\\]]*)?\\]\\]`, 'i'),
+      new RegExp(`\\[\\[${escapedTarget}(?:[|#][^\\]]*)?\\]\\]`, 'i'),
+      new RegExp(`\\[[^\\]]+\\]\\(${escapedTarget}(?:#[^)]*)?\\)`, 'i'),
+    ];
+
+    function walk(dir: string): void {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith('.')) continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) { walk(full); continue; }
+        if (!entry.name.endsWith('.md')) continue;
+        const rel = path.relative(mindRoot, full);
+        if (rel === targetPath) continue;
+        const content = fs.readFileSync(full, 'utf-8');
+        if (patterns.some(p => p.test(content))) results.push(rel);
+      }
+    }
+    walk(mindRoot);
+    return results;
+  }
+
+  it('finds wikilink references', () => {
+    seed(root, 'target.md', '# Target');
+    seed(root, 'linker.md', 'See [[target]] for details');
+    expect(findBacklinksLocal(root, 'target.md')).toEqual(['linker.md']);
+  });
+
+  it('finds markdown link references', () => {
+    seed(root, 'notes/plan.md', '# Plan');
+    seed(root, 'index.md', 'Check [the plan](notes/plan.md) here');
+    expect(findBacklinksLocal(root, 'notes/plan.md')).toEqual(['index.md']);
+  });
+
+  it('returns empty when no references', () => {
+    seed(root, 'a.md', '# A');
+    seed(root, 'b.md', '# B - no links');
+    expect(findBacklinksLocal(root, 'a.md')).toEqual([]);
+  });
+
+  it('excludes self-references', () => {
+    seed(root, 'self.md', 'Link to [[self]]');
+    expect(findBacklinksLocal(root, 'self.md')).toEqual([]);
+  });
+});
+
+// ── Recent files logic tests ──
+
+describe('getRecentFiles', () => {
+  let root: string;
+  beforeEach(() => { root = mkTmp(); });
+  afterEach(() => { cleanup(root); });
+
+  function getRecentFiles(mindRoot: string, limit: number): Array<{path: string; mtime: number}> {
+    const results: Array<{path: string; mtime: number}> = [];
+    function walk(dir: string): void {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith('.')) continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) { walk(full); continue; }
+        if (!entry.name.endsWith('.md') && !entry.name.endsWith('.csv')) continue;
+        const stat = fs.statSync(full);
+        results.push({ path: path.relative(mindRoot, full), mtime: stat.mtimeMs });
+      }
+    }
+    walk(mindRoot);
+    results.sort((a, b) => b.mtime - a.mtime);
+    return results.slice(0, limit);
+  }
+
+  it('returns files sorted by modification time', () => {
+    seed(root, 'old.md', 'old');
+    const oldTime = Date.now() - 10000;
+    fs.utimesSync(path.join(root, 'old.md'), new Date(oldTime), new Date(oldTime));
+    seed(root, 'new.md', 'new');
+    const result = getRecentFiles(root, 10);
+    expect(result[0].path).toBe('new.md');
+    expect(result[1].path).toBe('old.md');
+  });
+
+  it('respects limit', () => {
+    seed(root, 'a.md', 'a');
+    seed(root, 'b.md', 'b');
+    seed(root, 'c.md', 'c');
+    expect(getRecentFiles(root, 2)).toHaveLength(2);
+  });
+
+  it('returns empty for empty directory', () => {
+    expect(getRecentFiles(root, 10)).toEqual([]);
+  });
+
+  it('skips hidden files', () => {
+    seed(root, '.hidden.md', 'hidden');
+    seed(root, 'visible.md', 'visible');
+    const result = getRecentFiles(root, 10);
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe('visible.md');
+  });
+});
+
+// ── Git history tests (integration, requires git) ──
+
+describe('gitHistory', () => {
+  let root: string;
+  let hasGit: boolean;
+
+  beforeEach(() => {
+    root = mkTmp();
+    try {
+      execFileSync('git', ['--version'], { stdio: 'pipe' });
+      hasGit = true;
+    } catch { hasGit = false; }
+  });
+  afterEach(() => { cleanup(root); });
+
+  it('returns git log entries for a file', () => {
+    if (!hasGit) return;
+    execFileSync('git', ['init'], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: root, stdio: 'pipe' });
+    seed(root, 'test.md', 'v1');
+    execFileSync('git', ['add', '.'], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', 'initial'], { cwd: root, stdio: 'pipe' });
+
+    const output = execFileSync(
+      'git',
+      ['log', '--follow', '--format=%H%x00%aI%x00%s%x00%an', '-n', '10', '--', path.join(root, 'test.md')],
+      { cwd: root, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+
+    const entries = output.split('\n').map(line => {
+      const [hash, date, message, author] = line.split('\0');
+      return { hash, date, message, author };
+    });
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0].message).toBe('initial');
+    expect(entries[0].author).toBe('Test');
+  });
+
+  it('returns empty for file with no commits', () => {
+    if (!hasGit) return;
+    execFileSync('git', ['init'], { cwd: root, stdio: 'pipe' });
+    seed(root, 'untracked.md', 'content');
+    let output = '';
+    try {
+      output = execFileSync(
+        'git',
+        ['log', '--follow', '--format=%H%x00%aI%x00%s%x00%an', '-n', '10', '--', path.join(root, 'untracked.md')],
+        { cwd: root, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+      ).trim();
+    } catch {
+      output = '';
+    }
+    expect(output).toBe('');
+  });
+});

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

@@ -57,12 +57,12 @@ describe('tools: list_files', () => {
     seedFile('data.csv', 'a,b,c');
   });
 
-  it('lists all files with default params (excluding system files)', async () => {
+  it('lists all files with default params', async () => {
     const result = await callTool('list_files', {});
     expect(result).toContain('Profile/');
     expect(result).toContain('Identity.md');
     expect(result).toContain('Goals.md');
-    expect(result).not.toContain('README.md'); // System file hidden from Agent
+    expect(result).toContain('README.md'); // System files now included in tree
     expect(result).toContain('data.csv');
     expect(result).not.toContain('Error:');
   });
@@ -71,15 +71,13 @@ describe('tools: list_files', () => {
     const result = await callTool('list_files', { path: 'Profile' });
     expect(result).toContain('Identity.md');
     expect(result).toContain('Goals.md');
-    expect(result).not.toContain('README.md');
     expect(result).not.toContain('data.csv');
   });
 
-  it('respects depth parameter (hides system files)', async () => {
+  it('respects depth parameter', async () => {
     const result = await callTool('list_files', { depth: 1 });
     expect(result).toContain('Profile/');
     expect(result).toContain('...');
-    expect(result).not.toContain('README.md'); // System file hidden
   });
 
   it('returns error message for non-existent directory', async () => {
@@ -91,7 +89,6 @@ describe('tools: list_files', () => {
   it('handles nested subdirectory path', async () => {
     const result = await callTool('list_files', { path: 'Projects/Products' });
     expect(result).toContain('ProductA.md');
-    expect(result).not.toContain('README.md');
   });
 
   it('returns (empty directory) for dir with no allowed files', async () => {