mixdog 0.9.152 → 0.9.154

package/src/runtime/agent/orchestrator/session/cache/prefetch-cache.test.mjs

@@ -1,40 +0,0 @@
-import assert from 'node:assert/strict';
-import {
-  mkdtempSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-
-test('prefetch disk cache uses a full hash and rejects a mismatched path identity', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-prefetch-cache-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  const source = join(root, 'source.txt');
-  writeFileSync(source, 'source');
-  try {
-    const first = await import(`./prefetch-cache.mjs?writer=${Date.now()}`);
-    first.setPrefetchCached(source, 'cached output');
-    first.drainPrefetchDiskWrites();
-    const cacheDir = join(root, 'cache', 'prefetch');
-    const [cacheFile] = readdirSync(cacheDir);
-    assert.match(cacheFile, /^[0-9a-f]{64}\.json$/);
-
-    const path = join(cacheDir, cacheFile);
-    const payload = JSON.parse(readFileSync(path, 'utf8'));
-    mkdirSync(cacheDir, { recursive: true });
-    writeFileSync(path, JSON.stringify({ ...payload, absPath: `${source}.other` }));
-
-    const second = await import(`./prefetch-cache.mjs?reader=${Date.now()}`);
-    assert.equal(second.tryPrefetchCached(source), null);
-  } finally {
-    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});

package/src/runtime/agent/orchestrator/session/compact-policy.test.mjs

@@ -1,176 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import {
-    compactionTelemetryPressureTokens,
-    currentContextEstimateTokens,
-    rememberCompactTelemetry,
-    resolveCompactionPressureTokens,
-    resolveContextTokens,
-    resolveGaugeContextTokens,
-    resolveWorkerCompactPolicy,
-    shouldCompactForSession,
-} from './loop/compact-policy.mjs';
-import { contextMessagesSignature, estimateMessagesTokens } from './context-utils.mjs';
-
-test('Cursor main sessions preserve the configured 200k compact boundary', () => {
-    const session = {
-        provider: 'cursor-oauth',
-        model: 'gemini-3.7-flash',
-        contextWindow: 200_000,
-        compactBoundaryTokens: 200_000,
-        compaction: { auto: true },
-    };
-
-    const policy = resolveWorkerCompactPolicy(session, []);
-    assert.equal(policy.boundaryTokens, 200_000);
-    assert.equal(policy.triggerTokens, 200_000);
-    assert.equal(policy.bufferTokens, 0);
-});
-
-test('successful compaction publishes post-compact pressure and invalidates the old baseline', () => {
-    const session = {
-        provider: 'cursor-oauth',
-        model: 'gemini-3.7-flash',
-        contextWindow: 200_000,
-        compactBoundaryTokens: 200_000,
-        contextPressureBaselineTokens: 225_000,
-        contextPressureBaselineUpdatedAt: Date.now(),
-        lastContextTokensStaleAfterCompact: false,
-        compaction: { auto: true },
-    };
-    const policy = resolveWorkerCompactPolicy(session, []);
-
-    rememberCompactTelemetry(session, policy, {
-        stage: 'pre_send',
-        beforeTokens: 225_000,
-        afterTokens: 20_000,
-        pressureTokens: 225_000,
-        compactChanged: true,
-    });
-
-    assert.equal(session.compaction.currentEstimatedTokens, 20_000);
-    assert.equal(session.contextPressureBaselineTokens, null);
-    assert.equal(session.lastContextTokensStaleAfterCompact, true);
-});
-
-// Reported compaction numbers must share ONE scale with the context gauge
-// (user: 게이지는 499k인데 압축 알림은 131k→23k). The pre-compact side follows
-// the provider-billed prompt; the post-compact side is the same calibrated
-// estimate the gauge falls back to once compaction drops the baseline.
-test('gauge and post-compact estimate are one scale', () => {
-    const messages = [
-        { role: 'user', content: 'hello world '.repeat(200) },
-        { role: 'assistant', content: 'reply text '.repeat(200) },
-    ];
-    const session = {
-        provider: 'anthropic-oauth',
-        model: 'claude-opus-5',
-        contextWindow: 500_000,
-        compactBoundaryTokens: 500_000,
-        compaction: { auto: true },
-        tools: [],
-    };
-    const policy = resolveWorkerCompactPolicy(session, []);
-    const messageTokensEst = estimateMessagesTokens(messages);
-
-    // No baseline: both ends resolve through the identical calibrated formula.
-    assert.equal(
-        resolveGaugeContextTokens(messageTokensEst, policy, { messages, sessionRef: session }),
-        currentContextEstimateTokens(messageTokensEst, policy),
-    );
-
-    // Live baseline: the reported "before" follows the provider-billed prompt
-    // instead of the much smaller raw transcript estimate.
-    Object.assign(session, {
-        contextPressureBaselineTokens: 499_000,
-        contextPressureBaselineOutputTokens: 0,
-        contextPressureBaselineMessageCount: messages.length,
-        contextPressureBaselinePrefixSignature: contextMessagesSignature(messages),
-        contextPressureBaselineProvider: session.provider,
-        contextPressureBaselineModel: session.model,
-        contextPressureBaselineToolSignature: policy.toolSchemaSignature,
-        contextPressureBaselineBoundary: 'complete',
-        contextPressureBaselineUpdatedAt: Date.now(),
-        lastContextTokensStaleAfterCompact: false,
-    });
-
-    const gauged = resolveGaugeContextTokens(messageTokensEst, policy, { messages, sessionRef: session });
-    assert.equal(gauged, 499_000);
-    assert.equal(
-        resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef: session }),
-        gauged,
-    );
-    assert.equal(
-        shouldCompactForSession(messageTokensEst, policy, { messages, sessionRef: session }),
-        false,
-    );
-    assert.ok(gauged > currentContextEstimateTokens(messageTokensEst, policy) * 10);
-});
-
-test('provider baseline plus trailing growth is the only display and compaction value', () => {
-    const prefix = [
-        { role: 'user', content: 'large provider-aligned prefix '.repeat(5_000) },
-    ];
-    const trailing = { role: 'user', content: 'new trailing message' };
-    const messages = [...prefix, trailing];
-    const session = {
-        provider: 'anthropic-oauth',
-        model: 'claude-opus-5',
-        contextWindow: 500_000,
-        compactBoundaryTokens: 500_000,
-        compaction: { auto: true },
-        tools: [],
-    };
-    const policy = resolveWorkerCompactPolicy(session, []);
-    const messageTokensEst = estimateMessagesTokens(messages);
-    const providerTokens = 1_000;
-    Object.assign(session, {
-        contextPressureBaselineTokens: providerTokens,
-        contextPressureBaselineOutputTokens: 0,
-        contextPressureBaselineMessageCount: prefix.length,
-        contextPressureBaselinePrefixSignature: contextMessagesSignature(messages, prefix.length),
-        contextPressureBaselineProvider: session.provider,
-        contextPressureBaselineModel: session.model,
-        contextPressureBaselineToolSignature: policy.toolSchemaSignature,
-        contextPressureBaselineBoundary: 'complete',
-        contextPressureBaselineUpdatedAt: Date.now(),
-        lastContextTokensStaleAfterCompact: false,
-    });
-
-    const expected = providerTokens + Math.round(
-        estimateMessagesTokens([trailing]) * policy.tokenCalibration,
-    );
-    const contextTokens = resolveContextTokens(messageTokensEst, policy, { messages, sessionRef: session });
-    assert.equal(contextTokens, expected);
-    assert.equal(
-        resolveGaugeContextTokens(messageTokensEst, policy, { messages, sessionRef: session }),
-        contextTokens,
-    );
-    assert.equal(
-        resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef: session }),
-        contextTokens,
-    );
-    assert.ok(currentContextEstimateTokens(messageTokensEst, policy) > contextTokens * 2);
-
-    const decisionPolicy = { ...policy, triggerTokens: contextTokens + 1 };
-    assert.equal(
-        shouldCompactForSession(messageTokensEst, decisionPolicy, { messages, sessionRef: session }),
-        false,
-    );
-    assert.equal(
-        compactionTelemetryPressureTokens(messageTokensEst, decisionPolicy, {
-            messages,
-            sessionRef: session,
-        }),
-        contextTokens,
-    );
-    assert.equal(
-        compactionTelemetryPressureTokens(messageTokensEst, decisionPolicy, {
-            reactivePending: true,
-            messages,
-            sessionRef: session,
-        }),
-        decisionPolicy.triggerTokens,
-    );
-});

