mixdog 0.9.38 → 0.9.39

package/scripts/memory-cycle-routing-test.mjs

@@ -0,0 +1,111 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { resolveMaintenancePreset } from '../src/runtime/shared/llm/index.mjs'
+import { sonnetCascade } from '../src/runtime/memory/lib/memory-cycle2-gate.mjs'
+import { runPhaseMerge } from '../src/runtime/memory/lib/memory-cycle2-mutations.mjs'
+import { invokeCycle3Maintenance } from '../src/runtime/memory/lib/memory-cycle3.mjs'
+
+test('cycle2 cascade uses the memory maintenance route', async () => {
+  const expected = resolveMaintenancePreset('memory')
+  let received
+  await sonnetCascade(
+    [{ id: 1, status: 'pending', verb: 'active', category: 'fact', element: 'x', summary: 'y' }],
+    '',
+    {
+      callLlm: (opts) => {
+        received = opts
+        return '1|keep'
+      },
+    },
+  )
+  assert.deepEqual(received.preset, expected)
+  assert.equal(received.mode, 'cycle2-cascade')
+})
+
+test('cycle2 cascade preserves an explicit test override', async () => {
+  let received
+  await sonnetCascade(
+    [{ id: 1, status: 'pending', verb: 'active', category: 'fact', element: 'x', summary: 'y' }],
+    '',
+    {
+      cascadePreset: 'test-route',
+      callLlm: (opts) => {
+        received = opts
+        return '1|keep'
+      },
+    },
+  )
+  assert.equal(received.preset, 'test-route')
+})
+
+test('cycle2 phase merge judge dispatches through the memory maintenance route', async () => {
+  const expected = resolveMaintenancePreset('memory')
+  let received
+  const db = {
+    query: async () => ({ rows: [] }),
+  }
+  db.query = async (sql) => {
+    if (sql.includes('WITH active AS')) {
+      return {
+        rows: [{
+          a_id: 1, a_category: 'fact', a_summary: 'a', a_score: 1, a_last_seen_at: 1, a_status: 'active',
+          b_id: 2, b_category: 'fact', b_summary: 'b', b_score: 1, b_last_seen_at: 1, b_status: 'active',
+          sim: 0.8,
+        }],
+      }
+    }
+    return { rows: [] }
+  }
+  const result = await runPhaseMerge(db, {
+    callLlm: (opts) => {
+      received = opts
+      return 'distinct'
+    },
+  })
+  assert.equal(result.llm_calls, 1)
+  assert.deepEqual(received.preset, expected)
+  assert.equal(received.mode, 'cycle2-phase_merge_judge')
+})
+
+test('cycle2 phase merge preserves an explicit test override', async () => {
+  let received
+  const db = {
+    query: async (sql) => (sql.includes('WITH active AS')
+      ? { rows: [{ a_id: 1, a_category: 'fact', a_summary: 'a', a_score: 1, a_last_seen_at: 1, a_status: 'active', b_id: 2, b_category: 'fact', b_summary: 'b', b_score: 1, b_last_seen_at: 1, b_status: 'active', sim: 0.8 }] }
+      : { rows: [] }),
+  }
+  await runPhaseMerge(db, {
+    preset: 'test-route',
+    callLlm: (opts) => {
+      received = opts
+      return 'distinct'
+    },
+  })
+  assert.equal(received.preset, 'test-route')
+})
+
+test('cycle3 dispatches through the memory maintenance route', async () => {
+  const expected = resolveMaintenancePreset('memory')
+  let received
+  await invokeCycle3Maintenance('test prompt', {
+    callLlm: (opts) => {
+      received = opts
+      return '1|keep'
+    },
+  })
+  assert.deepEqual(received.preset, expected)
+  assert.equal(received.agent, 'cycle3-agent')
+  assert.equal(received.mode, 'cycle3-review')
+})
+
+test('cycle3 preserves an explicit test override', async () => {
+  let received
+  await invokeCycle3Maintenance('test prompt', {
+    preset: 'test-route',
+    callLlm: (opts) => {
+      received = opts
+      return '1|keep'
+    },
+  })
+  assert.equal(received.preset, 'test-route')
+})

