@teamvibe/poller 0.8.6 → 0.8.7-rc.1

package/dist/connections-client.d.ts

@@ -0,0 +1,66 @@
+export type GitCredential = {
+    source: 'platform';
+    host: 'github.com';
+    username: 'x-access-token';
+    token: string;
+    connectionId: string;
+    credentialVersion: string;
+    bindingVersion: number;
+    expiresAt?: string;
+    kind?: 'github_token' | 'github_app';
+} | {
+    source: 'none';
+    legacyAllowed?: boolean;
+};
+export interface BindingTuple {
+    connectionId?: string;
+    credentialVersion?: string;
+    bindingVersion?: number;
+}
+type Scope = 'brain' | 'channel';
+export declare class ConnectionFetchError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, status: number);
+}
+/** Cache keys include consumer scope. Binding tuples arrive at startup and
+ * each brains refresh; a changed tuple evicts immediately. */
+export declare class ConnectionsClient {
+    private options;
+    private entries;
+    private tuples;
+    private legacyBrains;
+    private serverHasConnections;
+    private lastLegacyNotice;
+    constructor(options: {
+        apiUrl: string;
+        pollerToken: string;
+        fetch?: typeof fetch;
+        now?: () => number;
+    });
+    private key;
+    private now;
+    refreshTuples(brains: ReadonlyArray<{
+        brainId: string;
+        channelId: string;
+        connectionId?: string;
+        credentialVersion?: string;
+        bindingVersion?: number;
+        channelConnectionId?: string;
+        channelCredentialVersion?: string;
+        channelBindingVersion?: number;
+    }>, channels?: ReadonlyArray<{
+        channelId: string;
+        connectionId?: string;
+        credentialVersion?: string;
+        bindingVersion?: number;
+    }>): void;
+    invalidate(scope: Scope, id: string): void;
+    recordBrainSource(brainId: string, source: 'platform' | 'legacy'): void;
+    get legacyGitBrains(): number;
+    private noticeLegacyServer;
+    get(scope: Scope, id: string, force?: boolean): Promise<GitCredential>;
+}
+export declare const connectionsClient: ConnectionsClient;
+export declare function refreshConnectionTuples(pollerId: string): Promise<void>;
+export {};

package/dist/connections-client.js

