@withtruing/companion 0.13.3 → 0.14.1

package/dist/cli.js

@@ -1,22 +1,29 @@
 #!/usr/bin/env node
 import Anthropic from '@anthropic-ai/sdk';
 import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { addConnection, configPath, enableWorkspacePolling, loadConfig, managedReposDir, normalizeConsoleUrl, recordWorkspaceId, removePairing, } from './config.js';
-import { CompanionClient, CompanionHttpError, PairingHttpError, } from './http-client.js';
-import { assertIsRepo, checkRepositoryReadiness, currentCommit, GIT_UNAVAILABLE_MESSAGE, REMOTE_TROUBLESHOOTING_HINT, repositoryIdentity, RepositoryIdentityError, repositoryTopLevel, } from './local-scan.js';
+import { addConnection, cleanupMigratedManagedRepositories, configPath, enableWorkspacePolling, hasTemporaryManagedRepository, loadConfig, managedReposDir, migrateManagedRepositoriesToTemporaryStorage, normalizeConsoleUrl, recordWorkspaceId, removePairing, } from './config.js';
+import { CompanionClient, CompanionHttpError, CLAUDE_CLI_FAST_MODEL, wholeReadBackendName as sharedWholeReadBackendName, CODEX_FAST_MODEL, PairingHttpError, } from './http-client.js';
+import { assertIsRepo, currentCommit, GIT_UNAVAILABLE_MESSAGE, REMOTE_TROUBLESHOOTING_HINT, repositoryIdentity, RepositoryIdentityError, repositoryTopLevel, } from './local-scan.js';
 import { runAnalyseShipmentTask, runDesignPromptTask, runGenerateSpecBatchTask, runGenericTask, runProposeNewCapabilitiesTask, runProposeSkeletonTask, runStructuredModelCall, runVerifyModuleTask } from './api-key-caller.js';
-import { runAnalyseShipmentTaskViaCli, runDesignPromptTaskViaCli, runGenerateSpecBatchTaskViaCli, runGenericTaskViaCli, runProposeNewCapabilitiesTaskViaCli, runProposeSkeletonTaskViaCli, runStructuredModelCallViaCli, runVerifyModuleTaskViaCli } from './claude-cli-caller.js';
+import { runAnalyseShipmentTaskViaCli, runDesignPromptTaskViaCli, runGenerateSpecBatchTaskViaCli, runGenericTaskViaCli, runProposeNewCapabilitiesTaskViaCli, runProposeSkeletonTaskViaCli, runStructuredModelCallViaCli, runVerifyModuleTaskViaCli, runWholeReadModelCallViaCli } from './claude-cli-caller.js';
 import { spawnClaude } from './claude-binary.js';
 import { checkCodexLogin, CODEX_CODE_MODE_MODELS, codexTextModel, defaultCodexHome, runStructuredModelCallViaCodex } from './codex-cli-caller.js';
 import { formatInvestigationReaderDiagnostic, INVESTIGATION_MODEL, runAndReportInvestigation } from './investigation-reader.js';
 import { anthropicTextModel } from './text-model.js';
-import { MappingFailure, runSurfaceMapping, SURFACE_SEED_MODEL } from './surface-mapper.js';
+import { MappingFailure, readSurfaceSnapshotChangeSet, runSurfaceMapping, runSurfaceMappingCheckout, SURFACE_SEED_MODEL, } from './surface-mapper.js';
 import { assertSnapshotReadBoundary, createSandbox } from './sandbox.js';
 import { runGitRangeTask } from './git-range.js';
-import { gitAvailable, githubLabel, interactiveFetch, labelFromCopyPath, ManagedRepoError, managedCopyPath, parseGitHubRepo, prepareManagedCopy, readManagedState, relativeTime, removeManagedCopy, watchManagedCopy, } from './managed-repo.js';
+import { configuredManagedRepository, gitAvailable, githubCloneUrl, githubLabel, interactiveFetch, labelFromCopyPath, ManagedRepoError, managedCopyPath, parseGitHubRepo, prepareManagedCopy, readManagedState, relativeTime, removeManagedCopy, watchManagedCopy, usesTemporaryManagedStorage, } from './managed-repo.js';
 import { isUsageLimitError, UsageLimitPause } from './usage-limit.js';
+import { AttemptSourceCleanupError, createCompanionAttemptSourceManager, startAttemptSourceSweeper, stopAttemptSourceSweeper, withAttemptSource, } from './whole-read-temp.js';
+import { createWholeReadAssignmentPool, } from './whole-read-pool.js';
+import { createWholeReadSharedSourceManager, } from './whole-read-shared-source.js';
+import { checkConnectionRepositoryReadiness, createRepositoryProvider, proveManagedRepositoryAccess, RepositoryProviderError, } from './repository-provider.js';
+import { WholeReadGitError } from './whole-read-git.js';
+import { acquireGithubCompanionSource, acquireAssignedSource, assignmentRouteReadinessCode, acquireLocalSource, dispatchWholeReadClaim, } from './whole-read-runner.js';
+import { WHOLE_READ_PHASE_POLICY } from './whole-read/phase-policy.js';
 import { acquireInstanceLock, installService, isNpxCachePath, releaseInstanceLock, runDaemon, servicePaths, serviceStatus, startService, stopService, uninstallService, } from './service.js';
 const DEFAULT_CODEX_MODEL = 'gpt-6-astra';
 const SURFACE_MAPPING_UNAVAILABLE_STATUSES = new Set([401, 403, 404, 405]);
@@ -100,6 +107,21 @@ function testCloneUrl(repo) {
     const base = process.env.NODE_ENV === 'test' ? process.env.PC_TEST_GITHUB_CLONE_BASE : undefined;
     return base ? `${base.replace(/\/+$/, '')}/${repo.owner}/${repo.name}.git` : undefined;
 }
