winter-super-cli 2026.5.24 → 2026.5.26

package/src/cli/repl.test.js

@@ -1,5 +1,8 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 
 import { WinterREPL } from './repl.js';
 
@@ -23,6 +26,104 @@ test('resource paths point at bundled project resources', () => {
   assert.equal(paths.designs, 'E:\\dev\\app\\winter\\resources\\local\\awesome-design-md\\design-md');
 });
 
+test('project context includes winter.md rules', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-context-'));
+  await writeFile(
+    path.join(root, 'winter.md'),
+    '# Winter Rules\n\n- Always use Vietnamese\n- Keep changes surgical\n'
+  );
+
+  const repl = new WinterREPL({ projectPath: root });
+  const context = await repl.getProjectContext();
+
+  assert.match(context, /\[winter\.md\]/);
+  assert.match(context, /Always use Vietnamese/);
+  assert.match(context, /Keep changes surgical/);
+});
+
+test('project context includes local resource manifest summary', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  const context = await repl.getProjectContext();
+
+  assert.match(context, /\[Local Resources\]/);
+  assert.match(context, /agents\.md/);
+  assert.match(context, /awesome-design-md/);
+  assert.match(context, /codex/);
+});
+
+test('local resource context indexes Claude and Codex resource roots', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  const context = await repl.getLocalResourceContext();
+
+  assert.match(context, /Claude skills/);
+  assert.match(context, /skill-creator/);
+  assert.match(context, /vercel-react-best-practices/);
+  assert.match(context, /Codex skills/);
+  assert.match(context, /vibefigma/);
+  assert.match(context, /Codex memories/);
+});
+
+test('inferStartupSkills promotes design skills for React-like projects', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  repl.getStartupSkillCatalog = async () => new Set([
+    'coding',
+    'debug',
+    'refactor',
+    'test',
+    'design',
+    'web-design-guidelines',
+    'vercel-react-best-practices',
+  ]);
+  repl.getProjectSignals = async () => ['react', 'next', 'tsx', 'ui'];
+
+  const snapshot = await repl.inferStartupSkills();
+
+  assert(snapshot.activeSkills.includes('coding'));
+  assert(snapshot.activeSkills.includes('web-design-guidelines'));
+  assert(snapshot.activeSkills.includes('vercel-react-best-practices'));
+  assert(snapshot.activeSkills.includes('design'));
+});
+
+test('bootstrapProjectCapabilities creates a startup plan and stores skills', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  repl.getStartupSkillCatalog = async () => new Set(['coding', 'debug', 'refactor', 'test']);
+  repl.getProjectSignals = async () => ['node', 'cli'];
+
+  const contextStore = {};
+  const plans = [];
+  const memoryWrites = [];
+  repl.session = {
+    getContext: () => contextStore,
+    getPlans: () => plans,
+    createPlan: async (title, description) => {
+      const plan = { id: 'plan-1', title, description };
+      plans.push(plan);
+      return plan;
+    },
+    addPlanStep: async () => {},
+    updateContext: async (key, value) => {
+      contextStore[key] = value;
+    },
+    replaceMemory: async (prefix, content) => {
+      memoryWrites.push({ prefix, content });
+    },
+  };
+
+  await repl.bootstrapProjectCapabilities();
+
+  assert.equal(plans.length, 1);
+  assert.equal(contextStore.bootstrapPlan.title, 'Bootstrap project context');
+  assert.deepEqual(contextStore.activeSkills, ['coding', 'debug', 'refactor', 'test']);
+  assert.match(memoryWrites[0].content, /Auto-applied skills/);
+});
+
+test('shouldUseTools keeps agent mode enabled by default', () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+
+  assert.equal(repl.shouldUseTools('hello'), true);
+  assert.equal(repl.shouldUseTools('just chat'), true);
+});
+
 test('extractModelIdsFromCache reads model slugs without service tier ids', () => {
   const repl = new WinterREPL({ projectPath: process.cwd() });
   const raw = JSON.stringify({
@@ -41,6 +142,25 @@ test('extractModelIdsFromCache reads model slugs without service tier ids', () =
   ]);
 });
 
+test('system prompt compresses oversized memories and project context', () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  repl.session = {
+    getSessionId: () => 'test-session',
+    getMemory: () => Array.from({ length: 24 }, (_, index) => ({
+      text: `Memory ${index + 1}: ${'x'.repeat(2500)}`,
+    })),
+    getPlans: () => [{ status: 'pending', title: 'Huge plan', description: 'y'.repeat(1200) }],
+    getContext: () => ({ activeSkills: ['coding', 'debug'], bootstrapPlan: { title: 'Bootstrap', description: 'Inspect everything' } }),
+  };
+
+  const prompt = repl.getSystemPrompt('Project context ' + 'z'.repeat(18000));
+
+  assert(prompt.length < 30000);
+  assert.match(prompt, /Memories \(Important Context\)/);
+  assert.match(prompt, /truncated/i);
+  assert.match(prompt, /project context truncated/i);
+});
+
 test('readCachedModels returns bundled cache model ids', async () => {
   const repl = new WinterREPL({ projectPath: process.cwd() });
   const models = await repl.readCachedModels(repl.getResourcePaths().codex.models);
@@ -49,10 +169,41 @@ test('readCachedModels returns bundled cache model ids', async () => {
   assert(!models.includes('priority'));
 });
 
-test('shouldUseTools keeps simple chat on the fast path', () => {
+test('provider slash command switches and persists configured provider', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  const saved = [];
+  repl.config = {
+    setDefaultProvider: async provider => saved.push(provider),
+  };
+  repl.ai = {
+    active: 'ollama',
+    providers: {
+      custom: { model: 'custom-model', ready: true },
+      ollama: { model: 'llama3', ready: true },
+    },
+    async switchProvider(name) {
+      if (!this.providers[name]) return null;
+      this.active = name;
+      return name;
+    },
+    getActiveProvider() {
+      return this.active;
+    },
+    listProviders() {
+      return Object.entries(this.providers).map(([name, provider]) => ({ name, ...provider }));
+    },
+  };
+
+  await repl.handleSlashCommand('/provider custom');
+
+  assert.equal(repl.ai.getActiveProvider(), 'custom');
+  assert.deepEqual(saved, ['custom']);
+});
+
+test('shouldUseTools keeps agent mode enabled by default', () => {
   const repl = new WinterREPL({ projectPath: process.cwd() });
 
-  assert.equal(repl.shouldUseTools('trả lời đúng một từ: ok'), false);
+  assert.equal(repl.shouldUseTools('trả lời đúng một từ: ok'), true);
   assert.equal(repl.shouldUseTools('sửa lỗi trong src/cli/repl.js rồi chạy test'), true);
   assert.equal(repl.shouldUseTools('git push lên github đi'), true);
 });
@@ -166,6 +317,87 @@ test('runConversation executes streamed tool calls then streams final answer', a
   assert.deepEqual(executed, [{ name: 'Read', args: { file_path: 'README.md' } }]);
 });
 
+test('runConversation executes multiple tool calls across multiple turns before answering', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  repl.simulateTyping = async (text) => {
+    process.stdout.write(text);
+  };
+
+  let streamCount = 0;
+  const executed = [];
+  repl.ai = {
+    tools: [],
+    providers: { custom: { model: 'test-model' } },
+    getActiveProvider: () => 'custom',
+    setTools(tools) {
+      this.tools = tools;
+    },
+    async *streamRequest() {
+      streamCount++;
+      if (streamCount === 1) {
+        yield {
+          raw: {
+            choices: [{
+              delta: {
+                tool_calls: [{
+                  index: 0,
+                  id: 'call-read',
+                  type: 'function',
+                  function: { name: 'Read', arguments: '{"file_path":"README.md"}' },
+                }],
+              },
+              finish_reason: 'tool_calls',
+            }],
+          },
+        };
+        return;
+      }
+
+      if (streamCount === 2) {
+        yield {
+          raw: {
+            choices: [{
+              delta: {
+                tool_calls: [{
+                  index: 0,
+                  id: 'call-grep',
+                  type: 'function',
+                  function: { name: 'Grep', arguments: '{"pattern":"Winter","path":"README.md"}' },
+                }],
+              },
+              finish_reason: 'tool_calls',
+            }],
+          },
+        };
+        return;
+      }
+
+      yield { content: 'Finished', usage: { prompt_tokens: 6, completion_tokens: 2, total_tokens: 8 } };
+    },
+  };
+  repl.tools = {
+    normalizeToolName: name => name,
+    async execute(name, args) {
+      executed.push({ name, args });
+      if (name === 'Read') {
+        return { success: true, path: args.file_path, content: 'Winter CLI\n', lines: 1, size: 10 };
+      }
+      if (name === 'Grep') {
+        return { success: true, pattern: args.pattern, path: args.path, matches: ['README.md:1:Winter CLI'], count: 1 };
+      }
+      return { success: true };
+    },
+  };
+
+  const answer = await repl.runConversation([{ role: 'user', content: 'analyze README and search it' }], 'Test', [{ name: 'Read' }, { name: 'Grep' }]);
+
+  assert.equal(answer, 'Finished');
+  assert.deepEqual(executed, [
+    { name: 'Read', args: { file_path: 'README.md' } },
+    { name: 'Grep', args: { pattern: 'Winter', path: 'README.md' } },
+  ]);
+});
+
 test('runConversation reports malformed tool arguments instead of executing empty args', async () => {
   const repl = new WinterREPL({ projectPath: process.cwd() });
 

package/src/cli/snowflake-logo.js

@@ -1,3 +1,5 @@
+import { renderBox, terminalWidth } from './terminal-ui.js';
+
 export const colors = {
   reset: '\x1b[0m',
   bright: '\x1b[1m',
@@ -52,7 +54,6 @@ export function welcomeBanner(version, info = {}) {
   // Tính toán chiều rộng động (nhỏ hơn 5% cửa sổ, tối thiểu 60, tối đa 100 cho đẹp)
   const columns = process.stdout.columns || 80;
   const W = Math.max(60, Math.min(Math.floor(columns * 0.95), 100));
-  const line = '═'.repeat(W);
   const dot = `${colors.green}●${colors.reset}`;
 
   // Căn giữa Snowflake Art
@@ -69,16 +70,23 @@ export function welcomeBanner(version, info = {}) {
   const subtitle = `Build by Atus | fb: iam.anhtu | github: anhtu1707`;
   const subPadding = Math.max(0, Math.floor((W - subtitle.length) / 2));
 
+  const infoWidth = Math.max(60, Math.min(terminalWidth(60, 100, 80), 100));
   const banner = `${colors.cyan}${centeredArt}${colors.reset}
 
 ${' '.repeat(titlePadding)}${colors.bright}${colors.magenta}W I N T E R${colors.reset}  ${colors.dim}v${version}${colors.reset}
 ${' '.repeat(subPadding)}${colors.dim}${subtitle}${colors.reset}
-${colors.blue}${line}${colors.reset}
-  ${dot} ${colors.cyan}Project:${colors.reset} ${colors.green}${displayPath}${colors.reset}
-  ${dot} ${colors.cyan}Model:  ${colors.reset} ${model} ${colors.dim}(${provider})${colors.reset}
-  ${dot} ${colors.cyan}Session:${colors.reset} ${colors.yellow}${pId}${colors.reset}
-${colors.blue}${line}${colors.reset}
-${colors.dim}Gõ ${colors.cyan}/help${colors.dim} để xem lệnh · ${colors.cyan}/auto${colors.dim} chế độ tự sửa · ${colors.cyan}ESC${colors.dim} để hủy${colors.reset}
+${renderBox({
+  title: '',
+  width: infoWidth,
+  borderColor: colors.blue,
+  titleColor: colors.blue,
+  body: [
+    `${dot} ${colors.cyan}Project:${colors.reset} ${colors.green}${displayPath}${colors.reset}`,
+    `${dot} ${colors.cyan}Model:  ${colors.reset} ${model} ${colors.dim}(${provider})${colors.reset}`,
+    `${dot} ${colors.cyan}Session:${colors.reset} ${colors.yellow}${pId}${colors.reset}`,
+    `${colors.dim}Gõ ${colors.cyan}/help${colors.dim} để xem lệnh · ${colors.cyan}/auto${colors.dim} chế độ tự sửa · ${colors.cyan}ESC${colors.dim} để hủy${colors.reset}`,
+  ],
+})}
 `;
   return banner;
 }

package/src/cli/terminal-ui.js

@@ -0,0 +1,125 @@
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+
+export function stripAnsi(text) {
+  return String(text ?? '').replace(ANSI_PATTERN, '');
+}
+
+export function visibleWidth(text) {
+  return Array.from(stripAnsi(text)).length;
+}
+
+export function terminalWidth(min = 72, max = 120, fallback = 88) {
+  const columns = process.stdout.columns || fallback;
+  return Math.max(min, Math.min(columns - 2, max));
+}
+
+export function padVisible(text, width, fill = ' ') {
+  const visible = visibleWidth(text);
+  const padCount = Math.max(0, width - visible);
+  return `${text}${fill.repeat(padCount)}`;
+}
+
+export function wrapText(text, width) {
+  const output = [];
+  const lines = String(text ?? '').split(/\r?\n/);
+
+  for (const line of lines) {
+    const plain = stripAnsi(line);
+    if (visibleWidth(plain) <= width) {
+      output.push(line);
+      continue;
+    }
+
+    const words = plain.split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+      output.push(plain.slice(0, width));
+      continue;
+    }
+
+    let current = '';
+    for (const word of words) {
+      const candidate = current ? `${current} ${word}` : word;
+      if (visibleWidth(candidate) <= width) {
+        current = candidate;
+      } else {
+        if (current) output.push(current);
+        if (visibleWidth(word) > width) {
+          const chunks = chunkText(word, width);
+          output.push(...chunks.slice(0, -1));
+          current = chunks[chunks.length - 1] || '';
+        } else {
+          current = word;
+        }
+      }
+    }
+    if (current) output.push(current);
+  }
+
+  return output;
+}
+
+export function chunkText(text, width) {
+  const chars = Array.from(stripAnsi(text));
+  const chunks = [];
+  for (let i = 0; i < chars.length; i += width) {
+    chunks.push(chars.slice(i, i + width).join(''));
+  }
+  return chunks.length > 0 ? chunks : [''];
+}
+
+export function renderBox({ title = '', body = [], width, borderColor = '\x1b[35m', titleColor = '\x1b[36m', reset = '\x1b[0m' }) {
+  const innerWidth = Math.max(28, (width || terminalWidth()) - 4);
+  const top = `${borderColor}╭${'─'.repeat(innerWidth)}╮${reset}`;
+  const bottom = `${borderColor}╰${'─'.repeat(innerWidth)}╯${reset}`;
+  const lines = [];
+  const titleText = title ? ` ${title} ` : '';
+
+  if (titleText) {
+    const wrappedTitle = wrapText(titleText, innerWidth);
+    wrappedTitle.forEach((segment, index) => {
+      const plainSegment = stripAnsi(segment);
+      const visible = visibleWidth(plainSegment);
+      const padding = Math.max(0, innerWidth - visible);
+      const left = index === 0 ? Math.floor(padding / 2) : 0;
+      const right = index === 0 ? padding - left : padding;
+      lines.push(`${borderColor}│${reset}${' '.repeat(left)}${titleColor}${plainSegment}${reset}${' '.repeat(right)}${borderColor}│${reset}`);
+    });
+    lines.push(`${borderColor}├${'─'.repeat(innerWidth)}┤${reset}`);
+  }
+
+  for (const item of body) {
+    const rawText = String(item ?? '');
+    if (visibleWidth(rawText) <= innerWidth) {
+      const visible = visibleWidth(rawText);
+      const padding = Math.max(0, innerWidth - visible);
+      lines.push(`${borderColor}│${reset} ${rawText}${' '.repeat(Math.max(0, padding - 1))}${borderColor}│${reset}`);
+      continue;
+    }
+
+    const wrapped = wrapText(rawText, innerWidth);
+    if (wrapped.length === 0) {
+      lines.push(`${borderColor}│${reset} ${' '.repeat(Math.max(0, innerWidth - 1))}${borderColor}│${reset}`);
+      continue;
+    }
+
+    for (const segment of wrapped) {
+      const text = stripAnsi(segment);
+      const visible = visibleWidth(text);
+      const padding = Math.max(0, innerWidth - visible);
+      lines.push(`${borderColor}│${reset} ${text}${' '.repeat(Math.max(0, padding - 1))}${borderColor}│${reset}`);
+    }
+  }
+
+  return [top, ...lines, bottom].join('\n');
+}
+
+export function renderKeyValueRows(rows, width, colors) {
+  const innerWidth = Math.max(28, (width || terminalWidth()) - 4);
+  return rows.map(([left, right]) => {
+    const leftWidth = Math.floor(innerWidth * 0.5);
+    const rightWidth = innerWidth - leftWidth - 1;
+    const leftText = padVisible(left, leftWidth);
+    const rightText = padVisible(right, rightWidth);
+    return `${colors.border}│${colors.reset} ${leftText}${colors.spacer}${rightText} ${colors.border}│${colors.reset}`;
+  });
+}

package/src/cli/terminal-ui.test.js

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { renderBox, stripAnsi, visibleWidth, wrapText } from './terminal-ui.js';
+
+test('visibleWidth ignores ANSI styling', () => {
+  assert.equal(visibleWidth('\u001b[36mWinter\u001b[0m'), 6);
+});
+
+test('wrapText splits long lines by visible width', () => {
+  assert.deepEqual(wrapText('winter cli is surprisingly compact', 10), [
+    'winter cli',
+    'is',
+    'surprising',
+    'ly compact',
+  ]);
+});
+
+test('renderBox keeps borders balanced', () => {
+  const box = renderBox({
+    title: 'Demo',
+    width: 40,
+    body: ['hello world'],
+    borderColor: '',
+    titleColor: '',
+    reset: '',
+  });
+
+  const lines = box.split('\n');
+  assert.equal(stripAnsi(lines[0]).startsWith('╭'), true);
+  assert.equal(stripAnsi(lines[lines.length - 1]).startsWith('╰'), true);
+  assert.equal(stripAnsi(lines[1]).includes('Demo'), true);
+  assert.equal(stripAnsi(lines[3]).includes('hello world'), true);
+});

package/src/plugins/manager.js

@@ -6,6 +6,7 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import { homedir } from 'os';
+import { pathToFileURL } from 'url';
 import { colors, statusIcons } from '../cli/snowflake-logo.js';
 
 export class PluginManager {
@@ -61,7 +62,8 @@ export class PluginManager {
       for (const file of files) {
         if (file.endsWith('.js')) {
           try {
-            const plugin = await import(path.join(this.pluginsDir, file));
+            const pluginPath = pathToFileURL(path.join(this.pluginsDir, file)).href;
+            const plugin = await import(pluginPath);
             plugins.push({
               name: plugin.default?.name || file.replace('.js', ''),
               version: plugin.default?.version || '1.0.0',

package/src/session/manager.js

@@ -33,6 +33,7 @@ export class SessionManager {
     if (options.sessionId) {
       const success = await this.loadSession(options.sessionId);
       if (success) {
+        await this.rememberProject(this.currentSession?.project || options.project || process.cwd());
         this.initialized = true;
         return;
       }
@@ -41,6 +42,7 @@ export class SessionManager {
 
     // Luôn tạo session mới nếu không yêu cầu load hoặc load thất bại
     await this.newSession(options);
+    await this.rememberProject(options.project || this.currentSession?.project || process.cwd());
     this.initialized = true;
   }
 
@@ -86,6 +88,8 @@ export class SessionManager {
     this.plans = session.plans;
     this.memory = session.memory;
 
+    await this.rememberProject(session.project || options.project || process.cwd());
+
     // Update current session pointer
     const currentPath = path.join(this.sessionsDir, 'active', 'current.json');
     await fs.writeFile(currentPath, JSON.stringify({ id: sessionId }));
@@ -148,6 +152,27 @@ export class SessionManager {
     await this.saveSession();
   }
 
+  // Backwards-compatible alias used by other modules
+  async addMemory(text, type = 'info') {
+    return this.addToMemory(text, type);
+  }
+
+  // Replace previous memory entries that start with a given prefix
+  // Handles both legacy string entries and object entries with `text`.
+  async replaceMemory(prefix, content, type = 'info') {
+    const mem = this.memory || [];
+    const filtered = mem.filter(m => {
+      if (!m) return true;
+      if (typeof m === 'string') return !m.startsWith(prefix);
+      if (typeof m === 'object' && m.text) return !m.text.startsWith(prefix);
+      return true;
+    });
+
+    this.memory = filtered;
+    await this.addToMemory(`${prefix}:
+${content}`, type);
+  }
+
   async updateContext(key, value) {
     this.context[key] = {
       value,
@@ -269,10 +294,29 @@ export class SessionManager {
     this.plans = session.plans || [];
     this.memory = session.memory || [];
 
+    await this.rememberProject(session.project || process.cwd());
+
     await this.saveSession();
     return session;
   }
 
+  async rememberProject(projectPath) {
+    if (!projectPath) return;
+
+    if (this.config?.setProjectCurrent) {
+      await this.config.setProjectCurrent(projectPath);
+      return;
+    }
+
+    if (this.config?.load && this.config?.save) {
+      const config = await this.config.load();
+      config.project = config.project || {};
+      config.project.current = projectPath;
+      config.project.lastOpenedAt = new Date().toISOString();
+      await this.config.save(config);
+    }
+  }
+
   getSessionId() {
     return this.currentSession?.id || 'none';
   }

package/src/session/manager.test.js

@@ -0,0 +1,72 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { SessionManager } from './manager.js';
+
+function createConfigStub() {
+  const state = {};
+  return {
+    state,
+    async load() {
+      return state;
+    },
+    async save(config) {
+      Object.assign(state, config);
+    },
+    async setProjectCurrent(projectPath) {
+      state.project = state.project || {};
+      state.project.current = projectPath;
+      state.project.lastOpenedAt = 'now';
+    },
+  };
+}
+
+test('new sessions remember the current project path in config', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-session-project-'));
+  const config = createConfigStub();
+  const session = new SessionManager(config);
+  session.winterDir = path.join(root, '.winter');
+  session.sessionsDir = path.join(session.winterDir, 'sessions');
+
+  const projectPath = path.join(root, 'demo-project');
+  const created = await session.init({ project: projectPath });
+
+  assert.equal(created, undefined);
+  assert.equal(session.currentSession.project, projectPath);
+  assert.equal(config.state.project.current, projectPath);
+});
+
+test('switchSession updates the remembered project anchor', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-session-switch-'));
+  const config = createConfigStub();
+  const session = new SessionManager(config);
+  session.winterDir = path.join(root, '.winter');
+  session.sessionsDir = path.join(session.winterDir, 'sessions');
+
+  const firstProject = path.join(root, 'project-a');
+  const secondProject = path.join(root, 'project-b');
+
+  await session.init({ project: firstProject });
+  const firstSessionId = session.getSessionId();
+
+  const secondSessionPath = path.join(session.sessionsDir, 'active', 'session-b.json');
+  await writeFile(secondSessionPath, JSON.stringify({
+    id: 'session-b',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    project: secondProject,
+    context: {},
+    plans: [],
+    memory: [],
+    history: [],
+  }, null, 2));
+
+  await session.switchSession('session-b');
+
+  assert.notEqual(firstSessionId, 'session-b');
+  assert.equal(session.getSessionId(), 'session-b');
+  assert.equal(config.state.project.current, secondProject);
+});

package/src/tools/executor.js

@@ -998,7 +998,7 @@ export class ToolExecutor {
         success: true,
         url,
         content: cleanText.substring(0, 15000), // Cho phép đọc dài hơn
-        length: text.length
+        length: cleanText.length
       };
     } catch (error) {
       return { success: false, error: error.message, url };