kiku-agent 1.3.0 → 1.3.2

package/server/agent/tests/telemetryAndProfiles.test.js

@@ -0,0 +1,179 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  estimateTokens,
+  calculateTokenCost,
+  formatCostUsd,
+  formatTokenCount,
+  MODEL_PRICING
+} from '../telemetry.js';
+import {
+  BUILTIN_PROFILES,
+  loadProfiles,
+  getProfile,
+  getActiveProfile,
+  setActiveProfile,
+  createOrUpdateProfile,
+  deleteProfile,
+  listProfiles
+} from '../profiles.js';
+import { parseCliArgs } from '../cli.js';
+import { routeCommand } from '../commands.js';
+import { PACKAGE_VERSION } from '../version.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const cliPath = path.resolve(__dirname, '../cli.js');
+
+test('Telemetry: estimateTokens calculates token heuristics for various scripts', () => {
+  assert.equal(estimateTokens(''), 0);
+  assert.equal(estimateTokens(null), 0);
+
+  const enTokens = estimateTokens('Ju Jingyi is an accomplished artist and singer.');
+  assert.ok(enTokens >= 8 && enTokens <= 20, `enTokens ${enTokens} out of expected range`);
+
+  const zhTokens = estimateTokens('鞠婧祎中国女演员歌手');
+  assert.ok(zhTokens >= 10 && zhTokens <= 25, `zhTokens ${zhTokens} out of expected range`);
+
+  const thTokens = estimateTokens('จวีจิ้งอี นักแสดงและนักร้องสาว');
+  assert.ok(thTokens >= 15 && thTokens <= 40, `thTokens ${thTokens} out of expected range`);
+});
+
+test('Telemetry: calculateTokenCost calculates pricing accurately across providers', () => {
+  const lmCost = calculateTokenCost('lmstudio', 'google/gemma-4-e4b', 1000, 500);
+  assert.equal(lmCost, 0);
+
+  const groqCost = calculateTokenCost('groq', 'openai/gpt-oss-20b', 1000, 1000);
+  assert.ok(groqCost > 0 && groqCost < 0.01, `Groq cost: ${groqCost}`);
+
+  const deepseekCost = calculateTokenCost('deepseek', 'deepseek-v4-flash', 10000, 5000);
+  assert.ok(deepseekCost > 0 && deepseekCost < 0.05, `DeepSeek cost: ${deepseekCost}`);
+
+  const openaiCost = calculateTokenCost('openai', 'gpt-5.6-luna', 1000, 1000);
+  assert.ok(openaiCost > 0, `OpenAI cost: ${openaiCost}`);
+
+  const geminiCost = calculateTokenCost('gemini', 'gemini-3.7-flash', 1000, 1000);
+  assert.ok(geminiCost > 0, `Gemini cost: ${geminiCost}`);
+});
+
+test('Telemetry: formatCostUsd and formatTokenCount format numbers cleanly', () => {
+  assert.equal(formatCostUsd(0), '$0.00 (Local)');
+  assert.equal(formatCostUsd(0.00005), '<$0.0001');
+  assert.equal(formatCostUsd(0.0012), '$0.0012');
+  assert.equal(formatCostUsd(1.5), '$1.5000');
+
+  assert.equal(formatTokenCount(500), '500');
+  assert.equal(formatTokenCount(1500), '1,500');
+  assert.equal(formatTokenCount(2500000), '2,500,000');
+});
+
+test('Profiles: BUILTIN_PROFILES has required production profiles', () => {
+  const expectedProfiles = ['default', 'fast', 'deep-reasoning', 'cloud', 'gemini'];
+  for (const name of expectedProfiles) {
+    assert.ok(BUILTIN_PROFILES[name], `Missing built-in profile: ${name}`);
+    assert.ok(BUILTIN_PROFILES[name].provider);
+    assert.ok(BUILTIN_PROFILES[name].model);
+    assert.ok(BUILTIN_PROFILES[name].description);
+  }
+});
+
+test('Profiles: lifecycle methods support create, activate, query, and delete', () => {
+  const initialList = listProfiles();
+  assert.ok(initialList.length >= 5);
+
+  const active = getActiveProfile();
+  assert.ok(active && active.name);
+
+  const switched = setActiveProfile('fast');
+  assert.equal(switched.name, 'fast');
+  assert.equal(getActiveProfile().name, 'fast');
+
+  const custom = createOrUpdateProfile('unit-test-profile', {
+    provider: 'openai',
+    model: 'gpt-5.6-luna',
+    temperature: 0.5,
+    description: 'Temporary profile for unit tests'
+  });
+  assert.equal(custom.name, 'unit-test-profile');
+  assert.equal(custom.provider, 'openai');
+  assert.equal(custom.model, 'gpt-5.6-luna');
+
+  const retrieved = getProfile('unit-test-profile');
+  assert.equal(retrieved.name, 'unit-test-profile');
+
+  assert.throws(() => {
+    deleteProfile('default');
+  }, /Cannot delete built-in profile/);
+
+  const deleted = deleteProfile('unit-test-profile');
+  assert.equal(deleted, true);
+  assert.equal(getProfile('unit-test-profile'), null);
+
+  setActiveProfile('default');
+  assert.equal(getActiveProfile().name, 'default');
+});
+
+test('CLI: parseCliArgs handles --profile flag', () => {
+  const opts1 = parseCliArgs(['--profile', 'fast']);
+  assert.equal(opts1.profile, 'fast');
+
+  const opts2 = parseCliArgs(['-q', 'what is in blossom', '--profile', 'deep-reasoning', '--output', 'json']);
+  assert.equal(opts2.profile, 'deep-reasoning');
+  assert.equal(opts2.output, 'json');
+  assert.equal(opts2.query, 'what is in blossom');
+});
+
+test('CLI: headless JSON output contains token metrics and cost accounting', () => {
+  const res = spawnSync(process.execPath, [
+    cliPath,
+    '--url', 'http://127.0.0.1:9999/v1',
+    '-q', 'test query',
+    '--output', 'json',
+    '--profile', 'fast'
+  ], { encoding: 'utf8' });
+
+  assert.equal(res.status, 2);
+  const payload = JSON.parse(res.stdout);
+  assert.equal(payload.version, PACKAGE_VERSION);
+  assert.equal(payload.status, 'error');
+  assert.ok(payload.metrics, 'Metrics object must be present');
+  assert.ok(payload.metrics.tokens !== undefined, 'Tokens object must be present in metrics');
+  assert.ok(typeof payload.metrics.costUsd === 'number', 'costUsd must be a number in metrics');
+});
+
+test('Commands: /profile and /config execute cleanly in routeCommand', async () => {
+  const logs = [];
+  const fakeContext = {
+    sub: 'list',
+    extra: '',
+    parts: ['/profile', 'list'],
+    agent: null,
+    client: {
+      provider: 'lmstudio',
+      providerName: 'LM Studio (Local)',
+      model: 'google/gemma-4-e4b',
+      baseUrl: 'http://localhost:1234/v1'
+    }
+  };
+
+  const oldLog = console.log;
+  try {
+    console.log = (msg) => logs.push(msg);
+
+    await routeCommand('/profile', fakeContext);
+    assert.ok(logs.length > 0);
+
+    logs.length = 0;
+    await routeCommand('/profile', { ...fakeContext, sub: 'show', extra: 'fast', parts: ['/profile', 'show', 'fast'] });
+    assert.ok(logs.length > 0);
+
+    logs.length = 0;
+    await routeCommand('/config', { ...fakeContext, sub: '', extra: '', parts: ['/config'] });
+    assert.ok(logs.length > 0);
+  } finally {
+    console.log = oldLog;
+  }
+});