package/src/runtime/agent/orchestrator/session/compaction-read-reset.test.mjs

@@ -1,161 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-
-import { executeBuiltinTool } from '../tools/builtin.mjs';
-import { COMPACT_TYPE_SEMANTIC } from './compact.mjs';
-import { runSessionCompaction } from './manager/compaction-runner.mjs';
-import { runPreSendCompactPass } from './pre-send-compact.mjs';
-import { resetReadStateAfterCompaction } from './read-dedup.mjs';
-
-const SUMMARY = [
-    '## Goal',
-    '- continue after compaction',
-    '',
-    '## Constraints & Preferences',
-    '- (none)',
-    '',
-    '## Progress',
-    '### Done',
-    '- old context summarized',
-    '',
-    '### In Progress',
-    '- (none)',
-    '',
-    '### Blocked',
-    '- (none)',
-    '',
-    '## Key Decisions',
-    '- (none)',
-    '',
-    '## Next Steps',
-    '- reread the working file',
-    '',
-    '## Critical Context',
-    '- active file must be readable again',
-    '',
-    '## Relevant Files',
-    '- working.txt',
-].join('\n');
-
-function fixture(t, tag) {
-    const dir = mkdtempSync(join(tmpdir(), `mixdog-compact-read-${tag}-`));
-    const file = join(dir, 'working.txt');
-    const sessionId = `compact-read-${tag}-${process.pid}-${Date.now()}`;
-    writeFileSync(file, 'alpha\nbeta\n', 'utf8');
-    t.after(() => {
-        resetReadStateAfterCompaction(sessionId);
-        rmSync(dir, { recursive: true, force: true });
-    });
-    return { dir, file, sessionId };
-}
-
-async function establishUnchangedSnapshot({ dir, file, sessionId }) {
-    const first = String(await executeBuiltinTool('read', { path: file }, dir, { sessionId }));
-    assert.match(first, /alpha/);
-    const duplicate = await executeBuiltinTool('read', { path: file }, dir, { sessionId });
-    assert.equal(duplicate, `[file unchanged: ${file.replaceAll('\\', '/')}]`);
-}
-
-function semanticProvider(name) {
-    return {
-        name,
-        async send() {
-            return { content: SUMMARY };
-        },
-    };
-}
-
-test('manual compaction starts a fresh read epoch', async (t) => {
-    const fx = fixture(t, 'manual');
-    await establishUnchangedSnapshot(fx);
-
-    const session = {
-        id: fx.sessionId,
-        provider: 'compact-read-manual',
-        model: 'fake-model',
-        contextWindow: 100_000,
-        compactBoundaryTokens: 100_000,
-        messages: [
-            { role: 'system', content: 'system rules stay exact' },
-            { role: 'user', content: 'older request about working.txt' },
-            { role: 'assistant', content: 'older answer with file details' },
-            { role: 'user', content: 'current request remains verbatim' },
-        ],
-        tools: [],
-        compaction: {
-            type: COMPACT_TYPE_SEMANTIC,
-            compactType: COMPACT_TYPE_SEMANTIC,
-            tailTurns: 1,
-        },
-    };
-    const result = await runSessionCompaction(session, {
-        mode: 'manual',
-        force: true,
-        compactType: COMPACT_TYPE_SEMANTIC,
-        provider: semanticProvider('compact-read-manual'),
-        model: 'fake-model',
-    });
-
-    assert.equal(result.changed, true);
-    const reread = String(await executeBuiltinTool('read', { path: fx.file }, fx.dir, { sessionId: fx.sessionId }));
-    assert.doesNotMatch(reread, /file unchanged/);
-    assert.match(reread, /alpha/);
-});
-
-test('automatic pre-send compaction resets reads only after transcript change', async (t) => {
-    const fx = fixture(t, 'auto');
-    await establishUnchangedSnapshot(fx);
-
-    const session = {
-        id: fx.sessionId,
-        owner: 'agent',
-        provider: 'compact-read-auto',
-        model: 'fake-model',
-        cwd: fx.dir,
-        contextWindow: 20_000,
-        compactBoundaryTokens: 20_000,
-        messages: [
-            { role: 'user', content: 'small request' },
-            { role: 'assistant', content: 'small answer' },
-        ],
-        tools: [],
-        compaction: { auto: true, tailTurns: 1 },
-    };
-    const state = {
-        provider: semanticProvider('compact-read-auto'),
-        messages: session.messages,
-        model: session.model,
-        requestTools: [],
-        sessionRef: session,
-        sessionId: fx.sessionId,
-        cwd: fx.dir,
-        opts: {},
-        signal: null,
-        iterations: 1,
-        lastUsage: null,
-        firstTurnUsage: null,
-        providerState: null,
-        reactiveOverflowRetryPending: false,
-        loopUsageMetricsTurnId: () => 'test-turn',
-        loopUsageMetricsEpoch: () => 0,
-    };
-
-    const noChange = await runPreSendCompactPass(state);
-    assert.equal(noChange.compactChanged, false);
-    const stillUnchanged = await executeBuiltinTool('read', { path: fx.file }, fx.dir, { sessionId: fx.sessionId });
-    assert.equal(stillUnchanged, `[file unchanged: ${fx.file.replaceAll('\\', '/')}]`);
-
-    session.messages.unshift(
-        { role: 'user', content: `large old request ${'context '.repeat(12_000)}` },
-        { role: 'assistant', content: `large old answer ${'detail '.repeat(12_000)}` },
-    );
-    const changed = await runPreSendCompactPass({ ...state, messages: session.messages });
-    assert.equal(changed.compactChanged, true);
-
-    const reread = String(await executeBuiltinTool('read', { path: fx.file }, fx.dir, { sessionId: fx.sessionId }));
-    assert.doesNotMatch(reread, /file unchanged/);
-    assert.match(reread, /alpha/);
-});