package/scripts/memory-rule-contract-test.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+
+const root = new URL('..', import.meta.url)
+const rawRules = Object.fromEntries(await Promise.all([
+  ['cycle1', 'src/rules/agent/40-cycle1-agent.md'],
+  ['cycle2', 'src/rules/agent/41-cycle2-agent.md'],
+  ['cycle3', 'src/rules/agent/42-cycle3-agent.md'],
+].map(async ([name, path]) => [
+  name,
+  await readFile(new URL(path, root), 'utf8'),
+])))
+const rules = Object.fromEntries(Object.entries(rawRules)
+  .map(([name, text]) => [name, text.replace(/\s+/g, ' ').trim()]))
+
+function includesAll(text, clauses) {
+  for (const clause of clauses) assert.ok(text.includes(clause), `missing: ${clause}`)
+}
+
+test('cycle1 preserves chunk schema, taxonomy, coverage, and escaping', () => {
+  const text = rules.cycle1
+  includesAll(text, [
+    '<idx_csv>|<element>|<category>|<summary>', 'included input row numbers',
+    'comma-separated, without `@`', '5–10-word recall key',
+    '`rule` (standing policy)', '`constraint` (hard limit)',
+    '`decision` (agreed choice)', '`fact` (verified truth)', '`goal` (open target)',
+    '`preference` (style/taste)', '`task` (pending work)', '`issue` (broken state)',
+    '1–3 complete sentences', 'important names, paths, IDs, versions, numbers, errors, causes, and outcomes verbatim',
+    'match input language', 'Every input row appears exactly once',
+    'Group nearby same-topic rows, splitting only at real topic changes',
+    'retain clarifications with their topic', 'Never mix `[sess:XXX]` markers',
+    'Replace literal `|` with `/`', 'fields contain no newlines',
+    'No JSON, fences, prose, preamble, or tool calls',
+  ])
+})
+
+test('cycle2 preserves essential taxonomy, phases, rejects, formats, and fields', () => {
+  const text = rules.cycle2
+  includesAll(text, [
+    '`is_root` long-term memory', 'candidate `id`/`category`/`score`/`element`/`summary`',
+    'only when clearly exactly one essential concept',
+    'identity (stable non-derivable user fact)', 'preference (durable taste/style/interaction preference)',
+    'goal (long-running committed goal)', 'principle (cross-session behavior directive)',
+    'policy (standing team decision)', 'procedure (recurring trigger + steps + caveats)',
+    'event (rare foundational change not reconstructible from its rule)',
+    'system constant (durable path/schema/model/channel invariant needed later and absent from rules)',
+    'Anything unclear or outside these concepts is `archived`',
+    '`phase1_new_chunks` → `active` if clearly essential, otherwise `archived`',
+    '`phase2_reevaluate` → `active` to promote, otherwise `archived`',
+    '`phase3_active_review` requires every-row verdict: default `archived`, or `active`, `update`, `merge`',
+    'silence is not keep', 'work narratives', 'static facts without behavior/user value',
+    'rule-system meta', 'resolved bug/fix logs', 'rule-file duplicates',
+    'single-run measurements/counts/versions', 'session-scoped or in-progress decisions',
+    '<id>|<verb>', '<id>|update|<element>|<summary>',
+    '<id>|merge|<target_id>|<source_ids_csv>|<element>|<summary>',
+    'Use only input IDs; never invent IDs', 'fresh `element` and a 3-sentence `summary`',
+    'keeps `target_id`, absorbs `source_ids_csv`, and uses only one `project_id`',
+    'complete sentences in input language', 'preserve important specifics verbatim',
+    'omit actor/meta filler', '`rule > constraint > decision > fact > goal > preference > task > issue`',
+    'Replace literal `|` with `/`', 'fields contain no newlines',
+    'For phase 3, emit one verdict per input row', 'start with a digit',
+  ])
+})
+
+test('cycle3 preserves durable-event verdicts, formats, and exceptions', () => {
+  const text = rules.cycle3
+  includesAll(text, [
+    'one digit-starting pipe verdict line per input id', 'CORE is durable standing knowledge',
+    'rules, preferences, identity, goals, and current system/structure descriptions—not a log',
+    'Each entry is one short clause (≤120 chars)',
+    'Current rule/preference/live structure = durable',
+    'past event (shipped version, measured value, made fix) = not durable', 'When unsure, keep',
+    '`keep`: durable, already one short clause',
+    '`update`: durable but verbose/multi-sentence; compress to one ≤120-char clause',
+    '`merge`: duplicate; fold into its survivor in the same project pool',
+    '`delete`: past event, not a current rule or structure',
+    'Verbose durable is always `update`, never `keep`',
+    '<id>|keep', '<id>|update|<element>|<summary>',
+    '<id>|merge|<target_id>|<source_ids_csv>', '<id>|delete',
+    'IDs match input rows; never invent them', 'summary is one ≤120-char clause',
+    '`element` is short', 'retains `target_id`, absorbs sources, and stays within one `project_id`',
+    'Replace literal `|` with `/`', 'fields contain no newlines',
+    'Emit a verdict for every input row', 'start with a digit',
+  ])
+})
+
+test('compacted rules remain below their pre-compaction character counts', () => {
+  const preCompaction = { cycle1: 1214, cycle2: 2166, cycle3: 1530 }
+  for (const [name, before] of Object.entries(preCompaction)) {
+    assert.ok(rawRules[name].length < before, `${name} was not compacted`)
+  }
+})

