@thegitai/cli 1.0.0-preview.5 → 1.0.0-preview.51

package/dist/src/api/contracts.js

@@ -1 +1,55 @@
-export {};
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+const USER_INPUT_ID_PATTERN = /^[a-z][a-z0-9_]*$/;
+export function isUserInputQuestionArray(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 4) {
+        return false;
+    }
+    const questionIds = new Set();
+    return value.every((question) => {
+        if (!question || typeof question !== 'object' || Array.isArray(question)) {
+            return false;
+        }
+        const candidate = question;
+        if (!nonEmptyString(candidate.id) ||
+            !USER_INPUT_ID_PATTERN.test(candidate.id) ||
+            questionIds.has(candidate.id) ||
+            !nonEmptyString(candidate.header) ||
+            Array.from(candidate.header).length > 12 ||
+            !nonEmptyString(candidate.question) ||
+            typeof candidate.multiSelect !== 'boolean' ||
+            !Array.isArray(candidate.options) ||
+            candidate.options.length < 2 ||
+            candidate.options.length > 4) {
+            return false;
+        }
+        questionIds.add(candidate.id);
+        const optionIds = new Set();
+        const optionsValid = candidate.options.every((option) => {
+            if (!option || typeof option !== 'object' || Array.isArray(option)) {
+                return false;
+            }
+            const item = option;
+            if (!nonEmptyString(item.id) ||
+                !USER_INPUT_ID_PATTERN.test(item.id) ||
+                optionIds.has(item.id) ||
+                !nonEmptyString(item.label) ||
+                !nonEmptyString(item.description)) {
+                return false;
+            }
+            optionIds.add(item.id);
+            return true;
+        });
+        if (!optionsValid) {
+            return false;
+        }
+        if (candidate.recommendedOptionId !== undefined &&
+            (!nonEmptyString(candidate.recommendedOptionId) ||
+                candidate.recommendedOptionId !==
+                    candidate.options[0].id)) {
+            return false;
+        }
+        return true;
+    });
+}

package/dist/src/api/default-host.js

@@ -0,0 +1 @@
+export const DEFAULT_THEGITAI_HOST = 'https://thegit.ai';

package/dist/src/api/http.js

@@ -1,16 +1,20 @@
 import { randomUUID } from 'node:crypto';
