@withtruing/companion 0.13.3 → 0.14.1

package/dist/codex-cli-caller.js

@@ -12,6 +12,8 @@ import { assertSingleLineArguments } from './cli-arguments.js';
 import { resolveCodexCommand } from './codex-binary.js';
 import { gitErrorMessage } from './sandbox.js';
 import { stripIntroducedNulls, toCodexStrictSchema } from './strict-schema.js';
+import { WholeReadTransportError, } from './text-model.js';
+import { isUsageLimitError, parseUsageLimitReset } from './usage-limit.js';
 const WALL_CLOCK_TIMEOUT_MS = 10 * 60 * 1000;
 const STDOUT_SAMPLE_CHARS = 200;
 const UNPARSEABLE_LINE_SAMPLE_CHARS = 120;
@@ -78,10 +80,19 @@ function terminateChild(child) {
     if (process.platform === 'win32' && child.pid) {
         const killer = spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
         killer.on('error', () => child.kill());
+        killer.on('close', (code) => { if (code !== 0)
+            child.kill(); });
         return;
     }
     child.kill();
 }
+async function terminateChildAndWait(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = new Promise((resolvePromise) => child.once('close', () => resolvePromise()));
+    terminateChild(child);
+    await closed;
+}
 function isWithin(base, candidate) {
     const relation = relative(resolve(base), resolve(candidate));
     return relation === '' || (!relation.startsWith('..') && !isAbsolute(relation));
@@ -240,6 +251,19 @@ function namedCodexFailure(message, codexHome) {
     }
     return null;
 }
