@teamvibe/poller 0.8.6 → 0.8.7

package/bin/tv-git-credential.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+// Defence in depth for direct invocations that bypass Git's env -u launcher.
+for (const key of ['GITHUB_TOKEN', 'GH_TOKEN', 'GITLAB_TOKEN']) delete process.env[key]
+
+import { appendFileSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+// Git calls this executable with only get/store/erase in argv. Read each get
+// afresh; never cache credentials or ask for input beyond Git's request.
+if (process.argv[2] === 'get') {
+  try {
+    const request = {}
+    for (const line of readFileSync(0, 'utf8').split('\n')) {
+      if (!line) break
+      const separator = line.indexOf('=')
+      if (separator > 0) request[line.slice(0, separator)] = line.slice(separator + 1)
+    }
+    const file = process.env.TV_GIT_TOKEN_FILE
+    const credential = JSON.parse(readFileSync(file, 'utf8'))
+    if (request.protocol !== 'https' || request.host !== credential.host ||
+        credential.host !== 'github.com' || typeof credential.token !== 'string' ||
+        !credential.token || /[\r\n\0]/.test(credential.token) ||
+        !['github_token', 'github_app'].includes(credential.kind)) process.exit(0)
+    if (credential.expiresAt !== undefined) {
+      const expiry = Date.parse(credential.expiresAt)
+      if (!Number.isFinite(expiry) || expiry <= Date.now()) {
+        const diagnostic = `git_credential_expired kind=${credential.kind}\n`
+        process.stderr.write(diagnostic)
+        // Value-free spool lets the poller report detached-task expiry through
+        // its usual error queue even after the launching agent has exited.
+        try { appendFileSync(join(dirname(file), 'git-credential-events'), diagnostic, { mode: 0o600 }) } catch {}
+        process.exit(0)
+      }
+    }
+    process.stdout.write(`username=x-access-token\npassword=${credential.token}\n`)
+  } catch {
+    // No output and success means Git proceeds to its prompt-disabled failure.
+  }
+}

package/dist/auth-provider.js

@@ -2,6 +2,7 @@ import { config, POLLER_VERSION } from './config.js';
 import { logger } from './logger.js';
 import { emitError } from './event-queue.js';
 import { getBaseBrainCommitSha } from './base-brain-metadata.js';
+import { connectionsClient, refreshConnectionTuples } from './connections-client.js';
 export class AuthHttpError extends Error {
     status;
     constructor(status, _body) {
@@ -24,6 +25,12 @@ const REFRESH_INTERVAL_MS = 50 * 60 * 1000; // 50 minutes (before 1hr expiry)
 const HEARTBEAT_INTERVAL_MS = 60 * 1000; // 1 minute
 async function sendHeartbeat(apiUrl, token, version) {
     try {
+        if (currentPollerId) {
+            try {
+                await refreshConnectionTuples(currentPollerId);
+            }
+            catch { /* Heartbeat must still report liveness if tuple refresh fails. */ }
+        }
         const baseBrainSha = await getBaseBrainCommitSha(config.BASE_BRAIN_PATH);
         if (!baseBrainSha)
             logger.warn('[Heartbeat] Could not read base-brain HEAD for pin readback');
@@ -33,7 +40,7 @@ async function sendHeartbeat(apiUrl, token, version) {
                 Authorization: `Bearer ${token}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ version, baseBrainSha, baseBrainBranch: config.BASE_BRAIN_BRANCH }),
+            body: JSON.stringify({ version, baseBrainSha, baseBrainBranch: config.BASE_BRAIN_BRANCH, legacyGitBrains: connectionsClient.legacyGitBrains }),
         });
         if (!response.ok) {
             logger.warn(`Heartbeat failed (${response.status})`);

package/dist/bg-task-registry.d.ts

@@ -0,0 +1,12 @@
+export interface BgTaskStatus {
+    state?: string;
+    runner_crashed?: string;
+    pid?: string;
+    started?: string;
+    ttl?: string;
+}
+export declare function parseStatus(text: string): BgTaskStatus;
+export declare function pidAlive(pid: number): boolean;
+export declare function lifecycleOf(kv: BgTaskStatus, now: number): string;
+export declare function bgTaskRoot(): string;
+export declare function listDirs(path: string): string[];

package/dist/bg-task-registry.js

@@ -0,0 +1,65 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { config } from './config.js';
+// Shared with idle restart and credential lifetime cleanup. Status belongs to
+// poller-brain's background-task skill; no second task-liveness registry.
+const ABANDON_GRACE_SEC = 60; // mirrors bg-task.mjs's ABANDON_GRACE_SEC
+export function parseStatus(text) {
+    const kv = {};
+    for (const line of text.split('\n')) {
+        const i = line.indexOf('=');
+        if (i > 0)
+            kv[line.slice(0, i)] = line.slice(i + 1);
+    }
+    return kv;
+}
+export function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Same four-way classification as bg-task.mjs's lifecycleOf, minus the tests-only
+// `alive` injection point (this module has its own dedicated tests instead).
+export function lifecycleOf(kv, now) {
+    // Trust the runner's own claim, whatever it says (bg-task.mjs:139) — not just the two
+    // values the runner writes today (`finished`/`timed-out`, bg-task-runner.mjs:403).
+    // Mirroring the check itself, not just its current output, means the two
+    // implementations of this format can't quietly diverge if the runner ever starts
+    // writing a state value this list doesn't happen to enumerate — hardcoding a closed
+    // set here would silently fall through to the pid/TTL heuristics below instead.
+    if (kv.state)
+        return kv.state;
+    if (kv.runner_crashed)
+        return 'crashed';
+    if (Object.keys(kv).length === 0)
+        return 'unknown';
+    const pid = Number(kv.pid);
+    if (!Number.isInteger(pid) || pid <= 0 || !pidAlive(pid))
+        return 'abandoned';
+    const started = kv.started ? Date.parse(kv.started) : NaN;
+    const ttl = Number(String(kv.ttl ?? '').replace(/s$/, ''));
+    if (Number.isFinite(started) && Number.isFinite(ttl) && now - started > (ttl + ABANDON_GRACE_SEC) * 1000) {
+        return 'abandoned';
+    }
+    return 'running';
+}
+export function bgTaskRoot() {
+    // Mirrors bg-task.mjs's taskRoot() default exactly, minus the per-channel
+    // namespace — the poller checks liveness across every channel it serves, not just
+    // one, so it walks the parent directory instead of joining a single channel ID.
+    return process.env['BG_TASK_ROOT'] || join(config.PERSISTENT_STORAGE_PATH || '/tmp', 'bg-tasks');
+}
+export function listDirs(path) {
+    try {
+        return readdirSync(path, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/brain-manager.d.ts

@@ -1,3 +1,7 @@
+import { exec } from 'child_process';
+declare const execAsync: typeof exec.__promisify__;
+/** @internal Inject a git process for clone/push contract tests. */
+export declare function __setGitExecForTest(runner?: typeof execAsync): void;
 export declare function withBrainLock<T>(key: string, fn: () => Promise<T>): Promise<T>;
 interface BrainConfig {
     brainId: string;

package/dist/brain-manager.js

@@ -1,3 +1,4 @@
+import { createGitCredentialSession, finishGitCredentialSession } from './git-credential-session.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { existsSync, mkdirSync } from 'fs';
@@ -8,7 +9,14 @@ import { logger } from './logger.js';
 import { emitError } from './event-queue.js';
 import { brainLockKey, resolveBrainDir, fallbackBrainPath, legacyBrainPath } from './brain-path.js';
 import { startupFailureDetail } from './startup-auth.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { connectionsClient } from './connections-client.js';
+import { buildGitCredentialEnv } from './git-credential-env.js';
+import { redactGitDiagnostic, redactRepoUrl } from './redact-text.js';
 const execAsync = promisify(exec);
+let gitRunner = execAsync;
+/** @internal Inject a git process for clone/push contract tests. */
+export function __setGitExecForTest(runner) { gitRunner = runner ?? execAsync; }
 // Clean env for git commands:
 // - npm/npx sets GIT_ASKPASS which prevents credential helpers from working
 // - PERSISTENT_STORAGE_PATH/bin may contain tools like gh not in default PATH
@@ -20,8 +28,68 @@ if (config.PERSISTENT_STORAGE_PATH) {
         gitEnv['PATH'] = `${binDir}:${gitEnv['PATH'] || ''}`;
     }
 }
-function gitExec(command, options) {
-    return execAsync(command, { ...options, env: gitEnv });
+const gitCredentialContext = new AsyncLocalStorage();
+const githubBrains = new Set();
+async function gitExec(command, options) {
+    const context = gitCredentialContext.getStore();
+    const run = async (credential) => {
+        const session = credential?.source === 'platform'
+            ? createGitCredentialSession(credential, { channelId: '', threadId: `brain:${context?.brainId ?? ''}` }) : undefined;
+        try {
+            return await gitRunner(command, { ...options, env: credential ? buildGitCredentialEnv(gitEnv, credential, session?.tokenFile) : gitEnv });
+        }
+        finally {
+            if (session)
+                finishGitCredentialSession(session);
+        }
+    };
+    const recorded = () => {
+        if (context && /^git (?:clone|fetch|pull|push|submodule)\b/.test(command))
+            connectionsClient.recordBrainSource(context.brainId, context.credential.source === 'platform' ? 'platform' : 'legacy');
+    };
+    const safeResult = (result) => ({ stdout: redactGitDiagnostic(result.stdout), stderr: redactGitDiagnostic(result.stderr) });
+    const safeError = (error) => {
+        if (error instanceof Error) {
+            error.message = redactGitDiagnostic(error.message);
+            const detail = error;
+            if (detail.stdout)
+                detail.stdout = redactGitDiagnostic(detail.stdout);
+            if (detail.stderr)
+                detail.stderr = redactGitDiagnostic(detail.stderr);
+            return error;
+        }
+        return new Error(redactGitDiagnostic(String(error)));
+    };
+    try {
+        const result = await run(context?.credential);
+        recorded();
+        return safeResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!context || context.credential.source !== 'platform' || !/(?:HTTP|returned error:)\s*(?:401|403)|Authentication failed/i.test(message))
+            throw safeError(error);
+        connectionsClient.invalidate('brain', context.brainId);
+        const refreshed = await connectionsClient.get('brain', context.brainId, true);
+        if (refreshed.source !== 'platform')
+            throw safeError(error);
+        context.credential = refreshed;
+        let result;
+        try {
+            result = await run(refreshed);
+        }
+        catch (retryError) {
+            throw safeError(retryError);
+        } // exactly one remote-auth retry
+        recorded();
+        return safeResult(result);
+    }
+}
+async function withGitCredential(brainId, workspaceId, fn) {
+    if (!workspaceId || !githubBrains.has(brainId) || !config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN)
+        return fn();
+    const credential = await connectionsClient.get('brain', brainId);
+    return gitCredentialContext.run({ brainId, credential }, fn);
 }
 // Node's child_process.exec() defaults to a 1MB stdout cap. This bounds the
 // text output of a git plumbing command (e.g. one line per object listed),
@@ -119,7 +187,7 @@ async function reportBrainSync(brainId, workspaceId, event) {
                 Authorization: `Bearer ${config.TEAMVIBE_POLLER_TOKEN}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ brainId, workspaceId, event }),
+            body: JSON.stringify({ brainId: redactGitDiagnostic(brainId), workspaceId: redactGitDiagnostic(workspaceId), event, source: gitCredentialContext.getStore()?.credential.source === 'platform' ? 'platform' : 'legacy' }),
         });
         if (!response.ok) {
             logger.warn(`Brain sync report failed (${response.status})`);
@@ -127,8 +195,9 @@ async function reportBrainSync(brainId, workspaceId, event) {
         }
     }
     catch (error) {
-        logger.warn(`Brain sync report error: ${error instanceof Error ? error.message : error}`);
-        emitError('brain', `Brain sync report error: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn', context: { brainId } });
+        const diagnostic = redactGitDiagnostic(error instanceof Error ? error.message : String(error));
+        logger.warn(`Brain sync report error: ${diagnostic}`);
+        emitError('brain', `Brain sync report error: ${diagnostic}`, { severity: 'warn', context: { brainId: redactGitDiagnostic(brainId) } });
     }
 }
 // tv#247: local-only (never committed, never synced) merge-driver config for
@@ -184,7 +253,9 @@ export async function getBrainPath(brain, channelId, workspaceId) {
         return config.DEFAULT_BRAIN_PATH;
     }
     const brainDir = resolveBrainDir(workspaceId, brain.brainId);
-    return withBrainLock(brainLockKey(brainDir, brain.brainId, workspaceId), () => getWorkspaceBrainPath(brain, workspaceId));
+    if (/^https:\/\/github\.com\//i.test(brain.gitRepoUrl))
+        githubBrains.add(brain.brainId);
+    return withBrainLock(brainLockKey(brainDir, brain.brainId, workspaceId), () => withGitCredential(brain.brainId, workspaceId, () => getWorkspaceBrainPath(brain, workspaceId)));
 }
 async function getWorkspaceBrainPath(brain, workspaceId) {
     const brainDir = resolveBrainDir(workspaceId, brain.brainId);
@@ -195,7 +266,7 @@ async function getWorkspaceBrainPath(brain, workspaceId) {
     }
     mkdirSync(dirname(brainDir), { recursive: true });
     if (!existsSync(brainDir)) {
-        logger.info(`Cloning brain ${brain.brainId} from ${brain.gitRepoUrl} (branch: ${brain.branch})...`);
+        logger.info(`Cloning brain ${brain.brainId} from ${redactRepoUrl(brain.gitRepoUrl)} (branch: ${brain.branch})...`);
         await gitExec(`git clone --recurse-submodules ${brain.gitRepoUrl} ${brainDir}`);
         // Ensure the desired branch exists (handles empty repos and missing branches)
         const { stdout: currentBranch } = await gitExec('git branch --show-current', { cwd: brainDir });
@@ -214,8 +285,8 @@ async function getWorkspaceBrainPath(brain, workspaceId) {
             reportBrainSync(brain.brainId, workspaceId, 'pulled');
     }
     else if (config.BRAIN_AUTO_UPDATE) {
-        await updateBrainLocked(brainDir, brain.brainId, brain.branch, `${workspaceId}:${brain.brainId}`);
-        if (workspaceId)
+        const pulled = await updateBrainLocked(brainDir, brain.brainId, brain.branch, `${workspaceId}:${brain.brainId}`);
+        if (pulled && workspaceId)
             reportBrainSync(brain.brainId, workspaceId, 'pulled');
     }
     // Idempotent, local-only — covers both the fresh-clone and existing-dir
@@ -229,14 +300,14 @@ async function getWorkspaceBrainPath(brain, workspaceId) {
  */
 export async function updateBrain(brainDir, brainId, branch, workspaceId) {
     const key = brainLockKey(brainDir, brainId, workspaceId);
-    return withBrainLock(key, () => updateBrainLocked(brainDir, brainId, branch, key));
+    return withBrainLock(key, () => withGitCredential(brainId, workspaceId, async () => { await updateBrainLocked(brainDir, brainId, branch, key); }));
 }
 async function updateBrainLocked(brainDir, brainId, branch, key) {
     const now = Date.now();
     const lastUpdate = lastUpdateTimes.get(key) || 0;
     if (now - lastUpdate < config.BRAIN_UPDATE_COOLDOWN_MS) {
         logger.debug(`Brain ${brainId} update skipped - cooldown active (${Math.round((config.BRAIN_UPDATE_COOLDOWN_MS - (now - lastUpdate)) / 1000)}s remaining)`);
-        return;
+        return false;
     }
     // Guard: skip `reset --hard` when the working tree has uncommitted writes or
     // unpushed commits, otherwise an in-flight session's mid-message memory
@@ -265,7 +336,7 @@ async function updateBrainLocked(brainDir, brainId, branch, key) {
             // long-term skip means pushBrainChanges is persistently failing and the brain is
             // silently drifting away from base-brain / skills updates.
             logger.info(`Brain ${brainId} update skipped — local changes present (dirty=${!!dirty.trim()}, hasLocalCommits=${hasLocalCommits})`);
-            return;
+            return false;
         }
     }
     catch (error) {
@@ -273,7 +344,7 @@ async function updateBrainLocked(brainDir, brainId, branch, key) {
         // the next iteration will retry.
         const errorMessage = startupFailureDetail(error, 'BaseBrain', [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO]);
         logger.warn(`Brain ${brainId} pre-check failed, skipping update: ${errorMessage}`);
-        return;
+        return false;
     }
     await cleanupStaleLocks(brainDir);
     try {
@@ -283,11 +354,13 @@ async function updateBrainLocked(brainDir, brainId, branch, key) {
         });
         lastUpdateTimes.set(key, Date.now());
         logger.info(`Brain ${brainId} updated successfully`);
+        return true;
     }
     catch (error) {
         const errorMessage = startupFailureDetail(error, 'BaseBrain', [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO]);
         logger.error(`Failed to update brain ${brainId}: ${errorMessage}`);
         emitError('brain', `Failed to update brain ${brainId}: ${errorMessage}`, { context: { brainId, brainDir } });
+        return false;
     }
 }
 /**
@@ -421,7 +494,7 @@ export async function findOversizedBlobs(brainDir, maxBytes) {
  * process-wide env/module-load-order tricks.
  */
 export async function pushBrainChanges(brainDir, brainId, workspaceId, retryOptions) {
-    return withBrainLock(brainLockKey(brainDir, brainId, workspaceId), () => pushBrainChangesLocked(brainDir, brainId, workspaceId, retryOptions));
+    return withBrainLock(brainLockKey(brainDir, brainId, workspaceId), () => withGitCredential(brainId, workspaceId, () => pushBrainChangesLocked(brainDir, brainId, workspaceId, retryOptions)));
 }
 async function pushBrainChangesLocked(brainDir, brainId, workspaceId, retryOptions) {
     await cleanupStaleLocks(brainDir);

package/dist/brains-bootstrap.js

@@ -3,6 +3,7 @@ import { logger } from './logger.js';
 import { getPollerId } from './auth-provider.js';
 import { seedTrackedBrains } from './maintenance-cron.js';
 import { emitEvent, emitError } from './event-queue.js';
+import { connectionsClient } from './connections-client.js';
 // Client-side timeout kept comfortably above the server-side route timeout
 // (infra/poller-auth.ts: GET /poller/brains, 25s) so the poller never aborts
 // a request the Lambda could still have answered (DevGuru round-2 review —
@@ -80,7 +81,7 @@ async function attemptFetch(url, token, timeoutMs) {
         if (!body || typeof body !== 'object' || !Array.isArray(body.brains)) {
             return { ok: false, reason: 'malformed-body', detail: 'missing brains array', retryable: false };
         }
-        return { ok: true, brains: body.brains };
+        return { ok: true, brains: body.brains, channels: body.channels };
     }
     catch (err) {
         const isTimeout = err instanceof Error && err.name === 'AbortError';
@@ -97,7 +98,8 @@ async function attemptFetch(url, token, timeoutMs) {
 }
 /** Seed trackedBrains from a successful fetch and emit success telemetry.
  * Shared by both the critical-path attempt and the detached retry below. */
-function applySuccess(brains) {
+function applySuccess(brains, channels) {
+    connectionsClient.refreshTuples(brains, channels);
     const seeded = seedTrackedBrains(brains);
     logger.info(`[Bootstrap] Seeded ${seeded} brain(s) into trackedBrains from backend (${brains.length} returned)`);
     emitEvent('poller.brains_bootstrap.success', 'system', {
@@ -176,7 +178,7 @@ export async function bootstrapTrackedBrains() {
     const url = `${config.TEAMVIBE_API_URL}/poller/brains?pollerId=${encodeURIComponent(pollerId)}`;
     const outcome = await attemptFetch(url, token, CRITICAL_PATH_TIMEOUT_MS);
     if (outcome.ok) {
-        applySuccess(outcome.brains);
+        applySuccess(outcome.brains, outcome.channels);
         return;
     }
     logger.warn(`[Bootstrap] GET /poller/brains failed on first attempt: ${outcome.reason} (${outcome.detail})`);
@@ -204,7 +206,7 @@ export async function bootstrapTrackedBrains() {
             await sleep(RETRY_DELAY_MS);
             const retryOutcome = await attemptFetch(url, token, FETCH_TIMEOUT_MS);
             if (retryOutcome.ok) {
-                applySuccess(retryOutcome.brains);
+                applySuccess(retryOutcome.brains, retryOutcome.channels);
                 return;
             }
             logger.warn(`[Bootstrap] GET /poller/brains failed on retry: ${retryOutcome.reason} (${retryOutcome.detail})`);

package/dist/claude-spawner.d.ts

@@ -9,6 +9,7 @@ import { type ClaudeRateLimitInfo } from './claude-rate-limit.js';
 import { type ClaudeQuotaFailure } from './claude-quota.js';
 import { type PoolRuntimeOptions, type PoolAttempt } from './subscription-runtime.js';
 import type { SubscriptionAccount } from './subscription-pool-client.js';
+import { type GitCredential } from './connections-client.js';
 export declare function progressNotificationMarks(estimateMinutes: number): number[];
 export declare function computeCompactionKillDeadline(previousActivityTime: number, now: number, idleKillMs: number, graceMs: number): number;
 export interface ContextHintParams {
@@ -176,6 +177,8 @@ export interface BuildSpawnEnvParams {
     inboxThreadId: string;
     brainPath: string;
     subscriptionAccount?: SubscriptionAccount;
+    gitCredential?: GitCredential;
+    gitTokenFile?: string;
 }
 /**
  * Pure construction of the env object passed to the spawned `claude` child

package/dist/claude-spawner.js

@@ -1,8 +1,11 @@
+import { createSessionInstance, writeSessionOwner } from './session-instance.js';
+import { buildGitCredentialEnv } from './git-credential-env.js';
+import { createGitCredentialSession, finishGitCredentialSession, setGitCredentialSessionPid } from './git-credential-session.js';
 import { blockingUsageWindows, normalizePassiveUsage, selectSubscriptionAccount } from './subscription-selection.js';
 import { logPoolFetch, logPoolUsageWrite, poolInfo, poolLabel } from './pool-logging.js';
 import { emitPoolSelection, accountUsageTelemetry, emitCandidateUsage, poolRunTelemetry } from './pool-telemetry.js';
 import { spawn } from 'child_process';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { readFileSync, existsSync } from 'fs';
 import { WebClient } from '@slack/web-api';
 import { config } from './config.js';
@@ -21,6 +24,7 @@ import { abortLocalProbe, accountPin, preparePool, fetchRuntimePool, validateAcc
 import { selectPoolForResolvedModel } from './subscription-pool.js';
 import { isQuotaPaused, QuotaPausedError } from './quota-pause.js';
 import { redactStartupText } from './startup-auth.js';
+import { connectionsClient } from './connections-client.js';
 /** Inspect Claude's user/project settings without changing any brain files. */
 function warnTokenAliasSettings(claudeConfigDir, cwd, brainPath, sessionLog) {
     // CLAUDE_CONFIG_DIR replaces ~/.claude for user settings. settings.local.json
@@ -464,7 +468,7 @@ export function buildSpawnEnv(params) {
     const exposeToken = !/^(0|false|no|off)$/i.test(params.processEnv['EXPOSE_CLAUDE_TOKEN_TO_AGENT'] ?? '');
     const accountToken = params.subscriptionAccount?.credential.unwrap();
     const sessionToken = accountToken ?? params.processEnv['CLAUDE_CODE_OAUTH_TOKEN'];
-    return {
+    const env = {
         // Secrets platform (#105) injection — SOLE call site of
         // `SpawnSecretsEnvelope.unwrap()` in the entire poller codebase.
         // Placed FIRST so subsequent spreads can overwrite. Belt-and-
@@ -530,6 +534,12 @@ export function buildSpawnEnv(params) {
             CLAUDE_CODE_USE_FOUNDRY: undefined,
         } : {}),
     };
+    const git = params.gitCredential ?? { source: 'none' };
+    const gitEnv = buildGitCredentialEnv(env, git, params.gitTokenFile);
+    if (git.source === 'platform' && params.gitTokenFile) {
+        gitEnv['TV_GIT_BG_TASKS_FILE'] = join(dirname(params.gitTokenFile), 'bg-tasks');
+    }
+    return gitEnv;
 }
 export function buildPrompt(msg, contextHint) {
     const isEmail = msg.source === 'email';
@@ -848,7 +858,7 @@ function resultMetrics(event, pooled, lastAssistant) {
         metrics.context_window = window;
     return metrics;
 }
-async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator, runtime) {
+async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator, runtime, gitDelivery = {}) {
     const slackContext = msg.response_context.slack;
     const isCronMessage = msg.source === 'cron';
     const isMaintenance = msg.source === 'maintenance';
@@ -886,6 +896,10 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
         workspaceId: msg.teamvibe.workspaceId,
         channelId: msg.teamvibe.channelId,
     });
+    const gitCredential = gitDelivery.credential ??= await connectionsClient.get('channel', msg.teamvibe.channelId);
+    if (gitCredential.source === 'platform' && !gitDelivery.session) {
+        gitDelivery.session = createGitCredentialSession(gitCredential, { channelId: msg.teamvibe.channelId, threadId: msg.thread_id, instance: gitDelivery.instance });
+    }
     const secretsReminder = buildSecretsReminder(spawnSecrets.reminders);
     // Fetch scoped model config for this spawn — same hoisting rationale as
     // secrets above. Fail-soft: returns {} on any error, which resolveModel
@@ -1005,10 +1019,12 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
             inboxThreadId: msg.thread_id,
             brainPath: directory.path,
             subscriptionAccount: runtime?.account,
+            gitCredential,
+            gitTokenFile: gitDelivery.session?.tokenFile,
         });
         // Capture the actual credentials for this attempt, including pool selection
         // and secrets overlays, regardless of whether alias exposure is enabled.
-        const outputTokens = [spawnEnv['CLAUDE_CODE_OAUTH_TOKEN'], spawnEnv['TEAMVIBE_CLAUDE_OAUTH_TOKEN']]
+        const outputTokens = [spawnEnv['CLAUDE_CODE_OAUTH_TOKEN'], spawnEnv['TEAMVIBE_CLAUDE_OAUTH_TOKEN'], spawnEnv['GH_TOKEN'], spawnEnv['GITHUB_TOKEN']]
             .filter((token) => !!token);
         const redactOutput = (text) => redactStartupText(text, outputTokens);
         const safeEvent = (value) => {
@@ -1020,7 +1036,7 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
                 return value;
             return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
                 redactOutput(key),
-                /^(?:CLAUDE_CODE_OAUTH_TOKEN|TEAMVIBE_CLAUDE_OAUTH_TOKEN)$/i.test(key) ? '[REDACTED]' : safeEvent(entry),
+                /^(?:CLAUDE_CODE_OAUTH_TOKEN|TEAMVIBE_CLAUDE_OAUTH_TOKEN|GH_TOKEN|GITHUB_TOKEN|GITLAB_TOKEN)$/i.test(key) ? '[REDACTED]' : safeEvent(entry),
             ]));
         };
         warnTokenAliasSettings(spawnEnv['CLAUDE_CONFIG_DIR'], cwd, directory.path, sessionLog);
@@ -1042,6 +1058,8 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
             // itself.
             detached: true,
         });
+        if (gitDelivery.session)
+            setGitCredentialSessionPid(gitDelivery.session, proc.pid);
         // Track active process by message ID and thread ID
         activeProcesses.set(msg.id, proc);
         activeProcessesByThread.set(msg.thread_id, proc);
@@ -1467,10 +1485,11 @@ export async function spawnClaudeCode(msg, sessionLog, selectedDirectory, sessio
     // the main working dir can't trample in-flight writes or pre-push commits.
     // See teamvibe.ai#120. cwd remains the main brain path on fallback / failure.
     let effectiveCwd = cwd;
+    const gitDelivery = { instance: createSessionInstance() };
     let worktreeOwner;
     if (shouldIsolateInWorktree(msg)) {
         try {
-            effectiveCwd = await createWorktree(cwd, msg.thread_id);
+            effectiveCwd = await createWorktree(cwd, msg.thread_id, 'main', gitDelivery.instance);
             worktreeOwner = { brainPath: cwd, id: msg.thread_id };
             sessionLog.info(`[Worktree] Spawned session running in ${effectiveCwd}`);
         }
@@ -1487,12 +1506,12 @@ export async function spawnClaudeCode(msg, sessionLog, selectedDirectory, sessio
             const { randomUUID } = await import('crypto');
             effectiveSessionId = randomUUID();
         }
-        const result = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, effectiveSessionId, isFirstMessage, lastMessageTs, onMessageSent, typingIndicator);
+        const result = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, effectiveSessionId, isFirstMessage, lastMessageTs, onMessageSent, typingIndicator, undefined, gitDelivery);
         // If --resume failed, retry as a fresh session (session files may have been lost on container restart)
         let retryResult = result;
         if (!result.success && !result.quota && effectiveSessionId && !isFirstMessage) {
             sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');
-            retryResult = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, effectiveSessionId, true, lastMessageTs, onMessageSent, typingIndicator);
+            retryResult = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, effectiveSessionId, true, lastMessageTs, onMessageSent, typingIndicator, undefined, gitDelivery);
         }
         // If session ID is "already in use" (stale lock file), retry immediately with a
         // fresh ID — no zombie kill first. Zombie cleanup is #73's concern, not spawn
@@ -1501,17 +1520,23 @@ export async function spawnClaudeCode(msg, sessionLog, selectedDirectory, sessio
             sessionLog.info('Session ID already in use (stale lock), retrying with fresh session ID');
             const { randomUUID } = await import('crypto');
             const freshId = randomUUID();
-            const freshResult = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, freshId, true, lastMessageTs, onMessageSent, typingIndicator);
+            const freshResult = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, freshId, true, lastMessageTs, onMessageSent, typingIndicator, undefined, gitDelivery);
             return finalizeSpawnResult(freshResult, true, freshId);
         }
         return finalizeSpawnResult(retryResult, isFirstMessage, effectiveSessionId);
     }
     finally {
-        if (worktreeOwner) {
-            removeWorktree(worktreeOwner.brainPath, worktreeOwner.id).catch((err) => {
-                sessionLog.warn(`[Worktree] Cleanup failed (will be retried by orphan janitor): ${err instanceof Error ? err.message : err}`);
-            });
-        }
+        const cleanup = () => {
+            if (worktreeOwner) {
+                removeWorktree(worktreeOwner.brainPath, worktreeOwner.id, gitDelivery.instance).catch((err) => {
+                    sessionLog.warn(`[Worktree] Cleanup failed (will be retried by orphan janitor): ${err instanceof Error ? err.message : err}`);
+                });
+            }
+        };
+        if (gitDelivery.session)
+            finishGitCredentialSession(gitDelivery.session, cleanup);
+        else
+            cleanup();
     }
 }
 // Configured-pool orchestration is deliberately separate from legacy spawns.
@@ -1543,6 +1568,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
     let effectiveCwd = cwd;
     let retainWorktree = resumePending;
     const poolAttempts = poolRuntime?.attempts?.slice(-1000) ?? [];
+    const gitDelivery = { instance: createSessionInstance() };
     let worktreeOwner;
     if (isolate) {
         try {
@@ -1550,7 +1576,8 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
             if (resumePending && !existsSync(derivedCwd)) {
                 sessionLog.warn(`[Worktree] Pinned worktree missing; recreating ${derivedCwd} for pending session ${sessionId ?? 'unknown'}`);
             }
-            effectiveCwd = resumePending && existsSync(derivedCwd) ? derivedCwd : await createWorktree(cwd, msg.thread_id);
+            effectiveCwd = resumePending && existsSync(derivedCwd) ? derivedCwd : await createWorktree(cwd, msg.thread_id, 'main', gitDelivery.instance);
+            writeSessionOwner(join(effectiveCwd, '.teamvibe-session-owner.json'), gitDelivery.instance);
             worktreeOwner = { brainPath: cwd, id: msg.thread_id };
             sessionLog.info(`[Worktree] Spawned session running in ${effectiveCwd}`);
         }
@@ -1621,7 +1648,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
             // fallback must report the fresh attempt's delivery flags independently.
             if (!runtime?.resumePending)
                 sawSendMessageCall = false;
-            const spawned = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, id, runtime?.resumePending ? false : first, lastMessageTs, onMessageSent, typingIndicator, runtime);
+            const spawned = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, id, runtime?.resumePending ? false : first, lastMessageTs, onMessageSent, typingIndicator, runtime, gitDelivery);
             const result = prepared?.account
                 ? { ...spawned, quota: quotaForModel(spawned.quota), success: rejectedForModel(spawned.rateLimitInfo) ? false : spawned.success } : spawned;
             sawSendMessageCall ||= result.sawSendMessageCall === true;
@@ -1766,11 +1793,17 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
         throw error;
     }
     finally {
-        if (worktreeOwner && !retainWorktree) {
-            removeWorktree(worktreeOwner.brainPath, worktreeOwner.id).catch((err) => {
-                sessionLog.warn(`[Worktree] Cleanup failed (will be retried by orphan janitor): ${err instanceof Error ? err.message : err}`);
-            });
-        }
+        const cleanup = () => {
+            if (worktreeOwner && !retainWorktree) {
+                removeWorktree(worktreeOwner.brainPath, worktreeOwner.id, gitDelivery.instance).catch((err) => {
+                    sessionLog.warn(`[Worktree] Cleanup failed (will be retried by orphan janitor): ${err instanceof Error ? err.message : err}`);
+                });
+            }
+        };
+        if (gitDelivery.session)
+            finishGitCredentialSession(gitDelivery.session, cleanup);
+        else
+            cleanup();
     }
 }
 const activeProcesses = new Map();