@semalt-ai/code 1.8.5 → 1.20.0

package/test/md-stream.test.js

@@ -0,0 +1,183 @@
+'use strict';
+
+// Focused tests for lib/ui/md-stream.js — the line-at-a-time Markdown → ANSI
+// styler that drives both live agent narration and --resume / history replay.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+// The styler gates colour through theme.colorEnabled(), which requires a TTY and
+// no NO_COLOR. Force a colour-on baseline before requiring anything.
+process.stdout.isTTY = true;
+delete process.env.NO_COLOR;
+process.stdout.columns = 80;
+
+const { StreamMarkdown, renderBlock } = require('../lib/ui/md-stream');
+const { ChatHistory } = require('../lib/ui/chat-history');
+
+const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+const hasAnsi = (s) => /\x1b\[/.test(String(s));
+
+// Feed a multi-line string through a styler line-by-line, then flush. Returns
+// the array of committed (non-null) styled chunks.
+function feedAll(md, text) {
+  const out = [];
+  for (const line of text.split('\n')) {
+    const s = md.feedLine(line);
+    if (s !== null) out.push(s);
+  }
+  const tail = md.flush();
+  if (tail !== null) out.push(tail);
+  return out;
+}
+
+// ── inline spans within a complete line ──────────────────────────────────────
+
+test('inline: bold, italic, and inline code are styled within a line', () => {
+  const md = new StreamMarkdown();
+  const styled = md.feedLine('a **bold** and *em* and `code` here');
+  assert.ok(hasAnsi(styled), 'emits SGR for inline spans');
+  assert.ok(styled.includes('\x1b[1m'), 'bold open');
+  assert.ok(styled.includes('\x1b[3m'), 'italic open');
+  assert.ok(styled.includes('\x1b[38;5;75m'), 'inline-code fg color');
+  // Markers are consumed; the words survive.
+  const plain = stripAnsi(styled);
+  assert.strictEqual(plain, '  a bold and em and code here');
+});
+
+test('inline: every styled line ends reset so no ANSI bleeds forward', () => {
+  const md = new StreamMarkdown();
+  const styled = md.feedLine('plain **bold**');
+  assert.ok(styled.endsWith('\x1b[0m'), 'line ends with RST');
+});
+
+// ── headings, lists, blockquotes, rules ──────────────────────────────────────
+
+test('block: headings, list items, blockquote, and rule are recognised', () => {
+  const md = new StreamMarkdown();
+  assert.strictEqual(stripAnsi(md.feedLine('# Title')).split('\n')[0], '  Title');
+  assert.match(stripAnsi(md.feedLine('## Sub')), /^ {2}Sub/);
+  assert.match(stripAnsi(md.feedLine('### Small')), /^ {2}Small$/);
+  assert.match(stripAnsi(md.feedLine('- item')), /❯ item/);
+  assert.match(stripAnsi(md.feedLine('1. first')), /1\. first/);
+  assert.match(stripAnsi(md.feedLine('> quoted')), /│ quoted/);
+  assert.match(stripAnsi(md.feedLine('---')), /^ {2}─+$/);
+});
+
+// ── fenced code block with a language ────────────────────────────────────────
+
+test('code: a fenced block with a language emits a box at fence close', () => {
+  const md = new StreamMarkdown();
+  assert.strictEqual(md.feedLine('```python'), null, 'open fence emits nothing');
+  assert.strictEqual(md.feedLine('def f():'), null, 'body buffered, nothing emitted');
+  assert.strictEqual(md.feedLine('    return 1'), null);
+  const box = md.feedLine('```');
+  assert.notStrictEqual(box, null, 'closing fence emits the whole box');
+  const lines = stripAnsi(box).split('\n');
+  assert.match(lines[0], /╭.*python/, 'top border carries the language label');
+  assert.match(box, /\x1b\[38;5;176m/, 'a keyword (def/return) is syntax-highlighted');
+  assert.match(box, /\x1b\[K/, 'code body fills background to edge via EL');
+  assert.match(lines[lines.length - 1], /╰─+$/, 'bottom border closes the box');
+});
+
+test('code: a block split across multiple feedLine calls renders both body lines', () => {
+  const md = new StreamMarkdown();
+  md.feedLine('```js');         // open
+  md.feedLine('const a = 1;');
+  md.feedLine('const b = 2;');
+  const box = md.feedLine('```');
+  const plain = stripAnsi(box);
+  assert.match(plain, /const a = 1;/);
+  assert.match(plain, /const b = 2;/);
+});
+
+// ── flush() with an unclosed fence ───────────────────────────────────────────
+
+test('flush: an UNCLOSED fence is closed cleanly with no stranded SGR', () => {
+  const md = new StreamMarkdown();
+  md.feedLine('```python');
+  md.feedLine('x = 1');
+  const tail = md.flush();
+  assert.notStrictEqual(tail, null, 'flush emits the buffered box');
+  const plain = stripAnsi(tail);
+  assert.match(plain, /╭/, 'top border present');
+  assert.match(plain, /╰/, 'bottom border present (fence closed cleanly)');
+  assert.ok(tail.endsWith('\x1b[0m'), 'no SGR left open at the end');
+  // After flush the styler is back to a clean state.
+  assert.strictEqual(md.inCodeBlock, false);
+  assert.strictEqual(md.feedLine('plain again').includes('╭'), false);
+});
+
+// ── NO_COLOR → plain output, no SGR ──────────────────────────────────────────
+
+test('NO_COLOR: output is plain text with no escape codes', () => {
+  process.env.NO_COLOR = '1';
+  try {
+    const md = new StreamMarkdown();
+    const prose = md.feedLine('a **bold** and `code`');
+    assert.strictEqual(hasAnsi(prose), false, 'no SGR under NO_COLOR');
+    assert.strictEqual(prose, '  a bold and code', 'markers stripped, plain prose');
+    // Code blocks also stay plain (box-drawing chars are not ANSI).
+    md.feedLine('```js');
+    md.feedLine('const a = 1;');
+    const box = md.feedLine('```');
+    assert.strictEqual(hasAnsi(box), false, 'no SGR in the code box under NO_COLOR');
+    assert.match(box, /const a = 1;/);
+  } finally {
+    delete process.env.NO_COLOR;
+  }
+});
+
+// ── live-vs-_buildAI parity (the strongest constraint) ───────────────────────
+
+test('parity: live streaming and _buildAI render the SAME bytes for the same content', () => {
+  const content = [
+    'Here is **bold** and `inline`.',
+    '',
+    '- one',
+    '- two',
+    '',
+    '```python',
+    'def f():',
+    '    return 42',
+    '```',
+    'Done.',
+  ].join('\n');
+
+  // (a) Live path: simulate streamToken receiving the content (plus the trailing
+  // newline the model emits) one chunk, then a finalize/flush. Capture commits.
+  const live = new ChatHistory();
+  const liveOut = [];
+  live._commit = (t) => liveOut.push(t);
+  live.streamToken(content + '\n');
+  live._flushStream();
+  // Drop the header (first commit) and the trailing blank-line commit so we
+  // compare only the styled body, which is what _buildAI's renderBlock produces.
+  const liveBody = liveOut.slice(1, -1).join('');
+
+  // (b) Replay path: _buildAI → renderBlock for the same content.
+  const replay = renderBlock(content);
+  // renderBlock returns the body with no trailing newline; the live path commits
+  // each styled chunk followed by '\n'. Normalise by appending the same '\n'.
+  assert.strictEqual(liveBody, replay + '\n', 'live body bytes == replay body bytes');
+});
+
+test('parity: renderBlock matches a manual feed-then-flush over the same lines', () => {
+  const content = 'alpha\n**beta**\n\n```\ncode\n```';
+  const md = new StreamMarkdown();
+  const manual = feedAll(md, content).join('\n');
+  assert.strictEqual(renderBlock(content), manual);
+});
+
+// ── reset() clears cross-turn state ──────────────────────────────────────────
+
+test('reset: clears an in-progress fenced block between turns', () => {
+  const md = new StreamMarkdown();
+  md.feedLine('```python');
+  md.feedLine('leftover');
+  md.reset();
+  assert.strictEqual(md.inCodeBlock, false);
+  // Next turn's first line is treated as prose, not buffered code.
+  const styled = md.feedLine('fresh line');
+  assert.match(stripAnsi(styled), /^ {2}fresh line$/);
+});

package/test/memory-truncation-warning.test.js

@@ -0,0 +1,222 @@
+'use strict';
+
+// Fail-loud project-memory truncation (memory-truncation warning task).
+//
+// Project memory (AGENTS.md/CLAUDE.md) is loaded and capped at
+// DEFAULT_MEMORY_MAX_BYTES. Before this change the cut was SILENT — a user with
+// a large memory file had most of it dropped with no notice. These tests prove
+// the fail-loud behavior now matching the rest of the project (cf. config
+// quarantine, sandbox-unavailable):
+//   * a file over the cap → a one-time user-facing warning naming the path and
+//     the loaded/original sizes + dropped %, while the (truncated) content still
+//     loads;
+//   * a file under the cap → NO warning (paired negative — "warned" can never be
+//     confused with "always warns");
+//   * the warning is user-facing only — never injected into the model/system
+//     prompt content;
+//   * headless json mode keeps stdout byte-pure: the warning goes to stderr;
+//   * the SDK surfaces it via its 'warning' event, once per agent;
+//   * no memory file present → no warning, prompt section absent (intact).
+
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Redirect HOME before requiring lib modules so the global-memory level
+// (~/.semalt-ai/AGENTS.md) resolves under an empty temp home and never picks up
+// the developer's real memory.
+const TMP_HOME = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-memwarn-home-')));
+const PREV_HOME = process.env.HOME;
+const PREV_USERPROFILE = process.env.USERPROFILE;
+process.env.HOME = TMP_HOME;
+process.env.USERPROFILE = TMP_HOME;
+
+const { test, after } = require('node:test');
+const assert = require('node:assert');
+
+const {
+  loadProjectMemory,
+  memoryTruncationWarnings,
+  DEFAULT_MEMORY_MAX_BYTES,
+} = require('../lib/memory');
+const { getSystemPrompt } = require('../lib/prompts');
+
+const { createAgent } = require('../lib/sdk');
+const { startMockLLM } = require('./harness/mock-llm');
+
+const PREV_CWD = process.cwd();
+const PREV_KEY = process.env.SEMALT_API_KEY;
+after(() => {
+  process.chdir(PREV_CWD);
+  if (PREV_HOME === undefined) delete process.env.HOME; else process.env.HOME = PREV_HOME;
+  if (PREV_USERPROFILE === undefined) delete process.env.USERPROFILE; else process.env.USERPROFILE = PREV_USERPROFILE;
+  if (PREV_KEY === undefined) delete process.env.SEMALT_API_KEY; else process.env.SEMALT_API_KEY = PREV_KEY;
+});
+
+function mkRepo(prefix) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), prefix)));
+  fs.mkdirSync(path.join(root, '.git'), { recursive: true });
+  return root;
+}
+function write(p, data) { fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, data); }
+const emptyHome = () => fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-memwarn-eh-')));
+
+// ---------------------------------------------------------------------------
+// Pure logic: warning content + the paired negative
+// ---------------------------------------------------------------------------
+
+test('a memory file larger than the cap → warning with path + loaded/original sizes; content still loads', () => {
+  const home = emptyHome();
+  const root = mkRepo('semalt-memwarn-big-');
+  const file = path.join(root, 'AGENTS.md');
+  write(file, 'X'.repeat(5000));
+
+  const r = loadProjectMemory({ cwd: root, home, maxBytes: 1000 });
+  assert.strictEqual(r.truncated, true);
+  assert.strictEqual(r.truncatedFiles.length, 1, 'one file recorded as truncated');
+  assert.strictEqual(r.truncatedFiles[0].path, file);
+  assert.strictEqual(r.truncatedFiles[0].originalBytes, 5000);
+  assert.ok(r.truncatedFiles[0].loadedBytes < 5000, 'loaded less than original');
+
+  const warnings = memoryTruncationWarnings(r);
+  assert.strictEqual(warnings.length, 1, 'exactly one warning');
+  const w = warnings[0];
+  assert.ok(w.includes(file), 'warning names the file path');
+  assert.ok(/loaded \d+ (?:B|KB) of \d+ (?:B|KB)/.test(w), 'warning shows loaded of original size');
+  assert.ok(/\d+% dropped/.test(w), 'warning shows the dropped fraction');
+
+  // The (truncated) memory content STILL loads — the warning is additive only.
+  assert.ok(r.block.includes('XXXX'), 'truncated content is still present in the block');
+});
+
+test('a memory file UNDER the cap → no warning (paired negative)', () => {
+  const home = emptyHome();
+  const root = mkRepo('semalt-memwarn-small-');
+  write(path.join(root, 'AGENTS.md'), 'concise project guidance');
+
+  const r = loadProjectMemory({ cwd: root, home });
+  assert.strictEqual(r.truncated, false);
+  assert.deepStrictEqual(r.truncatedFiles, []);
+  assert.deepStrictEqual(memoryTruncationWarnings(r), [], 'nothing dropped → no warning');
+});
+
+test('multiple files: only the truncated ones are warned about', () => {
+  const home = emptyHome();
+  const root = mkRepo('semalt-memwarn-multi-');
+  // global (home) small, project-root large → only the large one is cut.
+  write(path.join(home, '.semalt-ai', 'AGENTS.md'), 'tiny');
+  const big = path.join(root, 'AGENTS.md');
+  write(big, 'Q'.repeat(8000));
+
+  const r = loadProjectMemory({ cwd: root, home, maxBytes: 600 });
+  const warnings = memoryTruncationWarnings(r);
+  assert.ok(warnings.length >= 1, 'at least the large file is warned about');
+  assert.ok(warnings.some((w) => w.includes(big)), 'the oversized project file is named');
+});
+
+// ---------------------------------------------------------------------------
+// The warning is user-facing only — never in the model/system prompt content
+// ---------------------------------------------------------------------------
+
+test('the warning is NOT injected into the system prompt content', () => {
+  const home = emptyHome();
+  const root = mkRepo('semalt-memwarn-prompt-');
+  write(path.join(root, 'AGENTS.md'), 'Y'.repeat(DEFAULT_MEMORY_MAX_BYTES + 5000));
+  process.chdir(root);
+
+  const r = loadProjectMemory({ cwd: root, home });
+  assert.strictEqual(r.truncated, true);
+  const warnings = memoryTruncationWarnings(r);
+  assert.ok(warnings.length >= 1);
+
+  // The block keeps its existing inline notice, but NOT the user warning string.
+  assert.ok(!r.block.includes('Consider trimming it to the most relevant guidance'),
+    'user-facing warning text is not in the memory block');
+  for (const w of warnings) {
+    assert.ok(!r.block.includes(w), 'the warning string is not embedded in the block');
+  }
+
+  // getSystemPrompt loads memory from cwd; the warning must not leak into it.
+  const prompt = getSystemPrompt(false);
+  for (const w of warnings) {
+    assert.ok(!prompt.includes(w), 'the warning string is not in the system prompt');
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Headless json mode: warning → stderr, stdout stays pure JSON
+// ---------------------------------------------------------------------------
+
+test('headless json mode: truncation warning goes to stderr, JSON envelope intact on stdout', () => {
+  // Run cmdCode in a CHILD process so its stdout/stderr are fully isolated —
+  // swapping the parent's global process.stdout would collide with the
+  // node:test TAP reporter (it would swallow other tests' result lines).
+  const { spawnSync } = require('node:child_process');
+  const child = path.join(__dirname, 'harness', 'memwarn-headless-child.js');
+  const res = spawnSync(process.execPath, [child], { encoding: 'utf8' });
+  assert.strictEqual(res.status, 0, `child exited cleanly (stderr: ${res.stderr})`);
+
+  const stdout = res.stdout || '';
+  const stderr = res.stderr || '';
+
+  // The warning is on stderr — the user channel machine modes already use
+  // (matching the config-quarantine / sandbox-unavailable startup warnings).
+  assert.ok(/⚠ Memory file .*AGENTS\.md truncated/.test(stderr), 'warning surfaced on stderr');
+
+  // The warning does NOT corrupt stdout: no warning glyph / text leaks there,
+  // and the JSON envelope on stdout is intact and parseable.
+  assert.ok(!stdout.includes('⚠'), 'no warning glyph pollutes stdout');
+  assert.ok(!/Memory file .*truncated/.test(stdout), 'no warning text pollutes stdout');
+  const jsonLine = stdout.split('\n').find((l) => l.trim().startsWith('{'));
+  assert.ok(jsonLine, 'the JSON envelope line is present on stdout');
+  assert.strictEqual(JSON.parse(jsonLine).result, 'All done.', 'the JSON envelope is intact');
+});
+
+// ---------------------------------------------------------------------------
+// SDK: surfaced via the 'warning' event, once per agent
+// ---------------------------------------------------------------------------
+
+test('SDK emits a one-time "warning" event for a truncated memory file', async () => {
+  const root = mkRepo('semalt-memwarn-sdk-');
+  write(path.join(root, 'AGENTS.md'), 'W'.repeat(DEFAULT_MEMORY_MAX_BYTES + 3000));
+  process.chdir(root);
+  process.env.SEMALT_API_KEY = 'test-key';
+
+  const mock = await startMockLLM();
+  mock.replyWith('ok one');
+  mock.replyWith('ok two');
+  const agent = createAgent({
+    apiBase: mock.base, apiKey: 'test-key', model: 'test-model', sandbox: { mode: 'off' },
+  });
+  const warnings = [];
+  agent.on('warning', (m) => warnings.push(m));
+  try {
+    await agent.run('first');
+    await agent.run('second'); // a second run must NOT re-warn
+  } finally {
+    await agent.close();
+    await mock.close();
+  }
+  const memWarnings = warnings.filter((w) => /Memory file .*AGENTS\.md truncated/.test(w));
+  assert.strictEqual(memWarnings.length, 1, 'warned exactly once across two runs');
+});
+
+// ---------------------------------------------------------------------------
+// Absent memory → no warning, prompt section absent (existing behavior intact)
+// ---------------------------------------------------------------------------
+
+test('no memory file present → no warning and no memory section', () => {
+  const home = emptyHome();
+  const root = mkRepo('semalt-memwarn-none-');
+
+  const r = loadProjectMemory({ cwd: root, home });
+  assert.strictEqual(r.block, '');
+  assert.strictEqual(r.truncated, false);
+  assert.deepStrictEqual(r.truncatedFiles, []);
+  assert.deepStrictEqual(memoryTruncationWarnings(r), [], 'no memory → no warning');
+
+  // Empty memory leaves the prompt unchanged (no PROJECT_MEMORY section).
+  const base = getSystemPrompt(false, '', '');
+  assert.ok(!base.includes('PROJECT_MEMORY'), 'no memory section when memory is empty');
+  assert.strictEqual(getSystemPrompt(false, r.block, ''), base, 'empty block appends nothing');
+});

package/test/memory.test.js

@@ -0,0 +1,198 @@
+'use strict';
+
+// Characterization tests for project memory (Task 2.3): the AGENTS.md/CLAUDE.md
+// hierarchy loader and its injection into the system prompt. Filesystem work is
+// isolated under temp dirs; HOME is redirected before requiring lib modules so
+// the global-memory level resolves under the temp home.
+
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const TMP_HOME = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-memhome-')));
+const PREV_HOME = process.env.HOME;
+const PREV_USERPROFILE = process.env.USERPROFILE;
+process.env.HOME = TMP_HOME;
+process.env.USERPROFILE = TMP_HOME;
+
+const { test, after } = require('node:test');
+const assert = require('node:assert');
+
+const {
+  loadProjectMemory,
+  discoverMemoryFiles,
+  findRepoRoot,
+  memoryStatusLines,
+} = require('../lib/memory');
+const { getSystemPrompt } = require('../lib/prompts');
+
+const PREV_CWD = process.cwd();
+after(() => {
+  process.chdir(PREV_CWD);
+  if (PREV_HOME === undefined) delete process.env.HOME; else process.env.HOME = PREV_HOME;
+  if (PREV_USERPROFILE === undefined) delete process.env.USERPROFILE; else process.env.USERPROFILE = PREV_USERPROFILE;
+});
+
+function mkRepo(prefix) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), prefix)));
+  fs.mkdirSync(path.join(root, '.git'), { recursive: true });
+  return root;
+}
+function write(p, data) { fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, data); }
+
+// ---------------------------------------------------------------------------
+// Absent files → no memory, base prompt unchanged
+// ---------------------------------------------------------------------------
+
+test('no memory files present → empty block and no files', () => {
+  const emptyHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-emptyhome-')));
+  const root = mkRepo('semalt-mem-none-');
+  const r = loadProjectMemory({ cwd: root, home: emptyHome });
+  assert.strictEqual(r.block, '');
+  assert.deepStrictEqual(r.files, []);
+  assert.strictEqual(r.truncated, false);
+});
+
+test('getSystemPrompt is byte-for-byte the base prompt when memory is empty', () => {
+  const base = getSystemPrompt(false, '');
+  assert.ok(!base.includes('PROJECT_MEMORY'), 'no memory section in the base prompt');
+  // Memory is appended verbatim to the end — proves append-only + empty == base.
+  assert.strictEqual(getSystemPrompt(false, '\n\nMEMBLOCK'), base + '\n\nMEMBLOCK');
+  // Same for the native template.
+  const nbase = getSystemPrompt(true, '');
+  assert.strictEqual(getSystemPrompt(true, '\n\nX'), nbase + '\n\nX');
+});
+
+test('getSystemPrompt with no project memory in CWD/home equals the explicit-empty base', () => {
+  const emptyHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-eh2-')));
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-nomem-cwd-')));
+  const prevHome = process.env.HOME;
+  process.env.HOME = emptyHome; process.env.USERPROFILE = emptyHome;
+  process.chdir(dir);
+  try {
+    assert.strictEqual(getSystemPrompt(false), getSystemPrompt(false, ''));
+  } finally {
+    process.env.HOME = prevHome; process.env.USERPROFILE = prevHome;
+    process.chdir(PREV_CWD);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Hierarchy: global → project root → nested CWD, in order
+// ---------------------------------------------------------------------------
+
+test('hierarchy loads global, repo root, and nested CWD in order', () => {
+  write(path.join(TMP_HOME, '.semalt-ai', 'AGENTS.md'), 'GLOBAL_MEM');
+  const root = mkRepo('semalt-mem-hier-');
+  write(path.join(root, 'AGENTS.md'), 'ROOT_MEM');
+  const nested = path.join(root, 'pkg', 'sub');
+  write(path.join(nested, 'AGENTS.md'), 'CWD_MEM');
+
+  const r = loadProjectMemory({ cwd: nested, home: TMP_HOME });
+  assert.deepStrictEqual(r.files.map((f) => f.source), ['global', 'project-root', 'cwd']);
+  const gi = r.block.indexOf('GLOBAL_MEM');
+  const ri = r.block.indexOf('ROOT_MEM');
+  const ci = r.block.indexOf('CWD_MEM');
+  assert.ok(gi !== -1 && ri !== -1 && ci !== -1, 'all three present');
+  assert.ok(gi < ri && ri < ci, 'concatenated in hierarchy order');
+  assert.ok(r.block.includes('<<<PROJECT_MEMORY>>>') && r.block.includes('<<<END_PROJECT_MEMORY>>>'));
+
+  // cleanup global so it does not leak into other tests
+  fs.rmSync(path.join(TMP_HOME, '.semalt-ai'), { recursive: true, force: true });
+});
+
+test('CWD at the repo root is not double-loaded', () => {
+  const emptyHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-eh3-')));
+  const root = mkRepo('semalt-mem-rootcwd-');
+  write(path.join(root, 'AGENTS.md'), 'ONLY_ROOT');
+  const r = loadProjectMemory({ cwd: root, home: emptyHome });
+  assert.deepStrictEqual(r.files.map((f) => f.source), ['project-root']);
+});
+
+// ---------------------------------------------------------------------------
+// AGENTS.md vs CLAUDE.md alias
+// ---------------------------------------------------------------------------
+
+test('AGENTS.md is preferred over CLAUDE.md and the choice is reported', () => {
+  const emptyHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-eh4-')));
+  const root = mkRepo('semalt-mem-alias-');
+  write(path.join(root, 'AGENTS.md'), 'A_WINS');
+  write(path.join(root, 'CLAUDE.md'), 'C_IGNORED');
+  const r = loadProjectMemory({ cwd: root, home: emptyHome });
+  assert.strictEqual(r.files.length, 1);
+  assert.strictEqual(r.files[0].name, 'AGENTS.md');
+  assert.strictEqual(r.files[0].alsoPresent, true);
+  assert.ok(r.block.includes('A_WINS'));
+  assert.ok(!r.block.includes('C_IGNORED'), 'CLAUDE.md content is not loaded when AGENTS.md exists');
+});
+
+test('CLAUDE.md is used as the alias when AGENTS.md is absent', () => {
+  const emptyHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-eh5-')));
+  const root = mkRepo('semalt-mem-claude-');
+  write(path.join(root, 'CLAUDE.md'), 'CLAUDE_ONLY');
+  const r = loadProjectMemory({ cwd: root, home: emptyHome });
+  assert.strictEqual(r.files[0].name, 'CLAUDE.md');
+  assert.strictEqual(r.files[0].alsoPresent, false);
+  assert.ok(r.block.includes('CLAUDE_ONLY'));
+});
+
+// ---------------------------------------------------------------------------
+// Truncation
+// ---------------------------------------------------------------------------
+
+test('oversized memory is truncated with a visible notice', () => {
+  const emptyHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-eh6-')));
+  const root = mkRepo('semalt-mem-big-');
+  write(path.join(root, 'AGENTS.md'), 'X'.repeat(5000));
+  const r = loadProjectMemory({ cwd: root, home: emptyHome, maxBytes: 200 });
+  assert.strictEqual(r.truncated, true);
+  assert.ok(/truncated/i.test(r.block), 'block carries a truncation notice');
+});
+
+// ---------------------------------------------------------------------------
+// findRepoRoot + status lines
+// ---------------------------------------------------------------------------
+
+test('findRepoRoot locates the nearest .git ancestor and returns null without one', () => {
+  const root = mkRepo('semalt-mem-root-');
+  const nested = path.join(root, 'a', 'b');
+  fs.mkdirSync(nested, { recursive: true });
+  assert.strictEqual(findRepoRoot(nested), root);
+  const bare = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-bare-')));
+  // a temp dir under the OS tmpdir is not inside a git repo
+  assert.strictEqual(findRepoRoot(bare), null);
+});
+
+test('memoryStatusLines reports loaded files, alias note, and edit target', () => {
+  const result = {
+    files: [
+      { path: '/home/u/.semalt-ai/AGENTS.md', source: 'global', name: 'AGENTS.md', alsoPresent: false },
+      { path: '/repo/AGENTS.md', source: 'project-root', name: 'AGENTS.md', alsoPresent: true },
+    ],
+    truncated: false,
+  };
+  const lines = memoryStatusLines(result).join('\n');
+  assert.ok(lines.includes('/home/u/.semalt-ai/AGENTS.md'));
+  assert.ok(lines.includes('[global]') && lines.includes('[project-root]'));
+  assert.ok(/CLAUDE\.md also present/.test(lines), 'alias note shown');
+  assert.ok(lines.includes('Edit project memory: /repo/AGENTS.md'), 'points at the nearest project file');
+});
+
+test('memoryStatusLines handles the no-memory case', () => {
+  const lines = memoryStatusLines({ files: [], truncated: false }).join('\n');
+  assert.ok(/No project memory files found/.test(lines));
+});
+
+// ---------------------------------------------------------------------------
+// discoverMemoryFiles direct
+// ---------------------------------------------------------------------------
+
+test('discoverMemoryFiles returns ordered entries with resolved paths', () => {
+  const emptyHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-eh7-')));
+  const root = mkRepo('semalt-disc-');
+  write(path.join(root, 'CLAUDE.md'), 'x');
+  const found = discoverMemoryFiles(root, emptyHome);
+  assert.strictEqual(found.length, 1);
+  assert.strictEqual(found[0].source, 'project-root');
+  assert.strictEqual(path.isAbsolute(found[0].path), true);
+});