+function safeCodexFailure(message) {
+    if (isUsageLimitError(message)) {
+        const reset = parseUsageLimitReset(message);
+        return new WholeReadTransportError('usage_limit', 'codex', reset?.toISOString());
+    }
+    if (/billing|credit|payment required/i.test(message)) {
+        return new WholeReadTransportError('billing_exhausted', 'codex');
+    }
+    if (/rate_limit_error|http 429|too many requests|overloaded/i.test(message)) {
+        return new WholeReadTransportError('provider_rate_limit', 'codex');
+    }
+    return new WholeReadTransportError('capability_failure', 'codex');
+}
 function usageFrom(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return null;
@@ -253,7 +277,7 @@ function usageFrom(value) {
 function toolUseAttempt(type) {
     return new Error(`CodexToolUseAttempted: Codex attempted a tool (${type}) in a no-tools call; the result was discarded.`);
 }
-export function buildArgs(request, options, cwd, outputPath, schemaPath, instructionsPath) {
+export function buildArgs(request, options, cwd, outputPath, schemaPath, instructionsPath, tempRoot = tmpdir()) {
     const args = [
         'exec',
         '--json',
@@ -285,7 +309,7 @@ export function buildArgs(request, options, cwd, outputPath, schemaPath, instruc
         '-',
     ];
     assertSingleLineArguments('codex', args);
-    assertSafeInvocation(args);
+    assertSafeInvocation(args, tempRoot);
     return args;
 }
 function diagnostic(exitCode, stderrTail, stdoutBytes, stdoutLines, parsedLines, unparseableLines, stdoutFirst, stdoutLast, firstUnparseableLineLength, firstUnparseableLineFirst, firstUnparseableLineLast, typeCounts, toleratedErrorItems, purpose) {
@@ -315,10 +339,11 @@ removeDirectory = rm) {
     }
     assertAllowedModel(options.model);
     const codexHome = await validatedCodexHome(options.codexHome ?? defaultCodexHome());
-    const invocationCwd = await mkdtemp(join(tmpdir(), 'product-console-codex-empty-'));
+    const tempRoot = request.wholeRead?.attemptDirectory ?? tmpdir();
+    const invocationCwd = await mkdtemp(join(tempRoot, 'product-console-codex-empty-'));
     let callDir = null;
     try {
-        callDir = await mkdtemp(join(tmpdir(), 'product-console-codex-call-'));
+        callDir = await mkdtemp(join(tempRoot, 'product-console-codex-call-'));
         const outputPath = join(callDir, 'last-message.txt');
         const instructionsPath = join(callDir, 'model-instructions.txt');
         await writeFile(instructionsPath, request.system, { encoding: 'utf8', mode: 0o600 });
@@ -330,13 +355,15 @@ removeDirectory = rm) {
             schemaPath = join(callDir, 'schema.json');
             await writeFile(schemaPath, JSON.stringify(strict.schema), { encoding: 'utf8', mode: 0o600 });
         }
-        const args = buildArgs(request, options, invocationCwd, outputPath, schemaPath, instructionsPath);
+        const args = buildArgs(request, options, invocationCwd, outputPath, schemaPath, instructionsPath, tempRoot);
         let stderrTail = '';
         let timedOut = false;
         let stdinError = null;
         let fatalError = null;
         let turnFailure = '';
         let usage = null;
+        let actualModel = null;
+        let finishReason = null;
         let toleratedErrorItems = 0;
         let stdoutBytes = 0;
         let stdoutLines = 0;
@@ -356,7 +383,7 @@ removeDirectory = rm) {
         });
         const stdoutDecoder = new StringDecoder('utf8');
         const recordStdout = (text) => {
-            if (!text)
+            if (!text || request.wholeRead)
                 return;
             if (stdoutFirst.length < STDOUT_SAMPLE_CHARS) {
                 stdoutFirst += text.slice(0, STDOUT_SAMPLE_CHARS - stdoutFirst.length);
@@ -373,7 +400,8 @@ removeDirectory = rm) {
             terminateChild(child);
         });
         child.stderr.on('data', (chunk) => {
-            stderrTail = (stderrTail + chunk.toString()).slice(-2000);
+            if (!request.wholeRead)
+                stderrTail = (stderrTail + chunk.toString()).slice(-2000);
         });
         const rl = createInterface({ input: child.stdout });
         rl.on('line', (line) => {
@@ -384,7 +412,7 @@ removeDirectory = rm) {
             }
             catch {
                 unparseableLines++;
-                if (firstUnparseableLineLength === null) {
+                if (!request.wholeRead && firstUnparseableLineLength === null) {
                     firstUnparseableLineLength = line.length;
                     firstUnparseableLineFirst = line.slice(0, UNPARSEABLE_LINE_SAMPLE_CHARS);
                     firstUnparseableLineLast = line.slice(-UNPARSEABLE_LINE_SAMPLE_CHARS);
@@ -403,22 +431,29 @@ removeDirectory = rm) {
                     toleratedErrorItems++;
                 }
                 else if (classified !== 'agent_message' && classified !== 'reasoning') {
-                    fatalError ??= toolUseAttempt(classified);
+                    fatalError ??= request.wholeRead
+                        ? new WholeReadTransportError('capability_failure', 'codex')
+                        : toolUseAttempt(classified);
                     terminateChild(child);
                 }
             }
-            if (eventType === 'turn.completed')
+            if (eventType === 'turn.completed') {
                 usage = usageFrom(event.usage);
+                if (typeof event.model === 'string')
+                    actualModel = event.model;
+                if (typeof event.finish_reason === 'string')
+                    finishReason = event.finish_reason;
+            }
             if (eventType === 'error' || eventType === 'turn.failed') {
                 const message = eventMessage(event);
                 const named = namedCodexFailure(message, codexHome);
                 if (named) {
-                    fatalError ??= named;
+                    fatalError ??= request.wholeRead ? safeCodexFailure(message) : named;
                     if (/401 Unauthorized/i.test(message))
                         terminateChild(child);
                 }
                 else if (eventType === 'turn.failed') {
-                    turnFailure = message;
+                    turnFailure = request.wholeRead ? 'capability_failure' : message;
                 }
             }
         });
@@ -430,6 +465,14 @@ removeDirectory = rm) {
             child.on('error', reject);
             child.on('close', (code) => resolvePromise(code ?? 1));
         });