package/server/agent/tests/terminalImage.test.js

@@ -0,0 +1,80 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  createTerminalImageGallery,
+  renderJpegFile,
+  supportsTerminalImages,
+} from '../terminalImage.js';
+import { getStringDisplayWidth, stripAnsi } from '../ui.js';
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const imageDirectory = path.resolve(testDirectory, '../../../src/assets/images');
+const squareImage = path.join(imageDirectory, '0040jbadly8icq3if7twwj60qy0qy0uc02.jpg');
+
+test('renders a JPEG as bounded true-color quadrant rows', () => {
+  const lines = renderJpegFile(squareImage, { columns: 30, rows: 20, maxWidth: 20, maxRows: 6 });
+
+  assert.equal(lines.length, 6);
+  assert.match(lines[0], /\x1b\[38;2;\d+;\d+;\d+m/);
+  assert.match(lines[0], /\x1b\[48;2;\d+;\d+;\d+m/);
+  assert.match(stripAnsi(lines[0]), /^  [ ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█]+$/);
+  assert.ok(getStringDisplayWidth(lines[0]) <= 22);
+  assert.match(stripAnsi(lines.join('')), /[▘▝▖▗▚▞▛▜▙▟]/);
+});
+
+test('default gallery rendering uses most of a standard TUI viewport', () => {
+  const lines = renderJpegFile(squareImage, { columns: 80, rows: 24 });
+
+  assert.equal(lines.length, 17);
+  assert.equal(getStringDisplayWidth(lines[0]), 36);
+  assert.ok(new Set(lines).size > 12, 'photo detail should survive downsampling');
+});
+
+test('terminal image detection respects TTY, NO_COLOR, and explicit overrides', () => {
+  assert.equal(supportsTerminalImages({ env: {}, isTTY: true }), true);
+  assert.equal(supportsTerminalImages({ env: {}, isTTY: false }), false);
+  assert.equal(supportsTerminalImages({ env: { NO_COLOR: '1' }, isTTY: true }), false);
+  assert.equal(supportsTerminalImages({ env: { KIKU_TUI_IMAGES: 'on' }, isTTY: false }), true);
+  assert.equal(supportsTerminalImages({ env: { KIKU_TUI_IMAGES: 'off' }, isTTY: true }), false);
+});
+
+test('gallery renders on its cadence, supports manual display, and cycles assets', () => {
+  const gallery = createTerminalImageGallery({
+    directory: imageDirectory,
+    frequency: 3,
+    env: { KIKU_TUI_IMAGES: 'on' },
+    isTTY: false,
+    getColumns: () => 40,
+    getRows: () => 24,
+  });
+
+  assert.equal(gallery.enabled, true);
+  assert.equal(gallery.imageCount, 8);
+  assert.deepEqual(gallery.maybeRender(1), []);
+  assert.match(stripAnsi(gallery.maybeRender(3)[1]), /Gallery 1\/8/);
+  assert.match(stripAnsi(gallery.maybeRender(4, { force: true })[1]), /Gallery 2\/8/);
+});
+
+test('renderTwoImagesSideBySide and getWelcomeGalleryLines render 2 photos', async () => {
+  const { renderTwoImagesSideBySide, getWelcomeGalleryLines, discoverImages } = await import('../terminalImage.js');
+  const images = discoverImages(imageDirectory);
+  assert.ok(images.length >= 2);
+
+  const pair = renderTwoImagesSideBySide(images[0], images[1], { columns: 100, rows: 24, maxRows: 10 });
+  assert.ok(pair.length > 0);
+  assert.ok(pair.every(line => typeof line === 'string'));
+
+  const welcomeGallery = getWelcomeGalleryLines(2, {
+    directory: imageDirectory,
+    env: { KIKU_TUI_IMAGES: 'on' },
+    isTTY: false,
+    columns: 100,
+    rows: 30,
+  });
+
+  assert.ok(welcomeGallery.length > 0);
+  assert.match(stripAnsi(welcomeGallery[1]), /JU JINGYI • 鞠婧祎 GALLERY/);
+});
+

package/server/agent/tests/terminalMarkdown.test.js

@@ -0,0 +1,166 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  expandMarkdownLinks,
+  formatMarkdownLines,
+  formatSolidPanelLines,
+  isMarkdownTableSeparator,
+  parseMarkdownTableRow,
+} from '../ui.js';
+
+test('parses Markdown table rows without retaining outer pipes', () => {
+  assert.deepEqual(
+    parseMarkdownTableRow('| Brand | Role & Highlight | Media Link |'),
+    ['Brand', 'Role & Highlight', 'Media Link']
+  );
+  assert.deepEqual(parseMarkdownTableRow('Brand | Category'), ['Brand', 'Category']);
+});
+
+test('recognizes Markdown table alignment separators', () => {
+  assert.equal(isMarkdownTableSeparator([':---', '---:', ':---:']), true);
+  assert.equal(isMarkdownTableSeparator(['Brand', 'Category']), false);
+});
+
+test('expands Markdown links before terminal line wrapping', () => {
+  assert.equal(
+    expandMarkdownLinks('[Search Commercial](https://example.com/a-very-long-link)'),
+    'Search Commercial: https://example.com/a-very-long-link'
+  );
+});
+
+test('formatMarkdownLines converts markdown headers, bold, and tables to formatted terminal rows', () => {
+  const sample = `### Evidence Report: Ju Jingyi Brand Endorsements
+
+**Summary:**
+Ju Jingyi has secured multiple ambassador roles.
+
+| Brand Name | Category | Role/Title |
+| :--- | :--- | :--- |
+| **PRSR** | Luxury Eyewear | Global Ambassador |
+| **Lafang** | Haircare | Ambassador |`;
+
+  const rows = formatMarkdownLines(sample, 80);
+  assert.ok(rows.length > 0);
+  assert.ok(rows.some(r => r.includes('Evidence Report')));
+  assert.ok(rows.some(r => r.includes('┌') && r.includes('┐')));
+  assert.ok(rows.some(r => r.includes('PRSR')));
+  assert.ok(rows.some(r => r.includes('└') && r.includes('┘')));
+});
+
+test('formatSolidPanelLines preserves ANSI-colored box table lines without destroying structure', () => {
+  const tableSample = `| Year | Award Title | Ceremony |
+| :--- | :--- | :--- |
+| 2024 | Popular Actress | Weibo TV |
+| 2021 | Outstanding Actress | Tencent Video |`;
+
+  const tableRows = formatMarkdownLines(tableSample, 80);
+  const panelRows = formatSolidPanelLines({
+    title: 'Awards Panel',
+    lines: tableRows,
+    width: 80,
+  });
+
+  assert.ok(panelRows.length > 0);
+  assert.ok(panelRows.some(r => r.includes('┌') && r.includes('┐')));
+  assert.ok(panelRows.some(r => r.includes('Popular Actress')));
+  assert.ok(panelRows.some(r => r.includes('Outstanding Actress')));
+  assert.ok(panelRows.some(r => r.includes('└') && r.includes('┘')));
+});
+
+test('formatMarkdownLines handles markdown tables with URLs without column breakage', () => {
+  const tableWithUrls = `| Detail | Finding | Source URLs |
+| :--- | :--- | :--- |
+| SNH48 Debut | Joined SNH48 Team NII in November 2013 | [https://snh48.fandom.com/wiki/Ju_Jingyi](https://snh48.fandom.com/wiki/Ju_Jingyi) |
+| Solo Debut | Established studio in December 2017 | [https://baike.baidu.com/item/Ju_Jingyi](https://baike.baidu.com/item/Ju_Jingyi) |`;
+
+  const rows = formatMarkdownLines(tableWithUrls, 120);
+  assert.ok(rows.length > 0);
+
+  assert.ok(rows.some(r => r.includes('┌') && r.includes('┐')));
+  assert.ok(rows.some(r => r.includes('SNH48 Debut')));
+  assert.ok(rows.some(r => r.includes('Solo Debut')));
+  assert.ok(rows.some(r => r.includes('└') && r.includes('┘')));
+});
+
+test('formatMarkdownLines handles markdown tables with short separators and unequal columns', () => {
+  const unevenTable = `| Title | Year | Category |
+| -- | :-: | -- |
+| In Blossom | 2024 | Drama |
+| Everyday | 2016 |
+| Rain Love | 2024 | Single | Extra Info |`;
+
+  const rows = formatMarkdownLines(unevenTable, 100);
+  assert.ok(rows.length > 0);
+  assert.ok(rows.some(r => r.includes('┌') && r.includes('┐')));
+  assert.ok(rows.some(r => r.includes('In Blossom')));
+  assert.ok(rows.some(r => r.includes('Everyday')));
+  assert.ok(rows.some(r => r.includes('Rain Love')));
+  assert.ok(rows.some(r => r.includes('└') && r.includes('┘')));
+});
+
+test('formatTerminalMarkdown formats headings h1-h5 and numbered list items', () => {
+  const markdownText = `#### Subheading 4
+##### Subheading 5
+1. First point
+2. Second point`;
+
+  const rows = formatMarkdownLines(markdownText, 80);
+  assert.ok(rows.some(r => r.includes('Subheading 4')));
+  assert.ok(rows.some(r => r.includes('Subheading 5')));
+  assert.ok(rows.some(r => r.includes('1.') && r.includes('First point')));
+  assert.ok(rows.some(r => r.includes('2.') && r.includes('Second point')));
+});
+
+test('formatMarkdownLines wraps long cell contents across multiple lines without truncating with ellipsis', () => {
+  const table = `| Detail | Finding | Source URL(s) | Uncertainty |
+| :--- | :--- | :--- | :--- |
+| SNH48 General Election Success | Elected No.4 (2014), No.2 (2015), No.1 (2016), No.1 (2017) | [Wikipedia](https://en.wikipedia.org/wiki/Ju_Jingyi) | Low |
+| Solo Transition | Established personal studio on December 15, 2017 | [carrd.co](https://ju-jingyi.carrd.co/) | Low |`;
+
+  const rows = formatMarkdownLines(table, 90);
+  assert.ok(rows.length > 0);
+  
+  const tableBorderRows = rows.filter(r => r.includes('│'));
+  assert.ok(tableBorderRows.length > 0);
+  assert.ok(!tableBorderRows.some(r => r.includes('…')));
+ 
+  assert.ok(rows.some(r => r.includes('Uncertainty')));
+
+  assert.ok(rows.some(r => r.includes('Elected No.4')));
+  assert.ok(rows.some(r => r.includes('(2017)')));
+});
+
+test('cleanTableCell and formatMarkdownLines handle <br> tags cleanly without raw HTML tags', () => {
+  const tableWithBr = `| Service | Links |
+| :--- | :--- |
+| Portals | [carrd.co](https://ju-jingyi.carrd.co/)<br>[Wikipedia](https://en.wikipedia.org/wiki/Ju_Jingyi) |`;
+
+  const rows = formatMarkdownLines(tableWithBr, 80);
+  assert.ok(rows.length > 0);
+  assert.ok(!rows.some(r => r.includes('<br')));
+  assert.ok(!rows.some(r => r.includes('<b…')));
+  assert.ok(rows.some(r => r.includes('carrd.co')));
+  assert.ok(rows.some(r => r.includes('Wikipedia')));
+});
+
+test('formatMarkdownLines does not corrupt bullet points with pipes into artificial tables', () => {
+  const markdownText = [
+    'Sources:',
+    '  • DuckDuckGo - Ju Jingyi Drama Tops Charts: https://www.youtube.com/watch?v=lkFoSXBARkQ',
+    '* DuckDuckGo - Best Chinese Dramas of 2026 So Far | Updated Rankings: https://mijudrama.com/blog/best-chinese-dramas-2026-updated-rankings',
+    '  • DuckDuckGo - Ju Jing Yi - DramaWiki: https://wiki.d-addicts.com/Ju_Jing_Yi',
+  ].join('\n');
+
+  const rows = formatMarkdownLines(markdownText, 100);
+  assert.equal(rows.some(r => r.startsWith('|') && r.endsWith('|')), false, 'Bullet with pipe should not become a table');
+  assert.ok(rows.some(r => r.includes('Best Chinese Dramas of 2026 So Far | Updated Rankings')));
+});
+
+test('formatTerminalMarkdown divider lines do not exceed maxWidth', () => {
+  const rows = formatMarkdownLines('---\n***\n___', 80);
+  for (const r of rows) {
+    const plain = r.replace(/\x1b\[[0-9;]*m/g, '');
+    assert.ok(plain.length <= 80, `Divider line should not exceed maxWidth (got ${plain.length})`);
+  }
+});

package/server/agent/tests/terminalText.test.js

@@ -0,0 +1,133 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  getGraphemeSegments,
+  getStringDisplayWidth,
+  getNewOutputScrollOffset,
+  fitStyledText,
+  getWelcomeHeroLines,
+  getTuiViewportLayout,
+  getMultilinePromptLayout,
+  nextGraphemeBoundary,
+  previousGraphemeBoundary,
+  sanitizeTerminalText,
+  sliceLineForDisplay,
+} from '../ui.js';
+
+test('TUI viewport never overlaps the status bar', () => {
+  for (const rows of [10, 24, 30, 60]) {
+    const layout = getTuiViewportLayout(rows);
+    const viewportLastRow = layout.viewportStartRow + layout.viewportHeight - 1;
+
+    assert.equal(viewportLastRow, layout.statusBarRow - 1);
+    assert.ok(viewportLastRow < layout.statusBarRow);
+    assert.ok(layout.statusBarRow < layout.promptRow);
+    assert.ok(layout.promptRow < layout.separatorRow);
+  }
+});
+
+test('long output opens at its first page and preserves manual scroll position', () => {
+  const viewportHeight = getTuiViewportLayout(24).viewportHeight;
+  assert.equal(getNewOutputScrollOffset(viewportHeight - 1, 24, 0), 0);
+  assert.equal(getNewOutputScrollOffset(viewportHeight + 7, 24, 0), 7);
+  assert.equal(getNewOutputScrollOffset(5, 24, 9), 14);
+});
+
+test('welcome hero keeps the logo without the removed marketing copy', () => {
+  const hero = getWelcomeHeroLines().join('\n');
+
+  assert.match(hero, /██╗/);
+  assert.doesNotMatch(hero, /Kiku AI Terminal Agent/);
+  assert.doesNotMatch(hero, /Intelligent Fan Portal/);
+  assert.doesNotMatch(hero, /SSOT • DAG • Dynamic Tools/);
+  assert.doesNotMatch(hero, /LM Studio \/ Cloud Providers/);
+});
+
+test('grapheme boundaries keep emoji and Thai combining marks intact', () => {
+  const value = 'A👩🏽‍💻ก้B';
+  const segments = getGraphemeSegments(value);
+
+  assert.deepEqual(segments.map(item => item.segment), ['A', '👩🏽‍💻', 'ก้', 'B']);
+  assert.equal(nextGraphemeBoundary(value, 1), 8);
+  assert.equal(previousGraphemeBoundary(value, 8), 1);
+  assert.equal(nextGraphemeBoundary(value, 8), 10);
+  assert.equal(previousGraphemeBoundary(value, 10), 8);
+});
+
+test('untrusted terminal text cannot inject ANSI, OSC, or control sequences', () => {
+  const malicious = '\x1b[31mred\x1b[0m\x1b]0;owned\x07\nnext\titem';
+  const sanitized = sanitizeTerminalText(malicious);
+  assert.equal(sanitized, 'red next item');
+  assert.equal(sanitized.includes('\x1b'), false);
+  assert.equal(sanitized.includes('\x07'), false);
+});
+
+test('gray surface rows fit narrow terminals without breaking styled graphemes', () => {
+  const fitted = fitStyledText('\x1b[1mคำสั่ง 👩🏽‍💻 autocomplete\x1b[0m', 10);
+
+  assert.ok(getStringDisplayWidth(fitted) <= 10);
+  assert.ok(!fitted.includes('👩') || fitted.includes('👩🏽‍💻'));
+});
+
+test('display width treats joined emoji and Thai marks as terminal graphemes', () => {
+  assert.equal(getStringDisplayWidth('👩🏽‍💻'), 2);
+  assert.equal(getStringDisplayWidth('ก้'), 1);
+  assert.equal(getStringDisplayWidth('你好'), 4);
+  assert.equal(getStringDisplayWidth('《鞠婧祎》'), 10);
+  assert.equal(getStringDisplayWidth('（年度最佳）'), 12);
+  assert.equal(getStringDisplayWidth('【花间令】'), 10);
+});
+
+test('long-line viewport stays within width without splitting graphemes', () => {
+  const value = 'aaaaa👩🏽‍💻ก้bbbbbbbbbbbb';
+  const cursor = value.indexOf('ก');
+  const viewport = sliceLineForDisplay(value, cursor, 10);
+
+  assert.ok(getStringDisplayWidth(viewport.displayLine) <= 10);
+  assert.ok(!viewport.displayLine.includes('👩') || viewport.displayLine.includes('👩🏽‍💻'));
+  assert.ok(!viewport.displayLine.startsWith('้'));
+  assert.ok(viewport.cursorVisualOffset >= 0);
+  assert.ok(viewport.cursorVisualOffset <= 10);
+});
+
+test('getMultilinePromptLayout wraps long text and positions cursor accurately', () => {
+  const single = getMultilinePromptLayout('hello world', 5, 20, 5);
+  assert.equal(single.visibleLines.length, 1);
+  assert.equal(single.visibleLines[0], 'hello world');
+  assert.equal(single.cursorRow, 0);
+  assert.equal(single.cursorCol, 5);
+
+  const multi = getMultilinePromptLayout('line 1\nline 2\nline 3', 10, 20, 5);
+  assert.equal(multi.visibleLines.length, 3);
+  assert.equal(multi.visibleLines[0], 'line 1');
+  assert.equal(multi.visibleLines[1], 'line 2');
+  assert.equal(multi.visibleLines[2], 'line 3');
+  assert.equal(multi.cursorRow, 1);
+  assert.equal(multi.cursorCol, 3);
+
+  const longText = 'Ju Jingyi 👩🏽‍💻 ก้ ' + 'a'.repeat(50);
+  const wrapped = getMultilinePromptLayout(longText, longText.length, 25, 4);
+  assert.ok(wrapped.visibleLines.length > 1);
+  assert.ok(wrapped.visibleLines.length <= 4);
+  for (const line of wrapped.visibleLines) {
+    assert.ok(getStringDisplayWidth(line) <= 25);
+  }
+  assert.ok(wrapped.cursorRow >= 0 && wrapped.cursorRow < wrapped.visibleLines.length);
+  assert.ok(wrapped.cursorCol >= 0 && wrapped.cursorCol <= 25);
+});
+
+test('getTuiViewportLayout dynamically expands prompt rows without overlapping', () => {
+  for (const promptRows of [1, 2, 3, 5]) {
+    const layout = getTuiViewportLayout(24, promptRows);
+    const viewportLastRow = layout.viewportStartRow + layout.viewportHeight - 1;
+
+    assert.equal(viewportLastRow, layout.statusBarRow - 1);
+    assert.ok(viewportLastRow < layout.statusBarRow);
+    assert.ok(layout.statusBarRow < layout.promptStartRow);
+    assert.equal(layout.promptHeight, promptRows);
+    assert.equal(layout.promptRow, layout.promptStartRow);
+    assert.ok(layout.promptEndRow < 24);
+  }
+});
+

package/server/agent/tests/textProtocolLoop.test.js

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import { mkdtemp, rm } from 'node:fs/promises';
+
+import { KikuAgent } from '../agentCore.js';
+import { McpClientManager } from '../mcpClient.js';
+
+function createMemoryStub() {
+  return {
+    _loaded: true,
+    facts: [],
+    async load() { },
+    trackTopicInterest() { },
+    buildMemoryContext() { return ''; },
+    buildUserSkillContext() { return ''; },
+    addFact() { },
+  };
+}
+
+test('text-emitted tool calls synthesize protocol-valid tool_calls in history', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-textproto-'));
+  const storageFile = path.join(tempDir, 'session.json');
+  const observedMessages = [];
+  let call = 0;
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat(options) {
+      call++;
+      observedMessages.push(options.messages.map(message => ({
+        role: message.role,
+        content: typeof message.content === 'string' ? message.content : null,
+        tool_calls: message.tool_calls || undefined,
+        tool_call_id: message.tool_call_id || undefined,
+      })));
+      if (call === 1) {
+        return {
+          role: 'assistant',
+          content: 'Checking the catalog.\n```json\n{"action": "get_quotes", "parameters": {"tag": "mindset"}}\n```',
+        };
+      }
+      return { role: 'assistant', content: 'คำคมที่ยืนยันแล้วจากคลังข้อมูลคือ...' };
+    },
+  };
+
+  const agent = new KikuAgent({
+    client,
+    memory: createMemoryStub(),
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp.json'),
+    }),
+    sessionId: 'textproto_test',
+    sessionStorageFile: storageFile,
+  });
+
+  try {
+    await agent.ready();
+    const answer = await agent.run('ขอคำคมของจวีจิ้งอีหน่อย');
+
+    assert.match(answer, /คำคมที่ยืนยันแล้ว/);
+
+   
+    const secondCall = observedMessages[1];
+    const assistantWithCalls = secondCall.find(m => m.role === 'assistant' && m.tool_calls?.length > 0);
+    assert.ok(assistantWithCalls, 'assistant message with synthesized tool_calls missing');
+    assert.equal(assistantWithCalls.tool_calls[0].function.name, 'get_quotes');
+
+    const toolMessage = secondCall.find(m => m.role === 'tool');
+    assert.ok(toolMessage, 'tool result message missing');
+    assert.equal(toolMessage.tool_call_id, assistantWithCalls.tool_calls[0].id);
+    assert.match(toolMessage.content, /authoritative/);
+
+
+    assert.ok(!assistantWithCalls.content.includes('```'));
+  } finally {
+    await agent.mcpManager.disconnectAll().catch(() => { });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('systemDirectives callbacks are injected as system messages without touching the user query', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-directives-'));
+  const observedMessages = [];
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat(options) {
+      observedMessages.push(options.messages.map(message => ({ role: message.role, content: message.content })));
+      return { role: 'assistant', content: 'ตอบแล้วค่ะ' };
+    },
+  };
+
+  const agent = new KikuAgent({
+    client,
+    memory: createMemoryStub(),
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp.json'),
+    }),
+    sessionId: 'directives_test',
+    sessionStorageFile: path.join(tempDir, 'session.json'),
+  });
+
+  try {
+    await agent.ready();
+    await agent.run('สวัสดีค่ะ', {
+      systemDirectives: ['[SYSTEM DIRECTIVE (Test): stay concise]'],
+    });
+
+    const lastCall = observedMessages.at(-1);
+    const directiveMessage = lastCall.find(m => m.role === 'system' && m.content.includes('[SYSTEM DIRECTIVE (Test): stay concise]'));
+    assert.ok(directiveMessage, 'directive must be injected as a system message');
+
+    const userMessage = lastCall.find(m => m.role === 'user');
+    assert.ok(userMessage);
+    assert.ok(!userMessage.content.includes('[SYSTEM DIRECTIVE (Test)'), 'user query must stay clean');
+  } finally {
+    await agent.mcpManager.disconnectAll().catch(() => { });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});