mixdog 0.9.152 → 0.9.154

package/src/runtime/agent/orchestrator/tools/builtin/enoent-outside-project.test.mjs

@@ -1,56 +0,0 @@
-// A missing ABSOLUTE path outside the project is recovered from its OWN
-// filesystem, never from a project-wide scan: no file inside the project can
-// be the correction for /sys/block/sd*/size, and the scan is what turned three
-// such reads into 17.5s each.
-import assert from 'node:assert/strict';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-
-import { executeBuiltinTool } from '../builtin.mjs';
-
-async function withDirs(run) {
-    const project = await mkdtemp(join(tmpdir(), 'mixdog-enoent-project-'));
-    const outside = await mkdtemp(join(tmpdir(), 'mixdog-enoent-outside-'));
-    try {
-        return await run({ project, outside });
-    } finally {
-        await rm(project, { recursive: true, force: true });
-        await rm(outside, { recursive: true, force: true });
-    }
-}
-
-test('an outside absolute miss names its own nearest directory, not the project', async () => {
-    await withDirs(async ({ project, outside }) => {
-        await mkdir(join(project, 'src'), { recursive: true });
-        await writeFile(join(project, 'src', 'size'), 'decoy\n');
-        await mkdir(join(outside, 'block'), { recursive: true });
-        await writeFile(join(outside, 'block', 'sda'), 'disk\n');
-
-        const out = String(await executeBuiltinTool('read', {
-            file_path: join(outside, 'block', 'sd*', 'size'),
-        }, project));
-
-        assert.match(out, /\[path absent\]/);
-        assert.match(out, /nearest existing directory/);
-        assert.match(out, /"sda"/);
-        // The decoy inside the project must never be offered for an outside path.
-        assert.doesNotMatch(out, /same filename exists at/);
-        assert.doesNotMatch(out, /project scan/);
-    });
-});
-
-test('a miss INSIDE the project keeps its same-name recovery', async () => {
-    await withDirs(async ({ project }) => {
-        await mkdir(join(project, 'src', 'tools'), { recursive: true });
-        await writeFile(join(project, 'src', 'tools', 'widget.mjs'), 'export const widget = 1;\n');
-
-        const out = String(await executeBuiltinTool('read', {
-            file_path: join(project, 'lib', 'widget.mjs'),
-        }, project));
-
-        assert.match(out, /widget\.mjs/);
-        assert.doesNotMatch(out, /nearest existing directory/);
-    });
-});

package/src/runtime/agent/orchestrator/tools/builtin/find-search-budget.test.mjs