+async function activateManagedCopyCleanup(url, workspaceId, output = console) {
+    try {
+        const cleanup = await cleanupMigratedManagedRepositories({
+            url, workspaceId, temporaryRepositories: true,
+        });
+        for (const path of cleanup.removed)
+            output.log(`Removed the companion's retired managed copy at ${path}.`);
+        for (const pending of cleanup.cleanupPending) {
+            output.error(`Managed-copy cleanup_pending at ${pending.path} (${pending.errorCode}); the companion will retry on restart.`);
+        }
+    }
+    catch {
+        output.error('Managed-copy cleanup_pending; the companion will retry on restart.');
+    }
+}
 const restartHint = 'The companion is already running in the background — run "truing stop" then "truing start" so it picks up this new connection.';
 function logRestartHintIfRunning() {
     if (serviceStatus().running)
@@ -205,43 +227,60 @@ async function cmdConnect(argv) {
             console.log(`Found Claude Code: ${version}`);
         }
         const client = new CompanionClient(url, token);
-        let workspaceId;
+        let serverIdentity;
         try {
-            ({ workspaceId } = await client.whoami());
+            serverIdentity = await client.whoami();
         }
         catch {
             console.error('Could not verify the companion token. Double check that you copied the whole token, including the part after the dot.');
             process.exitCode = 1;
             return;
         }
+        const { workspaceId } = serverIdentity;
+        const temporaryManagedRepository = managedRepo !== null && (serverIdentity.temporaryRepositories === true
+            || hasTemporaryManagedRepository({ url, workspaceId, repository: managedRepo }));
         let managedPath = null;
+        let managedDefaultBranch = null;
         if (managedRepo) {
+            let reconnectMessageShown = false;
+            const label = githubLabel(managedRepo);
+            const getToken = async () => {
+                const response = await client.githubToken(label);
+                if (response.reason === 'github_reconnect_needed' && !reconnectMessageShown) {
+                    reconnectMessageShown = true;
+                    console.error(response.message ?? 'Reconnect GitHub in the Console.');
+                }
+                return response.token;
+            };
             try {
-                let reconnectMessageShown = false;
-                const label = githubLabel(managedRepo);
-                const copy = await prepareManagedCopy({
-                    repo: managedRepo,
-                    branch: f.branch,
-                    reposDir: managedReposDir(),
-                    cloneUrl: testCloneUrl(managedRepo),
-                    getToken: async () => {
-                        const response = await client.githubToken(label);
-                        if (response.reason === 'github_reconnect_needed' && !reconnectMessageShown) {
-                            reconnectMessageShown = true;
-                            console.error(response.message ?? 'Reconnect GitHub in the Console.');
-                        }
-                        return response.token;
-                    },
-                });
-                managedPath = copy.path;
-                if (copy.fetchOk === false) {
-                    console.error(reconnectMessageShown
-                        ? `Couldn't bring the copy of ${githubLabel(managedRepo)} up to date just now. The companion keeps trying; if it keeps failing, reconnect GitHub in the Console.`
-                        : `Couldn't bring the copy of ${githubLabel(managedRepo)} up to date just now. The companion keeps trying; if it keeps failing, run: truing signin`);
+                if (temporaryManagedRepository) {
+                    const access = await proveManagedRepositoryAccess({
+                        repository: managedRepo,
+                        branch: f.branch,
+                        credential: await getToken(),
+                    }, { managedRepositoryUrl: (repository) => testCloneUrl(repository) ?? githubCloneUrl(repository) });
+                    managedDefaultBranch = access.defaultBranch;
+                }
+                else {
+                    const copy = await prepareManagedCopy({
+                        repo: managedRepo,
+                        branch: f.branch,
+                        reposDir: managedReposDir(),
+                        cloneUrl: testCloneUrl(managedRepo),
+                        getToken,
+                    });
+                    managedPath = copy.path;
+                    if (copy.fetchOk === false) {
+                        console.error(reconnectMessageShown
+                            ? `Couldn't bring the copy of ${githubLabel(managedRepo)} up to date just now. The companion keeps trying; if it keeps failing, reconnect GitHub in the Console.`
+                            : `Couldn't bring the copy of ${githubLabel(managedRepo)} up to date just now. The companion keeps trying; if it keeps failing, run: truing signin`);
+                    }
                 }
             }
             catch (error) {
-                console.error(error instanceof ManagedRepoError ? error.message : `Couldn't copy ${githubLabel(managedRepo)} from GitHub.`);
+                console.error(error instanceof ManagedRepoError ? error.message : temporaryManagedRepository
+                    ? `Couldn't verify access to ${githubLabel(managedRepo)}. Reconnect GitHub in the Console, then run this command again.`
+                    : `Couldn't copy ${githubLabel(managedRepo)} from GitHub.`);
                 process.exitCode = 1;
                 return;
             }
@@ -263,9 +302,46 @@ async function cmdConnect(argv) {
             return;
         }
         const requestedFolder = managedPath ?? resolve(f.path || '.');
-        const topLevel = f['no-repo'] === 'true' ? null : await repositoryTopLevel(requestedFolder);
+        const topLevel = f['no-repo'] === 'true' || temporaryManagedRepository
+            ? null
+            : await repositoryTopLevel(requestedFolder);
         let registered = false;
-        if (topLevel) {
+        if (managedRepo && temporaryManagedRepository && managedDefaultBranch) {
+            try {
+                const identity = {
+                    host: 'github.com',
+                    port: null,
+                    path: githubLabel(managedRepo),
+                    defaultBranch: managedDefaultBranch,
+                };
+                const { connection } = await client.registerConnection(identity);
+                addConnection({
+                    url,
+                    token,
+                    workspaceId,
+                    connection: {
+                        connectionId: connection.id,
+                        repoPath: managedCopyPath(managedReposDir(), managedRepo),
+                        backend,
+                        codexModel: backend === 'codex' && f['codex-model'] ? codexModel : undefined,
+                        branch: identity.defaultBranch,
+                        label: githubLabel(managedRepo),
+                        managed: true,
+                        repository: { host: identity.host, port: identity.port, path: identity.path },
+                        repositoryStorage: 'temporary',
+                    },
+                    apiKey: backend === 'codex' ? undefined : apiKey,
+                });
+                console.log(`Connected ${githubLabel(managedRepo)}. The companion will access it temporarily when work needs it; no permanent code copy was created.`);
+                registered = true;
+            }
+            catch (error) {
+                console.error(error instanceof PairingHttpError
+                    ? `${error.code}: ${error.message}`
+                    : 'registration_failed: Could not register this repository with the console.');
+            }
+        }
+        else if (topLevel) {
             try {
                 const { remote, ...identity } = await repositoryIdentity(topLevel, {
                     remote: managedRepo ? 'origin' : f.remote,
@@ -282,6 +358,7 @@ async function cmdConnect(argv) {
                         backend,
                         codexModel: backend === 'codex' && f['codex-model'] ? codexModel : undefined,
                         remote,
+                        branch: identity.defaultBranch,
                         ...(managedRepo ? { label: githubLabel(managedRepo), managed: true } : {}),
                     },
                     apiKey: backend === 'codex' ? undefined : apiKey,
@@ -307,6 +384,10 @@ async function cmdConnect(argv) {
         else if (f['no-repo'] !== 'true') {
             console.log("No project folder here — to connect your code, run this same command inside your project's folder.");
         }
+        if (serverIdentity.temporaryRepositories === true) {
+            migrateManagedRepositoriesToTemporaryStorage({ url, workspaceId });
+            await activateManagedCopyCleanup(url, workspaceId);
+        }
         if (!registered) {
             try {
                 await client.recordPairingOutcome('workspace_only');
@@ -366,6 +447,7 @@ async function cmdConnect(argv) {
                 backend,
                 codexModel: backend === 'codex' && f['codex-model'] ? codexModel : undefined,
                 remote: f.remote,
+                ...(f.branch ? { branch: f.branch } : {}),
             },
             apiKey: backend === 'codex' ? undefined : apiKey,
         });
@@ -604,6 +686,9 @@ export function logInvestigationDiagnostic(diagnostic, output = console) {
     output.error(formatInvestigationReaderDiagnostic(diagnostic));
 }
 export function taskRunnerFor(backend, kind) {
+    if (kind.startsWith('whole-read-')) {
+        return async () => { throw new Error('build_task_kind_unsupported'); };
+    }
     if (backend === 'cli') {
         if (kind === 'verify_module')
             return runVerifyModuleTaskViaCli;
@@ -633,11 +718,18 @@ export function taskRunnerFor(backend, kind) {
         return runAnalyseShipmentTask;
     return runGenericTask;
 }
-export async function runTask(task, runtime, repoPath, connection) {
+export async function runTask(task, runtime, repoPath, connection, repositoryLease) {
     if (task.kind === 'git_range') {
         if (!connection)
             return { result: { ok: false, code: 'history_failed' }, filesRead: [] };
-        return runGitRangeTask(task, repoPath, connection);
+        if (!repositoryLease?.range)
+            return runGitRangeTask(task, repoPath, connection);
+        return runGitRangeTask(task, repositoryLease.gitDirectory, connection, {
+            ...repositoryLease.range,
+            environment: repositoryLease.gitEnvironment(),
+            signal: new AbortController().signal,
+            registerReader: (reader) => repositoryLease.registerReader(reader),
+        });
     }
     const runner = taskRunnerFor(runtime.backend, task.kind);
     const payload = task.payload;
@@ -648,6 +740,20 @@ export async function runTask(task, runtime, repoPath, connection) {
     }
     if (typeof payload.snapshotSha !== 'string')
         throw new Error('snapshot_unavailable');
+    if (repositoryLease) {
+        let checkout;
+        try {
+            checkout = await repositoryLease.checkout();
+            await assertSnapshotReadBoundary(checkout.path);
+        }
+        catch (error) {
+            throw error instanceof RepositoryProviderError ? error : new Error('snapshot_unavailable');
+        }
+        const outcome = runtime.backend === 'cli'
+            ? await runner(task, checkout.path)
+            : await runner(runtime.textModel, task, checkout.path);
+        return { ...outcome, snapshot: { sha: checkout.commit } };
+    }
     let sandbox;
     try {
         sandbox = await createSandbox(repoPath, payload.snapshotSha);
@@ -679,7 +785,7 @@ function formatCodexUsage(usage) {
         return 'unavailable';
     return Object.entries(usage).map(([name, value]) => `${name}=${value}`).join(', ');
 }
-export async function runOneTask(runtime, client, repoPath, task, connection, output = console) {
+export async function runOneTask(runtime, client, repoPath, task, connection, output = console, repositoryProvider) {
     runtime.takeCodexUsage();
     if (runtime.backend === 'codex') {
         output.log(`[${new Date().toISOString()}] claimed ${task.kind} task ${task.id} via codex (dollar budget $${task.maxBudgetUsd.toFixed(2)} is not enforced on this backend)`);
@@ -687,16 +793,52 @@ export async function runOneTask(runtime, client, repoPath, task, connection, ou
     else {
         output.log(`[${new Date().toISOString()}] claimed ${task.kind} task ${task.id} via ${runtime.backend} (budget $${task.maxBudgetUsd.toFixed(2)})`);
     }
+    const owner = task.repositoryProvider?.owner;
+    const usesTemporaryRepository = repositoryProvider !== undefined && owner !== undefined && connection !== undefined
+        && task.payload.connectionless !== true;
+    const controller = new AbortController();
+    let lease;
+    let leaseLost = false;
     const heartbeat = setInterval(() => {
-        void client.heartbeat(task.id).catch((err) => output.error('  heartbeat warning:', err instanceof Error ? err.message : err));
+        void (async () => {
+            try {
+                const renewed = await client.heartbeat(task.id, usesTemporaryRepository ? owner.claimToken : undefined);
+                if (usesTemporaryRepository && lease) {
+                    if (typeof renewed.expiresAt !== 'string')
+                        throw new Error('repository_lease_lost');
+                    await lease.heartbeat({ claimToken: owner.claimToken, expiresAt: renewed.expiresAt });
+                }
+            }
+            catch (err) {
+                leaseLost = true;
+                controller.abort();
+                output.error('  heartbeat warning:', err instanceof Error ? err.message : err);
+            }
+        })();
     }, HEARTBEAT_MS);
     try {
-        const { result, filesRead, snapshot } = await runTask(task, runtime, repoPath, connection);
+        if (usesTemporaryRepository) {
+            await repositoryProvider.sweepRepositories();
+            const target = task.kind === 'git_range'
+                ? { kind: 'range', base: task.payload.base,
+                    head: String(task.payload.branch ?? '') }
+                : { kind: 'snapshot', sha: String(task.payload.snapshotSha ?? '') };
+            lease = await repositoryProvider.acquireRepository({
+                connection, target, owner, signal: controller.signal,
+            });
+        }
+        const { result, filesRead, snapshot } = await runTask(task, runtime, repoPath, connection, lease);
+        if (leaseLost)
+            throw new RepositoryProviderError('repository_lease_lost');
+        if (lease) {
+            await lease.release();
+            lease = undefined;
+        }
         clearInterval(heartbeat);
         if (task.kind === 'git_range')
             await client.reportGitRangeResult(task.id, result);
         else
-            await client.reportResult(task.id, result, filesRead, snapshot);
+            await client.reportResult(task.id, result, filesRead, snapshot, usesTemporaryRepository ? owner.claimToken : undefined);
         const done = `  done — reported result (${filesRead.length} file${filesRead.length === 1 ? '' : 's'} read)`;
         output.log(runtime.backend === 'codex'
             ? `${done}; token usage: ${formatCodexUsage(runtime.takeCodexUsage())}; dollar budget is not enforced (Codex reports tokens and has no cost cap)`
@@ -704,7 +846,16 @@ export async function runOneTask(runtime, client, repoPath, task, connection, ou
         return null;
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+        let failure = err;
+        if (lease) {
+            try {
+                await lease.release();
+            }
+            catch (cleanupError) {
+                failure = cleanupError;
+            }
+        }
+        const message = failure instanceof Error ? failure.message : String(failure);
         if (runtime.backend === 'codex' && message.includes('CodexToolUseAttempted')) {
             output.error(`  TOOL USE BLOCKED — ${message}`);
         }
@@ -712,19 +863,40 @@ export async function runOneTask(runtime, client, repoPath, task, connection, ou
             output.error('  failed:', message);
         }
         try {
-            await client.reportError(task.id, message);
+            await client.reportError(task.id, message, usesTemporaryRepository ? owner.claimToken : undefined);
         }
         catch (reportErr) {
             output.error('  could not even report the error back:', reportErr instanceof Error ? reportErr.message : reportErr);
         }
-        return runtime.backend === 'cli' && isUsageLimitError(err) ? message : null;
+        return runtime.backend === 'cli' && isUsageLimitError(failure) ? message : null;
     }
     finally {
         clearInterval(heartbeat);
     }
 }
+// Every pairing shares one local lifecycle registry. Separate managers pointed at the same root
+// would mistake another Console's live source for an orphan during a sweep.
+const repositoryAttemptSourceManager = createCompanionAttemptSourceManager({
+    root: join(dirname(configPath), 'repository-attempts'),
+    // The Console's signed claim metadata gates acquisition; this is never invoked while the
+    // server-side rollout is off.
+    buildsEnabled: () => true,
+});
+function ordinaryTaskRepositoryProvider(pairing, client) {
+    return createRepositoryProvider({
+        sourceManager: repositoryAttemptSourceManager,
+        workspaceId: pairing.workspaceId ?? 'unpaired',
+        hostId: pairing.workspaceId ?? 'companion',
+        // Renewal first heartbeats the server below. A rejected heartbeat aborts this attempt.
+        isClaimLive: async () => true,
+        getCredential: async (_connection, repository) => (await client.githubToken(githubLabel(repository))).token,
+        managedRepositoryUrl: (repository) => testCloneUrl(repository) ?? githubCloneUrl(repository),
+    });
+}
 export function backendForInvestigation(request, connections) {
     for (const source of request.requestedSources) {
+        if (source.kind === 'prd')
+            continue;
         const configured = connections.find((connection) => connection.connectionId === source.connectionId);
         if (configured)
             return configured.backend;
@@ -740,13 +912,14 @@ export function structuredModelCallerForRuntime(runtime, anthropic, callViaCodex
     }
     return (request) => runStructuredModelCall(anthropic, request);
 }
-async function runOneInvestigation(anthropic, client, connections, runtimes, request, output = console) {
+async function runOneInvestigation(anthropic, client, connections, runtimes, request, output = console, repositoryProvider) {
     const backend = backendForInvestigation(request, connections);
     output.log(`[${new Date().toISOString()}] claimed investigation ${request.investigationId} attempt ${request.attempt} via ${backend} (${request.obligations.length} obligation${request.obligations.length === 1 ? '' : 's'})`);
     if (Date.now() >= Date.parse(request.claimExpiresAt)) {
         output.error(`  CLAIM LEASE WARNING: ${request.investigationId} was already expired at ${request.claimExpiresAt}; the result may be rejected.`);
     }
     const runtime = request.requestedSources
+        .filter((source) => source.kind !== 'prd')
         .map((source) => runtimes.get(source.connectionId))
         .find((candidate) => !!candidate);
     const baseCallModel = runtime
@@ -769,6 +942,10 @@ async function runOneInvestigation(anthropic, client, connections, runtimes, req
         }
         : baseCallModel;
     const validationRejectedObligationIds = new Set();
+    const controller = new AbortController();
+    const repositoryOwner = request.repositoryProvider
+        ? { ...request.repositoryProvider.owner, expiresAt: request.claimExpiresAt }
+        : undefined;
     try {
         const result = await runAndReportInvestigation(request, connections, callModel, async (envelope) => {
             if (Date.now() >= Date.parse(request.claimExpiresAt)) {
@@ -790,26 +967,116 @@ async function runOneInvestigation(anthropic, client, connections, runtimes, req
             model: runtime?.backend === 'codex'
                 ? runtime.codexOptions?.model
                 : INVESTIGATION_MODEL,
-        });
+        }, repositoryProvider && repositoryOwner
+            ? { repositoryProvider, owner: repositoryOwner, signal: controller.signal }
+            : undefined);
         logInvestigationResult(result, output, validationRejectedObligationIds);
     }
     catch (error) {
         output.error(`  RESULT NOT DELIVERED for ${request.investigationId} attempt ${request.attempt}; no automatic retry will be made and the claim must expire:`, error instanceof Error ? error.message : error);
     }
+    finally {
+        controller.abort();
+    }
     return usageLimitMessage;
 }
-async function runOneSurfaceMapping(anthropic, client, connection, runtime, job, output = console) {
+export async function runOneSurfaceMapping(anthropic, client, connection, runtime, job, output = console, repositoryProvider, options = {}) {
     output.log(`[${new Date().toISOString()}] claimed surface mapping ${job.jobId} attempt ${job.attempt} via ${runtime.backend}`);
+    const owner = job.repositoryProvider?.owner;
+    const usesTemporaryRepository = repositoryProvider !== undefined && owner !== undefined;
+    const controller = new AbortController();
+    const leases = [];
+    let leaseLost = false;
+    const releaseLeases = async () => {
+        const pending = leases.splice(0).reverse();
+        let failure;
+        for (const lease of pending) {
+            try {
+                await lease.release();
+            }
+            catch (error) {
+                failure ??= error;
+            }
+        }
+        if (failure)
+            throw failure;
+    };
+    const heartbeat = usesTemporaryRepository ? setInterval(() => {
+        void (async () => {
+            try {
+                const renewed = await client.heartbeatSurfaceMapping(job);
+                for (const lease of leases) {
+                    await lease.heartbeat({ claimToken: owner.claimToken, expiresAt: renewed.expiresAt });
+                }
+            }
+            catch (error) {
+                leaseLost = true;
+                controller.abort();
+                output.error('  heartbeat warning:', error instanceof Error ? error.message : error);
+            }
+        })();
+    }, options.heartbeatMs ?? HEARTBEAT_MS) : null;
     try {
-        const manifest = await runSurfaceMapping({
-            claim: job,
-            repoPath: connection.repoPath,
-            callModel: structuredModelCallerForRuntime(runtime, anthropic),
-            execution: {
-                backend: runtime.backend,
-                model: runtime.backend === 'codex' ? runtime.codexOptions?.model ?? DEFAULT_CODEX_MODEL : SURFACE_SEED_MODEL,
-            },
-        });
+        const callModel = options.callModel ?? structuredModelCallerForRuntime(runtime, anthropic);
+        const execution = {
+            backend: runtime.backend,
+            model: runtime.backend === 'codex' ? runtime.codexOptions?.model ?? DEFAULT_CODEX_MODEL : SURFACE_SEED_MODEL,
+        };
+        let manifest;
+        if (usesTemporaryRepository) {
+            await repositoryProvider.sweepRepositories();
+            const headLease = await repositoryProvider.acquireRepository({
+                connection, target: { kind: 'snapshot', sha: job.commit }, owner, signal: controller.signal,
+            });
+            leases.push(headLease);
+            const head = await headLease.checkout();
+            let reuseChangeSet = null;
+            if (job.reuseCandidate) {
+                try {
+                    const baseLease = await repositoryProvider.acquireRepository({
+                        connection,
+                        target: { kind: 'snapshot', sha: job.reuseCandidate.commit },
+                        owner,
+                        signal: controller.signal,
+                    });
+                    leases.push(baseLease);
+                    const base = await baseLease.checkout();
+                    reuseChangeSet = await readSurfaceSnapshotChangeSet(base.path, base.commit, head.path, head.commit);
+                }
+                catch (error) {
+                    if (!(error instanceof RepositoryProviderError)
+                        || !['snapshot_unavailable', 'repository_access_denied'].includes(error.code))
+                        throw error;
+                    reuseChangeSet = null;
+                }
+            }
+            manifest = await runSurfaceMappingCheckout({
+                claim: job,
+                checkoutPath: head.path,
+                callModel,
+                execution,
+                reuseChangeSet,
+                assertLive: () => {
+                    if (leaseLost || controller.signal.aborted)
+                        throw new RepositoryProviderError('repository_lease_lost');
+                    for (const lease of leases)
+                        lease.assertLive();
+                },
+            });
+            if (leaseLost)
+                throw new RepositoryProviderError('repository_lease_lost');
+            if (heartbeat)
+                clearInterval(heartbeat);
+            await releaseLeases();
+        }
+        else {
+            manifest = await runSurfaceMapping({
+                claim: job,
+                repoPath: connection.repoPath,
+                callModel,
+                execution,
+            });
+        }
         let acknowledgment;
         try {
             acknowledgment = await client.reportSurfaceMappingResult(job, manifest);
@@ -826,16 +1093,29 @@ async function runOneSurfaceMapping(anthropic, client, connection, runtime, job,
         return null;
     }
     catch (error) {
+        let failure = error;
+        try {
+            await releaseLeases();
+        }
+        catch (cleanupError) {
+            failure = cleanupError;
+        }
         const usageLimitMessage = runtime.backend === 'cli' && isUsageLimitError(error)
             ? (error instanceof Error ? error.message : String(error))
             : null;
-        const report = error instanceof MappingFailure
-            ? { kind: error.kind, code: error.code, detail: error.message }
-            : {
-                kind: 'transient',
-                code: 'mapper_crashed',
-                detail: error instanceof Error ? error.message : String(error),
-            };
+        const report = failure instanceof MappingFailure
+            ? { kind: failure.kind, code: failure.code, detail: failure.message }
+            : failure instanceof RepositoryProviderError
+                ? {
+                    kind: failure.code === 'snapshot_unavailable' ? 'stable' : 'transient',
+                    code: failure.code,
+                    detail: failure.code,
+                }
+                : {
+                    kind: 'transient',
+                    code: 'mapper_crashed',
+                    detail: failure instanceof Error ? failure.message : String(failure),
+                };
         output.error(`  surface mapping ${job.jobId} failed (${report.code}): ${report.detail}`);
         try {
             await client.reportSurfaceMappingError(job, report);
@@ -850,6 +1130,219 @@ async function runOneSurfaceMapping(anthropic, client, connection, runtime, job,
         }
         return usageLimitMessage;
     }
+    finally {
+        if (heartbeat)
+            clearInterval(heartbeat);
+        controller.abort();
+    }
+}
+export function wholeReadModelRequest(request, callContext) {
+    const policy = WHOLE_READ_PHASE_POLICY[request.phase];
+    const thinking = policy.thinking[request.model] ?? 'adaptive';
+    return { purpose: 'whole-read', model: request.model, effort: policy.effort, thinking,
+        maxTokens: request.maxTokens, system: '', stableText: '', text: request.prompt, schema: request.schema,
+        wholeRead: callContext };
+}
+function wholeReadBackend(runtime, callContext) {
+    return async (request) => {
+        const modelRequest = wholeReadModelRequest(request, callContext);
+        const reply = runtime.backend === 'cli'
+            ? await runWholeReadModelCallViaCli(modelRequest)
+            : await runtime.textModel(modelRequest);
+        let result;
+        try {
+            result = JSON.parse(reply.text);
+        }
+        catch {
+            throw new Error('note_schema_invalid');
+        }
+        const inputTokens = reply.usage?.input_tokens ?? reply.usage?.inputTokens;
+        const outputTokens = reply.usage?.output_tokens ?? reply.usage?.outputTokens;
+        const usage = Number.isSafeInteger(inputTokens) && Number(inputTokens) >= 0
+            && Number.isSafeInteger(outputTokens) && Number(outputTokens) >= 0
+            ? { inputTokens: Number(inputTokens), outputTokens: Number(outputTokens) } : null;
+        return { result, usage, metadata: reply.metadata };
+    };
+}
+function wholeReadTransport(client, onUsageLimit) {
+    return {
+        putPage: (claim, page) => client.putBuildResultPage(claim, page),
+        seal: (claim, request) => client.sealBuildResult(claim, request),
+        accept: (claim, request) => client.acceptBuildResult(claim, request),
+        fail: async (claim, failure, usage) => {
+            if (failure.code === 'usage_limit')
+                onUsageLimit();
+            const result = await client.reportBuildError(claim, failure, usage);
+            if (result.status === 'retrying')
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            return result;
+        },
+    };
+}
+function wholeReadBackendName(runtime) {
+    return sharedWholeReadBackendName(runtime.backend);
+}
+async function runWholeReadAssignment(input) {
+    const connection = input.connections.find((candidate) => candidate.connectionId === input.assignment.connectionId);
+    const local = connection && !connection.managed ? connection : undefined;
+    const runtime = [
+        connection ? input.runtimes.get(connection.connectionId) : undefined,
+        input.workspaceRuntime ?? undefined,
+        ...input.runtimes.values(),
+    ].find((candidate) => candidate !== undefined
+        && wholeReadBackendName(candidate) === input.assignment.frozenBackend);
+    const backendReady = runtime !== undefined
+        && wholeReadBackendName(runtime) === input.assignment.frozenBackend;
+    const routeReadiness = assignmentRouteReadinessCode(input.assignment.route);
+    if (routeReadiness !== 'ready') {
+        await input.client.acceptBuildAssignment(input.assignment, {
+            lsRemoteVerified: false, exactCommitFetched: false,
+            backend: input.assignment.frozenBackend, backendReady,
+            routeSupported: false,
+        });
+        return { status: 'not_claimed' };
+    }
+    if (input.assignment.state === 'offered') {
+        let verified = false;
+        try {
+            const acquired = await input.sharedSources.acquire(wholeReadSharedSourceKey(input.pairing, input.assignment), async (lease, signal) => {
+                const source = await acquireAssignedSource({
+                    route: input.assignment.route,
+                    acquireLocal: () => local?.branch
+                        ? acquireLocalSource({ repoPath: local.repoPath, branch: local.branch,
+                            snapshotSha: input.assignment.snapshotSha, signal })
+                        : Promise.reject(new WholeReadGitError('snapshot_unavailable')),
+                    acquireGithubCompanion: () => {
+                        const repositoryUrl = `https://github.com/${githubLabel(parseGitHubRepo(input.assignment.canonicalRepository))}.git`;
+                        return acquireGithubCompanionSource({ lease, repositoryUrl,
+                            snapshotSha: input.assignment.snapshotSha, signal });
+                    },
+                });
+                if (!source)
+                    throw new WholeReadGitError('snapshot_unavailable');
+                return source;
+            });
+            await acquired.release();
+            verified = true;
+        }
+        catch {
+            verified = false;
+        }
+        const acceptance = await input.client.acceptBuildAssignment(input.assignment, {
+            lsRemoteVerified: verified, exactCommitFetched: verified,
+            backend: input.assignment.frozenBackend, backendReady,
+            routeSupported: routeReadiness === 'ready',
+        });
+        if (acceptance.status !== 'ready')
+            return { status: 'not_claimed' };
+    }
+    if (!runtime || !backendReady || input.shouldStop())
+        return { status: 'not_claimed' };
+    const claimed = await input.client.claimBuildUnit(input.assignment, {
+        backend: input.assignment.frozenBackend, backendReady: true,
+        payerIdentities: input.assignment.payerIdentity ? [input.assignment.payerIdentity] : [],
+    });
+    if (claimed.status !== 'claimed')
+        return {
+            status: claimed.status === 'build_concurrency_limit' ? 'build_concurrency_limit' : 'not_claimed',
+        };
+    const claim = claimed;
+    const controller = new AbortController();
+    if (claim.kind === 'group' || claim.kind === 'prd') {
+        try {
+            await withAttemptSource({
+                workspaceId: input.assignment.workspaceId,
+                buildId: input.assignment.buildId,
+                attemptId: claim.attemptId,
+                hostId: input.pairing.workspaceId ?? 'companion',
+                leaseExpiresAt: claim.leaseExpiresAt,
+            }, async (lease) => dispatchWholeReadClaim(claim, {
+                backend: wholeReadBackend(runtime, {
+                    attemptDirectory: lease.path,
+                    signal: controller.signal,
+                    registerReader: (reader) => lease.registerReader(reader),
+                }),
+                transport: wholeReadTransport(input.client, input.onUsageLimit),
+                signal: controller.signal,
+            }));
+            return { status: 'claimed' };
+        }
+        catch (reason) {
+            if (reason instanceof AttemptSourceCleanupError) {
+                await input.client.reportBuildError(claim, { code: 'cleanup_pending', source: 'companion' });
+                return { status: 'claimed' };
+            }
+            await input.client.reportBuildError(claim, {
+                code: 'capability_failure', source: wholeReadBackendName(runtime),
+            });
+            return { status: 'claimed' };
+        }
+    }
+    try {
+        await withAttemptSource({
+            workspaceId: input.assignment.workspaceId,
+            buildId: input.assignment.buildId,
+            attemptId: claim.attemptId,
+            hostId: input.pairing.workspaceId ?? 'companion',
+            leaseExpiresAt: claim.leaseExpiresAt,
+        }, async (lease) => {
+            const shared = await input.sharedSources.acquire(wholeReadSharedSourceKey(input.pairing, input.assignment), async (sourceLease, signal) => {
+                const source = await acquireAssignedSource({
+                    route: input.assignment.route,
+                    acquireLocal: () => local?.branch
+                        ? acquireLocalSource({ repoPath: local.repoPath, branch: local.branch,
+                            snapshotSha: input.assignment.snapshotSha, signal })
+                        : Promise.reject(new WholeReadGitError('snapshot_unavailable')),
+                    acquireGithubCompanion: async () => {
+                        const repositoryUrl = `https://github.com/${githubLabel(parseGitHubRepo(input.assignment.canonicalRepository))}.git`;
+                        return acquireGithubCompanionSource({ lease: sourceLease, repositoryUrl,
+                            snapshotSha: input.assignment.snapshotSha, signal });
+                    },
+                });
+                if (!source)
+                    throw new WholeReadGitError('snapshot_unavailable');
+                return source;
+            }, controller.signal);
+            try {
+                await dispatchWholeReadClaim(claim, { source: shared.source,
+                    backend: wholeReadBackend(runtime, {
+                        attemptDirectory: lease.path,
+                        signal: controller.signal,
+                        registerReader: (reader) => lease.registerReader(reader),
+                    }),
+                    transport: wholeReadTransport(input.client, input.onUsageLimit), signal: controller.signal });
+            }
+            finally {
+                await shared.release();
+            }
+        });
+        return { status: 'claimed' };
+    }
+    catch (reason) {
+        if (reason instanceof AttemptSourceCleanupError) {
+            await input.client.reportBuildError(claim, { code: 'cleanup_pending', source: 'companion' });
+        }
+        else if (reason instanceof WholeReadGitError || (reason instanceof Error
+            && reason.message === 'snapshot_unavailable')) {
+            await input.client.reportBuildError(claim, { code: 'snapshot_unavailable', source: 'companion' });
+        }
+        else {
+            await input.client.reportBuildError(claim, {
+                code: 'capability_failure', source: wholeReadBackendName(runtime),
+            });
+        }
+        return { status: 'claimed' };
+    }
+}
+function wholeReadSharedSourceKey(pairing, assignment) {
+    return {
+        workspaceId: assignment.workspaceId,
+        buildId: assignment.buildId,
+        assignmentId: assignment.id,
+        assignmentRevision: assignment.assignmentRevision,
+        snapshotSha: assignment.snapshotSha,
+        hostId: pairing.workspaceId ?? 'companion',
+    };
 }
 function pairingPrefix(pairing) {
     try {
@@ -864,16 +1357,25 @@ async function runPairing(pairing, options) {
     const log = (...values) => console.log(prefix + String(values[0] ?? ''), ...values.slice(1));
     const error = (...values) => console.error(prefix + String(values[0] ?? ''), ...values.slice(1));
     const warn = (...values) => console.warn(prefix + String(values[0] ?? ''), ...values.slice(1));
-    const client = new CompanionClient(pairing.url, pairing.token);
+    const fastModelsByConnection = Object.fromEntries(pairing.connections.flatMap((connection) => {
+        if (connection.backend === 'cli')
+            return [[connection.connectionId, CLAUDE_CLI_FAST_MODEL]];
+        if (connection.backend === 'codex')
+            return [[connection.connectionId, CODEX_FAST_MODEL]];
+        return [];
+    }));
+    const backendsByConnection = Object.fromEntries(pairing.connections.map((connection) => [connection.connectionId, sharedWholeReadBackendName(connection.backend)]));
+    const client = new CompanionClient(pairing.url, pairing.token, fastModelsByConnection, backendsByConnection);
     const tokenRejected = () => {
         error(`The Console at ${pairing.url} no longer accepts this computer's token — stopped working for it. Pair again from that Console to reconnect.`);
         return 'token_rejected';
     };
+    let serverIdentity;
     if (options.multiple) {
         let failures = 0;
         while (!options.shouldStop()) {
             try {
-                await client.whoami();
+                serverIdentity = await client.whoami();
                 break;
             }
             catch (reason) {
@@ -889,13 +1391,23 @@ async function runPairing(pairing, options) {
             return 'stopped';
     }
     else {
-        await client.whoami();
+        serverIdentity = await client.whoami();
+    }
+    const temporaryRepositories = serverIdentity.temporaryRepositories === true;
+    if (temporaryRepositories) {
+        const migrated = migrateManagedRepositoriesToTemporaryStorage({
+            url: pairing.url,
+            workspaceId: serverIdentity.workspaceId,
+        });
+        if (migrated)
+            pairing.connections = migrated.connections;
+        await activateManagedCopyCleanup(pairing.url, serverIdentity.workspaceId, { log, error });
     }
     const workspaceBackend = pairing.workspaceBackend ?? 'api-key';
     const activeConnections = pairing.connections.filter((connection) => !options.unavailableConnections.has(connection.connectionId));
     for (const connection of activeConnections) {
-        if (connection.managed) {
-            const label = connection.label ?? labelFromCopyPath(connection.repoPath);
+        if (connection.managed && !temporaryRepositories && !usesTemporaryManagedStorage(connection)) {
+            const label = githubLabel(configuredManagedRepository(connection));
             watchManagedCopy(connection.repoPath, label, (message) => error(`[${new Date().toISOString()}] ${message}`), () => client.githubToken(label));
         }
     }
@@ -903,13 +1415,18 @@ async function runPairing(pairing, options) {
         connection.connectionId,
         createBackendRuntime(connection, options.anthropic),
     ]));
+    const repositoryProvider = ordinaryTaskRepositoryProvider(pairing, client);
+    const repositoryReadinessFor = (connection) => checkConnectionRepositoryReadiness(connection, temporaryRepositories, {
+        getCredential: async (_configured, repository) => (await client.githubToken(githubLabel(repository))).token,
+        managedRepositoryUrl: (repository) => testCloneUrl(repository) ?? githubCloneUrl(repository),
+    });
     const workspaceRuntime = pairing.pollWorkspaceTasks && !options.workspaceTasksUnavailable
         ? createBackendRuntime({ backend: workspaceBackend, codexModel: pairing.codexModel }, options.anthropic)
         : null;
     const repositoryReadiness = new Map();
     for (const connection of activeConnections) {
         repositoryReadiness.set(connection.connectionId, {
-            readiness: await checkRepositoryReadiness(connection.repoPath),
+            readiness: await repositoryReadinessFor(connection),
             checkedAt: Date.now(),
         });
     }
@@ -924,6 +1441,10 @@ async function runPairing(pairing, options) {
     for (const connection of activeConnections) {
         const readiness = repositoryReadiness.get(connection.connectionId).readiness;
         if (readiness.state === 'ready') {
+            if (temporaryRepositories && connection.managed) {
+                log(`  - ${connection.connectionId} (${githubLabel(configuredManagedRepository(connection))}; temporary repository access ready) (${connection.backend})`);
+                continue;
+            }
             const sha = await currentCommit(connection.repoPath).catch(() => '(unknown)');
             log(options.safeStartupDiagnostics
                 ? `  - ${connection.connectionId} @ ${sha.slice(0, 7)} (${connection.backend})`
@@ -950,6 +1471,7 @@ async function runPairing(pairing, options) {
     let investigationPollFailures = 0;
     let nextInvestigationPollAt = 0;
     let surfaceMappingPollingEnabled = true;
+    let wholeReadBuildPollingEnabled = true;
     const skippedConnections = new Set();
     const loggedSkippedConnections = new Set();
     const readinessReporting = {
@@ -964,164 +1486,217 @@ async function runPairing(pairing, options) {
         loggedSkippedConnections.add(connectionId);
         error(`Project ${connectionId} isn't part of the workspace at ${pairing.url} anymore — skipping it. Run connect again from that project's folder to re-add it.`);
     };
-    while (!options.shouldStop()) {
-        try {
-            let claimedAny = false;
-            const pollableConnections = activeConnections.filter((connection) => !skippedConnections.has(connection.connectionId));
-            const readyConnections = [];
-            const readinessNow = Date.now();
-            for (const connection of pollableConnections) {
-                if (options.shouldStop())
-                    break;
-                let cached = repositoryReadiness.get(connection.connectionId);
-                if (readinessNow - cached.checkedAt >= REPOSITORY_RECHECK_MS) {
-                    const next = await checkRepositoryReadiness(connection.repoPath);
-                    if (next.state !== cached.readiness.state) {
-                        if (next.state === 'ready') {
-                            log(`[${new Date().toISOString()}] Repository ready for ${connection.connectionId}; resuming repository-aware polling.`);
-                        }
-                        else {
-                            error(options.safeStartupDiagnostics
-                                ? `[${new Date().toISOString()}] Repository not ready for ${connection.connectionId}.`
-                                : `[${new Date().toISOString()}] Repository not ready for ${connection.connectionId}: ${next.reason}`);
+    let usageClaimLimit = 0;
+    let asyncTokenRejected = false;
+    const mayClaim = () => usageClaimLimit === null || usageClaimLimit > 0;
+    const recordCompletedClaim = (usageLimitMessage) => {
+        if (usageClaimLimit !== null)
+            usageClaimLimit--;
+        if (usageLimitMessage) {
+            options.usageLimitPause.pause(usageLimitMessage);
+            usageClaimLimit = 0;
+        }
+    };
+    const sharedSources = createWholeReadSharedSourceManager({
+        onCleanupPending: () => { error('[whole-read-temp] cleanup_pending'); },
+    });
+    const wholeReadPool = createWholeReadAssignmentPool({
+        key: (assignment) => assignment.id,
+        mayClaim,
+        shouldStop: options.shouldStop,
+        onStart: () => { if (usageClaimLimit !== null)
+            usageClaimLimit--; },
+        run: (assignment) => runWholeReadAssignment({ pairing, client, assignment,
+            connections: activeConnections, runtimes, workspaceRuntime, sharedSources,
+            onUsageLimit: () => recordCompletedClaim('usage limit reached'),
+            shouldStop: options.shouldStop }),
+        onError: (reason) => {
+            if (reason instanceof CompanionHttpError && reason.status === 401)
+                asyncTokenRejected = true;
+            else
+                error('Whole-read build attempt failed:', reason instanceof Error ? reason.message : reason);
+        },
+    });
+    try {
+        while (!options.shouldStop()) {
+            try {
+                if (asyncTokenRejected)
+                    return tokenRejected();
+                let claimedAny = false;
+                const pollableConnections = activeConnections.filter((connection) => !skippedConnections.has(connection.connectionId));
+                const readyConnections = [];
+                const readinessNow = Date.now();
+                for (const connection of pollableConnections) {
+                    if (options.shouldStop())
+                        break;
+                    let cached = repositoryReadiness.get(connection.connectionId);
+                    if (readinessNow - cached.checkedAt >= REPOSITORY_RECHECK_MS) {
+                        const next = await repositoryReadinessFor(connection);
+                        if (next.state !== cached.readiness.state) {
+                            if (next.state === 'ready') {
+                                log(`[${new Date().toISOString()}] Repository ready for ${connection.connectionId}; resuming repository-aware polling.`);
+                            }
+                            else {
+                                error(options.safeStartupDiagnostics
+                                    ? `[${new Date().toISOString()}] Repository not ready for ${connection.connectionId}.`
+                                    : `[${new Date().toISOString()}] Repository not ready for ${connection.connectionId}: ${next.reason}`);
+                            }
                         }
+                        cached = { readiness: next, checkedAt: readinessNow };
+                        repositoryReadiness.set(connection.connectionId, cached);
                     }
-                    cached = { readiness: next, checkedAt: readinessNow };
-                    repositoryReadiness.set(connection.connectionId, cached);
-                }
-                if (cached.readiness.state === 'ready')
-                    readyConnections.push(connection);
-            }
-            const readinessOutcome = await reportLoopReadiness(client, buildReadinessReport(pollableConnections, options.unavailableConnections, repositoryReadiness), readinessReporting, { error });
-            for (const connectionId of [...skippedConnections])
-                skipConnection(connectionId);
-            if (readinessOutcome === 'token_rejected')
-                return tokenRejected();
-            let usageClaimLimit = options.usageLimitPause.claimLimit();
-            const mayClaim = () => usageClaimLimit === null || usageClaimLimit > 0;
-            const recordCompletedClaim = (usageLimitMessage) => {
-                if (usageClaimLimit !== null)
-                    usageClaimLimit--;
-                if (usageLimitMessage) {
-                    options.usageLimitPause.pause(usageLimitMessage);
-                    usageClaimLimit = 0;
+                    if (cached.readiness.state === 'ready')
+                        readyConnections.push(connection);
                 }
-            };
-            for (const connection of readyConnections) {
-                if (options.shouldStop() || !mayClaim())
-                    break;
-                if (skippedConnections.has(connection.connectionId))
-                    continue;
-                if (surfaceMappingPollingEnabled) {
+                const repositoryPollableConnections = readyConnections;
+                const readinessOutcome = await reportLoopReadiness(client, buildReadinessReport(temporaryRepositories
+                    ? pairing.connections.filter((connection) => !skippedConnections.has(connection.connectionId))
+                    : pollableConnections, options.unavailableConnections, repositoryReadiness), readinessReporting, { error });
+                for (const connectionId of [...skippedConnections])
+                    skipConnection(connectionId);
+                if (readinessOutcome === 'token_rejected')
+                    return tokenRejected();
+                usageClaimLimit = options.usageLimitPause.claimLimit();
+                if (!options.shouldStop() && wholeReadBuildPollingEnabled) {
                     try {
-                        const mapping = await client.claimNextSurfaceMapping(connection.connectionId);
-                        if (mapping.job) {
+                        const { assignments } = await client.listBuildAssignments();
+                        void sharedSources.reconcile(assignments.map((assignment) => wholeReadSharedSourceKey(pairing, assignment))).catch((reason) => {
+                            error('[whole-read-temp] cleanup_failed:', reason instanceof Error ? reason.message : reason);
+                        });
+                        if (wholeReadPool.poll(assignments) > 0)
                             claimedAny = true;
-                            recordCompletedClaim(await runOneSurfaceMapping(options.anthropic, client, connection, runtimes.get(connection.connectionId), mapping.job, { log, error }));
-                        }
                     }
                     catch (reason) {
                         if (reason instanceof CompanionHttpError && reason.status === 401)
                             return tokenRejected();
-                        if (isUnknownConnectionError(reason)) {
-                            skipConnection(connection.connectionId);
-                            continue;
-                        }
-                        const status = surfaceMappingUnavailableStatus(reason);
-                        if (status !== null) {
-                            error(`Automatic mapping is not available on this server (HTTP ${status}); continuing without it.`);
-                            surfaceMappingPollingEnabled = false;
+                        if (reason instanceof CompanionHttpError && [403, 404, 405].includes(reason.status)) {
+                            wholeReadBuildPollingEnabled = false;
                         }
                         else {
-                            error(`Surface-mapping poll failed for ${connection.connectionId}:`, reason instanceof Error ? reason.message : reason);
+                            error('Whole-read build poll failed:', reason instanceof Error ? reason.message : reason);
                         }
                     }
                 }
-                if (!mayClaim() || skippedConnections.has(connection.connectionId))
-                    continue;
-                try {
-                    const claim = await client.claimNext(connection.connectionId);
-                    if (!claim.task)
-                        continue;
-                    claimedAny = true;
-                    recordCompletedClaim(await runOneTask(runtimes.get(connection.connectionId), client, connection.repoPath, claim.task, connection, { log, error }));
-                }
-                catch (reason) {
-                    if (reason instanceof CompanionHttpError && reason.status === 401)
-                        return tokenRejected();
-                    if (isUnknownConnectionError(reason)) {
-                        skipConnection(connection.connectionId);
+                for (const connection of repositoryPollableConnections) {
+                    if (options.shouldStop() || !mayClaim())
+                        break;
+                    if (skippedConnections.has(connection.connectionId))
                         continue;
+                    if (surfaceMappingPollingEnabled) {
+                        try {
+                            const mapping = await client.claimNextSurfaceMapping(connection.connectionId);
+                            if (mapping.job) {
+                                claimedAny = true;
+                                recordCompletedClaim(await runOneSurfaceMapping(options.anthropic, client, connection, runtimes.get(connection.connectionId), mapping.job, { log, error }, repositoryProvider));
+                            }
+                        }
+                        catch (reason) {
+                            if (reason instanceof CompanionHttpError && reason.status === 401)
+                                return tokenRejected();
+                            if (isUnknownConnectionError(reason)) {
+                                skipConnection(connection.connectionId);
+                                continue;
+                            }
+                            const status = surfaceMappingUnavailableStatus(reason);
+                            if (status !== null) {
+                                error(`Automatic mapping is not available on this server (HTTP ${status}); continuing without it.`);
+                                surfaceMappingPollingEnabled = false;
+                            }
+                            else {
+                                error(`Surface-mapping poll failed for ${connection.connectionId}:`, reason instanceof Error ? reason.message : reason);
+                            }
+                        }
                     }
-                    error(`Poll failed for ${connection.connectionId}:`, reason instanceof Error ? reason.message : reason);
-                }
-            }
-            if (!options.shouldStop() && workspaceRuntime && mayClaim()) {
-                try {
-                    const claim = await client.claimNext();
-                    if (claim.task) {
+                    if (!mayClaim() || skippedConnections.has(connection.connectionId))
+                        continue;
+                    try {
+                        const claim = await client.claimNext(connection.connectionId);
+                        if (!claim.task)
+                            continue;
                         claimedAny = true;
-                        recordCompletedClaim(await runOneTask(workspaceRuntime, client, process.cwd(), claim.task, undefined, { log, error }));
+                        recordCompletedClaim(await runOneTask(runtimes.get(connection.connectionId), client, connection.repoPath, claim.task, connection, { log, error }, repositoryProvider));
+                    }
+                    catch (reason) {
+                        if (reason instanceof CompanionHttpError && reason.status === 401)
+                            return tokenRejected();
+                        if (isUnknownConnectionError(reason)) {
+                            skipConnection(connection.connectionId);
+                            continue;
+                        }
+                        error(`Poll failed for ${connection.connectionId}:`, reason instanceof Error ? reason.message : reason);
                     }
                 }
-                catch (reason) {
-                    if (reason instanceof CompanionHttpError && reason.status === 401)
-                        return tokenRejected();
-                    error('Workspace-level poll failed:', reason instanceof Error ? reason.message : reason);
-                }
-            }
-            const remainingConfigured = pairing.connections.filter((connection) => !skippedConnections.has(connection.connectionId));
-            if (!options.shouldStop() && mayClaim() && readyConnections.length > 0
-                && readyConnections.length === pollableConnections.length
-                && pollableConnections.length === remainingConfigured.length
-                && Date.now() >= nextInvestigationPollAt) {
-                try {
-                    const investigation = await client.claimNextInvestigation();
-                    ({ consecutiveFailures: investigationPollFailures } = nextInvestigationPollBackoff(investigationPollFailures, true));
-                    nextInvestigationPollAt = 0;
-                    if (investigation) {
-                        claimedAny = true;
-                        recordCompletedClaim(await runOneInvestigation(options.anthropic, client, pollableConnections, runtimes, investigation, { log, error }));
+                if (!options.shouldStop() && workspaceRuntime && mayClaim()) {
+                    try {
+                        const claim = await client.claimNext();
+                        if (claim.task) {
+                            claimedAny = true;
+                            recordCompletedClaim(await runOneTask(workspaceRuntime, client, process.cwd(), claim.task, undefined, { log, error }));
+                        }
+                    }
+                    catch (reason) {
+                        if (reason instanceof CompanionHttpError && reason.status === 401)
+                            return tokenRejected();
+                        error('Workspace-level poll failed:', reason instanceof Error ? reason.message : reason);
                     }
                 }
-                catch (reason) {
-                    if (reason instanceof CompanionHttpError && reason.status === 401)
-                        return tokenRejected();
-                    const backoff = nextInvestigationPollBackoff(investigationPollFailures, false);
-                    investigationPollFailures = backoff.consecutiveFailures;
-                    nextInvestigationPollAt = Date.now() + backoff.delayMs;
-                    if (investigationPollFailures === 1) {
-                        error('Investigation poll failed:', reason instanceof Error ? reason.message : reason, `Retrying in ${backoff.delayMs / 1000}s.`);
+                const remainingConfigured = pairing.connections.filter((connection) => !skippedConnections.has(connection.connectionId));
+                if (!options.shouldStop() && mayClaim() && repositoryPollableConnections.length > 0
+                    && repositoryPollableConnections.length === pollableConnections.length
+                    && pollableConnections.length === remainingConfigured.length
+                    && Date.now() >= nextInvestigationPollAt) {
+                    try {
+                        const investigation = await client.claimNextInvestigation();
+                        ({ consecutiveFailures: investigationPollFailures } = nextInvestigationPollBackoff(investigationPollFailures, true));
+                        nextInvestigationPollAt = 0;
+                        if (investigation) {
+                            claimedAny = true;
+                            recordCompletedClaim(await runOneInvestigation(options.anthropic, client, pollableConnections, runtimes, investigation, { log, error }, repositoryProvider));
+                        }
                     }
-                    else {
-                        warn(`Investigation poll still failing (${investigationPollFailures} consecutive); retrying in ${backoff.delayMs / 1000}s.`);
+                    catch (reason) {
+                        if (reason instanceof CompanionHttpError && reason.status === 401)
+                            return tokenRejected();
+                        const backoff = nextInvestigationPollBackoff(investigationPollFailures, false);
+                        investigationPollFailures = backoff.consecutiveFailures;
+                        nextInvestigationPollAt = Date.now() + backoff.delayMs;
+                        if (investigationPollFailures === 1) {
+                            error('Investigation poll failed:', reason instanceof Error ? reason.message : reason, `Retrying in ${backoff.delayMs / 1000}s.`);
+                        }
+                        else {
+                            warn(`Investigation poll still failing (${investigationPollFailures} consecutive); retrying in ${backoff.delayMs / 1000}s.`);
+                        }
                     }
                 }
-            }
-            if (claimedAny) {
-                lastIdleStatusAt = Date.now();
-            }
-            else if (!options.shouldStop()) {
-                const now = Date.now();
-                if (now - lastIdleStatusAt >= IDLE_STATUS_MS) {
-                    log(`[${new Date(now).toISOString()}] still watching — no work claimed.`);
-                    lastIdleStatusAt = now;
+                if (claimedAny) {
+                    lastIdleStatusAt = Date.now();
+                }
+                else if (!options.shouldStop()) {
+                    const now = Date.now();
+                    if (now - lastIdleStatusAt >= IDLE_STATUS_MS) {
+                        log(`[${new Date(now).toISOString()}] still watching — no work claimed.`);
+                        lastIdleStatusAt = now;
+                    }
+                    await new Promise((done) => setTimeout(done, IDLE_POLL_MS));
                 }
-                await new Promise((done) => setTimeout(done, IDLE_POLL_MS));
             }
-        }
-        catch (reason) {
-            if (reason instanceof CompanionHttpError && reason.status === 401)
-                return tokenRejected();
-            error('Unexpected run-loop error:', reason instanceof Error ? reason.message : reason);
-            if (!options.shouldStop())
-                await new Promise((done) => setTimeout(done, LOOP_RECOVERY_DELAY_MS));
+            catch (reason) {
+                if (reason instanceof CompanionHttpError && reason.status === 401)
+                    return tokenRejected();
+                error('Unexpected run-loop error:', reason instanceof Error ? reason.message : reason);
+                if (!options.shouldStop())
+                    await new Promise((done) => setTimeout(done, LOOP_RECOVERY_DELAY_MS));
+            }
         }
     }
+    finally {
+        await wholeReadPool.shutdown();
+        await sharedSources.shutdown();
+    }
     log('Stopped.');
     return 'stopped';
 }
-async function cmdRun(options = {}) {
+async function runCompanionLoop(options = {}) {
     let config;
     try {
         config = loadConfig();
@@ -1271,6 +1846,22 @@ async function cmdRun(options = {}) {
         }
     }));
 }
+async function cmdRun(options = {}) {
+    // Cleanup is deliberately not flag-gated: source left by an older enabled build must still be
+    // removed after rollback or while its Console is offline. Importing the module starts no timer.
+    try {
+        await startAttemptSourceSweeper();
+    }
+    catch {
+        console.error('[whole-read-temp] cleanup_sweep_failed');
+    }
+    try {
+        await runCompanionLoop(options);
+    }
+    finally {
+        stopAttemptSourceSweeper();
+    }
+}
 async function cmdRunWithInstance(options = {}) {
     if (process.env.PRODUCT_CONSOLE_COMPANION_DAEMON_CHILD === '1')
         return cmdRun(options);
@@ -1393,9 +1984,8 @@ async function cmdDisconnect(argv) {
     await removeManagedCopies(removed.flatMap((pairing) => pairing.connections));
     logRestartHintIfRunning();
 }
-/** Deletes the companion's own copies behind removed connections. A copy another remaining
- *  connection still uses (the same repo connected to a second Console) is kept. Only paths inside
- *  <config dir>/repos/ are ever deleted, and only for connections marked managed. */
+/** Legacy disconnect behavior. B38-c owns deletion for migrated storage; until then those paths
+ *  are left untouched. A legacy copy another remaining connection uses is also kept. */
 async function removeManagedCopies(removedConnections) {
     const reposDir = managedReposDir();
     const stillUsed = new Set((loadConfig()?.pairings ?? [])
@@ -1403,7 +1993,7 @@ async function removeManagedCopies(removedConnections) {
         .map((connection) => resolve(connection.repoPath).toLowerCase()));
     const handled = new Set();
     for (const connection of removedConnections) {
-        if (!connection.managed)
+        if (!connection.managed || usesTemporaryManagedStorage(connection))
             continue;
         const key = resolve(connection.repoPath).toLowerCase();
         if (stillUsed.has(key) || handled.has(key))
@@ -1427,7 +2017,7 @@ async function cmdSignin(argv) {
     let wanted = null;
     if (flags.repo !== undefined) {
         try {
-            wanted = managedCopyPath(managedReposDir(), parseGitHubRepo(flags.repo)).toLowerCase();
+            wanted = githubLabel(parseGitHubRepo(flags.repo)).toLowerCase();
         }
         catch (error) {
             console.error(error instanceof ManagedRepoError ? error.message : String(error));
@@ -1435,24 +2025,39 @@ async function cmdSignin(argv) {
             return;
         }
     }
-    const copies = new Map();
+    const targets = new Map();
     for (const pairing of loadConfig()?.pairings ?? []) {
         const client = new CompanionClient(pairing.url, pairing.token);
         for (const connection of pairing.connections) {
             if (!connection.managed)
                 continue;
-            const key = resolve(connection.repoPath).toLowerCase();
-            if (copies.has(key) || (wanted !== null && key !== wanted))
+            let repository;
+            try {
+                repository = configuredManagedRepository(connection);
+            }
+            catch {
+                continue;
+            }
+            const label = githubLabel(repository);
+            const key = `${normalizeConsoleUrl(pairing.url)}\0${pairing.workspaceId ?? ''}\0${label.toLowerCase()}`;
+            if (targets.has(key) || (wanted !== null && label.toLowerCase() !== wanted))
                 continue;
-            const label = connection.label ?? labelFromCopyPath(connection.repoPath);
-            copies.set(key, {
+            targets.set(key, usesTemporaryManagedStorage(connection) ? {
+                storage: 'temporary',
+                repository,
+                label,
+                branch: connection.branch,
+                getToken: () => client.githubToken(label).then((response) => response.token),
+            } : {
+                storage: 'persistent',
+                repository,
                 repoPath: connection.repoPath,
                 label,
                 getToken: () => client.githubToken(label).then((response) => response.token),
             });
         }
     }
-    if (copies.size === 0) {
+    if (targets.size === 0) {
         console.log(wanted === null
             ? "There's no companion-kept copy of any repo on this computer."
             : `There's no companion-kept copy of ${flags.repo} on this computer.`);
@@ -1460,7 +2065,24 @@ async function cmdSignin(argv) {
             process.exitCode = 1;
         return;
     }
-    for (const { repoPath, label, getToken } of copies.values()) {
+    for (const target of targets.values()) {
+        const { label, getToken } = target;
+        if (target.storage === 'temporary') {
+            try {
+                await proveManagedRepositoryAccess({
+                    repository: target.repository,
+                    branch: target.branch,
+                    credential: await getToken(),
+                }, { managedRepositoryUrl: (repository) => testCloneUrl(repository) ?? githubCloneUrl(repository) });
+                console.log(`GitHub access is ready for ${label}.`);
+            }
+            catch {
+                console.log(`Still can't reach ${label} on GitHub. Reconnect GitHub in the Console.`);
+                process.exitCode = 1;
+            }
+            continue;
+        }
+        const { repoPath } = target;
         if (!existsSync(repoPath)) {
             console.log(`The companion's copy of ${label} is missing. Run the connect command for it again.`);
             process.exitCode = 1;
@@ -1496,6 +2118,11 @@ function cmdStatus() {
             const workspace = pairing.workspaceId ? ` (workspace ${pairing.workspaceId.slice(0, 8)}…)` : '';
             console.log(`  ${pairing.url}${workspace}`);
             for (const project of pairing.projects) {
+                if (project.managed && project.repositoryStorage === 'temporary') {
+                    const label = project.repository?.path ?? project.label ?? labelFromCopyPath(project.repoPath);
+                    console.log(`    ${project.connectionId} — ${label} — temporary repository access`);
+                    continue;
+                }
                 console.log(`    ${project.connectionId} — ${project.repoPath}`);
                 if (!project.managed)
                     continue;