@@ -0,0 +1,128 @@
+import { config } from './config.js';
+import { registerConfiguredToken } from './redact-text.js';
+export class ConnectionFetchError extends Error {
+    code;
+    status;
+    constructor(code, status) {
+        super(code);
+        this.code = code;
+        this.status = status;
+    }
+}
+/** Cache keys include consumer scope. Binding tuples arrive at startup and
+ * each brains refresh; a changed tuple evicts immediately. */
+export class ConnectionsClient {
+    options;
+    entries = new Map();
+    tuples = new Map();
+    legacyBrains = new Set();
+    serverHasConnections = true;
+    lastLegacyNotice = -Infinity;
+    constructor(options) {
+        this.options = options;
+    }
+    key(scope, id) { return `${scope}:${id}`; }
+    now() { return (this.options.now ?? Date.now)(); }
+    refreshTuples(brains, channels) {
+        if (brains.some(brain => Object.hasOwn(brain, 'bindingVersion')) || channels?.some(channel => Object.hasOwn(channel, 'bindingVersion'))) {
+            this.serverHasConnections = true;
+        }
+        else if ((brains.length > 0 || (channels?.length ?? 0) > 0) && brains.every(brain => !Object.hasOwn(brain, 'bindingVersion') && !Object.hasOwn(brain, 'connectionId') && !Object.hasOwn(brain, 'credentialVersion'))) {
+            this.serverHasConnections = false;
+            this.entries.clear();
+            this.noticeLegacyServer();
+        }
+        const next = new Map();
+        for (const brain of brains) {
+            next.set(this.key('brain', brain.brainId), JSON.stringify([brain.connectionId, brain.credentialVersion, brain.bindingVersion ?? 0]));
+            next.set(this.key('channel', brain.channelId), JSON.stringify([brain.channelConnectionId, brain.channelCredentialVersion, brain.channelBindingVersion ?? 0]));
+        }
+        for (const channel of channels ?? [])
+            next.set(this.key('channel', channel.channelId), JSON.stringify([channel.connectionId, channel.credentialVersion, channel.bindingVersion ?? 0]));
+        for (const [key, entry] of this.entries)
+            if (next.get(key) !== entry.tuple)
+                this.entries.delete(key);
+        for (const brainId of this.legacyBrains)
+            if (!next.has(this.key('brain', brainId)))
+                this.legacyBrains.delete(brainId);
+        this.tuples = next;
+    }
+    invalidate(scope, id) { this.entries.delete(this.key(scope, id)); }
+    recordBrainSource(brainId, source) {
+        if (source === 'legacy')
+            this.legacyBrains.add(brainId);
+        else
+            this.legacyBrains.delete(brainId);
+    }
+    get legacyGitBrains() { return this.legacyBrains.size; }
+    noticeLegacyServer() {
+        if (this.now() - this.lastLegacyNotice >= 3600_000) {
+            console.warn('Connections API unavailable; using legacy git credentials');
+            this.lastLegacyNotice = this.now();
+        }
+    }
+    async get(scope, id, force = false) {
+        if (!this.serverHasConnections) {
+            this.noticeLegacyServer();
+            return { source: 'none', legacyAllowed: true };
+        }
+        const key = this.key(scope, id);
+        const tuple = this.tuples.get(key);
+        const entry = this.entries.get(key);
+        if (!force && entry && entry.tuple === (tuple ?? '') && entry.validUntil > this.now())
+            return entry.value;
+        this.entries.delete(key);
+        if (!/^[A-Za-z0-9_-]{1,128}$/.test(id))
+            throw new ConnectionFetchError('invalid_request', 400);
+        const url = new URL(scope === 'brain' ? `/brains/${encodeURIComponent(id)}/git-credential` : '/connections/git/spawn', this.options.apiUrl);
+        if (scope === 'channel')
+            url.searchParams.set('channelId', id);
+        const response = await (this.options.fetch ?? fetch)(url, { headers: { Authorization: `Bearer ${this.options.pollerToken}`, 'Cache-Control': 'no-store' }, redirect: 'error' });
+        if (!response.ok) {
+            if (response.status === 405 || response.status === 404 && !(await response.clone().json().catch(() => ({}))).code) {
+                this.serverHasConnections = false;
+                this.noticeLegacyServer();
+                return { source: 'none', legacyAllowed: true };
+            }
+            const code = { 400: 'invalid_request', 401: 'unauthorized', 403: 'forbidden', 404: 'connection_unbound', 409: 'connection_disabled', 410: 'connection_deleted' }[response.status] ?? 'credential_store_unavailable';
+            throw new ConnectionFetchError(code, response.status);
+        }
+        const body = await response.json();
+        let value;
+        if (body.source === 'none')
+            value = { source: 'none', ...(body.legacyAllowed === true ? { legacyAllowed: true } : {}) };
+        else if (body.source === 'platform' && body.host === 'github.com' && body.username === 'x-access-token' &&
+            typeof body.token === 'string' && body.token && typeof body.connectionId === 'string' &&
+            typeof body.credentialVersion === 'string' && typeof body.bindingVersion === 'number') {
+            value = body;
+            registerConfiguredToken(body.token);
+        }
+        else
+            throw new ConnectionFetchError('invalid_response', 503);
+        const validUntil = value.source === 'platform' && value.expiresAt
+            ? Date.parse(value.expiresAt) - 5 * 60_000 : this.now() + 10 * 60_000;
+        if (validUntil > this.now())
+            this.entries.set(key, { value, tuple: tuple ?? '', validUntil });
+        return value;
+    }
+}
+export const connectionsClient = new ConnectionsClient({ apiUrl: config.TEAMVIBE_API_URL, pollerToken: config.TEAMVIBE_POLLER_TOKEN ?? '' });
+export async function refreshConnectionTuples(pollerId) {
+    if (!pollerId || !config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN)
+        return;
+    const url = new URL('/poller/brains', config.TEAMVIBE_API_URL);
+    url.searchParams.set('pollerId', pollerId);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30_000);
+    try {
+        const response = await fetch(url, { headers: { Authorization: `Bearer ${config.TEAMVIBE_POLLER_TOKEN}` }, signal: controller.signal });
+        if (!response.ok)
+            return;
+        const body = await response.json();
+        if (Array.isArray(body.brains))
+            connectionsClient.refreshTuples(body.brains, body.channels);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/git-credential-env.d.ts

@@ -0,0 +1,3 @@
+import type { GitCredential } from './connections-client.js';
+export declare const GIT_CREDENTIAL_HELPER: string;
+export declare function buildGitCredentialEnv(base: NodeJS.ProcessEnv, credential: GitCredential, tokenFile?: string): NodeJS.ProcessEnv;

package/dist/git-credential-env.js

@@ -0,0 +1,37 @@
+import { fileURLToPath } from 'node:url';
+import { registerConfiguredToken } from './redact-text.js';
+// Works from both src/ (tests) and dist/ (published package).
+export const GIT_CREDENTIAL_HELPER = fileURLToPath(new URL('../bin/tv-git-credential.mjs', import.meta.url));
+export function buildGitCredentialEnv(base, credential, tokenFile) {
+    const env = { ...base };
+    const legacy = credential.source === 'none' && credential.legacyAllowed === true;
+    for (const key of Object.keys(env)) {
+        // Do not inherit a prior session's helper/file, even on eligible legacy.
+        if (key.startsWith('TV_GIT_') || !legacy && (/^GIT_(?:CONFIG|CREDENTIAL|TRACE|SSL|HTTP|SSH)(?:_|$)/.test(key) ||
+            ['GIT_ASKPASS', 'GIT_EXEC_PATH', 'GIT_PROXY_COMMAND', 'GIT_DIR', 'GIT_COMMON_DIR', 'GIT_WORK_TREE', 'GIT_NAMESPACE', 'GIT_TEMPLATE_DIR', 'GIT_PROTOCOL', 'GIT_ALLOW_PROTOCOL', 'SSH_ASKPASS'].includes(key) ||
+            ['GITHUB_TOKEN', 'GH_TOKEN', 'GITLAB_TOKEN'].includes(key)))
+            delete env[key];
+    }
+    if (legacy)
+        return env;
+    env['GIT_TERMINAL_PROMPT'] = '0';
+    env['GIT_CONFIG_COUNT'] = credential.source === 'platform' ? '3' : '1';
+    env['GIT_CONFIG_KEY_0'] = 'credential.helper';
+    env['GIT_CONFIG_VALUE_0'] = '';
+    if (credential.source === 'platform') {
+        if (!tokenFile)
+            throw new Error('Git credential token file required');
+        registerConfiguredToken(credential.token);
+        env['TV_GIT_TOKEN_FILE'] = tokenFile;
+        env['GIT_CONFIG_KEY_1'] = `credential.https://${credential.host}.helper`;
+        // Strip CLI snapshots before the helper process starts. Git appends only
+        // get/store/erase; the token remains exclusively in the private file.
+        const helperPath = "'" + GIT_CREDENTIAL_HELPER.replace(/'/g, "'\\''") + "'";
+        env['GIT_CONFIG_VALUE_1'] = `!env -u GITHUB_TOKEN -u GH_TOKEN -u GITLAB_TOKEN ${helperPath}`;
+        env['GIT_CONFIG_KEY_2'] = `credential.https://${credential.host}.useHttpPath`;
+        env['GIT_CONFIG_VALUE_2'] = 'true';
+        env['GH_TOKEN'] = credential.token;
+        env['GITHUB_TOKEN'] = credential.token;
+    }
+    return env;
+}

package/dist/git-credential-session.d.ts

@@ -0,0 +1,33 @@
+import type { GitCredential } from './connections-client.js';
+import { type SessionInstance } from './session-instance.js';
+type PlatformCredential = Extract<GitCredential, {
+    source: 'platform';
+}>;
+export interface GitCredentialSession extends SessionInstance {
+    dir: string;
+    tokenFile: string;
+    tasksFile: string;
+}
+export interface AgentGitDelivery {
+    instance?: SessionInstance;
+    credential?: GitCredential;
+    session?: GitCredentialSession;
+}
+export declare function gitCredentialRoot(): string;
+export declare function gitCredentialKind(credential: PlatformCredential): 'github_app' | 'github_token';
+export declare function writeGitTokenFile(dir: string, credential: PlatformCredential): void;
+export declare function createGitCredentialSession(credential: PlatformCredential, options: {
+    root?: string;
+    channelId: string;
+    threadId: string;
+    instance?: SessionInstance;
+}): GitCredentialSession;
+export declare function setGitCredentialSessionPid(session: GitCredentialSession, pid: number | undefined): void;
+export declare function isGitCredentialInstanceRetained(instance?: SessionInstance, root?: string, threadId?: string): boolean;
+export declare function isGitCredentialInstanceKnownDead(instance: SessionInstance, root?: string): boolean;
+export declare function registeredWorktreeOwner(threadId: string, root?: string): SessionInstance | undefined;
+export declare function finishGitCredentialSession(session: GitCredentialSession, cleanup?: () => void): void;
+export declare function registeredGitCredentialTasks(root?: string): ReadonlySet<string>;
+export declare function sweepGitCredentialSessions(root?: string): void;
+export declare function startGitCredentialJanitor(): void;
+export {};

package/dist/git-credential-session.js

@@ -0,0 +1,265 @@
+import { execFileSync } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { config } from './config.js';
+import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
+import { lifecycleOf, listDirs, parseStatus, pidAlive } from './bg-task-registry.js';
+import { registerConfiguredToken } from './redact-text.js';
+import { createSessionInstance, readSessionOwner, writeSessionOwner, sameSessionInstance, reportSessionOwnerMismatch } from './session-instance.js';
+const deferredCleanup = new Map();
+// PID alone is insufficient after container restart (PID 1) or ordinary PID
+// reuse. Linux start ticks include sub-second precision; macOS exposes lstart.
+function processIdentity(pid) {
+    try {
+        if (process.platform === 'linux') {
+            const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+            return readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim() + ':' + stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19];
+        }
+        return execFileSync('ps', ['-p', String(pid), '-o', 'lstart='], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameProcess(pid, identity) {
+    return pidAlive(pid) && (identity === undefined || identity === processIdentity(pid));
+}
+const ownerIdentity = processIdentity(process.pid);
+export function gitCredentialRoot() {
+    return resolve(config.PERSISTENT_STORAGE_PATH || tmpdir(), 'teamvibe-git-sessions');
+}
+function atomicWrite(path, contents) {
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, contents, { mode: 0o600, flag: 'wx' });
+        chmodSync(temporary, 0o600);
+        renameSync(temporary, path);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+// The PAT contract omits expiry; installation tokens always carry provider expiry.
+export function gitCredentialKind(credential) {
+    return credential.kind ?? (credential.expiresAt ? 'github_app' : 'github_token');
+}
+export function writeGitTokenFile(dir, credential) {
+    registerConfiguredToken(credential.token);
+    atomicWrite(join(dir, 'git-token'), JSON.stringify({ host: credential.host, token: credential.token, expiresAt: credential.expiresAt, kind: gitCredentialKind(credential) }));
+}
+export function createGitCredentialSession(credential, options) {
+    const root = options.root ?? gitCredentialRoot();
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    chmodSync(root, 0o700);
+    const dir = mkdtempSync(join(root, 'session-'));
+    chmodSync(dir, 0o700);
+    try {
+        const instance = options.instance ?? createSessionInstance();
+        writeSessionOwner(join(dir, 'owner.json'), instance);
+        writeGitTokenFile(dir, credential);
+        const metadata = { ...instance, ownerPid: process.pid, ownerIdentity, active: true, channelId: options.channelId, threadId: options.threadId, connectionId: credential.connectionId, kind: gitCredentialKind(credential) };
+        atomicWrite(join(dir, 'session.json'), JSON.stringify(metadata));
+        const tasksFile = join(dir, 'bg-tasks');
+        writeFileSync(tasksFile, '', { mode: 0o600, flag: 'wx' });
+        return { ...instance, dir, tasksFile, tokenFile: join(dir, 'git-token') };
+    }
+    catch (error) {
+        rmSync(dir, { recursive: true, force: true });
+        throw error;
+    }
+}
+export function setGitCredentialSessionPid(session, pid) {
+    const path = join(session.dir, 'session.json');
+    const metadata = readMetadata(session.dir);
+    if (!metadata || !ownsSession(session.dir, session) || !sameSessionInstance(metadata, session)) {
+        reportSessionOwnerMismatch(session, readSessionOwner(join(session.dir, 'owner.json')));
+        return;
+    }
+    metadata.sessionPid = pid;
+    metadata.sessionIdentity = pid === undefined ? undefined : processIdentity(pid);
+    atomicWrite(path, JSON.stringify(metadata));
+}
+function hasRegisteredTasks(dir) {
+    // The launcher appends an existing registry task directory before starting its
+    // runner. Status/PID/TTL semantics are shared with idle restart, not duplicated.
+    let tasks;
+    try {
+        tasks = readFileSync(join(dir, 'bg-tasks'), 'utf8').split('\n').filter(Boolean);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error; // unreadable registrations retain credentials until retry
+    }
+    return tasks.some(task => {
+        if (!existsSync(task))
+            return false;
+        let status = '';
+        try {
+            status = readFileSync(join(task, 'status'), 'utf8');
+        }
+        catch { }
+        const state = lifecycleOf(parseStatus(status), Date.now());
+        // A new directory has no status until its runner starts; bound the grace
+        // period so a crashed launcher cannot keep credentials forever.
+        if (state === 'unknown')
+            return Date.now() - statSync(task).mtimeMs < 60_000;
+        return state === 'running';
+    });
+}
+// Shared retention decision table (always evaluated BEFORE ownership/age):
+// live session OR live registered task => retain, even with a bad/missing marker.
+// Otherwise: matching known-dead owner => delete; missing/malformed owner =>
+// delete only after orphan age; different live owner => retain; unknown owner
+// => retain until its death can be established. Deferred cleanup is stricter:
+// only the exact scheduling owner may delete, with no age/file-identity fallback.
+function isSessionRetained(dir, metadata) {
+    return !!(metadata?.active && (sameProcess(metadata.ownerPid, metadata.ownerIdentity) ||
+        metadata.sessionPid !== undefined && sameProcess(metadata.sessionPid, metadata.sessionIdentity))) || hasRegisteredTasks(dir);
+}
+function readMetadata(dir) {
+    try {
+        return JSON.parse(readFileSync(join(dir, 'session.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isGitCredentialInstanceRetained(instance, root = gitCredentialRoot(), threadId) {
+    for (const name of listDirs(root)) {
+        if (!name.startsWith('session-'))
+            continue;
+        const dir = join(root, name);
+        const metadata = readMetadata(dir);
+        // Metadata associates the worktree's reusable thread path with its live
+        // session even when either ownership marker is damaged or replaced.
+        if (metadata && (sameSessionInstance(metadata, instance) || threadId !== undefined && metadata.threadId === threadId)) {
+            if (isSessionRetained(dir, metadata))
+                return true;
+        }
+        else if (instance && ownsSession(dir, instance) && (!metadata || isSessionRetained(dir, metadata)))
+            return true;
+    }
+    return false;
+}
+export function isGitCredentialInstanceKnownDead(instance, root = gitCredentialRoot()) {
+    let known = false;
+    for (const name of listDirs(root)) {
+        if (!name.startsWith('session-'))
+            continue;
+        const dir = join(root, name);
+        const metadata = readMetadata(dir);
+        if (!sameSessionInstance(metadata, instance))
+            continue;
+        if (isSessionRetained(dir, metadata))
+            return false;
+        known = true;
+    }
+    return known;
+}
+export function registeredWorktreeOwner(threadId, root = gitCredentialRoot()) {
+    for (const name of listDirs(root)) {
+        if (!name.startsWith('session-'))
+            continue;
+        const dir = join(root, name);
+        const metadata = readMetadata(dir);
+        if (metadata?.threadId === threadId && isSessionRetained(dir, metadata))
+            return metadata;
+    }
+    return undefined;
+}
+function ownsSession(dir, instance) {
+    return sameSessionInstance(readSessionOwner(join(dir, 'owner.json')), instance);
+}
+const ORPHAN_AGE_MS = 24 * 60 * 60 * 1000;
+function sweepSession(dir) {
+    const path = join(dir, 'session.json');
+    const metadata = readMetadata(dir);
+    const retained = isSessionRetained(dir, metadata);
+    const deferred = deferredCleanup.get(dir);
+    const expected = deferred?.session ?? metadata;
+    const current = readSessionOwner(join(dir, 'owner.json'));
+    const matches = sameSessionInstance(current, expected) && (!deferred || sameSessionInstance(metadata, expected));
+    if (expected && !matches)
+        reportSessionOwnerMismatch(expected, current);
+    const events = join(dir, 'git-credential-events');
+    if (metadata && matches && existsSync(events)) {
+        if (!metadata.expiryReported) {
+            emitError('session', `git_credential_expired kind=${metadata.kind}`, { channelId: metadata.channelId, context: { code: 'git_credential_expired', kind: metadata.kind, connectionId: metadata.connectionId, threadId: metadata.threadId } });
+            metadata.expiryReported = true;
+            atomicWrite(path, JSON.stringify(metadata));
+        }
+        rmSync(events, { force: true });
+    }
+    // Liveness is independent of marker integrity, including registered tasks
+    // whose owner died or whose session metadata is temporarily unreadable.
+    if (retained)
+        return false;
+    if (deferred && !matches) {
+        // Keep the guard for subsequent janitor ticks; losing it would turn the
+        // next tick into an age-based orphan deletion of the same unproven owner.
+        return false; // Never run the old callback against unproven ownership.
+    }
+    if (current && isGitCredentialInstanceRetained(current, resolve(dir, '..')))
+        return false;
+    if (!matches) {
+        if (current ? !isGitCredentialInstanceKnownDead(current, resolve(dir, '..')) : Date.now() - statSync(dir).mtimeMs < ORPHAN_AGE_MS)
+            return false;
+    }
+    rmSync(dir, { recursive: true, force: true });
+    const cleanup = deferredCleanup.get(dir);
+    deferredCleanup.delete(dir);
+    cleanup?.cleanup?.();
+    return true;
+}
+export function finishGitCredentialSession(session, cleanup) {
+    const path = join(session.dir, 'session.json');
+    const metadata = readMetadata(session.dir);
+    if (!metadata || !ownsSession(session.dir, session) || !sameSessionInstance(metadata, session)) {
+        reportSessionOwnerMismatch(session, readSessionOwner(join(session.dir, 'owner.json')));
+        return;
+    }
+    metadata.active = false;
+    atomicWrite(path, JSON.stringify(metadata));
+    deferredCleanup.set(session.dir, { session, cleanup });
+    try {
+        sweepSession(session.dir);
+    }
+    catch {
+        logger.warn('[GitCredential] Session cleanup deferred; will retry');
+    }
+}
+export function registeredGitCredentialTasks(root = gitCredentialRoot()) {
+    const tasks = new Set();
+    for (const name of listDirs(root)) {
+        if (!name.startsWith('session-'))
+            continue;
+        try {
+            for (const task of readFileSync(join(root, name, 'bg-tasks'), 'utf8').split('\n').filter(Boolean))
+                tasks.add(task);
+        }
+        catch { /* incomplete session directory; next sweep retries */ }
+    }
+    return tasks;
+}
+// Startup and periodic cleanup only: v1 never re-mints or rewrites git-token.
+export function sweepGitCredentialSessions(root = gitCredentialRoot()) {
+    for (const name of listDirs(root)) {
+        if (!name.startsWith('session-'))
+            continue;
+        try {
+            sweepSession(join(root, name));
+        }
+        catch {
+            logger.warn('[GitCredential] Session cleanup deferred; will retry');
+        }
+    }
+}
+export function startGitCredentialJanitor() {
+    sweepGitCredentialSessions();
+    const timer = setInterval(() => sweepGitCredentialSessions(), 1000);
+    timer.unref();
+}

package/dist/idle-restart.d.ts

@@ -1,6 +1,6 @@
 export declare function readReclaimableFileBytes(path?: string): number | null;
 export declare function findLiveBgTask(now?: number): string | null;
-export declare function reconcileBgTasksOnBoot(): void;
+export declare function reconcileBgTasksOnBoot(preserveTasks?: ReadonlySet<string>): void;
 export interface CheckIdleRestartDeps {
     now?: number;
     startTime?: number;

package/dist/idle-restart.js

@@ -1,4 +1,5 @@
-import { appendFileSync, readdirSync, readFileSync } from 'fs';
+import { bgTaskRoot, listDirs, parseStatus, lifecycleOf } from './bg-task-registry.js';
+import { appendFileSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { config } from './config.js';
 import { logger } from './logger.js';
@@ -38,66 +39,6 @@ export function readReclaimableFileBytes(path = MEMORY_STAT_PATH) {
 // skills/background-task/scripts/bg-task.mjs) rather than a raw /proc scan, which
 // false-negatives on interpreter/path variations and can't distinguish "stuck past TTL"
 // from "healthy" the way the status file's own started/ttl fields can.
-const ABANDON_GRACE_SEC = 60; // mirrors bg-task.mjs's ABANDON_GRACE_SEC
-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;
-}
-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).
-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';
-}
-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');
-}
-function listDirs(path) {
-    try {
-        return readdirSync(path, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name);
-    }
-    catch {
-        return [];
-    }
-}
 // Returns a "channel/taskId" label for the first live (running or unknown-state) task
 // found, or null if none. `unknown` (no status written yet) is treated as live —
 // deliberately conservative, per tv#317: a task a few milliseconds from its first
@@ -131,12 +72,16 @@ export function findLiveBgTask(now = Date.now()) {
 // a stale recorded `pid=`, so pidAlive() alone isn't reliable evidence either. Called
 // once at boot so every pre-restart dir is unambiguously stamped before the idle-restart
 // gate (or `--list`) ever reads it again.
-export function reconcileBgTasksOnBoot() {
+export function reconcileBgTasksOnBoot(preserveTasks = new Set()) {
     const root = bgTaskRoot();
     let stamped = 0;
     for (const channel of listDirs(root)) {
         const channelPath = join(root, channel);
         for (const taskDir of listDirs(channelPath)) {
+            // A registered task can survive a service restart on macOS. Credential
+            // startup cleanup has already removed registrations with no live owner/task.
+            if (preserveTasks.has(join(channelPath, taskDir)))
+                continue;
             const statusPath = join(channelPath, taskDir, 'status');
             let statusText;
             try {

package/dist/maintenance-cron.d.ts

@@ -37,6 +37,12 @@ export interface BootstrapBrainInfo {
     botId: string;
     botToken: string;
     channelId: string;
+    connectionId?: string;
+    credentialVersion?: string;
+    bindingVersion?: number;
+    channelConnectionId?: string;
+    channelCredentialVersion?: string;
+    channelBindingVersion?: number;
 }
 /**
  * Seed trackedBrains at startup from the backend's authoritative brain list

package/dist/poller.js

@@ -1,3 +1,4 @@
+import { startGitCredentialJanitor, registeredGitCredentialTasks } from './git-credential-session.js';
 import { isUsageProbe, handleUsageProbe } from './usage-probe-job.js';
 import { fetchSubscriptionPool } from './subscription-pool-client.js';
 import { formatPoolUsageLimitMessage } from './usage-limit-messages.js';
@@ -1232,7 +1233,8 @@ export async function startPoller() {
         logger.error(`Startup base brain failed permanently: ${startupFailureDetail(error, 'BaseBrain', [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO])}`);
         process.exit(1);
     }
-    reconcileBgTasksOnBoot();
+    startGitCredentialJanitor();
+    reconcileBgTasksOnBoot(registeredGitCredentialTasks());
     if (config.IDLE_RESTART_ENABLED) {
         // Defaults off (tv#317 follow-up, DevGuru review): a silent disabled gate and an
         // enabled gate that just hasn't hit its threshold yet look identical in production