@@ -1,103 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { _searchRemainingMsForTest } from './native-search-client.mjs';
-import { executeFuzzyFindTool } from './list-tool.mjs';
-import { runWithLocalSearchTelemetry } from './local-search-telemetry.mjs';
-
-test('server setup is not charged to the search budget', () => {
-  const deadline = 1_500;
-  const startedAt = 0;
-  // 1000ms of the elapsed wall time was server startup: the search itself has
-  // not begun, so the full deadline must still be available.
-  assert.equal(_searchRemainingMsForTest(deadline, startedAt, 1_000, 1_000), 1_500);
-  // Once searching starts, elapsed search time does reduce the budget.
-  assert.equal(_searchRemainingMsForTest(deadline, startedAt, 1_000, 1_400), 1_100);
-  // No setup recorded means the old behaviour: every elapsed ms counts.
-  assert.equal(_searchRemainingMsForTest(deadline, startedAt, 0, 400), 1_100);
-  // The budget never goes to zero or negative, which would break timers.
-  assert.equal(_searchRemainingMsForTest(deadline, startedAt, 0, 9_000), 1);
-});
-
-test('a fuzzy deadline returns promptly without starting another filesystem walk', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-find-budget-'));
-  try {
-    writeFileSync(join(root, 'anchor.txt'), 'anchor\n');
-    const timeout = Object.assign(
-      new Error('native fuzzy search timed out after 1500ms.'),
-      { code: 'NATIVE_SEARCH_TIMEOUT' },
-    );
-    const telemetry = {};
-    const out = String(await runWithLocalSearchTelemetry(telemetry, () => executeFuzzyFindTool(
-      { query: 'needle-that-never-ranks', path: '.', head_limit: 5 },
-      root,
-      {
-        __tryServeFuzzySearch: async () => { throw timeout; },
-      },
-    )));
-    assert.ok(!/^Error[\s:[]/.test(out.trimStart()), `must not surface as a tool failure:\n${out}`);
-    assert.match(out, /no fuzzy match yet/);
-    assert.match(out, /inventory is still building/);
-    assert.equal(telemetry.native_fuzzy_partials, 1);
-    assert.equal(telemetry.native_fuzzy_targeted_hits, undefined);
-    assert.equal(telemetry.native_fuzzy_errors, undefined);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('a served partial still reports its ranked matches', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-find-partial-'));
-  try {
-    const out = String(await executeFuzzyFindTool(
-      { query: 'alpha', path: '.', head_limit: 5 },
-      root,
-      {
-        __tryServeFuzzySearch: async () => ({
-          matches: ['src/alpha.ts'],
-          hasMore: false,
-          totalMatches: 1,
-          totalSeen: 1,
-          complete: false,
-          partial: true,
-          timeout: true,
-          scanErrors: 0,
-          walkErrorDetails: [],
-        }),
-      },
-    ));
-    assert.match(out, /src\/alpha\.ts/);
-    assert.ok(!/^Error[\s:[]/.test(out.trimStart()), `partials are results, not failures:\n${out}`);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('an empty served partial is returned without another filesystem walk', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-find-empty-partial-'));
-  try {
-    const out = String(await executeFuzzyFindTool(
-      { query: 'missing', path: '.', head_limit: 5 },
-      root,
-      {
-        __tryServeFuzzySearch: async () => ({
-          matches: [],
-          hasMore: false,
-          totalMatches: 0,
-          totalSeen: 1,
-          complete: false,
-          partial: true,
-          timeout: true,
-          scanErrors: 0,
-          walkErrorDetails: [],
-        }),
-      },
-    ));
-    assert.match(out, /inventory is still building/);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});

package/src/runtime/agent/orchestrator/tools/builtin/git-command-policy.test.mjs

@@ -1,30 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { _isGitMutationTool, _isMutationTool } from '../../session/loop/tool-classify.mjs';
-import { gitCommandMutates } from './git-command-policy.mjs';
-
-test('git mutation policy is shared by orchestration and evidence projection', () => {
-    for (const command of ['git status', 'git log -5', 'git fsck --full', 'git clean -n', 'git config get user.name']) {
-        assert.equal(gitCommandMutates({ command }), false, command);
-        assert.equal(_isMutationTool('git', { command }), false, command);
-        assert.equal(_isGitMutationTool('git', { command }), false, command);
-    }
-    for (const command of [
-        'git add --all',
-        'git commit -m test',
-        'git prune --expire=now',
-        'git reflog delete HEAD@{1}',
-        'git fsck --lost-found',
-        'git config --unset user.name',
-        'git config unset user.name',
-    ]) {
-        assert.equal(gitCommandMutates({ command }), true, command);
-        assert.equal(_isMutationTool('git', { command }), true, command);
-        assert.equal(_isGitMutationTool('git', { command }), true, command);
-    }
-    assert.equal(gitCommandMutates({ command: 'git status && git clean -fd' }), true);
-    const stage = { diff_id: 'diff_test', change_ids: ['chg_test'] };
-    assert.equal(_isMutationTool('git_stage', stage), true);
-    assert.equal(_isGitMutationTool('git_stage', stage), true);
-    assert.equal(_isMutationTool('apply_patch', {}), true);
-});

package/src/runtime/agent/orchestrator/tools/builtin/git-command-tool.test.mjs

@@ -1,390 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import test from 'node:test';
-import {
-    executeGitStageTool,
-    executeGitTool,
-    GIT_STAGE_TOOL_DEF,
-    GIT_TOOL_DEF,
-    _gitCommandInternals,
-} from './git-command-tool.mjs';
-import { commandHasShellSyntax, gitCommandMutates } from './git-command-policy.mjs';
-
-function parseOk(result) {
-    assert.doesNotMatch(String(result), /^Error:/, String(result));
-    const parsed = JSON.parse(String(result));
-    assert.equal(parsed.ok, true);
-    return parsed;
-}
-
-function quote(value) {
-    return `"${String(value).replaceAll('"', '\\"')}"`;
-}
-
-async function git(repo, command, options = {}) {
-    return executeGitTool({ command: `git -C ${quote(repo)} ${command}`, ...options }, repo);
-}
-
-test('git command tool preserves shell syntax, compacts output, and gates destructive commands', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-command-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const repo = join(root, 'repo');
-
-    assert.equal(parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root)).summary, 'initialized');
-    parseOk(await git(repo, 'config user.name "Mixdog Test"'));
-    parseOk(await git(repo, 'config user.email mixdog@example.invalid'));
-    assert.match(String(await git(repo, 'config --global user.name')), /outside the local repository scope/);
-    assert.match(String(await git(repo, 'config --system user.name')), /outside the local repository scope/);
-    assert.match(String(await git(repo, 'config --file ..\/outside user.name')), /outside the local repository scope/);
-    assert.match(String(await git(repo, 'config -f..\/outside user.name')), /outside the local repository scope/);
-    assert.equal(
-        _gitCommandInternals.creationTarget(_gitCommandInternals.parseCommand(`git clone origin ${quote(join(root, 'target'))}`, root)),
-        join(root, 'target'),
-    );
-
-    writeFileSync(join(repo, 'base.txt'), 'base\n');
-    const staged = parseOk(await git(repo, 'add --all'));
-    assert.equal(staged.summary, 'staged');
-    assert.equal(staged.status.after.staged, 1);
-    const committed = parseOk(await git(repo, 'commit -m base'));
-    assert.match(committed.summary, /^committed(?: [0-9a-f]+)?$/);
-    assert.equal(committed.output, undefined);
-    const base = parseOk(await git(repo, 'log', { output_limit: 1 })).commits[0].oid;
-    assert.match(JSON.stringify(parseOk(await git(repo, 'show-ref'))), /refs\/heads\//);
-    assert.match(JSON.stringify(parseOk(await git(repo, 'count-objects -v'))), /count:/);
-    parseOk(await git(repo, 'check-ref-format refs/heads/test'));
-    assert.match(String(await git(repo, 'archive HEAD')), /^Error: git archive requires -o\/--output/);
-    parseOk(await git(repo, 'prune --expire=now'));
-    const shown = parseOk(await git(repo, `show ${base}`, { output_limit: 5 }));
-    assert.equal(shown.commit.oid, base);
-    assert.deepEqual(shown.diff.files, ['base.txt']);
-
-    writeFileSync(join(repo, 'secret.txt'), 'secret[lost-object]\n');
-    parseOk(await git(repo, 'add -- secret.txt'));
-    parseOk(await git(repo, 'commit -m secret -m "Recovery context" -m "Signed-off-by: Test <test@example.invalid>"'));
-    const secretLog = parseOk(await git(repo, 'log', { output_limit: 1 })).commits[0];
-    const secretCommit = secretLog.oid;
-    assert.deepEqual(secretLog.body, ['Recovery context']);
-    const batchShow = parseOk(await git(repo, `show ${base} ${secretCommit}`, { output_limit: 5 })).commits;
-    assert.deepEqual(batchShow.map((row) => row.commit.oid), [base, secretCommit]);
-
-    parseOk(await git(repo, `reset --hard ${base}`));
-    const fsck = parseOk(await git(repo, 'fsck --full --unreachable --no-reflogs', { output_limit: 20 }));
-    assert.match(JSON.stringify(fsck), new RegExp(secretCommit));
-
-    const reflog = parseOk(await git(repo, 'reflog --all', { output_limit: 20 }));
-    assert.ok(reflog.entries.some((row) => row.oid === secretCommit));
-    const selectors = reflog.entries.map((row) => row.selector).filter((value, index, all) => all.indexOf(value) === index).slice(0, 2);
-    const deleteCommand = `reflog delete --rewrite ${selectors.map(quote).join(' ')}`;
-    parseOk(await git(repo, deleteCommand));
-    // Dry-run previews mutate nothing and still return a normal result.
-    parseOk(await git(repo, 'reflog expire --dry-run --verbose --expire-unreachable=now --all'));
-    parseOk(await git(repo, 'prune --dry-run'));
-    parseOk(await git(repo, 'clean -nd'));
-    parseOk(await git(repo, 'reflog expire --expire-unreachable=now --all --rewrite'));
-    parseOk(await git(repo, 'gc --prune=now'));
-
-    renameSync(join(repo, 'base.txt'), join(repo, 'renamed.txt'));
-    parseOk(await git(repo, 'add --all'));
-    const renameDiff = parseOk(await git(repo, 'diff --cached', { output_limit: 20 }));
-    const renameText = renameDiff.patch || renameDiff.output;
-    assert.match(renameText, /rename from base\.txt/);
-    assert.match(renameText, /rename to renamed\.txt/);
-    parseOk(await git(repo, 'reset --hard HEAD'));
-
-    writeFileSync(join(repo, 'base.txt'), `${Array.from({ length: 120 }, (_, i) => `changed-${i}`).join('\n')}\n`);
-    const rawDiff = spawnSync('git', ['-C', repo, 'diff', '--', 'base.txt'], { encoding: 'utf8' }).stdout;
-    const diff = parseOk(await git(repo, 'diff -- base.txt', { output_limit: 5 }));
-    assert.match(diff.patch, /-base/);
-    assert.match(diff.patch, /\+changed-0/);
-    assert.equal(diff.truncated, true);
-    assert.ok(JSON.stringify(diff).length < rawDiff.length / 2);
-    parseOk(await git(repo, 'restore -- base.txt'));
-    assert.equal(parseOk(await git(repo, 'status')).clean, true);
-
-    const bare = join(root, 'remote.git');
-    parseOk(await executeGitTool({ command: `git init --bare ${quote(bare)}` }, root));
-    parseOk(await git(repo, `remote add origin ${quote(bare)}`));
-    assert.equal(parseOk(await git(repo, 'remote get-url origin')).output, bare);
-    const pushed = parseOk(await git(repo, 'push --set-upstream origin HEAD'));
-    assert.match(pushed.summary, /^pushed/);
-    assert.ok(!JSON.stringify(pushed.output || []).includes('Enumerating objects:'));
-
-    const cloned = join(root, 'clone');
-    assert.equal(parseOk(await executeGitTool({ command: `git clone ${quote(bare)} ${quote(cloned)}` }, root)).summary, 'cloned');
-    assert.equal(parseOk(await git(cloned, 'pull --rebase')).summary, 'up-to-date');
-    assert.equal(parseOk(await git(cloned, 'log', { output_limit: 5 })).commits.length, 1);
-
-    for (let i = 0; i < 11; i++) {
-        const extra = spawnSync('git', ['-C', repo, 'commit', '--allow-empty', '-m', `extra-${i}`], { encoding: 'utf8' });
-        assert.equal(extra.status, 0, extra.stderr);
-    }
-    assert.equal(parseOk(await git(repo, 'log')).commits.length, 10);
-    assert.ok(parseOk(await git(repo, 'log --all', { output_limit: 20 })).commits.length >= 12);
-
-    for (const name of ['one.tmp', 'two.tmp', 'three.tmp']) writeFileSync(join(repo, name), name);
-    const cappedStatus = parseOk(await git(repo, 'status', { output_limit: 2 }));
-    assert.equal(cappedStatus.changes.length, 2);
-    assert.equal(cappedStatus.omitted, 1);
-    for (const name of ['one.tmp', 'two.tmp', 'three.tmp']) rmSync(join(repo, name));
-
-    const worktree = join(root, 'worktree');
-    parseOk(await git(repo, `worktree add -b topic ${quote(worktree)} HEAD`));
-    assert.match(JSON.stringify(parseOk(await git(repo, 'worktree list --porcelain'))), /topic/);
-    assert.match(JSON.stringify(parseOk(await git(repo, 'branch --list'))), /topic/);
-
-    assert.match(String(await executeGitTool({ command: 'git status && git log' }, root)), /^Error: git command must not contain shell operators/);
-});
-
-test('git tool answers semantic exits and keeps literal operator characters', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-semantic-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const repo = join(root, 'repo');
-    parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
-    parseOk(await git(repo, 'config user.name "Mixdog Test"'));
-    parseOk(await git(repo, 'config user.email mixdog@example.invalid'));
-    writeFileSync(join(repo, 'base.txt'), 'base\n');
-    parseOk(await git(repo, 'add --all'));
-    parseOk(await git(repo, 'commit -m base'));
-
-    // A separator inside one token is argument text, not a pipeline.
-    assert.match(JSON.stringify(parseOk(await git(repo, 'log --format=%h|%s -n 1'))), /\|base/);
-    assert.equal(commandHasShellSyntax('git log -- ":(exclude)node_modules"'), false);
-    assert.equal(commandHasShellSyntax('git log --format=$(whoami)'), true);
-    assert.match(String(await git(repo, 'log | head')), /^Error: git command must not contain shell operators/);
-
-    // grep exit 1 is "no match", not a failure.
-    assert.equal(parseOk(await git(repo, 'grep -n base -- base.txt')).matched, true);
-    assert.equal(parseOk(await git(repo, 'grep -n mixdog-absent-token')).matched, false);
-
-    // diff reports through the exit code for --quiet and --check.
-    assert.equal(parseOk(await git(repo, 'diff --quiet')).changed, false);
-    assert.equal(parseOk(await git(repo, 'diff --check')).problems, false);
-    assert.equal(parseOk(await git(repo, 'reflog exists HEAD')).exists, true);
-    assert.equal(parseOk(await git(repo, 'reflog exists refs/heads/missing')).exists, false);
-    assert.equal(parseOk(await git(repo, 'show-ref --verify --quiet refs/heads/missing')).exists, false);
-    assert.equal(parseOk(await git(repo, 'rev-parse --verify --quiet refs/heads/missing')).exists, false);
-    assert.equal(parseOk(await git(repo, 'merge-base --is-ancestor HEAD HEAD')).ancestor, true);
-    writeFileSync(join(repo, 'base.txt'), 'base\ntrailing   \n');
-    assert.equal(parseOk(await git(repo, 'diff --quiet')).changed, true);
-    const check = parseOk(await git(repo, 'diff --check'));
-    assert.equal(check.problems, true);
-    assert.match(JSON.stringify(check), /trailing whitespace/);
-});
-
-test('git preserves non-patch diff and history presentations', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-presentations-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const repo = join(root, 'repo');
-    parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
-    parseOk(await git(repo, 'config user.name "Mixdog Test"'));
-    parseOk(await git(repo, 'config user.email mixdog@example.invalid'));
-    writeFileSync(join(repo, 'base.txt'), 'base\n');
-    parseOk(await git(repo, 'add -- base.txt'));
-    parseOk(await git(repo, 'commit -m base'));
-    writeFileSync(join(repo, 'base.txt'), 'changed\n');
-
-    for (const command of [
-        'diff --stat -- base.txt',
-        'diff --raw -- base.txt',
-        'diff --numstat -- base.txt',
-        'diff --name-only -- base.txt',
-        'diff --name-status -- base.txt',
-        'diff-files -- base.txt',
-        'diff-index HEAD -- base.txt',
-    ]) {
-        const result = parseOk(await git(repo, command));
-        assert.match(JSON.stringify(result), /base\.txt/, command);
-    }
-
-    parseOk(await git(repo, 'add -- base.txt'));
-    parseOk(await git(repo, 'commit -m changed'));
-    assert.match(JSON.stringify(parseOk(await git(repo, 'diff-tree --no-commit-id HEAD^ HEAD -- base.txt'))), /base\.txt/);
-    for (const command of ['log --stat -1', 'log --raw -1', 'log -p -1', 'show --raw HEAD']) {
-        const result = parseOk(await git(repo, command));
-        assert.equal(result.commits, undefined, command);
-        assert.match(JSON.stringify(result), /base\.txt/, command);
-    }
-    assert.match(JSON.stringify(parseOk(await git(repo, 'reflog list'))), /refs\/heads\//);
-});
-
-test('git policy distinguishes probes from output and ref mutations', () => {
-    for (const command of [
-        'git --version',
-        'git remote -v',
-        'git reflog exists HEAD',
-        'git symbolic-ref HEAD',
-    ]) {
-        assert.equal(gitCommandMutates({ command }), false, command);
-    }
-    for (const command of [
-        'git remote -v update',
-        'git reflog delete HEAD@{0}',
-        'git symbolic-ref --delete HEAD',
-        'git diff --output=outside.patch',
-    ]) {
-        assert.equal(gitCommandMutates({ command }), true, command);
-    }
-});
-
-test('git plans patch, plumbing, and custom history output without over-reading', () => {
-    const plan = (operation, args, limit = 7) => _gitCommandInternals.prepare({ operation, args }, limit);
-    assert.equal(plan('diff', []).format, 'diff');
-    assert.equal(plan('diff', ['--stat']).format, 'text');
-    assert.equal(plan('diff-files', []).format, 'text');
-    assert.equal(plan('diff-files', ['-p']).format, 'diff');
-    assert.deepEqual(plan('log', ['--oneline']).argv.slice(0, 3), ['log', '-n7', '--no-color']);
-    assert.deepEqual(plan('log', ['--stat']).argv.slice(0, 3), ['log', '-n7', '--no-color']);
-    assert.equal(plan('reflog', ['list']).argv[0], 'reflog');
-    assert.notEqual(plan('reflog', ['list']).argv[1], 'show');
-});
-
-test('git failure detail folds progress frames and keeps the fatal tail', () => {
-    const { failureText, foldProgressFrames } = _gitCommandInternals;
-    assert.equal(
-        foldProgressFrames('Updating files:   1% (5/49152)\rUpdating files:  99% (48000/49152)\nfatal: boom'),
-        'Updating files:  99% (48000/49152)\nfatal: boom',
-    );
-    const noisy = [...Array.from({ length: 60 }, (_, i) => `line-${i}`), 'fatal: boom'].join('\n');
-    const text = failureText(noisy, 5);
-    assert.match(text, /^…\[56 earlier lines omitted\]\n/);
-    assert.match(text, /fatal: boom$/);
-});
-
-test('git and deferred git_stage expose separate compact contracts', () => {
-    const properties = GIT_TOOL_DEF.inputSchema.properties;
-    assert.deepEqual(Object.keys(properties), ['command', 'output_limit']);
-    assert.deepEqual(GIT_TOOL_DEF.inputSchema.required, ['command']);
-    assert.equal(properties.command.minLength, undefined);
-    assert.equal(properties.output_limit.maximum, 200);
-    const stageProperties = GIT_STAGE_TOOL_DEF.inputSchema.properties;
-    assert.deepEqual(Object.keys(stageProperties), ['diff_id', 'change_ids', 'output_limit']);
-    assert.deepEqual(GIT_STAGE_TOOL_DEF.inputSchema.required, ['diff_id', 'change_ids']);
-    assert.equal(stageProperties.change_ids.anyOf[1].maxItems, 50);
-    assert.equal(stageProperties.output_limit.maximum, 200);
-    assert.equal(GIT_STAGE_TOOL_DEF.annotations.destructiveHint, true);
-    assert.doesNotMatch(GIT_TOOL_DEF.description, /confirm/i);
-    assert.match(GIT_TOOL_DEF.description, /Owns repository state, diffs, history, and mutations/i);
-    assert.match(GIT_TOOL_DEF.description, /Use diff for known targets; otherwise use status alone to discover targets/i);
-    assert.match(GIT_TOOL_DEF.description, /Run one Git command directly, without a shell/i);
-    assert.match(GIT_TOOL_DEF.description, /repository mutations are serialized/i);
-});
-
-test('git clamps oversized output requests to 200 lines', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-output-cap-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const repo = join(root, 'repo');
-    parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
-    parseOk(await git(repo, 'config user.name "Mixdog Test"'));
-    parseOk(await git(repo, 'config user.email mixdog@example.invalid'));
-    writeFileSync(
-        join(repo, 'large.txt'),
-        `${Array.from({ length: 250 }, (_, index) => `line-${index}`).join('\n')}\n`,
-    );
-    parseOk(await git(repo, 'add -- large.txt'));
-    parseOk(await git(repo, 'commit -m large'));
-    const shown = parseOk(await git(repo, 'show HEAD:large.txt', { output_limit: 500 }));
-    assert.equal(shown.lines.length, 200);
-    assert.equal(shown.omitted, 50);
-});
-
-// `git --version` is how a caller checks whether git exists at all; rejecting
-// it as an "unsupported subcommand" turned the probe into a dead turn.
-test('git availability probes answer instead of erroring', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-probe-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const probe = String(await executeGitTool({ command: 'git --version' }, root));
-    assert.doesNotMatch(probe, /unsupported git subcommand/);
-    assert.match(probe, /git version/i);
-});
-
-// git dispatches any `git-*` executable on PATH as a subcommand, so a finite
-// allowlist could only ever go stale. An unknown name must reach git itself —
-// whatever git answers is actionable, an "unsupported subcommand" refusal was
-// not, and the shell tool ran the same command anyway.
-test('git forwards unknown subcommands to git instead of pre-rejecting them', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-open-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const repo = join(root, 'repo');
-    parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
-    for (const command of ['git filter-repo --version', 'git fast-export --no-data HEAD']) {
-        assert.doesNotMatch(String(await executeGitTool({ command }, repo)), /unsupported git subcommand/);
-    }
-});
-
-// The only commands this tool cannot host are the ones that never return: a
-// GUI blocks on a window nobody can click, and a resident server burns the
-// full timeout by working correctly. The server case is a routing hint, not a
-// verdict — shell can hold it as a background task.
-test('git refuses only non-returning subcommands and routes servers to shell', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-deny-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const repo = join(root, 'repo');
-    parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
-    assert.match(String(await executeGitTool({ command: 'git mergetool' }, repo)), /interactive GUI/i);
-    assert.match(String(await executeGitTool({ command: 'git daemon --export-all' }, repo)), /shell tool/i);
-    assert.match(String(await executeGitTool({ command: 'git fast-export --help' }, repo)), /external viewer/i);
-    assert.match(String(await executeGitTool({ command: 'git help fast-export' }, repo)), /external viewer/i);
-    assert.match(String(await executeGitTool({ command: 'git' }, repo)), /requires a subcommand/i);
-});
-
-test('git stages selected change IDs and rejects stale diff snapshots without touching the index', async (t) => {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-stage-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const repo = join(root, 'repo');
-    parseOk(await git(root, `init ${quote(repo)}`));
-    parseOk(await git(repo, 'config user.email test@example.com'));
-    parseOk(await git(repo, 'config user.name Test'));
-    writeFileSync(join(repo, 'sample.txt'), `${Array.from({ length: 12 }, (_, index) => `line-${index + 1}`).join('\n')}\n`);
-    parseOk(await git(repo, 'add sample.txt'));
-    parseOk(await git(repo, 'commit -m base'));
-
-    const changed = Array.from({ length: 12 }, (_, index) => `line-${index + 1}`);
-    changed[2] = 'selected-change';
-    changed[8] = 'remaining-change';
-    writeFileSync(join(repo, 'sample.txt'), `${changed.join('\n')}\n`);
-
-    const scopedDiff = parseOk(await git(repo, 'diff -- sample.txt', { output_limit: 100 }));
-    assert.equal(scopedDiff.diff_id, undefined);
-    assert.equal(scopedDiff.changes, undefined);
-    const diff = parseOk(await git(repo, 'diff', { output_limit: 100 }));
-    assert.match(diff.diff_id, /^diff_[0-9a-f]{20}$/);
-    assert.equal(diff.changes.length, 2);
-    const selected = diff.changes.find((change) => change.preview.some((line) => line.includes('selected-change')));
-    assert.ok(selected);
-    const wrongScope = parseOk(await executeGitStageTool({
-        diff_id: diff.diff_id,
-        change_ids: [selected.id],
-    }, root));
-    assert.equal(wrongScope.staged, false);
-    assert.equal(wrongScope.reason, 'scope_mismatch');
-    assert.equal(spawnSync('git', ['-C', repo, 'diff', '--cached'], { encoding: 'utf8' }).stdout, '');
-    const staged = parseOk(await executeGitStageTool({
-        diff_id: diff.diff_id,
-        change_ids: [selected.id],
-    }, repo));
-    assert.equal(staged.staged, true);
-    assert.deepEqual(staged.change_ids, [selected.id]);
-
-    const cached = spawnSync('git', ['-C', repo, 'diff', '--cached'], { encoding: 'utf8' }).stdout;
-    const unstaged = spawnSync('git', ['-C', repo, 'diff'], { encoding: 'utf8' }).stdout;
-    assert.match(cached, /selected-change/);
-    assert.doesNotMatch(cached, /remaining-change/);
-    assert.match(unstaged, /remaining-change/);
-    assert.doesNotMatch(unstaged, /selected-change/);
-
-    const next = parseOk(await git(repo, 'diff', { output_limit: 100 }));
-    changed[8] = 'changed-after-diff';
-    writeFileSync(join(repo, 'sample.txt'), `${changed.join('\n')}\n`);
-    const stale = parseOk(await executeGitStageTool({
-        diff_id: next.diff_id,
-        change_ids: next.changes[0].id,
-    }, repo));
-    assert.equal(stale.staged, false);
-    assert.equal(stale.reason, 'stale_diff');
-    const cachedAfterStale = spawnSync('git', ['-C', repo, 'diff', '--cached'], { encoding: 'utf8' }).stdout;
-    assert.equal(cachedAfterStale, cached);
-});