+        const unregisterReader = request.wholeRead?.registerReader({
+            cancel: () => terminateChildAndWait(child),
+        });
+        const abort = () => { void terminateChildAndWait(child); };
+        if (request.wholeRead?.signal.aborted)
+            abort();
+        else
+            request.wholeRead?.signal.addEventListener('abort', abort, { once: true });
         try {
             if (request.stableText)
                 child.stdin.write(`${request.stableText}\n\n`);
@@ -446,6 +489,11 @@ removeDirectory = rm) {
         }
         finally {
             clearTimeout(timer);
+            request.wholeRead?.signal.removeEventListener('abort', abort);
+            unregisterReader?.();
+        }
+        if (request.wholeRead?.signal.aborted) {
+            throw new WholeReadTransportError('cancelled', 'codex');
         }
         options.onDiagnostic?.({ toleratedErrorItems });
         if (/codex_core::tools::router/i.test(stderrTail) && /(?:spawn|exec_command)/i.test(stderrTail)) {
@@ -465,29 +513,52 @@ removeDirectory = rm) {
         }
         const capturedStdinError = stdinError;
         if (turnFailure) {
+            if (request.wholeRead)
+                throw new WholeReadTransportError('capability_failure', 'codex');
             const named = namedCodexFailure(turnFailure, codexHome);
             throw named ?? new Error(`Codex turn failed: ${gitErrorMessage(turnFailure)}; ${diagnostic(exitCode, stderrTail, stdoutBytes, stdoutLines, parsedLines, unparseableLines, stdoutFirst, stdoutLast, firstUnparseableLineLength, firstUnparseableLineFirst, firstUnparseableLineLast, typeCounts, toleratedErrorItems, request.purpose)}`);
         }
         if (finalText === null || finalText.length === 0) {
+            if (request.wholeRead)
+                throw new WholeReadTransportError('capability_failure', 'codex');
             if (capturedStdinError)
                 throw promptWriteFailure(capturedStdinError);
             throw new Error(diagnostic(exitCode, stderrTail, stdoutBytes, stdoutLines, parsedLines, unparseableLines, stdoutFirst, stdoutLast, firstUnparseableLineLength, firstUnparseableLineFirst, firstUnparseableLineLast, typeCounts, toleratedErrorItems, request.purpose));
         }
-        if (capturedStdinError)
+        if (capturedStdinError) {
+            if (request.wholeRead)
+                throw new WholeReadTransportError('capability_failure', 'codex');
             throw promptWriteFailure(capturedStdinError);
+        }
+        if (request.wholeRead && finishReason === 'max_tokens') {
+            throw new WholeReadTransportError('output_truncated', 'codex');
+        }
+        if (request.wholeRead && finishReason === 'refusal') {
+            throw new WholeReadTransportError('model_declined', 'codex');
+        }
         if (request.schema) {
             let result;
             try {
                 result = JSON.parse(finalText);
             }
             catch (error) {
+                if (request.wholeRead)
+                    throw new WholeReadTransportError('capability_failure', 'codex');
                 throw new Error(`Codex wrote an invalid JSON final message: ${gitErrorMessage(error)}`);
             }
             stripIntroducedNulls(result, schemaRecord);
             finalText = JSON.stringify(result);
         }
         options.onUsage?.(usage);