package/scripts/output-style-smoke.mjs

@@ -13,7 +13,7 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
-const DEFAULT_REPORT_LABELS = new Set(['\uBC14\uB010 \uC810', '\uD655\uC778\uD55C \uAC83', '\uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4', '\uB2E4\uC74C \uB2E8\uACC4']);
+const DEFAULT_REPORT_LABELS = new Set(['Changes', 'Verification', 'Risks / next steps', '\uBC14\uB010 \uC810', '\uD655\uC778\uD55C \uAC83', '\uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4', '\uB2E4\uC74C \uB2E8\uACC4']);
 
 function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedLabels = new Set() } = {}) {
   const text = String(value || '').trim();
@@ -52,7 +52,7 @@ for (const required of [
   'Mixdog default — the most detailed style',
   'State conclusions, not reasoning',
   'Use labels such as',
-  '`\uBC14\uB010 \uC810`, `\uD655\uC778\uD55C \uAC83`,',
+  '`Changes`, `Verification`,',
   'Synthesize agent or retrieval results',
   'Do not hide blockers',
 ]) {

package/scripts/rg-runner-test.mjs

@@ -0,0 +1,240 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import {
+    _resolveRgExecutable,
+    _rgEagainRetryArgs,
+    _rgThreadCap,
+    _withRgThreads,
+    ensureRgResolved,
+    rgSupportsPcre2,
+} from '../src/runtime/agent/orchestrator/tools/builtin/rg-runner.mjs';
+
+function makeRgFile(path) {
+    writeFileSync(path, '');
+    if (process.platform !== 'win32') chmodSync(path, 0o755);
+}
+
+test('rg resolver prefers direct current-directory/PATH search over where/which', async () => {
+    const originalCwd = process.cwd();
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    const pathDir = join(dir, 'path');
+    mkdirSync(pathDir);
+    const name = process.platform === 'win32' ? 'rg.exe' : 'rg';
+    const current = join(dir, name);
+    const fromPath = join(pathDir, name);
+    makeRgFile(current);
+    makeRgFile(fromPath);
+    try {
+        process.chdir(dir);
+        process.env.PATH = pathDir;
+        assert.equal(await _resolveRgExecutable(), process.platform === 'win32' ? current : fromPath);
+        assert.ok(isAbsolute(await _resolveRgExecutable()));
+    } finally {
+        process.chdir(originalCwd);
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('rg resolver honors PATH order when no current-directory executable exists', async () => {
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    const first = join(dir, 'first');
+    const second = join(dir, 'second');
+    mkdirSync(first);
+    mkdirSync(second);
+    const name = process.platform === 'win32' ? 'rg.exe' : 'rg';
+    const expected = join(second, name);
+    makeRgFile(expected);
+    try {
+        process.env.PATH = `${first}${process.platform === 'win32' ? ';' : ':'}${second}`;
+        assert.equal(await _resolveRgExecutable(), expected);
+    } finally {
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('rg resolver makes relative PATH candidates absolute', async () => {
+    const originalCwd = process.cwd();
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    const bin = join(dir, 'bin');
+    mkdirSync(bin);
+    const name = process.platform === 'win32' ? 'rg.exe' : 'rg';
+    const expected = join(bin, name);
+    makeRgFile(expected);
+    try {
+        process.chdir(dir);
+        process.env.PATH = `.${process.platform === 'win32' ? ';' : ':'}bin`;
+        const resolved = await _resolveRgExecutable();
+        assert.equal(resolved, expected);
+        assert.ok(isAbsolute(resolved));
+    } finally {
+        process.chdir(originalCwd);
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('rg resolver skips directories and non-executable POSIX files', async () => {
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    const bad = join(dir, 'bad');
+    const good = join(dir, 'good');
+    mkdirSync(bad);
+    mkdirSync(good);
+    const name = process.platform === 'win32' ? 'rg.exe' : 'rg';
+    const nonExecutable = join(bad, name);
+    const expected = join(good, name);
+    if (process.platform === 'win32') mkdirSync(nonExecutable);
+    else writeFileSync(nonExecutable, '');
+    makeRgFile(expected);
+    try {
+        process.env.PATH = `${bad}${process.platform === 'win32' ? ';' : ':'}${good}`;
+        assert.equal(await _resolveRgExecutable(), expected);
+    } finally {
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('rg resolver rejects Windows command wrappers', async (t) => {
+    if (process.platform !== 'win32') {
+        t.skip('Windows spawn resolution only');
+        return;
+    }
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    writeFileSync(join(dir, 'rg.cmd'), '@echo off\r\n');
+    try {
+        process.env.PATH = dir;
+        assert.notEqual(await _resolveRgExecutable(), join(dir, 'rg.cmd'));
+    } finally {
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('rg resolver preserves empty PATH components as current-directory entries', async () => {
+    const originalCwd = process.cwd();
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    const name = process.platform === 'win32' ? 'rg.exe' : 'rg';
+    const expected = join(dir, name);
+    makeRgFile(expected);
+    try {
+        process.chdir(dir);
+        process.env.PATH = process.platform === 'win32' ? `;${dir}` : `:${dir}`;
+        assert.equal(await _resolveRgExecutable(), expected);
+    } finally {
+        process.chdir(originalCwd);
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('rg resolver invalidates cached executable when PATH or file usability changes', async () => {
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    const firstDir = join(dir, 'first');
+    const secondDir = join(dir, 'second');
+    mkdirSync(firstDir);
+    mkdirSync(secondDir);
+    const name = process.platform === 'win32' ? 'rg.exe' : 'rg';
+    const first = join(firstDir, name);
+    const second = join(secondDir, name);
+    makeRgFile(first);
+    makeRgFile(second);
+    try {
+        process.env.PATH = firstDir;
+        assert.equal(await ensureRgResolved(), first);
+        process.env.PATH = secondDir;
+        assert.equal(await ensureRgResolved(), second);
+        if (process.platform === 'win32') rmSync(second);
+        else chmodSync(second, 0o644);
+        assert.notEqual(await ensureRgResolved(), second);
+        if (process.platform !== 'win32') rmSync(second);
+    } finally {
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('bare rg fallback is probed again after it becomes usable', async () => {
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    try {
+        process.env.PATH = dir;
+        assert.equal(await ensureRgResolved(), 'rg');
+        const name = process.platform === 'win32' ? 'rg.exe' : 'rg';
+        makeRgFile(join(dir, name));
+        assert.notEqual(await ensureRgResolved(), 'rg');
+    } finally {
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('PCRE2 capability cache follows the resolved executable', async (t) => {
+    if (process.platform === 'win32') {
+        t.skip('portable executable fixture unavailable on Windows');
+        return;
+    }
+    const originalPath = process.env.PATH;
+    const dir = mkdtempSync(join(tmpdir(), 'mixdog-rg-'));
+    const firstDir = join(dir, 'first');
+    const secondDir = join(dir, 'second');
+    mkdirSync(firstDir);
+    mkdirSync(secondDir);
+    const first = join(firstDir, 'rg');
+    const second = join(secondDir, 'rg');
+    writeFileSync(first, '#!/bin/sh\nprintf "PCRE2 10.40\\n"\n');
+    writeFileSync(second, '#!/bin/sh\nexit 1\n');
+    chmodSync(first, 0o755);
+    chmodSync(second, 0o755);
+    try {
+        process.env.PATH = firstDir;
+        assert.equal(await rgSupportsPcre2(), true);
+        process.env.PATH = secondDir;
+        assert.equal(await rgSupportsPcre2(), false);
+    } finally {
+        if (originalPath === undefined) delete process.env.PATH;
+        else process.env.PATH = originalPath;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test('rg thread cap honors the environment override', () => {
+    const original = process.env.MIXDOG_RG_THREADS;
+    try {
+        process.env.MIXDOG_RG_THREADS = '7.9';
+        assert.equal(_rgThreadCap(), 7);
+        process.env.MIXDOG_RG_THREADS = '0';
+        assert.ok(_rgThreadCap() >= 2);
+    } finally {
+        if (original === undefined) delete process.env.MIXDOG_RG_THREADS;
+        else process.env.MIXDOG_RG_THREADS = original;
+    }
+});
+
+test('rg treats a -e --threads pattern as a pattern during injection and retry', () => {
+    const args = ['-e', '--threads', 'needle'];
+    const injected = _withRgThreads(args);
+    assert.equal(injected[0], '--threads');
+    assert.equal(injected[2], '-e');
+    assert.deepEqual(injected.slice(3), ['--threads', 'needle']);
+    assert.deepEqual(_rgEagainRetryArgs(args), ['-j', '1', '-e', '--threads', 'needle']);
+});