package/src/runtime/agent/orchestrator/tools/builtin/git-repo-rw-lock.test.mjs

@@ -1,83 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { withGitRepoReadLock, withGitRepoWriteLock } from './git-repo-rw-lock.mjs';
-
-function gate() {
-    let release;
-    return { promise: new Promise((resolve) => { release = resolve; }), release };
-}
-
-test('git repo lock shares reads, excludes writes, and does not starve a queued writer', async () => {
-    const repo = `repo-${Date.now()}-${Math.random()}`;
-    const firstReads = gate();
-    const writerGate = gate();
-    const events = [];
-    const read = (name, wait) => withGitRepoReadLock(repo, async () => {
-        events.push(`${name}:start`);
-        await wait.promise;
-        events.push(`${name}:end`);
-    });
-    const r1 = read('r1', firstReads);
-    const r2 = read('r2', firstReads);
-    await Promise.resolve();
-    assert.deepEqual(events, ['r1:start', 'r2:start']);
-
-    const writer = withGitRepoWriteLock(repo, async () => {
-        events.push('w:start');
-        await writerGate.promise;
-        events.push('w:end');
-    });
-    const lateRead = withGitRepoReadLock(repo, async () => {
-        events.push('r3:start');
-        events.push('r3:end');
-    });
-    await Promise.resolve();
-    assert.deepEqual(events, ['r1:start', 'r2:start']);
-
-    firstReads.release();
-    await Promise.all([r1, r2]);
-    await Promise.resolve();
-    assert.equal(events.at(-1), 'w:start');
-    assert.ok(!events.includes('r3:start'));
-
-    writerGate.release();
-    await writer;
-    await lateRead;
-    assert.deepEqual(events.slice(-3), ['w:end', 'r3:start', 'r3:end']);
-});
-
-test('git repo writers on different repositories run in parallel', async () => {
-    const hold = gate();
-    const events = [];
-    const first = withGitRepoWriteLock('repo-a', async () => {
-        events.push('a');
-        await hold.promise;
-    });
-    const second = withGitRepoWriteLock('repo-b', async () => {
-        events.push('b');
-        await hold.promise;
-    });
-    await Promise.resolve();
-    assert.deepEqual(events.sort(), ['a', 'b']);
-    hold.release();
-    await Promise.all([first, second]);
-});
-
-test('a queued git repo lock aborts without running or blocking later work', async () => {
-    const repo = `repo-abort-${Date.now()}-${Math.random()}`;
-    const hold = gate();
-    const writer = withGitRepoWriteLock(repo, () => hold.promise);
-    await Promise.resolve();
-
-    const controller = new AbortController();
-    let ran = false;
-    const queued = withGitRepoReadLock(repo, async () => { ran = true; }, { signal: controller.signal });
-    controller.abort();
-    await assert.rejects(queued, /abort/i);
-    assert.equal(ran, false);
-
-    hold.release();
-    await writer;
-    await withGitRepoReadLock(repo, async () => { ran = true; });
-    assert.equal(ran, true);
-});