mixdog 0.9.132 → 0.9.133

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.132",
+  "version": "0.9.133",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/runtime/agent/orchestrator/session/agent-loop.mjs

@@ -22,7 +22,6 @@ import { isInvalidToolArgsMarker, formatInvalidToolArgsResult } from '../provide
 import {
     _stripMcpPrefix,
     _isReadTool,
-    _isMutationTool,
     _isScopedCacheableTool,
     _isShellTool,
     _intraTurnSig,
@@ -659,7 +658,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         });
         const _providerMessages = _evidenceProjection.messages;
         if (_evidenceProjection.stats.reusedRows > 0
-            || _evidenceProjection.stats.exactResultRefs > 0) {
+            || _evidenceProjection.stats.exactResultRefs > 0
+            || _evidenceProjection.stats.pathAliases > 0) {
             try {
                 const _evidencePayload = {
                     shadow: _evidenceUnionShadow,
@@ -671,6 +671,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                     changed_tool_results: _evidenceProjection.stats.changedToolResults,
                     exact_result_refs: _evidenceProjection.stats.exactResultRefs,
                     exact_result_bytes_saved: _evidenceProjection.stats.exactResultBytesSaved,
+                    path_facts: _evidenceProjection.stats.pathFacts,
+                    path_aliases: _evidenceProjection.stats.pathAliases,
+                    reused_path_facts: _evidenceProjection.stats.reusedPathFacts,
+                    path_alias_bytes_saved: _evidenceProjection.stats.pathAliasBytesSaved,
                 };
                 appendAgentTrace({
                     sessionId,

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

@@ -1,8 +1,8 @@
 // Eager tool-dispatch controller, extracted from agent-loop.mjs. Owns the
 // per-turn pending promise map, the intra-turn in-flight signature set, and
 // the mutation epoch. Every valid call dispatches while the provider is still
-// streaming. Calls execute in parallel except that shell after apply_patch
-// waits for every earlier patch in the turn and runs only if all succeeded;
+// streaming. Calls execute in parallel except that repository-wide Git writes
+// serialize against file edits, while shell waits for every earlier mutation;
 // results are collected later in call order.
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { classifyResultKind } from './result-classification.mjs';
@@ -11,6 +11,7 @@ import {
     _intraTurnSig,
     _argShapeSig,
     _isEditTool,
+    _isGitMutationTool,
     _isMutationTool,
     _isReadTool,
     _isScopedCacheableTool,
@@ -46,6 +47,9 @@ export function createEagerDispatcher({
         // Exact-string edits are single-replacement calls. Serialize them so
         // multiple edits to one file in the same model turn observe prior writes.
         let editBarrier = Promise.resolve();
+        // Git mutations have repository-wide effects. They wait for earlier
+        // file edits, and later edits/shell verification wait for them.
+        let gitMutationBarrier = Promise.resolve();
         // Streaming-time intra-turn dedup. When the LLM emits two
         // tool_use blocks with identical (name, args) signatures in
         // sequence, the provider's onToolCall fires for both BEFORE
@@ -131,19 +135,23 @@ export function createEagerDispatcher({
                 localSearchTelemetry: {},
                 resultTelemetry: {},
             };
-            const precedingPatches = _isShellTool(call.name) ? patchBarrier : null;
+            const gitMutation = _isGitMutationTool(call.name, call.arguments);
+            const mutation = _isMutationTool(call.name, call.arguments);
+            const precedingPatches = (_isShellTool(call.name) || gitMutation) ? patchBarrier : null;
+            const precedingGitMutation = (_isShellTool(call.name) || mutation) ? gitMutationBarrier : null;
             const precedingEdits = _isEditTool(call.name) ? editBarrier : null;
             if (_dedupEligible) _eagerInFlightSigs.set(_sig, call.id);
             entry.promise = (async () => {
                 try {
                     if (precedingEdits) await precedingEdits;
+                    if (precedingGitMutation) await precedingGitMutation;
                     if (precedingPatches) {
                         const patchState = await precedingPatches;
                         if (patchState.failedPatchIds.length > 0) {
                             return {
                                 ok: true,
                                 skipped: true,
-                                value: `[patch-dependency-guard] \`${call.name}\` skipped because earlier file-edit call(s) failed: ${patchState.failedPatchIds.join(', ')}; no verification ran.`,
+                                value: `[mutation-dependency-guard] \`${call.name}\` skipped because earlier mutation call(s) failed: ${patchState.failedPatchIds.join(', ')}; no verification ran.`,
                             };
                         }
                     }
@@ -215,7 +223,7 @@ export function createEagerDispatcher({
             if (_isEditTool(call.name)) {
                 editBarrier = entry.promise.then(() => undefined, () => undefined);
             }
-            if (_isMutationTool(call.name)) {
+            if (_isMutationTool(call.name, call.arguments)) {
                 const precedingPatchState = patchBarrier;
                 const currentPatch = entry.promise;
                 patchBarrier = Promise.all([precedingPatchState, currentPatch]).then(([state, settled]) => ({
@@ -224,6 +232,9 @@ export function createEagerDispatcher({
                         : state.failedPatchIds,
                 }));
             }
+            if (gitMutation) {
+                gitMutationBarrier = entry.promise.then(() => undefined, () => undefined);
+            }
             return entry;
         };
         const startEagerRun = (calls, startIndex, dupSet) => {

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

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createEagerDispatcher } from './eager-dispatch.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',
+    ]);
+});

package/src/runtime/agent/orchestrator/session/evidence-union.mjs

@@ -5,10 +5,10 @@
  * their toolCallId but omit exact file lines already visible in an earlier
  * result, replacing them with references to the earlier tool call and source
  * location. Exact repeated list/glob/find results use a whole-result reference.
- * Any apply_patch/shell batch starts a fresh evidence epoch.
+ * Any file, repository, or shell mutation starts a fresh evidence epoch.
  */
 
-import { tokenizeDirectArgv } from '../tools/builtin/shell-direct-exe.mjs';
+import { gitCommandMutates } from '../tools/builtin/git-command-policy.mjs';
 
 const EXACT_RESULT_TOOLS = new Set(['find', 'find_files', 'glob', 'list']);
 
@@ -156,70 +156,9 @@ function evidenceKey(row) {
     return `${row.path}\0${row.line}\0${row.content}`;
 }
 
-const READ_ONLY_GIT_COMMANDS = new Set([
-    'blame', 'cat-file', 'check-attr', 'check-ignore', 'check-ref-format',
-    'cherry', 'count-objects', 'describe', 'diff', 'diff-files', 'diff-index',
-    'diff-tree', 'for-each-ref', 'fsck', 'grep', 'help', 'log', 'ls-files',
-    'ls-remote', 'ls-tree', 'merge-base', 'merge-tree', 'name-rev',
-    'range-diff', 'rev-list', 'rev-parse', 'shortlog', 'show', 'show-branch',
-    'show-ref', 'status', 'verify-commit', 'verify-pack', 'verify-tag',
-    'whatchanged',
-]);
-
-function parsedGitCommand(command) {
-    const tokens = tokenizeDirectArgv(command);
-    if (!tokens?.length || !/(^|[\\/])git(?:\.exe)?$/i.test(tokens[0])) return null;
-    let index = 1;
-    while (index < tokens.length) {
-        const token = tokens[index];
-        if (token === '-C' || token === '-c' || token === '--git-dir' || token === '--work-tree' || token === '--namespace') {
-            index += 2;
-            continue;
-        }
-        if (/^-C.+/.test(token) || /^--(?:git-dir|work-tree|namespace)=/.test(token)
-            || ['--no-pager', '--paginate', '--bare', '--literal-pathspecs', '--glob-pathspecs', '--noglob-pathspecs', '--icase-pathspecs'].includes(token)) {
-            index++;
-            continue;
-        }
-        break;
-    }
-    return index < tokens.length ? { command: tokens[index], args: tokens.slice(index + 1) } : null;
-}
-
-function firstGitArg(args) {
-    return args.find((value) => value !== '--' && !value.startsWith('-')) || '';
-}
-
 function gitCallMutates(call) {
     let args = call?.arguments ?? call?.function?.arguments ?? {};
-    if (typeof args === 'string') {
-        try { args = JSON.parse(args); } catch { return true; }
-    }
-    const parsed = parsedGitCommand(args?.command);
-    if (!parsed) return true;
-    const operation = parsed.command;
-    const action = firstGitArg(parsed.args);
-    if (READ_ONLY_GIT_COMMANDS.has(operation)) return false;
-    if (operation === 'reflog') return ['delete', 'expire'].includes(action);
-    if (operation === 'branch' || operation === 'tag') {
-        return parsed.args.length > 0 && !parsed.args.some((value) => ['--list', '-l', '-a', '--all', '-r', '--remotes', '--show-current'].includes(value));
-    }
-    if (operation === 'worktree') return !['', 'list'].includes(action);
-    if (operation === 'stash') return !['list', 'show'].includes(action);
-    if (operation === 'remote') return !['', 'show', 'get-url'].includes(action);
-    if (operation === 'config') {
-        return !parsed.args.some((value) => ['--list', '-l', '--get', '--get-all', '--get-regexp', '--show-origin', '--show-scope'].includes(value))
-            && parsed.args.filter((value) => !value.startsWith('-')).length > 1;
-    }
-    if (operation === 'clean') return !parsed.args.some((value) => value === '-n' || value === '--dry-run');
-    if (operation === 'bundle') return !['list-heads', 'verify'].includes(action);
-    if (operation === 'notes') return !['', 'list', 'show'].includes(action);
-    if (operation === 'replace') return parsed.args.length > 0 && !parsed.args.includes('--list');
-    if (operation === 'sparse-checkout') return action !== 'list';
-    if (operation === 'submodule') return !['', 'status', 'summary'].includes(action);
-    if (operation === 'symbolic-ref') return parsed.args.filter((value) => !value.startsWith('-')).length > 1;
-    if (operation === 'hash-object') return parsed.args.includes('-w') || parsed.args.includes('--stdin-paths');
-    return true;
+    return gitCommandMutates(args);
 }
 
 function mutationBatch(toolCalls) {
@@ -271,6 +210,181 @@ function byteLength(value) {
     return Buffer.byteLength(String(value || ''), 'utf8');
 }
 
+const PATH_ONLY_TOOLS = new Set(['find', 'find_files', 'glob']);
+
+function pathOccurrenceForLine(toolName, line) {
+    const name = normalizeToolName(toolName);
+    if (PATH_ONLY_TOOLS.has(name)) {
+        if (!line || /^(?:\.\.\.|[[(#]|Error:)/.test(line)) return null;
+        return { path: line, start: 0, end: line.length };
+    }
+    if (name === 'list') {
+        const match = /^(.*)\t(?:file|dir|symlink|other)$/.exec(line);
+        return match?.[1]
+            ? { path: match[1], start: 0, end: match[1].length }
+            : null;
+    }
+    if (name === 'read') {
+        const match = /^(.+?)(?: \[[^\]]+\])? \[(?:ok|error)\](?: .*)?$/.exec(line);
+        return match?.[1]
+            ? { path: match[1], start: 0, end: match[1].length }
+            : null;
+    }
+    if (name === 'grep') {
+        const match = /^# (.+):\d+ \[lines \d+-\d+\]$/.exec(line);
+        return match?.[1]
+            ? { path: match[1], start: 2, end: 2 + match[1].length }
+            : null;
+    }
+    if (name === 'code_graph') {
+        const match = /^(.+):\d+-\d+:\d+ \([^)]+\)$/.exec(line);
+        return match?.[1]
+            ? { path: match[1], start: 0, end: match[1].length }
+            : null;
+    }
+    return null;
+}
+
+function projectProviderPathAliases(messages, { apply = true } = {}) {
+    const callById = new Map();
+    const occurrences = [];
+    let epoch = 0;
+    for (let messageIndex = 0; messageIndex < messages.length; messageIndex += 1) {
+        const message = messages[messageIndex];
+        if (!message || typeof message !== 'object') continue;
+        if (message.role === 'assistant' && Array.isArray(message.toolCalls)) {
+            if (mutationBatch(message.toolCalls)) epoch += 1;
+            for (const call of message.toolCalls) {
+                const id = call?.id || call?.toolCallId;
+                if (!id) continue;
+                callById.set(id, {
+                    epoch,
+                    name: call?.name || call?.function?.name,
+                });
+            }
+            continue;
+        }
+        if (message.role !== 'tool' || typeof message.content !== 'string'
+            || message.toolKind === 'error' || message.isError === true) continue;
+        const call = callById.get(message.toolCallId);
+        if (!call) continue;
+        const lines = message.content.split('\n');
+        for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+            const occurrence = pathOccurrenceForLine(call.name, lines[lineIndex]);
+            if (!occurrence?.path) continue;
+            occurrences.push({
+                ...occurrence,
+                epoch: call.epoch,
+                messageIndex,
+                lineIndex,
+            });
+        }
+    }
+
+    const groups = new Map();
+    for (const occurrence of occurrences) {
+        const key = `${occurrence.epoch}\0${occurrence.path}`;
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(occurrence);
+    }
+    const repeated = [...groups.values()]
+        .filter((group) => group.length > 1)
+        .sort((left, right) => (
+            left[0].messageIndex - right[0].messageIndex
+            || left[0].lineIndex - right[0].lineIndex
+            || left[0].start - right[0].start
+        ));
+    const aliasesByEpoch = new Map();
+    const dictionaries = new Map();
+    const edits = new Map();
+    let pathAliases = 0;
+    let reusedPathFacts = 0;
+    for (const group of repeated) {
+        const first = group[0];
+        const nextAlias = (aliasesByEpoch.get(first.epoch) || 0) + 1;
+        const alias = `p${nextAlias}`;
+        const dictionary = `[path-alias ${alias}=${JSON.stringify(first.path)}]`;
+        const originalBytes = group.reduce((sum, item) => sum + byteLength(item.path), 0);
+        const projectedBytes = byteLength(dictionary) + 1
+            + group.reduce((sum) => sum + byteLength(alias), 0);
+        if (projectedBytes >= originalBytes) continue;
+        aliasesByEpoch.set(first.epoch, nextAlias);
+        pathAliases += 1;
+        reusedPathFacts += group.length - 1;
+        if (!dictionaries.has(first.messageIndex)) dictionaries.set(first.messageIndex, []);
+        dictionaries.get(first.messageIndex).push(dictionary);
+        for (const occurrence of group) {
+            if (!edits.has(occurrence.messageIndex)) edits.set(occurrence.messageIndex, new Map());
+            const byLine = edits.get(occurrence.messageIndex);
+            if (!byLine.has(occurrence.lineIndex)) byLine.set(occurrence.lineIndex, []);
+            byLine.get(occurrence.lineIndex).push({
+                start: occurrence.start,
+                end: occurrence.end,
+                replacement: alias,
+            });
+        }
+    }
+    if (pathAliases === 0) {
+        return {
+            messages,
+            stats: {
+                pathFacts: occurrences.length,
+                pathAliases: 0,
+                reusedPathFacts: 0,
+                pathAliasBytesSaved: 0,
+                changedIndexes: [],
+            },
+        };
+    }
+
+    const changedIndexes = new Set([...dictionaries.keys(), ...edits.keys()]);
+    const projected = messages.slice();
+    let beforeBytes = 0;
+    let afterBytes = 0;
+    for (const messageIndex of changedIndexes) {
+        const message = messages[messageIndex];
+        beforeBytes += byteLength(message.content);
+        const lines = message.content.split('\n');
+        const byLine = edits.get(messageIndex);
+        if (byLine) {
+            for (const [lineIndex, lineEdits] of byLine) {
+                let line = lines[lineIndex];
+                for (const edit of [...lineEdits].sort((a, b) => b.start - a.start)) {
+                    line = line.slice(0, edit.start) + edit.replacement + line.slice(edit.end);
+                }
+                lines[lineIndex] = line;
+            }
+        }
+        const dictionaryLines = dictionaries.get(messageIndex) || [];
+        const content = [...dictionaryLines, ...lines].join('\n');
+        afterBytes += byteLength(content);
+        if (apply) projected[messageIndex] = { ...message, content };
+    }
+    const saved = beforeBytes - afterBytes;
+    if (saved <= 0) {
+        return {
+            messages,
+            stats: {
+                pathFacts: occurrences.length,
+                pathAliases: 0,
+                reusedPathFacts: 0,
+                pathAliasBytesSaved: 0,
+                changedIndexes: [],
+            },
+        };
+    }
+    return {
+        messages: apply ? projected : messages,
+        stats: {
+            pathFacts: occurrences.length,
+            pathAliases,
+            reusedPathFacts,
+            pathAliasBytesSaved: saved,
+            changedIndexes: [...changedIndexes],
+        },
+    };
+}
+
 export function projectProviderEvidence(messages, options = {}) {
     if (!Array.isArray(messages) || options.enabled === false) {
         return {
@@ -284,6 +398,10 @@ export function projectProviderEvidence(messages, options = {}) {
                 changedToolResults: 0,
                 exactResultRefs: 0,
                 exactResultBytesSaved: 0,
+                pathFacts: 0,
+                pathAliases: 0,
+                reusedPathFacts: 0,
+                pathAliasBytesSaved: 0,
             },
         };
     }
@@ -292,6 +410,7 @@ export function projectProviderEvidence(messages, options = {}) {
     const callById = new Map();
     const seen = new Map();
     const seenExactResults = new Map();
+    const changedToolResultIndexes = new Set();
     let projected = null;
     const stats = {
         beforeBytes: 0,
@@ -302,6 +421,10 @@ export function projectProviderEvidence(messages, options = {}) {
         changedToolResults: 0,
         exactResultRefs: 0,
         exactResultBytesSaved: 0,
+        pathFacts: 0,
+        pathAliases: 0,
+        reusedPathFacts: 0,
+        pathAliasBytesSaved: 0,
     };
 
     for (let index = 0; index < messages.length; index += 1) {
@@ -341,6 +464,7 @@ export function projectProviderEvidence(messages, options = {}) {
                     stats.exactResultRefs += 1;
                     stats.exactResultBytesSaved += originalBytes - nextBytes;
                     stats.changedToolResults += 1;
+                    changedToolResultIndexes.add(index);
                     stats.afterBytes += nextBytes;
                     if (apply) {
                         if (!projected) projected = messages.slice();
@@ -394,6 +518,7 @@ export function projectProviderEvidence(messages, options = {}) {
         stats.reusedRows += duplicates.length;
         stats.referenceGroups += references.length;
         stats.changedToolResults += 1;
+        changedToolResultIndexes.add(index);
         stats.afterBytes += nextBytes;
         if (apply) {
             if (!projected) projected = messages.slice();
@@ -401,6 +526,18 @@ export function projectProviderEvidence(messages, options = {}) {
         }
     }
 
+    const pathProjection = projectProviderPathAliases(projected || messages, { apply });
+    stats.pathFacts = pathProjection.stats.pathFacts;
+    stats.pathAliases = pathProjection.stats.pathAliases;
+    stats.reusedPathFacts = pathProjection.stats.reusedPathFacts;
+    stats.pathAliasBytesSaved = pathProjection.stats.pathAliasBytesSaved;
+    stats.afterBytes -= pathProjection.stats.pathAliasBytesSaved;
+    for (const index of pathProjection.stats.changedIndexes) changedToolResultIndexes.add(index);
+    stats.changedToolResults = changedToolResultIndexes.size;
+    if (apply && pathProjection.messages !== (projected || messages)) {
+        projected = pathProjection.messages;
+    }
+
     return { messages: projected || messages, stats };
 }
 

package/src/runtime/agent/orchestrator/session/evidence-union.test.mjs

@@ -81,6 +81,60 @@ test('keeps tiny exact results when a reference would be larger', () => {
     assert.equal(projected.stats.exactResultRefs, 0);
 });
 
+test('aliases repeated typed paths across same-turn glob and batch read results', () => {
+    const repeated = `src/${'deep/'.repeat(10)}feature.mjs`;
+    const first = result('glob_1', `${repeated}\nsrc/unique.mjs`);
+    const second = result('read_1', `read 1\n\n${repeated} [ok]\n1→export const value = 1;`);
+    const messages = [
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [
+                { id: 'glob_1', name: 'glob', arguments: { pattern: '**/*.mjs' } },
+                { id: 'read_1', name: 'read', arguments: { file_path: '**/*.mjs' } },
+            ],
+        },
+        first,
+        second,
+    ];
+    const projected = projectProviderEvidence(messages);
+    const combined = `${projected.messages[1].content}\n${projected.messages[2].content}`;
+    assert.equal(projected.messages[1].toolCallId, 'glob_1');
+    assert.equal(projected.messages[2].toolCallId, 'read_1');
+    assert.equal(combined.split(repeated).length - 1, 1);
+    assert.match(projected.messages[1].content, /\[path-alias p1="/);
+    assert.match(projected.messages[1].content, /(?:^|\n)p1(?:\n|$)/);
+    assert.match(projected.messages[2].content, /(?:^|\n)p1 \[ok\](?:\n|$)/);
+    assert.equal(projected.stats.pathAliases, 1);
+    assert.equal(projected.stats.reusedPathFacts, 1);
+    assert.ok(projected.stats.pathAliasBytesSaved > 0);
+    assert.equal(messages[1], first);
+    assert.equal(messages[2], second);
+});
+
+test('keeps short repeated paths and resets path aliases across mutations', () => {
+    const shortMessages = [
+        call('glob_1', 'glob'),
+        result('glob_1', 'src/a.mjs'),
+        call('read_1', 'read'),
+        result('read_1', 'src/a.mjs [ok]\n1→a'),
+    ];
+    assert.equal(projectProviderEvidence(shortMessages).stats.pathAliases, 0);
+
+    const repeated = `src/${'nested/'.repeat(10)}a.mjs`;
+    const mutationMessages = [
+        call('glob_1', 'glob'),
+        result('glob_1', repeated),
+        call('patch_1', 'apply_patch'),
+        result('patch_1', 'ok'),
+        call('read_1', 'read'),
+        result('read_1', `${repeated} [ok]\n1→a`),
+    ];
+    const projected = projectProviderEvidence(mutationMessages);
+    assert.equal(projected.messages, mutationMessages);
+    assert.equal(projected.stats.pathAliases, 0);
+});
+
 test('apply_patch, shell, and mutating git batches invalidate all earlier evidence', () => {
     const same = `same ${'s'.repeat(160)}`;
     const listing = Array.from({ length: 24 }, (_, index) => `src/item-${index}.mjs`).join('\n');

package/src/runtime/agent/orchestrator/session/loop/tool-classify.mjs

@@ -1,3 +1,5 @@
+import { gitCommandMutates } from '../../tools/builtin/git-command-policy.mjs';
+
 // Tool-name classification + intra-turn signature helpers, extracted from
 // loop.mjs. These drive cross-turn read dedup, scoped caching, shell routing,
 // and duplicate-call detection. Strips the MCP prefix so direct calls and
@@ -11,9 +13,13 @@ export function _stripMcpPrefix(name) {
 export function _isReadTool(name) {
     return _stripMcpPrefix(name) === 'read';
 }
-export function _isMutationTool(name) {
+export function _isMutationTool(name, args = null) {
+    const n = String(_stripMcpPrefix(name) || '').toLowerCase();
+    return n === 'apply_patch' || n === 'edit' || (n === 'git' && gitCommandMutates(args));
+}
+export function _isGitMutationTool(name, args = null) {
     const n = String(_stripMcpPrefix(name) || '').toLowerCase();
-    return n === 'apply_patch' || n === 'edit';
+    return n === 'git' && gitCommandMutates(args);
 }
 export function _isEditTool(name) {
     return String(_stripMcpPrefix(name) || '').toLowerCase() === 'edit';

package/src/runtime/agent/orchestrator/session/tool-batch.mjs

@@ -587,7 +587,7 @@ export async function processToolBatch(ctx) {
                     clearScopedToolsForSession(sessionId);
                 }
             }
-            if (_isMutationTool(call.name)) {
+            if (_isMutationTool(call.name, call.arguments)) {
                 epoch.mutation += 1;
             }
             // Bash always clears scoped cache UNCONDITIONALLY — a mutating bash

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

@@ -0,0 +1,107 @@
+import { tokenizeDirectArgv } from './shell-direct-exe.mjs';
+
+const ALWAYS_READ = new Set([
+    'blame', 'cat-file', 'check-attr', 'check-ignore', 'check-ref-format',
+    'cherry', 'count-objects', 'describe', 'diff', 'diff-files', 'diff-index',
+    'diff-tree', 'for-each-ref', 'fsck', 'grep', 'help', 'log', 'ls-files',
+    'ls-remote', 'ls-tree', 'merge-base', 'merge-tree', 'name-rev',
+    'range-diff', 'rev-list', 'rev-parse', 'shortlog', 'show', 'show-branch',
+    'show-ref', 'status', 'verify-commit', 'verify-pack', 'verify-tag',
+    'whatchanged',
+]);
+
+function commandHasShellSyntax(command) {
+    const text = String(command || '');
+    let quote = null;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (quote === "'") {
+            if (char === "'") quote = null;
+            continue;
+        }
+        if (quote === '"') {
+            if (char === '\\' && text[index + 1] === '"') { index++; continue; }
+            if (char === '"') { quote = null; continue; }
+            if (char === '$' || char === '`') return true;
+            continue;
+        }
+        if (char === "'" || char === '"') { quote = char; continue; }
+        if ('|&;<>()\n\r'.includes(char) || char === '$' || char === '`') return true;
+    }
+    return quote !== null;
+}
+
+export function gitActionOf(operation, args) {
+    const first = args.find((value) => value && !value.startsWith('-'));
+    if (operation === 'stash') return first || 'push';
+    if (operation === 'worktree') return first || 'list';
+    if (operation === 'remote') return first || 'list';
+    if (operation === 'reflog') return first || 'show';
+    return first || 'list';
+}
+
+export function gitPlanIsReadOnly(plan) {
+    const { operation, args } = plan;
+    if (operation === 'fsck' && args.includes('--lost-found')) return false;
+    if (ALWAYS_READ.has(operation)) return true;
+    if (operation === 'reflog') return !['delete', 'expire'].includes(gitActionOf(operation, args));
+    if (operation === 'stash') return ['list', 'show'].includes(gitActionOf(operation, args));
+    if (operation === 'worktree') return gitActionOf(operation, args) === 'list';
+    if (operation === 'remote') return args.length === 0 || args.includes('-v') || ['get-url', 'show'].includes(gitActionOf(operation, args));
+    if (operation === 'clean') return args.some((value) => value === '-n' || value === '--dry-run' || /^-[^-]*n/.test(value));
+    if (operation === 'bundle') return ['list-heads', 'verify'].includes(gitActionOf(operation, args));
+    if (operation === 'notes') return ['', 'list', 'show'].includes(gitActionOf(operation, args));
+    if (operation === 'replace') return args.length === 0 || args.includes('--list');
+    if (operation === 'sparse-checkout') return gitActionOf(operation, args) === 'list';
+    if (operation === 'submodule') return ['', 'status', 'summary'].includes(gitActionOf(operation, args));
+    if (operation === 'symbolic-ref') return args.filter((value) => !value.startsWith('-')).length <= 1;
+    if (operation === 'hash-object') return !args.includes('-w') && !args.includes('--stdin-paths');
+    if (operation === 'branch' || operation === 'tag') {
+        return args.length === 0 || args.some((value) => ['--list', '-l', '-a', '--all', '-r', '--remotes'].includes(value));
+    }
+    if (operation === 'config') {
+        const mutationFlags = new Set([
+            '--add', '--edit', '--rename-section', '--remove-section',
+            '--replace-all', '--unset', '--unset-all',
+        ]);
+        if (args.some((value) => mutationFlags.has(value))) return false;
+        const readFlag = args.some((value) => /^--(?:get|get-all|get-regexp|get-urlmatch|list|show-origin|show-scope)$/.test(value));
+        const positional = args.filter((value) => !value.startsWith('-'));
+        if (['set', 'unset', 'rename-section', 'remove-section'].includes(positional[0])) return false;
+        if (['get', 'get-all', 'get-regexp', 'get-urlmatch', 'list'].includes(positional[0])) return true;
+        return readFlag || positional.length <= 1;
+    }
+    return false;
+}
+
+function parsedGitOperation(command) {
+    if (commandHasShellSyntax(command)) return null;
+    const tokens = tokenizeDirectArgv(command);
+    if (!tokens?.length || !/(^|[\\/])git(?:\.exe)?$/i.test(tokens[0])) return null;
+    let index = 1;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token === '-C' || token === '-c' || token === '--config-env' || token === '--git-dir'
+            || token === '--work-tree' || token === '--namespace') {
+            index += 2;
+            continue;
+        }
+        if (/^-C.+/.test(token) || /^--(?:git-dir|work-tree|namespace|config-env)=/.test(token)
+            || ['--no-pager', '--paginate', '--bare', '--literal-pathspecs', '--glob-pathspecs', '--noglob-pathspecs', '--icase-pathspecs'].includes(token)) {
+            index++;
+            continue;
+        }
+        break;
+    }
+    const operation = String(tokens[index] || '').toLowerCase();
+    return operation ? { operation, args: tokens.slice(index + 1) } : null;
+}
+
+export function gitCommandMutates(value) {
+    let args = value;
+    if (typeof args === 'string') {
+        try { args = JSON.parse(args); } catch { args = { command: args }; }
+    }
+    const parsed = parsedGitOperation(args?.command);
+    return !parsed || !gitPlanIsReadOnly(parsed);
+}

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

@@ -0,0 +1,27 @@
+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);
+    assert.equal(_isMutationTool('apply_patch', {}), true);
+});

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

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import { basename, resolve } from 'node:path';
 import { tokenizeDirectArgv } from './shell-direct-exe.mjs';
 import { withBuiltinPathLocks } from './path-locks.mjs';
@@ -6,6 +5,8 @@ import { withAdvisoryLocks } from './advisory-lock.mjs';
 import { withGitRepoReadLock, withGitRepoWriteLock } from './git-repo-rw-lock.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { drainCodeGraphCache } from '../code-graph-state.mjs';
+import { ensureNativeSpawnServer, tryNativeSpawn } from '../lib/native-spawn-client.mjs';
+import { gitActionOf as actionOf, gitPlanIsReadOnly as isReadOnly } from './git-command-policy.mjs';
 
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_CAPTURE_BYTES = 128 * 1024 * 1024;
@@ -24,15 +25,6 @@ const SUPPORTED = new Set([
     'symbolic-ref', 'tag', 'update-ref', 'verify-commit', 'verify-pack',
     'verify-tag', 'whatchanged', 'worktree', 'write-tree',
 ]);
-const ALWAYS_READ = new Set([
-    'blame', 'cat-file', 'check-attr', 'check-ignore', 'check-ref-format',
-    'cherry', 'count-objects', 'describe', 'diff', 'diff-files', 'diff-index',
-    'diff-tree', 'for-each-ref', 'fsck', 'grep', 'help', 'log', 'ls-files',
-    'ls-remote', 'ls-tree', 'merge-base', 'merge-tree', 'name-rev',
-    'range-diff', 'rev-list', 'rev-parse', 'shortlog', 'show', 'show-branch',
-    'show-ref', 'status', 'verify-commit', 'verify-pack', 'verify-tag',
-    'whatchanged',
-]);
 const PUSH_NOISE = [
     'Enumerating objects:', 'Counting objects:', 'Compressing objects:',
     'Writing objects:', 'Delta compression using', 'Total ',
@@ -155,11 +147,14 @@ function parseCommand(command, workDir) {
     return { command: String(command), cwd, globalArgs, operation, args: tokens.slice(index + 1) };
 }
 
-function runProcess(program, argv, { cwd, signal, maxBytes = MAX_CAPTURE_BYTES } = {}) {
-    return new Promise((done) => {
-        let child;
-        try {
-            child = spawn(program, argv, {
+async function runProcess(program, argv, { cwd, signal, maxBytes = MAX_CAPTURE_BYTES } = {}) {
+    let child;
+    try {
+        await ensureNativeSpawnServer();
+        const native = tryNativeSpawn({
+            shell: program,
+            argv,
+            spawnOptions: {
                 cwd,
                 env: {
                     ...process.env,
@@ -169,14 +164,15 @@ function runProcess(program, argv, { cwd, signal, maxBytes = MAX_CAPTURE_BYTES }
                     GIT_SEQUENCE_EDITOR: 'true',
                     LC_ALL: 'C',
                 },
-                shell: false,
-                windowsHide: true,
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-        } catch (error) {
-            done({ exitCode: null, signal: null, stdout: Buffer.alloc(0), stderr: Buffer.alloc(0), error, timedOut: false, aborted: false, overflow: false });
-            return;
-        }
+                outputLimit: maxBytes,
+            },
+        });
+        if (!native?.child) throw Object.assign(new Error('verified native spawn server unavailable'), { code: 'NATIVE_SPAWN_UNAVAILABLE' });
+        child = native.child;
+    } catch (error) {
+        return { exitCode: null, signal: null, stdout: Buffer.alloc(0), stderr: Buffer.alloc(0), error, timedOut: false, aborted: false, overflow: false };
+    }
+    return new Promise((done) => {
         const stdout = [], stderr = [];
         let bytes = 0, timedOut = false, aborted = false, overflow = false, settled = false;
         const stop = () => { try { child.kill('SIGKILL'); } catch {} };
@@ -228,42 +224,6 @@ function runGit(plan, argv, options = {}) {
     return runProcess('git', [...plan.globalArgs, ...argv], { cwd: plan.cwd, signal: options.signal });
 }
 
-function actionOf(operation, args) {
-    const first = args.find((value) => value && !value.startsWith('-'));
-    if (operation === 'stash') return first || 'push';
-    if (operation === 'worktree') return first || 'list';
-    if (operation === 'remote') return first || 'list';
-    if (operation === 'reflog') return first || 'show';
-    return first || 'list';
-}
-
-function isReadOnly(plan) {
-    const { operation, args } = plan;
-    if (ALWAYS_READ.has(operation)) return true;
-    if (operation === 'reflog') return !['delete', 'expire'].includes(actionOf(operation, args));
-    if (operation === 'stash') return ['list', 'show'].includes(actionOf(operation, args));
-    if (operation === 'worktree') return actionOf(operation, args) === 'list';
-    if (operation === 'remote') return args.length === 0 || args.includes('-v') || ['get-url', 'show'].includes(actionOf(operation, args));
-    if (operation === 'clean') return args.some((value) => value === '-n' || value === '--dry-run' || /^-[^-]*n/.test(value));
-    if (operation === 'bundle') return ['list-heads', 'verify'].includes(actionOf(operation, args));
-    if (operation === 'notes') return ['', 'list', 'show'].includes(actionOf(operation, args));
-    if (operation === 'replace') return args.length === 0 || args.includes('--list');
-    if (operation === 'sparse-checkout') return actionOf(operation, args) === 'list';
-    if (operation === 'submodule') return ['', 'status', 'summary'].includes(actionOf(operation, args));
-    if (operation === 'symbolic-ref') return args.filter((value) => !value.startsWith('-')).length <= 1;
-    if (operation === 'hash-object') return !args.includes('-w') && !args.includes('--stdin-paths');
-    if (operation === 'branch' || operation === 'tag') {
-        if (args.length === 0 || args.some((value) => ['--list', '-l', '-a', '--all', '-r', '--remotes'].includes(value))) return true;
-        return false;
-    }
-    if (operation === 'config') {
-        const readFlag = args.some((value) => /^--(?:get|get-all|get-regexp|get-urlmatch|list|show-origin|show-scope)$/.test(value));
-        const positional = args.filter((value) => !value.startsWith('-'));
-        return readFlag || positional.length <= 1;
-    }
-    return false;
-}
-
 function destructiveReason(plan) {
     const { operation, args } = plan;
     if (operation === 'reset' && args.includes('--hard')) return 'git reset --hard';
@@ -544,8 +504,50 @@ async function resolveRepo(plan, signal) {
     return succeeded(result) ? cleanText(result.stdout) : null;
 }
 
-async function executeCreation(plan, limit, signal) {
-    return withBuiltinPathLocks([plan.cwd], () => withAdvisoryLocks([plan.cwd], async () => {
+function localizeConfigPlan(plan) {
+    if (plan.operation !== 'config') return plan;
+    const external = plan.args.find((value) => ['--global', '--system', '--file', '-f'].includes(value)
+        || value.startsWith('--file=')
+        || (/^-f./.test(value) && !value.startsWith('--')));
+    if (external) throw new Error(`git config ${external} is outside the local repository scope`);
+    if (plan.args.some((value) => value === '--local' || value === '--worktree')) return plan;
+    return { ...plan, args: ['--local', ...plan.args] };
+}
+
+function optionFreePositionals(args) {
+    const takesValue = new Set([
+        '-b', '--branch', '-c', '--config', '--depth', '-j', '--jobs', '-o',
+        '--origin', '--reference', '--reference-if-able', '--separate-git-dir',
+        '--template', '-u', '--upload-pack', '--filter', '--server-option',
+        '--shallow-since', '--shallow-exclude', '--bundle-uri', '--revision',
+        '--ref-format', '--object-format', '--initial-branch',
+    ]);
+    const out = [];
+    for (let index = 0; index < args.length; index++) {
+        const value = args[index];
+        if (value === '--') {
+            out.push(...args.slice(index + 1));
+            break;
+        }
+        if (takesValue.has(value)) { index++; continue; }
+        if (value.startsWith('-')) continue;
+        out.push(value);
+    }
+    return out;
+}
+
+function creationTarget(plan) {
+    const positional = optionFreePositionals(plan.args);
+    if (plan.operation === 'init') return resolve(plan.cwd, positional.at(-1) || '.');
+    if (plan.operation !== 'clone') return plan.cwd;
+    if (positional.length >= 2) return resolve(plan.cwd, positional.at(-1));
+    const source = String(positional[0] || '').replace(/[\\/]+$/, '');
+    const leaf = basename(source.includes(':') ? source.slice(source.lastIndexOf(':') + 1) : source).replace(/\.git$/i, '') || 'repo';
+    return resolve(plan.cwd, leaf);
+}
+
+async function executeCreation(plan, target, limit, signal) {
+    return withBuiltinPathLocks([target], () => withAdvisoryLocks([target], async () => {
         const result = await runGit(plan, [plan.operation, ...plan.args], { signal });
         if (!succeeded(result)) return commandFailure(plan, result);
         invalidateBuiltinResultCache();
@@ -557,7 +559,7 @@ async function executeCreation(plan, limit, signal) {
 export async function executeGitTool(input, workDir, options = {}) {
     if (!input || typeof input !== 'object' || Array.isArray(input)) return fail('git requires an arguments object');
     let plan;
-    try { plan = parseCommand(input.command, workDir); }
+    try { plan = localizeConfigPlan(parseCommand(input.command, workDir)); }
     catch (error) { return fail(error.message); }
     if (plan.operation === 'archive' && !plan.args.some((value) => value === '-o' || value === '--output' || value.startsWith('--output='))) {
         return fail('git archive requires -o/--output; binary stdout is not returned');
@@ -568,7 +570,8 @@ export async function executeGitTool(input, workDir, options = {}) {
     if (reason && input.confirm !== true) return fail(`${reason} requires confirm:true`);
     const signal = options?.signal || options?.abortSignal || null;
     if (plan.operation === 'init' || plan.operation === 'clone') {
-        return withGitRepoWriteLock(plan.cwd, () => executeCreation(plan, limit, signal));
+        const target = creationTarget(plan);
+        return withGitRepoWriteLock(target, () => executeCreation(plan, target, limit, signal), { signal });
     }
     const repo = await resolveRepo(plan, signal);
     if (!repo) {
@@ -581,7 +584,7 @@ export async function executeGitTool(input, workDir, options = {}) {
             const result = await runGit(plan, prepared.argv, { signal });
             if (!succeeded(result)) return commandFailure(plan, result);
             return ok(formatRead(prepared, cleanText(result.stdout), cleanText(result.stderr), limit));
-        });
+        }, { signal });
     }
     return withGitRepoWriteLock(repo, () => withBuiltinPathLocks([repo], () => withAdvisoryLocks([repo], async () => {
         const before = await statusSnapshot(repo, signal);
@@ -591,5 +594,7 @@ export async function executeGitTool(input, workDir, options = {}) {
         drainCodeGraphCache();
         if (!succeeded(result)) return `${commandFailure(plan, result)}\n${JSON.stringify({ status: statusDelta(before, after, limit) })}`;
         return ok({ ...mutationData(plan, cleanText(result.stdout), cleanText(result.stderr), limit), status: statusDelta(before, after, limit) });
-    })));
+    })), { signal });
 }
+
+export const _gitCommandInternals = { creationTarget, localizeConfigPlan, parseCommand };

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

@@ -4,7 +4,7 @@ import { mkdtempSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import test from 'node:test';
-import { executeGitTool, GIT_TOOL_DEF } from './git-command-tool.mjs';
+import { executeGitTool, GIT_TOOL_DEF, _gitCommandInternals } from './git-command-tool.mjs';
 
 function parseOk(result) {
     assert.doesNotMatch(String(result), /^Error:/, String(result));
@@ -29,6 +29,14 @@ test('git command tool preserves shell syntax, compacts output, and gates destru
     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'));

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

@@ -26,12 +26,16 @@ function drain(key, state) {
     if (state.readers === 0 && state.queue[0].mode === 'write') {
         const entry = state.queue.shift();
         state.writer = true;
+        entry.granted = true;
+        entry.signal?.removeEventListener?.('abort', entry.onAbort);
         entry.resolve(releaseFor(key, state, 'write'));
         return;
     }
     while (state.queue[0]?.mode === 'read' && !state.writer) {
         const entry = state.queue.shift();
         state.readers++;
+        entry.granted = true;
+        entry.signal?.removeEventListener?.('abort', entry.onAbort);
         entry.resolve(releaseFor(key, state, 'read'));
     }
 }
@@ -47,28 +51,46 @@ function releaseFor(key, state, mode) {
     };
 }
 
-function acquire(repo, mode) {
+function abortError(signal) {
+    if (signal?.reason instanceof Error) return signal.reason;
+    return Object.assign(new Error('git repository lock aborted'), { name: 'AbortError', code: 'ABORT_ERR' });
+}
+
+function acquire(repo, mode, signal) {
+    if (signal?.aborted) return Promise.reject(abortError(signal));
     const key = keyFor(repo);
     const state = stateFor(key);
-    return new Promise((resolveLock) => {
-        state.queue.push({ mode, resolve: resolveLock });
+    return new Promise((resolveLock, rejectLock) => {
+        const entry = { mode, resolve: resolveLock, reject: rejectLock, signal, onAbort: null, granted: false };
+        entry.onAbort = () => {
+            if (entry.granted) return;
+            const index = state.queue.indexOf(entry);
+            if (index >= 0) state.queue.splice(index, 1);
+            signal?.removeEventListener?.('abort', entry.onAbort);
+            rejectLock(abortError(signal));
+            drain(key, state);
+        };
+        state.queue.push(entry);
+        signal?.addEventListener?.('abort', entry.onAbort, { once: true });
         drain(key, state);
     });
 }
 
-async function withLock(repo, mode, fn) {
-    const release = await acquire(repo, mode);
+async function withLock(repo, mode, fn, options = {}) {
+    const signal = options?.signal || null;
+    const release = await acquire(repo, mode, signal);
     try {
+        if (signal?.aborted) throw abortError(signal);
         return await fn();
     } finally {
         release();
     }
 }
 
-export function withGitRepoReadLock(repo, fn) {
-    return withLock(repo, 'read', fn);
+export function withGitRepoReadLock(repo, fn, options = {}) {
+    return withLock(repo, 'read', fn, options);
 }
 
-export function withGitRepoWriteLock(repo, fn) {
-    return withLock(repo, 'write', fn);
+export function withGitRepoWriteLock(repo, fn, options = {}) {
+    return withLock(repo, 'write', fn, options);
 }

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

@@ -62,3 +62,22 @@ test('git repo writers on different repositories run in parallel', async () => {
     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);
+});