-const DEFAULT_SERVER_URL = 'https://thegit.ai';
+import { DEFAULT_THEGITAI_HOST } from './default-host.js';
 export const TRACE_ID_HEADER = 'x-thegitai-trace-id';
 export const CLIENT_HEADER = 'x-thegitai-client';
 export const CLIENT_PLATFORM_HEADER = 'x-thegitai-client-platform';
 export class ServerApiError extends Error {
     status;
     traceId;
-    constructor(message, status, traceId) {
+    code;
+    details;
+    constructor(message, status, traceId, code = '', details = {}) {
         super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
         this.name = 'ServerApiError';
         this.status = status;
         this.traceId = traceId;
+        this.code = code;
+        this.details = details;
     }
 }
 export function createTraceId() {
@@ -27,6 +31,14 @@ export function createTraceContext(traceId = createTraceId()) {
     };
 }
 export const REQUEST_TIMEOUT_MS = 8000;
+export const STARTUP_REQUEST_TIMEOUT_MS = 3000;
+export const STARTUP_DEADLINE_MS = 10_000;
+export const STARTUP_RETRY_BUDGET = {
+    retries: 3,
+    baseDelayMs: 200,
+    deadlineMs: STARTUP_DEADLINE_MS,
+    timeoutMs: STARTUP_REQUEST_TIMEOUT_MS,
+};
 const TRANSIENT_NETWORK_CODES = new Set([
     'ECONNRESET',
     'ECONNREFUSED',
@@ -58,7 +70,9 @@ export function isTransientNetworkError(error) {
     }
     return false;
 }
-export async function retryTransient(run, { retries = 2, baseDelayMs = 400 } = {}) {
+export async function retryTransient(run, { retries = 2, baseDelayMs = 400, deadlineMs, now = () => Date.now(), } = {}) {
+    const startedAt = now();
+    const remainingMs = () => deadlineMs == null ? Infinity : deadlineMs - (now() - startedAt);
     let attempt = 0;
     for (;;) {
         try {
@@ -68,13 +82,15 @@ export async function retryTransient(run, { retries = 2, baseDelayMs = 400 } = {
             if (attempt >= retries || !isTransientNetworkError(error))
                 throw error;
             const delayMs = baseDelayMs * 2 ** attempt;
+            if (remainingMs() <= delayMs)
+                throw error;
             attempt += 1;
             await new Promise((resolve) => setTimeout(resolve, delayMs));
         }
     }
 }
 export function normalizeServerUrl(serverUrl) {
-    const normalized = String(serverUrl || DEFAULT_SERVER_URL)
+    const normalized = String(serverUrl || DEFAULT_THEGITAI_HOST)
         .trim()
         .replace(/\/+$/, '');
     if (!/^https?:\/\//i.test(normalized)) {
@@ -82,6 +98,101 @@ export function normalizeServerUrl(serverUrl) {
     }
     return normalized;
 }
+const MAX_NON_JSON_BODY_CHARS = 200;
+const GATEWAY_STATUS_MESSAGES = {
+    502: 'Could not reach the TheGitAI server (bad gateway).',
+    503: 'The TheGitAI server is temporarily unavailable.',
+    504: 'The TheGitAI server did not respond in time (gateway timeout).',
+    520: 'The connection to the TheGitAI server failed (edge error 520).',
+    521: 'The TheGitAI server is not accepting connections (edge error 521).',
+    522: 'The connection to the TheGitAI server timed out (edge error 522).',
+    523: 'The TheGitAI server is unreachable (edge error 523).',
+    524: 'The TheGitAI server did not respond in time (edge error 524).',
+};
+function truncateByCodePoint(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const points = Array.from(text);
+    if (points.length <= maxChars)
+        return text;
+    return `${points.slice(0, maxChars).join('').trimEnd()}…`;
+}
+export function nonJsonErrorMessage(body, status) {
+    const rayId = /Cloudflare Ray ID:\s*(?:<[^>]*>\s*)*([0-9a-f]{8,})/i.exec(body)?.[1];
+    const gateway = GATEWAY_STATUS_MESSAGES[status];
+    const summary = truncateByCodePoint(body
+        .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<[^>]*>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim(), MAX_NON_JSON_BODY_CHARS);
+    const base = gateway ?? (summary || `Request failed with ${status}`);
+    return rayId ? `${base} (Cloudflare Ray ID: ${rayId})` : base;
+}
+const TRANSPORT_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ECONNABORTED',
+    'EPIPE',
+    'ETIMEDOUT',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'EPROTO',
+    'ERR_STREAM_PREMATURE_CLOSE',
+]);
+const TRANSPORT_PHRASES = [
+    [/\bsocket hang up\b/i, 'socket hang up'],
+    [/\bother side closed\b/i, 'other side closed'],
+    [/\bpremature close\b/i, 'premature close'],
+    [/\bterminated\b/i, 'terminated'],
+    [/\bfetch failed\b/i, 'fetch failed'],
+    [/\bnetwork timeout\b/i, 'network timeout'],
+    [/\bnetwork error\b/i, 'network error'],
+    [/\bheaders timeout\b/i, 'headers timeout'],
+    [/\bbody timeout\b/i, 'body timeout'],
+];
+export function transportFailureDetail(error) {
+    if (error instanceof ServerApiError)
+        return null;
+    const parts = [];
+    const seen = new Set();
+    const queue = [error];
+    while (queue.length && seen.size < 24) {
+        const current = queue.shift();
+        if (!current || typeof current !== 'object' || seen.has(current))
+            continue;
+        seen.add(current);
+        const code = String(current.code ?? '');
+        if (TRANSPORT_CODES.has(code) || /^UND_ERR_[A-Z_]+$/.test(code)) {
+            if (!parts.includes(code))
+                parts.push(code);
+        }
+        const message = String(current.message ?? '');
+        for (const [pattern, label] of TRANSPORT_PHRASES) {
+            if (pattern.test(message) && !parts.includes(label))
+                parts.push(label);
+        }
+        if (current.cause)
+            queue.push(current.cause);
+        const nested = current.errors;
+        if (Array.isArray(nested))
+            queue.push(...nested);
+    }
+    return parts.length ? parts.slice(0, 3).join(' <- ') : null;
+}
+function isTransportFailure(error) {
+    return transportFailureDetail(error) !== null;
+}
+export function gatewayFailureCategory(error) {
+    if (isTransportFailure(error))
+        return 'connection_error';
+    if (!(error instanceof ServerApiError))
+        return null;
+    if (isQuotaExceededError(error))
+        return 'quota_exceeded';
+    return error.status in GATEWAY_STATUS_MESSAGES ? 'gateway_error' : null;
+}
 export async function readJsonResponse(response) {
     const text = await response.text();
     if (!text.trim())
@@ -90,15 +201,48 @@ export async function readJsonResponse(response) {
         return JSON.parse(text);
     }
     catch {
-        return { error: { message: text } };
+        return {
+            error: { message: nonJsonErrorMessage(text, response.status) },
+        };
     }
 }
 export function failureMessage(data, status) {
     return String(data?.error?.message ?? data?.message ?? `Request failed with ${status}`);
 }
+export function failureCode(data) {
+    return typeof data?.error?.code === 'string' ? data.error.code : '';
+}
+export function failureDetails(data) {
+    const error = data?.error;
+    if (!error || typeof error !== 'object')
+        return {};
+    return {
+        ...(typeof error.window === 'string' ? { window: error.window } : {}),
+        ...(typeof error.resetsAt === 'string' ? { resetsAt: error.resetsAt } : {}),
+        ...(typeof error.percentLeft === 'number'
+            ? { percentLeft: error.percentLeft }
+            : {}),
+    };
+}
+export const QUOTA_EXCEEDED_CODE = 'QUOTA_EXCEEDED';
+export function isQuotaExceededError(error) {
+    if (!(error instanceof ServerApiError))
+        return false;
+    if (error.code === QUOTA_EXCEEDED_CODE)
+        return true;
+    return error.status === 429 && !error.code;
+}
+export function isAuthenticationError(error) {
+    return error instanceof ServerApiError && error.status === 401;
+}
+export function authenticationErrorMessage(error) {
+    return error.code === 'AUTH_TOKEN_EXPIRED'
+        ? 'Your login expired after 48 hours of inactivity. Run `ai login` and resume this saved session.'
+        : 'Your login is no longer valid. Run `ai login` and resume this saved session.';
+}
 export async function readErrorResponse(response, traceId = response.headers.get(TRACE_ID_HEADER) ?? '') {
     const data = await readJsonResponse(response);
-    return new ServerApiError(failureMessage(data, response.status), response.status, traceId);
+    return new ServerApiError(failureMessage(data, response.status), response.status, traceId, failureCode(data), failureDetails(data));
 }
 export async function authorizedJson({ config, path, method = 'GET', body = null, headers = {}, fetchImpl = globalThis.fetch, timeoutMs = REQUEST_TIMEOUT_MS, }) {
     const trace = createTraceContext();
@@ -115,7 +259,7 @@ export async function authorizedJson({ config, path, method = 'GET', body = null
     });
     const data = await readJsonResponse(response);
     if (!response.ok) {
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data), failureDetails(data));
     }
     return data;
 }

package/dist/src/api/models.js

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
-import { REQUEST_TIMEOUT_MS, ServerApiError, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
+import { REQUEST_TIMEOUT_MS, ServerApiError, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
 function sanitizeModelInfo(raw) {
     if (!raw || typeof raw !== 'object') {
         return null;
@@ -58,12 +58,21 @@ export function selectCacheForServer(cached, serverUrl) {
 export function writeCachedServerModels(cache, env = process.env) {
     const filePath = getModelsCachePath(env);
     mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    writeFileSync(filePath, `${JSON.stringify(cache, null, 2)}\n`, {
-        encoding: 'utf8',
-        mode: 0o600,
-    });
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tempPath, `${JSON.stringify(cache, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
 }
-export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, }) {
+export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, budget = {}, }) {
+    const { timeoutMs = REQUEST_TIMEOUT_MS, ...ladder } = budget;
     return retryTransient(async () => {
         const trace = createTraceContext();
         const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/models`, {
@@ -71,11 +80,11 @@ export async function fetchServerModels({ config, fetchImpl = globalThis.fetch,
                 authorization: `Bearer ${config.token}`,
                 ...trace.headers,
             },
-            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            signal: AbortSignal.timeout(timeoutMs),
         });
         const data = (await readJsonResponse(response));
         if (!response.ok) {
-            throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+            throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
         }
         const models = Array.isArray(data?.models)
             ? data.models.map(sanitizeModelInfo).filter(Boolean)
@@ -84,7 +93,7 @@ export async function fetchServerModels({ config, fetchImpl = globalThis.fetch,
             throw new Error('Server returned an invalid model list.');
         }
         return { models };
-    });
+    }, ladder);
 }
 export function selectServerModel({ requestedModelId, cached, serverModels, }) {
     const supportedIds = new Set(serverModels.models.map((model) => model.id));
@@ -113,6 +122,16 @@ export function validateServerModel(modelId, serverModels) {
     }
     return requested;
 }
+export function resolveResumedSessionModel(storedModelId, serverModels) {
+    if (serverModels.models.some((model) => model.id === storedModelId)) {
+        return { modelId: storedModelId, fellBack: false };
+    }
+    const fallbackId = serverModels.models[0]?.id;
+    return {
+        modelId: fallbackId ?? storedModelId,
+        fellBack: fallbackId != null,
+    };
+}
 export function updateSelectedModelCache({ config, selectedModelId, serverModels, env = process.env, }) {
     writeCachedServerModels({
         serverUrl: normalizeServerUrl(config.serverUrl),

package/dist/src/api/startup-handshake.js

@@ -0,0 +1,36 @@
+import { fetchWhoamiResponse } from './auth.js';
+import { STARTUP_RETRY_BUDGET, isTransientNetworkError, } from './http.js';
+import { fetchServerModels } from './models.js';
+import { abortableDelay, createTurnRecovery, isRetryableTurnFailure, isTurnRecoveryExhausted, } from './turn-recovery.js';
+export async function loadStartupHandshake({ config, canStartOffline, fetchImpl, budget = STARTUP_RETRY_BUDGET, sleep = abortableDelay, onStatus = () => { }, }) {
+    let lastFailure;
+    const recovery = createTurnRecovery({
+        signal: new AbortController().signal,
+        sleep,
+        onStatus: (status) => onStatus(status, lastFailure),
+    });
+    const attempt = async () => {
+        const [models, whoami] = await Promise.allSettled([
+            fetchServerModels({ config, fetchImpl, budget }),
+            fetchWhoamiResponse({ config, fetchImpl, budget }),
+        ]);
+        const unreachable = models.status === 'rejected' &&
+            isRetryableTurnFailure(models.reason) &&
+            !(canStartOffline && isTransientNetworkError(models.reason));
+        if (unreachable) {
+            lastFailure = models.reason;
+            throw models.reason;
+        }
+        return { models, whoami };
+    };
+    try {
+        return await recovery.run('loading your models', attempt);
+    }
+    catch (error) {
+        const reason = isTurnRecoveryExhausted(error) ? error.cause : error;
+        return {
+            models: { status: 'rejected', reason },
+            whoami: { status: 'rejected', reason },
+        };
+    }
+}

package/dist/src/api/turn-recovery.js

@@ -0,0 +1,189 @@
+import { isTransientNetworkError, ServerApiError, transportFailureDetail, } from './http.js';
+export const TURN_RECOVERY_DELAY_MS = 10_000;
+export const TURN_RECOVERY_RETRIES = 3;
+export const TURN_REQUEST_TIMEOUT_MS = 30_000;
+export const TURN_STREAM_IDLE_TIMEOUT_MS = 60_000;
+const RETRYABLE_TURN_STATUSES = new Set([408, 500, 502, 503, 504, 520, 521, 522, 523, 524]);
+export function isRetryableTurnStatus(status) {
+    return RETRYABLE_TURN_STATUSES.has(status);
+}
+export function isRetryableTurnFailure(error) {
+    if (error instanceof ServerApiError)
+        return isRetryableTurnStatus(error.status);
+    return isTransientNetworkError(error);
+}
+export function interruptedStream(message = 'The turn stream ended before the turn finished.') {
+    return Object.assign(new Error(message), { code: 'ECONNRESET' });
+}
+export function formatTurnRecoveryStatus(status) {
+    if (status.phase === 'waiting') {
+        return `Connection interrupted · retrying in ${TURN_RECOVERY_DELAY_MS / 1000}s · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`;
+    }
+    if (status.phase === 'reconnecting') {
+        return `Reconnecting · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`;
+    }
+    if (status.phase === 'reconnected')
+        return 'Reconnected';
+    if (status.phase === 'continuing')
+        return 'Server restarted · continuing from the finished steps';
+    if (status.phase === 'continued')
+        return 'Server restarted · continued from the finished steps';
+    return 'Connection restored · continued the same turn';
+}
+export const TURN_RECOVERY_EXHAUSTED = 'TURN_RECOVERY_EXHAUSTED';
+export function isTurnRecoveryExhausted(error) {
+    return error?.code === TURN_RECOVERY_EXHAUSTED;
+}
+function recoveryExhausted(operation, cause) {
+    const detail = transportFailureDetail(cause);
+    const reason = detail ?? (cause instanceof ServerApiError ? `HTTP ${cause.status}` : 'no response');
+    return Object.assign(new Error(`Connection lost while ${operation} (${reason}). Reconnecting failed after ${TURN_RECOVERY_RETRIES} retries. Some actions in this turn may already have completed.`, { cause }), { code: TURN_RECOVERY_EXHAUSTED });
+}
+export function abortableDelay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function untilAborted(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+export function createTurnRecovery({ signal, onStatus = () => { }, sleep = abortableDelay, }) {
+    const affected = new Set();
+    let retry = 0;
+    let gate = null;
+    let exhausted = null;
+    async function retryAfter(token, operation, error, caller = signal) {
+        signal.throwIfAborted();
+        withdrawIfAborted(token, caller);
+        if (exhausted)
+            throw exhausted;
+        if (!isRetryableTurnFailure(error))
+            throw error;
+        affected.add(token);
+        if (!gate) {
+            if (retry === TURN_RECOVERY_RETRIES) {
+                exhausted = recoveryExhausted(operation, error);
+                throw exhausted;
+            }
+            retry += 1;
+            const current = retry;
+            onStatus({ phase: 'waiting', retry: current });
+            gate = sleep(TURN_RECOVERY_DELAY_MS, signal)
+                .then(() => {
+                signal.throwIfAborted();
+                onStatus({ phase: 'reconnecting', retry: current });
+            })
+                .finally(() => {
+                gate = null;
+            });
+        }
+        if (caller === signal) {
+            await gate;
+            return;
+        }
+        await untilAborted(gate, caller).catch((reason) => {
+            withdrawIfAborted(token, caller);
+            throw reason;
+        });
+    }
+    function withdrawIfAborted(token, caller) {
+        if (!caller.aborted)
+            return;
+        affected.delete(token);
+        throw caller.reason;
+    }
+    function reconnected(token) {
+        if (!affected.has(token) || gate || exhausted)
+            return;
+        onStatus({ phase: 'reconnected' });
+    }
+    function restored(token) {
+        if (!affected.delete(token))
+            return;
+        if (affected.size > 0 || gate || exhausted)
+            return;
+        retry = 0;
+        onStatus({ phase: 'restored' });
+    }
+    async function run(operation, attempt, caller = signal) {
+        const token = {};
+        for (;;) {
+            signal.throwIfAborted();
+            withdrawIfAborted(token, caller);
+            if (exhausted)
+                throw exhausted;
+            try {
+                const value = await attempt();
+                restored(token);
+                return value;
+            }
+            catch (error) {
+                await retryAfter(token, operation, error, caller);
+            }
+        }
+    }
+    return { run, retryAfter, reconnected, restored };
+}
+export async function fetchTurnAttempt(fetchImpl, url, init, signal, { readBody = false } = {}) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(signal.reason);
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+    const timer = setTimeout(() => controller.abort(new DOMException('The request did not get a response in time.', 'TimeoutError')), TURN_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(url, { ...init, signal: controller.signal });
+        if (!readBody && response.ok)
+            return response;
+        return new Response(await response.arrayBuffer(), {
+            status: response.status,
+            headers: response.headers,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+export async function readTurnChunk(reader, signal) {
+    let timer;
+    let onAbort;
+    try {
+        return await Promise.race([
+            reader.read(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(interruptedStream(`The turn stream sent nothing for ${TURN_STREAM_IDLE_TIMEOUT_MS / 1000} seconds.`)), TURN_STREAM_IDLE_TIMEOUT_MS);
+                onAbort = () => reject(signal.reason);
+                signal.addEventListener('abort', onAbort, { once: true });
+                if (signal.aborted)
+                    onAbort();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}

package/dist/src/background-jobs.js

@@ -1,6 +1,6 @@
 import chalk from './colors.js';
 import { spawn } from 'child_process';
-import { buildCommandEnv, commandUsesSudo, sanitizeCommandText, terminateChild, } from './executor.js';
+import { buildCommandEnv, commandUsesSudo, resolveCommandShell, sanitizeCommandText, terminateChild, } from './executor.js';
 import { isTuiMode } from './runtime-mode.js';
 import { redactConnectionStringCredentials } from './secret-preview.js';
 const MAX_RUNNING_JOBS = 8;
@@ -196,7 +196,7 @@ export async function startBackgroundJob(command, cwd, { startupWaitMs, sessionI
     const id = `bg_${++jobCounter}`;
     const child = spawn(command, {
         cwd,
-        shell: true,
+        shell: resolveCommandShell(),
         detached: process.platform !== 'win32',
         stdio: ['pipe', 'pipe', 'pipe'],
         env: buildCommandEnv(cwd),
@@ -265,6 +265,7 @@ export function getJobOutputTail(id, maxLines) {
     if (!record || !belongsToSession(record) || maxLines <= 0)
         return [];
     const lines = sanitizeJobText(record, record.buffer)
+        .replace(/\r\n?/g, '\n')
         .split('\n')
         .filter((line) => line.trim().length > 0);
     return lines.slice(-maxLines);
@@ -277,6 +278,7 @@ export function getJobOutputPreview(id, maxTailLines) {
         ? sanitizeJobText(record, record.firstOutputLine).trim()
         : '';
     return {
+        droppedChars: Math.max(record.totalCaptured - record.buffer.length, 0),
         firstLine,
         tailLines: getJobOutputTail(id, maxTailLines),
     };