-        return { text: finalText, usage };
+        return {
+            text: finalText,
+            usage,
+            ...(request.wholeRead ? { metadata: {
+                    finishReason,
+                    model: actualModel ?? options.model,
+                    usageAvailable: usage !== null,
+                } } : {}),
+        };
     }
     finally {
         await removeTemporaryDirectory(invocationCwd, removeDirectory);

package/dist/config.js

@@ -1,7 +1,8 @@
 /** Reads/writes ~/.product-console-companion/config.json. */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
+import { configuredManagedRepository, githubLabel, ManagedCopyRetirementError, retireManagedCopy, usesTemporaryManagedStorage, } from './managed-repo.js';
 // Kept on purpose from the old name so existing pairings continue to load after upgrading.
 const CONFIG_DIR = join(homedir(), '.product-console-companion');
 const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
@@ -98,6 +99,180 @@ export function recordWorkspaceId(url, token, workspaceId, configFile) {
     save(config, configFile);
     return config;
 }
+export function hasTemporaryManagedRepository(args) {
+    const pairing = loadConfig(args.configFile)?.pairings.find((candidate) => samePairing(candidate, args));
+    if (!pairing)
+        return false;
+    const wanted = githubLabel(args.repository).toLowerCase();
+    return pairing.connections.some((connection) => {
+        if (connection.managed !== true || connection.repositoryStorage !== 'temporary')
+            return false;
+        try {
+            return githubLabel(configuredManagedRepository(connection)).toLowerCase() === wanted;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Marks legacy managed connections only after this Console enables temporary repositories.
+ *  The old path is retained as B38-c's cleanup target; no source storage is changed here. */
+export function migrateManagedRepositoriesToTemporaryStorage(args) {
+    const config = loadConfig(args.configFile);
+    if (!config)
+        return null;
+    let pairing = config.pairings.find((candidate) => samePairing(candidate, args));
+    if (!pairing) {
+        const legacy = config.pairings.filter((candidate) => candidate.workspaceId === undefined
+            && normalizeConsoleUrl(candidate.url) === normalizeConsoleUrl(args.url));
+        if (legacy.length === 1)
+            pairing = legacy[0];
+    }
+    if (!pairing)
+        return null;
+    let changed = false;
+    if (pairing.workspaceId === undefined) {
+        pairing.workspaceId = args.workspaceId;
+        changed = true;
+    }
+    for (const connection of pairing.connections) {
+        if (connection.managed !== true)
+            continue;
+        try {
+            const repository = configuredManagedRepository(connection);
+            const identity = { host: 'github.com', port: null, path: githubLabel(repository) };
+            if (connection.repositoryStorage !== 'temporary'
+                || connection.repository?.host !== identity.host
+                || connection.repository.port !== identity.port
+                || connection.repository.path !== identity.path) {
+                connection.repository = identity;
+                connection.repositoryStorage = 'temporary';
+                changed = true;
+            }
+        }
+        catch {
+            // An invalid legacy entry is left untouched and cannot be cleaned up as a migrated copy.
+        }
+    }
+    if (changed)
+        save(config, args.configFile);
+    return pairing;
+}
+function cleanupPathKey(path) {
+    let absolute = resolve(path);
+    try {
+        absolute = realpathSync.native(absolute);
+    }
+    catch {
+        // A missing path has no physical alias and is compared lexically.
+    }
+    return process.platform === 'win32' ? absolute.toLowerCase() : absolute;
+}
+/** Deletes historical managed copies only while this workspace advertises the rollout and only
+ * after the per-connection migration marker is durable. Every configured Console is considered
+ * before a shared path can be removed. */
+export async function cleanupMigratedManagedRepositories(args, dependencies = {}) {
+    const result = { removed: [], cleanupPending: [] };
+    if (!args.temporaryRepositories)
+        return result;
+    const config = loadConfig(args.configFile);
+    const pairing = config?.pairings.find((candidate) => samePairing(candidate, args));
+    if (!config || !pairing)
+        return result;
+    const reposDir = managedReposDir(args.configFile);
+    const handled = new Set();
+    for (const connection of pairing.connections) {
+        if (!usesTemporaryManagedStorage(connection) || connection.managedCopyCleanup?.state === 'removed')
+            continue;
+        const path = resolve(connection.repoPath);
+        const key = cleanupPathKey(path);
+        if (handled.has(key))
+            continue;
+        handled.add(key);
+        const references = config.pairings.flatMap((candidate) => candidate.connections)
+            .filter((candidate) => cleanupPathKey(candidate.repoPath) === key);
+        let repository;
+        try {
+            repository = configuredManagedRepository(connection);
+        }
+        catch {
+            const cleanupAttempts = connection.managedCopyCleanup?.cleanupAttempts ?? 0;
+            connection.managedCopyCleanup = {
+                state: 'cleanup_pending', path, cleanupAttempts, errorCode: 'cleanup_identity_mismatch',
+            };
+            save(config, args.configFile);
+            result.cleanupPending.push({ path, cleanupAttempts, errorCode: 'cleanup_identity_mismatch' });
+            continue;
+        }
+        const label = githubLabel(repository).toLowerCase();
+        const allReferencesMigrated = references.every((candidate) => {
+            if (!usesTemporaryManagedStorage(candidate))
+                return false;
+            try {
+                return githubLabel(configuredManagedRepository(candidate)).toLowerCase() === label;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!allReferencesMigrated) {
+            const cleanupAttempts = connection.managedCopyCleanup?.cleanupAttempts ?? 0;
+            connection.managedCopyCleanup = {
+                state: 'cleanup_pending', path, cleanupAttempts, errorCode: 'cleanup_path_referenced',
+            };
+            save(config, args.configFile);
+            result.cleanupPending.push({ path, cleanupAttempts, errorCode: 'cleanup_path_referenced' });
+            continue;
+        }
+        const migratedReferences = references.filter(usesTemporaryManagedStorage);
+        try {
+            const retired = await retireManagedCopy({
+                repoPath: path,
+                reposDir,
+                repo: repository,
+                onValidated() {
+                    for (const candidate of migratedReferences) {
+                        candidate.managedCopyCleanup = {
+                            state: 'cleanup_pending',
+                            path,
+                            cleanupAttempts: candidate.managedCopyCleanup?.cleanupAttempts ?? 0,
+                            errorCode: null,
+                        };
+                    }
+                    save(config, args.configFile);
+                },
+            }, dependencies);
+            for (const candidate of migratedReferences) {
+                candidate.managedCopyCleanup = {
+                    state: 'removed',
+                    path,
+                    cleanupAttempts: (candidate.managedCopyCleanup?.cleanupAttempts ?? 0) + retired.cleanupAttempts,
+                    errorCode: null,
+                };
+            }
+            save(config, args.configFile);
+            result.removed.push(path);
+        }
+        catch (error) {
+            const errorCode = error instanceof ManagedCopyRetirementError
+                ? error.code
+                : 'cleanup_delete_failed';
+            for (const candidate of migratedReferences) {
+                candidate.managedCopyCleanup = {
+                    state: 'cleanup_pending',
+                    path,
+                    cleanupAttempts: (candidate.managedCopyCleanup?.cleanupAttempts ?? 0)
+                        + (errorCode === 'cleanup_delete_failed' ? 5 : 0),
+                    errorCode,
+                };
+            }
+            save(config, args.configFile);
+            const cleanupAttempts = connection.managedCopyCleanup?.cleanupAttempts ?? 0;
+            result.cleanupPending.push({ path, cleanupAttempts, errorCode });
+        }
+    }
+    return result;
+}
 export function removePairing(url, workspaceId, configFile) {
     const config = loadConfig(configFile);
     if (!config)

package/dist/git-range.js

@@ -28,8 +28,10 @@ export function gitRangeEnvironment(parent = process.env) {
     delete environment.GIT_CONFIG_NOSYSTEM;
     return environment;
 }
-function runGit(repoPath, args, outputLimit, input, environment) {
+function runGit(repoPath, args, outputLimit, input, environment, execution) {
     return new Promise((resolve, reject) => {
+        if (execution?.signal.aborted)
+            return reject(new GitCommandFailure('resource'));
         const child = spawn('git', ['--no-replace-objects', ...args], {
             cwd: repoPath,
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -41,19 +43,35 @@ function runGit(repoPath, args, outputLimit, input, environment) {
         let stdoutBytes = 0;
         let stderrBytes = 0;
         let settled = false;
+        let closeProcess;
+        const processClosed = new Promise((done) => { closeProcess = done; });
+        const unregister = execution?.registerReader({
+            cancel: async () => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill('SIGKILL');
+                await processClosed;
+            },
+        }) ?? (() => undefined);
+        const abort = () => {
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL');
+        };
+        execution?.signal.addEventListener('abort', abort, { once: true });
         const finish = (error, value) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
+            execution?.signal.removeEventListener('abort', abort);
+            unregister();
             if (error)
                 reject(error);
             else
                 resolve(value);
         };
         const overflow = () => {
-            child.kill('SIGKILL');
-            finish(new GitCommandFailure('resource'));
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL');
         };
         child.stdout?.on('data', (chunk) => {
             stdoutBytes += chunk.length;
@@ -68,15 +86,19 @@ function runGit(repoPath, args, outputLimit, input, environment) {
             if (stdoutBytes + stderrBytes > outputLimit)
                 overflow();
         });
-        child.on('error', () => finish(new GitCommandFailure('resource')));
+        child.on('error', () => {
+            closeProcess();
+            finish(new GitCommandFailure('resource'));
+        });
         child.on('close', (code, signal) => {
+            closeProcess();
             if (signal || code === null)
                 return finish(new GitCommandFailure('resource'));
             finish(undefined, { stdout: Buffer.concat(stdout), exitCode: code, stderr: Buffer.concat(stderr).toString('utf8') });
         });
         const timer = setTimeout(() => {
-            child.kill('SIGKILL');
-            finish(new GitCommandFailure('resource'));
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL');
         }, GIT_RANGE_COMMAND_TIMEOUT_MS);
         if (input)
             child.stdin?.end(input);
@@ -166,7 +188,7 @@ export function fitsGitRangeTransport(result) {
     return Buffer.byteLength(JSON.stringify({ result, filesRead: [] }), 'utf8') <= GIT_RANGE_MAX_HTTP_BYTES;
 }
 const failure = (code) => ({ ok: false, code });
-export async function runGitRangeTask(task, repoPath, connection) {
+export async function runGitRangeTask(task, repoPath, connection, acquired) {
     const payload = task.payload;
     const branch = payload.branch;
     const base = payload.base;
@@ -178,40 +200,54 @@ export async function runGitRangeTask(task, repoPath, connection) {
             || (payload.schemaProbe !== undefined && !validSchemaProbe(payload.schemaProbe))) {
             return { result: failure('history_failed'), filesRead: [] };
         }
-        const branchCheck = await runGit(repoPath, ['check-ref-format', '--branch', branch], GIT_RANGE_METADATA_OUTPUT_BYTES);
-        const remoteList = await runGit(repoPath, ['remote'], GIT_RANGE_METADATA_OUTPUT_BYTES);
+        if (acquired && (acquired.base !== base || !SHA.test(acquired.head))) {
+            return { result: failure('history_failed'), filesRead: [] };
+        }
+        const executeGit = (args, outputLimit, input, environment = acquired?.environment) => runGit(repoPath, args, outputLimit, input, environment, acquired);
+        const branchCheck = await executeGit(['check-ref-format', '--branch', branch], GIT_RANGE_METADATA_OUTPUT_BYTES);
+        const remoteList = acquired ? null : await executeGit(['remote'], GIT_RANGE_METADATA_OUTPUT_BYTES);
         if (branchCheck.exitCode !== 0)
             return { result: failure('branch_missing'), filesRead: [] };
-        const remotes = exactLine(Buffer.concat([remoteList.stdout, remoteList.stdout.length === 0 ? Buffer.from('\n') : Buffer.alloc(0)]));
-        if (remoteList.exitCode !== 0 || !remotes.split('\n').includes(remote))
-            return { result: failure('branch_missing'), filesRead: [] };
-        destination = `refs/product-console/git-range/${task.id}/${randomUUID()}/head`;
-        const destinationCheck = await runGit(repoPath, ['check-ref-format', destination], GIT_RANGE_METADATA_OUTPUT_BYTES);
-        const sourceCheck = await runGit(repoPath, ['check-ref-format', `refs/heads/${branch}`], GIT_RANGE_METADATA_OUTPUT_BYTES);
-        if (destinationCheck.exitCode !== 0 || sourceCheck.exitCode !== 0)
-            return { result: failure('branch_missing'), filesRead: [] };
-        const fetchEnvironment = await managedFetchEnvironment(repoPath);
-        delete fetchEnvironment.GIT_CONFIG_NOSYSTEM;
-        const fetched = await runGit(repoPath, [
-            'fetch', '--no-tags', '--refmap=', '--no-write-fetch-head', '--no-recurse-submodules', '--',
-            remote, `+refs/heads/${branch}:${destination}`,
-        ], GIT_RANGE_METADATA_OUTPUT_BYTES, undefined, fetchEnvironment);
-        reportBackgroundFetch(repoPath, { ok: fetched.exitCode === 0, stderr: fetched.stderr });
-        if (fetched.exitCode !== 0)
-            return { result: failure('fetch_failed'), filesRead: [] };
-        const resolved = await runGit(repoPath, ['rev-parse', '--verify', `${destination}^{commit}`], GIT_RANGE_METADATA_OUTPUT_BYTES);
-        if (resolved.exitCode !== 0)
-            return { result: failure('history_failed'), filesRead: [] };
-        const head = exactLine(resolved.stdout);
-        if (!SHA.test(head))
-            return { result: failure('history_failed'), filesRead: [] };
-        const shallowOutput = await runGit(repoPath, ['rev-parse', '--is-shallow-repository'], GIT_RANGE_METADATA_OUTPUT_BYTES);
-        if (shallowOutput.exitCode !== 0)
-            return { result: failure('history_failed'), filesRead: [] };
-        const shallowText = exactLine(shallowOutput.stdout);
-        if (shallowText !== 'true' && shallowText !== 'false')
-            return { result: failure('history_failed'), filesRead: [] };
-        const historyShallow = shallowText === 'true';
+        let head;
+        let historyShallow;
+        if (acquired) {
+            head = acquired.head;
+            historyShallow = acquired.historyShallow;
+        }
+        else {
+            const remotes = exactLine(Buffer.concat([remoteList.stdout,
+                remoteList.stdout.length === 0 ? Buffer.from('\n') : Buffer.alloc(0)]));
+            if (remoteList.exitCode !== 0 || !remotes.split('\n').includes(remote)) {
+                return { result: failure('branch_missing'), filesRead: [] };
+            }
+            destination = `refs/product-console/git-range/${task.id}/${randomUUID()}/head`;
+            const destinationCheck = await executeGit(['check-ref-format', destination], GIT_RANGE_METADATA_OUTPUT_BYTES);
+            const sourceCheck = await executeGit(['check-ref-format', `refs/heads/${branch}`], GIT_RANGE_METADATA_OUTPUT_BYTES);
+            if (destinationCheck.exitCode !== 0 || sourceCheck.exitCode !== 0)
+                return { result: failure('branch_missing'), filesRead: [] };
+            const fetchEnvironment = await managedFetchEnvironment(repoPath);
+            delete fetchEnvironment.GIT_CONFIG_NOSYSTEM;
+            const fetched = await executeGit([
+                'fetch', '--no-tags', '--refmap=', '--no-write-fetch-head', '--no-recurse-submodules', '--',
+                remote, `+refs/heads/${branch}:${destination}`,
+            ], GIT_RANGE_METADATA_OUTPUT_BYTES, undefined, fetchEnvironment);
+            reportBackgroundFetch(repoPath, { ok: fetched.exitCode === 0, stderr: fetched.stderr });
+            if (fetched.exitCode !== 0)
+                return { result: failure('fetch_failed'), filesRead: [] };
+            const resolved = await executeGit(['rev-parse', '--verify', `${destination}^{commit}`], GIT_RANGE_METADATA_OUTPUT_BYTES);
+            if (resolved.exitCode !== 0)
+                return { result: failure('history_failed'), filesRead: [] };
+            head = exactLine(resolved.stdout);
+            if (!SHA.test(head))
+                return { result: failure('history_failed'), filesRead: [] };
+            const shallowOutput = await executeGit(['rev-parse', '--is-shallow-repository'], GIT_RANGE_METADATA_OUTPUT_BYTES);
+            if (shallowOutput.exitCode !== 0)
+                return { result: failure('history_failed'), filesRead: [] };
+            const shallowText = exactLine(shallowOutput.stdout);
+            if (shallowText !== 'true' && shallowText !== 'false')
+                return { result: failure('history_failed'), filesRead: [] };
+            historyShallow = shallowText === 'true';
+        }
         if (base === null) {
             const result = { ok: true, mode: 'head_only', head, base, commits: [], changedPaths: [], totalCommits: null, baseUnavailable: false, truncatedFiles: false, historyShallow };
             return { result: fitsGitRangeTransport(result) ? result : failure('history_failed'), filesRead: [] };
@@ -220,7 +256,12 @@ export async function runGitRangeTask(task, repoPath, connection) {
             const result = { ok: true, mode: 'range', head, base, commits: [], changedPaths: [], totalCommits: 0, baseUnavailable: false, truncatedFiles: false, historyShallow };
             return { result: fitsGitRangeTransport(result) ? result : failure('history_failed'), filesRead: [] };
         }
-        const baseCheck = await runGit(repoPath, ['cat-file', '--batch-check'], GIT_RANGE_METADATA_OUTPUT_BYTES, Buffer.from(`${base}\n`));
+        if (acquired?.baseUnavailableReason) {
+            return { result: { ok: true, mode: 'base_unavailable', head, base, commits: [], changedPaths: [],
+                    totalCommits: null, baseUnavailable: true,
+                    baseUnavailableReason: acquired.baseUnavailableReason, truncatedFiles: false, historyShallow }, filesRead: [] };
+        }
+        const baseCheck = await executeGit(['cat-file', '--batch-check'], GIT_RANGE_METADATA_OUTPUT_BYTES, Buffer.from(`${base}\n`));
         if (baseCheck.exitCode !== 0)
             return { result: failure('history_failed'), filesRead: [] };
         const baseDescription = exactLine(baseCheck.stdout);
@@ -229,19 +270,19 @@ export async function runGitRangeTask(task, repoPath, connection) {
         }
         if (!new RegExp(`^${base} commit [0-9]+$`).test(baseDescription))
             return { result: failure('history_failed'), filesRead: [] };
-        if (historyShallow) {
+        if (historyShallow && !acquired) {
             return { result: { ok: true, mode: 'base_unavailable', head, base, commits: [], changedPaths: [], totalCommits: null, baseUnavailable: true, baseUnavailableReason: 'shallow_history', truncatedFiles: false, historyShallow }, filesRead: [] };
         }
-        const ancestor = await runGit(repoPath, ['merge-base', '--is-ancestor', base, head], GIT_RANGE_METADATA_OUTPUT_BYTES);
+        const ancestor = await executeGit(['merge-base', '--is-ancestor', base, head], GIT_RANGE_METADATA_OUTPUT_BYTES);
         if (ancestor.exitCode === 1) {
             return { result: { ok: true, mode: 'base_unavailable', head, base, commits: [], changedPaths: [], totalCommits: null, baseUnavailable: true, baseUnavailableReason: 'not_ancestor', truncatedFiles: false, historyShallow }, filesRead: [] };
         }
         if (ancestor.exitCode !== 0)
             return { result: failure('history_failed'), filesRead: [] };
         const [enumerated, counted, diff] = await Promise.all([
-            runGit(repoPath, ['rev-list', '--topo-order', '--reverse', `${base}..${head}`, '--'], GIT_RANGE_ENUMERATION_OUTPUT_BYTES),
-            runGit(repoPath, ['rev-list', '--count', `${base}..${head}`, '--'], GIT_RANGE_METADATA_OUTPUT_BYTES),
-            runGit(repoPath, ['diff', '--no-color', '--name-status', '-z', '-M', base, head], GIT_RANGE_PATH_OUTPUT_BYTES),
+            executeGit(['rev-list', '--topo-order', '--reverse', `${base}..${head}`, '--'], GIT_RANGE_ENUMERATION_OUTPUT_BYTES),
+            executeGit(['rev-list', '--count', `${base}..${head}`, '--'], GIT_RANGE_METADATA_OUTPUT_BYTES),
+            executeGit(['diff', '--no-color', '--name-status', '-z', '-M', base, head], GIT_RANGE_PATH_OUTPUT_BYTES),
         ]);
         if (enumerated.exitCode !== 0 || counted.exitCode !== 0 || diff.exitCode !== 0)
             return { result: failure('history_failed'), filesRead: [] };
@@ -259,7 +300,7 @@ export async function runGitRangeTask(task, repoPath, connection) {
             return { result: failure('history_failed'), filesRead: [] };
         }
         const selected = oids.slice(0, GIT_RANGE_MAX_COMMITS);
-        const objects = await runGit(repoPath, ['cat-file', '--batch'], GIT_RANGE_OBJECT_OUTPUT_BYTES, Buffer.from(`${selected.join('\n')}\n`));
+        const objects = await executeGit(['cat-file', '--batch'], GIT_RANGE_OBJECT_OUTPUT_BYTES, Buffer.from(`${selected.join('\n')}\n`));
         if (objects.exitCode !== 0)
             return { result: failure('history_failed'), filesRead: [] };
         const commits = parseCommitObjects(objects.stdout, selected);
@@ -272,6 +313,7 @@ export async function runGitRangeTask(task, repoPath, connection) {
                 head,
                 changedPaths: paths.changedPaths,
                 probe: payload.schemaProbe,
+                environment: acquired?.environment,
             });
         const result = {
             ok: true, mode: 'range', head, base, commits, changedPaths: paths.changedPaths,