package/src/runtime/agent/orchestrator/session/eager-dispatch.test.mjs

@@ -1,115 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createEagerDispatcher } from './eager-dispatch.mjs';
-import {
-    _repeatFailurePatternWouldContinue,
-    _repeatFailureSig,
-} from './loop/tool-classify.mjs';
-
-function gate() {
-    let release;
-    return { promise: new Promise((resolve) => { release = resolve; }), release };
-}
-
-test('eager dispatch serializes Git mutations, file edits, and shell verification', async () => {
-    const gitGate = gate();
-    const patchGate = gate();
-    const events = [];
-    const executeToolFn = async (name) => {
-        events.push(`${name}:start`);
-        if (name === 'git') await gitGate.promise;
-        if (name === 'apply_patch') await patchGate.promise;
-        events.push(`${name}:end`);
-        return { result: 'ok', explicitSuccess: true };
-    };
-    const dispatcher = createEagerDispatcher({
-        tools: [],
-        cwd: process.cwd(),
-        sessionId: null,
-        sessionRef: {},
-        signal: null,
-        opts: {},
-        crossTurnCalls: new Map(),
-        getIterations: () => 1,
-        getNextIteration: () => 1,
-        repeatFailLimit: 3,
-        executeToolFn,
-    });
-    const calls = [
-        { id: 'git', name: 'git', arguments: { command: 'git add --all' } },
-        { id: 'patch', name: 'apply_patch', arguments: { patch: 'test' } },
-        { id: 'shell', name: 'shell', arguments: { command: 'git status' } },
-    ];
-
-    dispatcher.startEagerRun(calls, 0, new Set());
-    await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(events, ['git:start']);
-
-    gitGate.release();
-    await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(events, ['git:start', 'git:end', 'apply_patch:start']);
-
-    patchGate.release();
-    await Promise.all([...dispatcher.pending.values()].map((entry) => entry.promise));
-    assert.deepEqual(events, [
-        'git:start', 'git:end',
-        'apply_patch:start', 'apply_patch:end',
-        'shell:start', 'shell:end',
-    ]);
-});
-
-test('same-file edits serialize while different-file edits stay parallel', async () => {
-    const firstEditGate = gate();
-    const events = [];
-    const executeToolFn = async (name, args) => {
-        events.push(`start:${args.file_path}#${args.old_string}`);
-        if (args.old_string === 'a1') await firstEditGate.promise;
-        events.push(`end:${args.file_path}#${args.old_string}`);
-        return { result: 'ok', explicitSuccess: true };
-    };
-    const dispatcher = createEagerDispatcher({
-        tools: [],
-        cwd: process.cwd(),
-        sessionId: null,
-        sessionRef: {},
-        signal: null,
-        opts: {},
-        crossTurnCalls: new Map(),
-        getIterations: () => 1,
-        getNextIteration: () => 1,
-        repeatFailLimit: 3,
-        executeToolFn,
-    });
-    const calls = [
-        { id: 'e1', name: 'edit', arguments: { file_path: 'a.txt', old_string: 'a1', new_string: 'x' } },
-        { id: 'e2', name: 'edit', arguments: { file_path: 'A.TXT', old_string: 'a2', new_string: 'y' } },
-        { id: 'e3', name: 'edit', arguments: { file_path: 'b.txt', old_string: 'b1', new_string: 'z' } },
-    ];
-
-    dispatcher.startEagerRun(calls, 0, new Set());
-    await new Promise((resolve) => setImmediate(resolve));
-    // e1 runs and blocks. e2 targets the same file (case variant) and must
-    // wait. e3 targets an independent file and must run to completion in
-    // parallel with the blocked e1.
-    assert.ok(events.includes('start:a.txt#a1'));
-    assert.ok(!events.includes('start:A.TXT#a2'));
-    assert.ok(events.includes('end:b.txt#b1'));
-
-    firstEditGate.release();
-    await Promise.all([...dispatcher.pending.values()].map((entry) => entry.promise));
-    assert.ok(events.indexOf('start:A.TXT#a2') > events.indexOf('end:a.txt#a1'));
-});
-
-test('repeat failure signatures normalize paths and detect alternating cycles', () => {
-    const cwd = process.cwd();
-    const relative = _repeatFailureSig('read', { file_path: 'missing/file.txt' }, cwd);
-    const absolute = _repeatFailureSig('read', {
-        file_path: `${cwd}/missing/file.txt`,
-    }, cwd);
-    assert.equal(relative, absolute);
-
-    const other = _repeatFailureSig('read', { file_path: 'missing/other.txt' }, cwd);
-    const history = [relative, other, relative, other, relative, other];
-    assert.equal(_repeatFailurePatternWouldContinue(history, relative, 3), 2);
-    assert.equal(_repeatFailurePatternWouldContinue(history, other, 3), 0);
-});