@ponythewhite/base-context 1.0.0 → 1.0.1

package/dist/core/agent-traces.js

@@ -1,904 +0,0 @@
-import { Buffer } from "node:buffer";
-import { createHash, randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
-import { mkdir, readdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { appendRotatingLog, getAgentDir, getAgentTracesLogPath, getSessionsDir, VERSION } from "../config.js";
-import { assertProductStatePath } from "../runtime-paths.js";
-import { BASE_CONTEXT_TRACES_PROVIDER_ID, resolvePrimeAgentTracesBaseUrl } from "./prime-inference-auth.js";
-import { readSessionJournal, readSessionJournalHeader } from "./session-journal-reader.js";
-import { getSessionArtifactsRoot } from "./session-manager.js";
-const MAX_TRACE_BYTES = 20 * 1024 * 1024;
-const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
-const TRACE_UPLOAD_DEBOUNCE_MS = 1_000;
-const TRACE_UPLOAD_MIN_INTERVAL_MS = 60_000;
-const TRACE_UPLOAD_RETRY_BASE_DELAY_MS = 500;
-const TRACE_UPLOAD_RETRY_MAX_DELAY_MS = 10_000;
-const TRACE_UPLOAD_MAX_RETRIES = 3;
-const TRACE_UPLOAD_RETRY_JITTER = 0.2;
-const TRACE_PREVIEW_MAX_CHARS = 8_000;
-const TRACE_UPLOAD_ALL_CONCURRENCY = 4;
-const TRACE_UPLOAD_RATE_LIMIT_REQUESTS = 5;
-const TRACE_UPLOAD_RATE_LIMIT_WINDOW_MS = 60_000;
-const TRACE_UPLOAD_RATE_LIMIT_SAFETY_MS = 100;
-const MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
-const TRACE_UPLOAD_ALL_MIN_REQUEST_INTERVAL_MS = Math.ceil(TRACE_UPLOAD_RATE_LIMIT_WINDOW_MS / TRACE_UPLOAD_RATE_LIMIT_REQUESTS) + TRACE_UPLOAD_RATE_LIMIT_SAFETY_MS;
-function stringEnv(name) {
-    const value = process.env[name];
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function describeError(error) {
-    if (!(error instanceof Error)) {
-        return String(error);
-    }
-    const cause = error.cause;
-    if (isRecord(cause)) {
-        const code = typeof cause.code === "string" ? cause.code : undefined;
-        const causeMessage = typeof cause.message === "string" ? cause.message : undefined;
-        const detail = code ?? causeMessage;
-        if (detail && detail !== error.message) {
-            return `${error.message} (${detail})`;
-        }
-    }
-    return error.message;
-}
-class TraceUploadTimeoutError extends Error {
-    constructor(timeoutMs) {
-        super(`Trace upload timed out after ${timeoutMs}ms`);
-        this.name = "TraceUploadTimeoutError";
-    }
-}
-const RETRIABLE_NETWORK_CODES = new Set([
-    "ECONNRESET",
-    "ECONNREFUSED",
-    "ECONNABORTED",
-    "EPIPE",
-    "ETIMEDOUT",
-    "ENETUNREACH",
-    "ENETDOWN",
-    "EAI_AGAIN",
-    "UND_ERR_SOCKET",
-    "UND_ERR_CONNECT_TIMEOUT",
-]);
-// 429 is deliberately absent: a rate-limited upload is rescheduled by its caller instead of sleeping in-request.
-const RETRIABLE_HTTP_STATUSES = new Set([408, 425, 500, 502, 503, 504]);
-function isRetriableNetworkError(error) {
-    if (error instanceof TraceUploadTimeoutError) {
-        return true;
-    }
-    if (!(error instanceof Error) || error.name === "AbortError") {
-        return false;
-    }
-    const cause = error.cause;
-    return isRecord(cause) && typeof cause.code === "string" && RETRIABLE_NETWORK_CODES.has(cause.code);
-}
-function stringField(data, key) {
-    const value = data[key];
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function numberField(data, key) {
-    const value = data[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function isSessionHeader(value) {
-    return (isRecord(value) &&
-        value.type === "session" &&
-        typeof value.id === "string" &&
-        typeof value.timestamp === "string" &&
-        typeof value.cwd === "string" &&
-        (value.parentSession === undefined || typeof value.parentSession === "string"));
-}
-function readSessionHeader(sessionFile) {
-    try {
-        const parsed = readSessionJournalHeader(sessionFile);
-        return isSessionHeader(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function readSessionTraceBody(sessionFile) {
-    const lines = [];
-    for await (const { json } of readSessionJournal(sessionFile)) {
-        lines.push(`${json}\n`);
-    }
-    return lines.join("");
-}
-/** Active-branch git for the indexing headers: walk leaf to root, not the last git_state in
- * file order (which may belong to a sibling branch). */
-export function activeGitContext(body, header) {
-    const byId = new Map();
-    let leafId = null;
-    for (const line of body.split("\n")) {
-        if (!line.trim())
-            continue;
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (!isRecord(parsed) || parsed.type === "session" || typeof parsed.id !== "string")
-            continue;
-        byId.set(parsed.id, {
-            parentId: typeof parsed.parentId === "string" ? parsed.parentId : null,
-            type: typeof parsed.type === "string" ? parsed.type : "",
-            git: parsed.git,
-        });
-        leafId = parsed.id;
-    }
-    let current = leafId ? byId.get(leafId) : undefined;
-    for (let depth = 0; current && depth < byId.size + 1; depth += 1) {
-        if (current.type === "git_state" && isRecord(current.git)) {
-            return current.git;
-        }
-        current = current.parentId ? byId.get(current.parentId) : undefined;
-    }
-    return header.git;
-}
-function resolveParentSessionPath(sessionFile, parentSession) {
-    return isAbsolute(parentSession) ? parentSession : resolve(dirname(sessionFile), parentSession);
-}
-function resolveTraceContext(sessionFile, header) {
-    let traceId = header.id;
-    let parentSessionId;
-    let currentFile = sessionFile;
-    let currentHeader = header;
-    for (let depth = 0; depth < 32; depth += 1) {
-        if (!currentHeader.parentSession) {
-            break;
-        }
-        const parentPath = resolveParentSessionPath(currentFile, currentHeader.parentSession);
-        const parentHeader = readSessionHeader(parentPath);
-        if (!parentHeader) {
-            break;
-        }
-        if (depth === 0) {
-            parentSessionId = parentHeader.id;
-        }
-        traceId = parentHeader.id;
-        currentFile = parentPath;
-        currentHeader = parentHeader;
-    }
-    return { traceId, parentSessionId };
-}
-function parseResponseObject(text) {
-    if (!text.trim()) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(text);
-        return isRecord(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function readResponseMessage(response) {
-    const text = await response.text().catch(() => "");
-    if (!text.trim()) {
-        return response.statusText || "Unknown error";
-    }
-    const parsed = parseResponseObject(text);
-    if (parsed) {
-        const error = parsed.error;
-        if (isRecord(error)) {
-            const message = stringField(error, "message");
-            if (message)
-                return message;
-        }
-        const detail = stringField(parsed, "detail");
-        if (detail)
-            return detail;
-        const message = stringField(parsed, "message");
-        if (message)
-            return message;
-    }
-    return text.trim();
-}
-async function fetchWithTimeout(fetchFn, url, init, timeoutMs, signal) {
-    const controller = new AbortController();
-    const timeoutError = new TraceUploadTimeoutError(timeoutMs);
-    let timedOut = false;
-    const timeout = setTimeout(() => {
-        timedOut = true;
-        controller.abort(timeoutError);
-    }, timeoutMs);
-    timeout.unref();
-    const onAbort = () => controller.abort(signal?.reason);
-    if (signal?.aborted) {
-        onAbort();
-    }
-    else {
-        signal?.addEventListener("abort", onAbort, { once: true });
-    }
-    try {
-        return await fetchFn(url, { ...init, signal: controller.signal });
-    }
-    catch (error) {
-        if (timedOut) {
-            throw timeoutError;
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeout);
-        signal?.removeEventListener("abort", onAbort);
-    }
-}
-function delay(ms, signal) {
-    return new Promise((resolve) => {
-        if (signal?.aborted) {
-            resolve();
-            return;
-        }
-        const timeout = setTimeout(finish, ms);
-        timeout.unref();
-        const onAbort = () => finish();
-        function finish() {
-            clearTimeout(timeout);
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function traceUploadRetryDelay(retryIndex) {
-    const exponentialDelay = Math.min(TRACE_UPLOAD_RETRY_MAX_DELAY_MS, TRACE_UPLOAD_RETRY_BASE_DELAY_MS * 2 ** retryIndex);
-    const jitterMultiplier = 1 - TRACE_UPLOAD_RETRY_JITTER + Math.random() * TRACE_UPLOAD_RETRY_JITTER * 2;
-    return Math.max(0, Math.round(exponentialDelay * jitterMultiplier));
-}
-function retryAfterDelay(response, capMs = TRACE_UPLOAD_RATE_LIMIT_WINDOW_MS) {
-    const value = response.headers.get("retry-after")?.trim();
-    if (!value) {
-        return undefined;
-    }
-    const seconds = Number(value);
-    if (Number.isFinite(seconds) && seconds >= 0) {
-        return Math.min(Math.ceil(seconds * 1_000), capMs);
-    }
-    const retryAt = Date.parse(value);
-    return Number.isFinite(retryAt) ? Math.min(Math.max(0, retryAt - Date.now()), capMs) : undefined;
-}
-async function fetchWithRetry(fetchFn, url, init, timeoutMs, signal, beforeRequest) {
-    for (let attempt = 0;; attempt += 1) {
-        let retryDelayMs;
-        try {
-            await beforeRequest?.();
-            if (signal?.aborted) {
-                throw signal.reason ?? new Error("Trace upload cancelled");
-            }
-            const response = await fetchWithTimeout(fetchFn, url, init, timeoutMs, signal);
-            if (attempt >= TRACE_UPLOAD_MAX_RETRIES || !RETRIABLE_HTTP_STATUSES.has(response.status)) {
-                return response;
-            }
-            if (response.status === 503) {
-                retryDelayMs = retryAfterDelay(response);
-            }
-            await response.body?.cancel().catch(() => undefined);
-        }
-        catch (error) {
-            if (signal?.aborted) {
-                throw signal.reason ?? error;
-            }
-            if (attempt >= TRACE_UPLOAD_MAX_RETRIES || !isRetriableNetworkError(error)) {
-                throw error;
-            }
-        }
-        await delay(retryDelayMs ?? traceUploadRetryDelay(attempt), signal);
-        if (signal?.aborted) {
-            throw signal.reason ?? new Error("Trace upload cancelled");
-        }
-    }
-}
-function traceContentPreview(body, maxChars) {
-    if (body.length <= maxChars) {
-        return { content: body.trimEnd(), truncated: false };
-    }
-    const marker = "\n... middle of trace omitted ...\n";
-    const available = Math.max(0, maxChars - marker.length);
-    const headChars = Math.ceil(available / 2);
-    const tailChars = Math.floor(available / 2);
-    return {
-        content: `${body.slice(0, headChars).trimEnd()}${marker}${body.slice(body.length - tailChars).trimStart()}`,
-        truncated: true,
-    };
-}
-export async function previewAgentTraceFile(options) {
-    if (!options.sessionFile) {
-        return { status: "no_session_file" };
-    }
-    let fileSize;
-    try {
-        const stats = await stat(options.sessionFile);
-        if (!stats.isFile()) {
-            return { status: "no_session_file" };
-        }
-        fileSize = stats.size;
-    }
-    catch {
-        return { status: "no_session_file" };
-    }
-    if (fileSize === 0) {
-        return { status: "empty_session" };
-    }
-    const header = readSessionHeader(options.sessionFile);
-    if (!header) {
-        return { status: "invalid_session", message: "Session file is missing a valid session header" };
-    }
-    let body = "";
-    if (fileSize <= MAX_TRACE_BYTES) {
-        try {
-            body = await readSessionTraceBody(options.sessionFile);
-        }
-        catch (error) {
-            return { status: "failed", message: describeError(error) };
-        }
-        if (!body.trim()) {
-            return { status: "empty_session" };
-        }
-    }
-    const traceContext = resolveTraceContext(options.sessionFile, header);
-    const baseUrl = resolvePrimeAgentTracesBaseUrl(options.baseUrl);
-    const git = body ? activeGitContext(body, header) : header.git;
-    const preview = body
-        ? traceContentPreview(body, Math.max(256, options.maxContentChars ?? TRACE_PREVIEW_MAX_CHARS))
-        : { content: "", truncated: true };
-    return {
-        status: "ready",
-        sessionFile: options.sessionFile,
-        sessionId: header.id,
-        traceId: traceContext.traceId,
-        parentSessionId: traceContext.parentSessionId,
-        cwd: header.cwd,
-        size: fileSize,
-        maxBytes: MAX_TRACE_BYTES,
-        uploadable: fileSize <= MAX_TRACE_BYTES && baseUrl !== undefined,
-        endpoint: baseUrl ? `${baseUrl}/api/v1/agent-traces/sessions/${encodeURIComponent(header.id)}` : undefined,
-        gitRepo: git?.repoUrl,
-        gitCommit: git?.commit,
-        contentPreview: preview.content,
-        truncated: preview.truncated,
-    };
-}
-async function findSessionFilesUnder(root, files) {
-    let entries;
-    try {
-        entries = await readdir(root, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        const entryPath = join(root, entry.name);
-        if (entry.isDirectory()) {
-            await findSessionFilesUnder(entryPath, files);
-            continue;
-        }
-        if (entry.isFile() && entry.name.endsWith(".jsonl") && readSessionHeader(entryPath)) {
-            files.add(entryPath);
-        }
-    }
-}
-export async function findAgentTraceFiles(sessionDir = getSessionsDir()) {
-    const files = new Set();
-    const roots = new Set([resolve(sessionDir), resolve(getSessionArtifactsRoot(sessionDir))]);
-    await Promise.all([...roots].map((root) => findSessionFilesUnder(root, files)));
-    return [...files].sort();
-}
-function createTraceUploadAllRequestGate(signal) {
-    let nextRequestAt = 0;
-    let queue = Promise.resolve();
-    return () => {
-        const slot = queue.then(async () => {
-            const waitMs = Math.max(0, nextRequestAt - Date.now());
-            if (waitMs > 0) {
-                await delay(waitMs, signal);
-            }
-            if (!signal?.aborted) {
-                nextRequestAt = Date.now() + TRACE_UPLOAD_ALL_MIN_REQUEST_INTERVAL_MS;
-            }
-        });
-        queue = slot.catch(() => undefined);
-        return slot;
-    };
-}
-export async function uploadAllAgentTraces(options) {
-    const { sessionDir, concurrency, onProgress, ...uploadOptions } = options;
-    const sessionFiles = await findAgentTraceFiles(sessionDir);
-    const results = new Array(sessionFiles.length);
-    let cursor = 0;
-    let completed = 0;
-    const beforeRequest = createTraceUploadAllRequestGate(uploadOptions.signal);
-    onProgress?.({ completed, total: sessionFiles.length });
-    const worker = async () => {
-        while (true) {
-            if (uploadOptions.signal?.aborted) {
-                return;
-            }
-            const index = cursor;
-            cursor += 1;
-            const sessionFile = sessionFiles[index];
-            if (!sessionFile) {
-                return;
-            }
-            const result = await uploadAgentTraceFileWithRequestGate({
-                ...uploadOptions,
-                sessionFile,
-                reloadConfig: false,
-            }, beforeRequest);
-            if (uploadOptions.signal?.aborted && result.status === "failed") {
-                return;
-            }
-            results[index] = { sessionFile, result };
-            completed += 1;
-            onProgress?.({ completed, total: sessionFiles.length, sessionFile, result });
-        }
-    };
-    const requestedConcurrency = concurrency ?? TRACE_UPLOAD_ALL_CONCURRENCY;
-    const normalizedConcurrency = Number.isFinite(requestedConcurrency) && requestedConcurrency > 0
-        ? Math.max(1, Math.floor(requestedConcurrency))
-        : TRACE_UPLOAD_ALL_CONCURRENCY;
-    const workerCount = Math.min(sessionFiles.length, normalizedConcurrency);
-    await Promise.all(Array.from({ length: workerCount }, worker));
-    const completedResults = results.filter((item) => item !== undefined);
-    let uploaded = 0;
-    let failed = 0;
-    let bytesStored = 0;
-    for (const item of completedResults) {
-        if (item.result.status === "uploaded") {
-            uploaded += 1;
-            bytesStored += item.result.bytesStored;
-        }
-        else if (item.result.status === "failed") {
-            failed += 1;
-        }
-    }
-    return {
-        total: sessionFiles.length,
-        uploaded,
-        failed,
-        skipped: sessionFiles.length - uploaded - failed,
-        bytesStored,
-        results: completedResults,
-    };
-}
-export const SEMANTIC_EDGES_OUTBOX_KIND = "semantic-edges";
-function getAgentTraceOutboxDir() {
-    return assertProductStatePath(join(getAgentDir(), "trace-export-outbox"));
-}
-// One entry file per session file (keyed by path hash): concurrent writers cannot lose each other's cursors, and a bad read costs only its own entry.
-function agentTraceOutboxEntryPath(sessionFile) {
-    const key = createHash("sha256").update(sessionFile).digest("hex").slice(0, 32);
-    return join(getAgentTraceOutboxDir(), `${key}.json`);
-}
-function parseOutboxEntry(raw) {
-    const parsed = parseResponseObject(raw);
-    if (!parsed || typeof parsed.sessionFile !== "string") {
-        return undefined;
-    }
-    const uploaded = typeof parsed.size === "number" && typeof parsed.mtimeMs === "number"
-        ? { size: parsed.size, mtimeMs: parsed.mtimeMs }
-        : null;
-    return {
-        sessionFile: parsed.sessionFile,
-        kind: typeof parsed.kind === "string" ? parsed.kind : undefined,
-        uploaded,
-        uploadedBytes: typeof parsed.uploadedBytes === "number" ? parsed.uploadedBytes : undefined,
-    };
-}
-/** `undefined` = no usable cursor; `null` = scheduled but never uploaded. */
-async function readAgentTraceOutboxEntry(sessionFile) {
-    let raw;
-    try {
-        raw = await readFile(agentTraceOutboxEntryPath(sessionFile), "utf8");
-    }
-    catch {
-        return undefined;
-    }
-    const entry = parseOutboxEntry(raw);
-    return entry && entry.sessionFile === sessionFile ? entry.uploaded : undefined;
-}
-function signatureEquals(a, b) {
-    return a != null && a.size === b.size && a.mtimeMs === b.mtimeMs;
-}
-/** Session files with a live upload controller in this process; catch-up leaves them to their controller. */
-const locallyManagedSessionFiles = new Set();
-/** Best-effort and synchronous: upload intent must be on disk the moment the transcript persist returns. */
-function markAgentTraceOutboxPendingSync(sessionFile, kind) {
-    try {
-        const entryPath = agentTraceOutboxEntryPath(sessionFile);
-        if (existsSync(entryPath)) {
-            return true;
-        }
-        mkdirSync(getAgentTraceOutboxDir(), { recursive: true });
-        const tempPath = `${entryPath}.${process.pid}.${randomUUID()}.tmp`;
-        writeFileSync(tempPath, `${JSON.stringify(kind === undefined ? { sessionFile } : { sessionFile, kind })}\n`, "utf8");
-        renameSync(tempPath, entryPath);
-        return true;
-    }
-    catch {
-        // A broken agent dir must not break session persists.
-        return false;
-    }
-}
-async function recordAgentTraceOutboxUpload(sessionFile, signature) {
-    const entryPath = agentTraceOutboxEntryPath(sessionFile);
-    await mkdir(getAgentTraceOutboxDir(), { recursive: true });
-    const tempPath = `${entryPath}.${process.pid}.${randomUUID()}.tmp`;
-    await writeFile(tempPath, `${JSON.stringify({ sessionFile, ...signature })}\n`, "utf8");
-    await rename(tempPath, entryPath);
-}
-/**
- * Explicit catch-up for the Base Context export outbox. This is never run at
- * startup and does not read inherited agent-traces-outbox entries.
- */
-export async function catchUpAgentTraceUploads(options) {
-    const catchUp = { pruned: 0, semanticEdgeLedgersPending: 0, results: [] };
-    if (options.requireEnabled !== false && !(await getAgentTracesEnabled(options))) {
-        return catchUp;
-    }
-    let entryNames;
-    try {
-        entryNames = await readdir(getAgentTraceOutboxDir());
-    }
-    catch {
-        return catchUp;
-    }
-    const beforeRequest = createTraceUploadAllRequestGate(options.signal);
-    for (const entryName of entryNames) {
-        if (options.signal?.aborted) {
-            break;
-        }
-        if (!entryName.endsWith(".json")) {
-            continue;
-        }
-        const entryPath = join(getAgentTraceOutboxDir(), entryName);
-        let raw;
-        try {
-            raw = await readFile(entryPath, "utf8");
-        }
-        catch {
-            // Transient read error: keep the entry and retry at the next startup.
-            continue;
-        }
-        const entry = parseOutboxEntry(raw);
-        if (!entry) {
-            await unlink(entryPath).catch(() => undefined);
-            catchUp.pruned += 1;
-            continue;
-        }
-        if (entry.kind === SEMANTIC_EDGES_OUTBOX_KIND) {
-            let ledgerStats;
-            try {
-                ledgerStats = await stat(entry.sessionFile);
-            }
-            catch (error) {
-                if (error.code === "ENOENT") {
-                    await unlink(entryPath).catch(() => undefined);
-                    catchUp.pruned += 1;
-                }
-                continue;
-            }
-            if (!ledgerStats.isFile()) {
-                await unlink(entryPath).catch(() => undefined);
-                catchUp.pruned += 1;
-                continue;
-            }
-            // Append-only byte cursor: a ledger whose size equals its delivered offset has nothing new.
-            if (ledgerStats.size === entry.uploadedBytes) {
-                continue;
-            }
-            // No delivery endpoint exists yet (verifiers#2449 consumes edges in-band over ACP
-            // metadata; the trace server has no semantic-edges route). The delta and cursor stay
-            // untouched so the first real sender delivers the whole backlog.
-            catchUp.semanticEdgeLedgersPending += 1;
-            continue;
-        }
-        if (entry.kind !== undefined) {
-            // A newer build may register kinds this one cannot deliver; leave their cursors alone.
-            continue;
-        }
-        if (locallyManagedSessionFiles.has(entry.sessionFile)) {
-            continue;
-        }
-        let stats;
-        try {
-            stats = await stat(entry.sessionFile);
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                await unlink(entryPath).catch(() => undefined);
-                catchUp.pruned += 1;
-            }
-            continue;
-        }
-        if (!stats.isFile()) {
-            await unlink(entryPath).catch(() => undefined);
-            catchUp.pruned += 1;
-            continue;
-        }
-        if (signatureEquals(entry.uploaded, { size: stats.size, mtimeMs: stats.mtimeMs })) {
-            continue;
-        }
-        const result = await uploadAgentTraceFileWithRequestGate({ ...options, sessionFile: entry.sessionFile, reloadConfig: false }, beforeRequest);
-        catchUp.results.push({ sessionFile: entry.sessionFile, result });
-    }
-    return catchUp;
-}
-export async function getPrimeAgentTraceCredential(authStorage, options = {}) {
-    const traceEnvKey = stringEnv("BASE_CONTEXT_TRACES_API_KEY");
-    if (traceEnvKey) {
-        return { apiKey: traceEnvKey, source: "environment", label: "BASE_CONTEXT_TRACES_API_KEY" };
-    }
-    if (options.reloadAuth !== false) {
-        authStorage.reload();
-    }
-    const traceKey = await authStorage.getApiKey(BASE_CONTEXT_TRACES_PROVIDER_ID, { includeFallback: false });
-    if (traceKey) {
-        return { apiKey: traceKey, source: "stored", label: "Base Context Traces credential" };
-    }
-    return undefined;
-}
-async function getAgentTracesEnabled(options) {
-    if (options.reloadConfig !== false) {
-        await options.settingsManager.reload().catch(() => undefined);
-    }
-    return options.settingsManager.getAgentTracesEnabled();
-}
-async function uploadAgentTraceFileWithRequestGate(options, beforeRequest) {
-    const result = await performAgentTraceUpload(options, beforeRequest);
-    logAgentTraceOutcome(options.sessionFile, result);
-    return result;
-}
-export function uploadAgentTraceFile(options) {
-    return uploadAgentTraceFileWithRequestGate(options);
-}
-function logAgentTraceOutcome(sessionFile, result) {
-    let line;
-    switch (result.status) {
-        case "uploaded":
-            line = `uploaded session ${result.sessionId} (${result.bytesStored} bytes)`;
-            break;
-        case "failed":
-            line = `upload failed${result.statusCode ? ` (HTTP ${result.statusCode})` : ""}: ${result.message}`;
-            break;
-        case "too_large":
-            line = `upload skipped: session is ${result.size} bytes (limit ${result.maxBytes})`;
-            break;
-        case "invalid_session":
-            line = `upload skipped: ${result.message}`;
-            break;
-        case "missing_credentials":
-            line = "upload skipped: configure a dedicated BASE_CONTEXT_TRACES_API_KEY or Base Context Traces credential";
-            break;
-        default:
-            return;
-    }
-    const suffix = sessionFile ? ` [${sessionFile}]` : "";
-    appendRotatingLog(getAgentTracesLogPath(), `[${new Date().toISOString()}] ${line}${suffix}`);
-}
-async function performAgentTraceUpload(options, beforeRequest) {
-    const requireEnabled = options.requireEnabled !== false;
-    if (requireEnabled && !(await getAgentTracesEnabled(options))) {
-        return { status: "disabled" };
-    }
-    const baseUrl = resolvePrimeAgentTracesBaseUrl(options.baseUrl);
-    if (!baseUrl) {
-        return {
-            status: "failed",
-            message: "Trace export requires an explicit BASE_CONTEXT_TRACES_BASE_URL and dedicated BASE_CONTEXT_TRACES_API_KEY.",
-        };
-    }
-    if (!options.sessionFile) {
-        return { status: "no_session_file" };
-    }
-    let signature;
-    try {
-        const stats = await stat(options.sessionFile);
-        if (!stats.isFile()) {
-            return { status: "no_session_file" };
-        }
-        signature = { size: stats.size, mtimeMs: stats.mtimeMs };
-    }
-    catch {
-        return { status: "no_session_file" };
-    }
-    const fileSize = signature.size;
-    if (fileSize === 0) {
-        return { status: "empty_session" };
-    }
-    if (fileSize > MAX_TRACE_BYTES) {
-        return { status: "too_large", size: fileSize, maxBytes: MAX_TRACE_BYTES };
-    }
-    // Cursor invariant: an automatic upload never re-sends a file whose content already matches its uploaded cursor.
-    if (requireEnabled && signatureEquals(await readAgentTraceOutboxEntry(options.sessionFile), signature)) {
-        return { status: "unchanged" };
-    }
-    const header = readSessionHeader(options.sessionFile);
-    if (!header) {
-        return { status: "invalid_session", message: "Session file is missing a valid session header" };
-    }
-    const credential = await getPrimeAgentTraceCredential(options.authStorage, {
-        configPath: options.configPath,
-        reloadAuth: options.reloadConfig !== false,
-    });
-    if (!credential) {
-        return { status: "missing_credentials" };
-    }
-    if (requireEnabled && !(await getAgentTracesEnabled(options))) {
-        return { status: "disabled" };
-    }
-    let body;
-    try {
-        body = await readSessionTraceBody(options.sessionFile);
-    }
-    catch (error) {
-        return { status: "failed", message: describeError(error) };
-    }
-    if (!body.trim()) {
-        return { status: "empty_session" };
-    }
-    const traceContext = resolveTraceContext(options.sessionFile, header);
-    const bodyBytes = Buffer.byteLength(body, "utf8");
-    const headers = {
-        Authorization: `Bearer ${credential.apiKey}`,
-        "Content-Type": "application/x-ndjson",
-        Accept: "application/json",
-        "X-Trace-Id": traceContext.traceId,
-        "X-Cwd": header.cwd,
-        "X-Agent-Version": VERSION,
-    };
-    if (traceContext.parentSessionId) {
-        headers["X-Parent-Session"] = traceContext.parentSessionId;
-    }
-    const git = activeGitContext(body, header);
-    if (git?.repoUrl) {
-        headers["X-Git-Repo"] = git.repoUrl;
-    }
-    if (git?.commit) {
-        headers["X-Git-Commit"] = git.commit;
-    }
-    if (requireEnabled && !(await getAgentTracesEnabled(options))) {
-        return { status: "disabled" };
-    }
-    const url = `${baseUrl}/api/v1/agent-traces/sessions/${encodeURIComponent(header.id)}`;
-    const fetchFn = options.fetchFn ?? fetch;
-    let response;
-    try {
-        response = await fetchWithRetry(fetchFn, url, {
-            method: "PUT",
-            redirect: "error",
-            headers,
-            body,
-        }, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS, options.signal, beforeRequest);
-    }
-    catch (error) {
-        return { status: "failed", message: describeError(error) };
-    }
-    if (!response.ok) {
-        return {
-            status: "failed",
-            statusCode: response.status,
-            message: await readResponseMessage(response),
-            retryAfterMs: retryAfterDelay(response, MAX_TIMER_DELAY_MS),
-        };
-    }
-    const responseText = await response.text().catch(() => "");
-    const responseData = parseResponseObject(responseText);
-    try {
-        await recordAgentTraceOutboxUpload(options.sessionFile, signature);
-    }
-    catch (error) {
-        return { status: "failed", message: `stored, but recording the upload cursor failed: ${describeError(error)}` };
-    }
-    return {
-        status: "uploaded",
-        sessionId: responseData ? (stringField(responseData, "session_id") ?? header.id) : header.id,
-        traceId: responseData ? (stringField(responseData, "trace_id") ?? traceContext.traceId) : traceContext.traceId,
-        bytesStored: responseData ? (numberField(responseData, "bytes_stored") ?? bodyBytes) : bodyBytes,
-        key: responseData ? stringField(responseData, "key") : undefined,
-    };
-}
-export function uploadAgentTraceSession(options) {
-    return uploadAgentTraceFile({
-        ...options,
-        sessionFile: options.sessionManager.getSessionFile(),
-    });
-}
-class AgentTraceUploadController {
-    sessionManager;
-    options;
-    timeout;
-    pending = false;
-    inFlight;
-    lastUploadStartedAt;
-    notBeforeAt = 0;
-    constructor(sessionManager, options) {
-        this.sessionManager = sessionManager;
-        this.options = options;
-    }
-    update(options) {
-        this.options = options;
-    }
-    schedule = () => {
-        if (!this.options.settingsManager.getAgentTracesEnabled() ||
-            !resolvePrimeAgentTracesBaseUrl(this.options.baseUrl)) {
-            return;
-        }
-        this.pending = true;
-        // Intent is consent-gated at persist time: an entry created while sharing
-        // is off would turn a later enable into retroactive collection of
-        // opted-out sessions. Marking re-runs every persist (existsSync-cheap),
-        // so an entry pruned by a racing catch-up is re-registered.
-        if (this.options.settingsManager.getAgentTracesEnabled()) {
-            const sessionFile = this.sessionManager.getSessionFile();
-            if (sessionFile &&
-                !locallyManagedSessionFiles.has(sessionFile) &&
-                markAgentTraceOutboxPendingSync(sessionFile)) {
-                locallyManagedSessionFiles.add(sessionFile);
-            }
-            const ledgerPath = this.options.semanticEdgesLedgerPath;
-            if (ledgerPath) {
-                markAgentTraceOutboxPendingSync(ledgerPath, SEMANTIC_EDGES_OUTBOX_KIND);
-            }
-        }
-        this.arm();
-    };
-    arm() {
-        if (this.timeout) {
-            clearTimeout(this.timeout);
-        }
-        const elapsed = this.lastUploadStartedAt === undefined ? undefined : Date.now() - this.lastUploadStartedAt;
-        const throttleDelay = elapsed === undefined ? 0 : Math.max(0, TRACE_UPLOAD_MIN_INTERVAL_MS - elapsed);
-        const notBeforeDelay = Math.max(0, this.notBeforeAt - Date.now());
-        this.timeout = setTimeout(() => {
-            this.timeout = undefined;
-            void this.runScheduledUpload();
-        }, Math.max(TRACE_UPLOAD_DEBOUNCE_MS, throttleDelay, notBeforeDelay));
-        this.timeout.unref();
-    }
-    async runScheduledUpload() {
-        if (this.inFlight) {
-            return;
-        }
-        this.pending = false;
-        this.lastUploadStartedAt = Date.now();
-        this.inFlight = uploadAgentTraceSession({
-            ...this.options,
-            sessionManager: this.sessionManager,
-        }).then((result) => {
-            if (result.status === "failed" && isRescheduledUploadFailure(result.statusCode)) {
-                this.pending = true;
-                if (result.retryAfterMs !== undefined) {
-                    this.notBeforeAt = Date.now() + result.retryAfterMs;
-                }
-            }
-        }, () => undefined);
-        await this.inFlight;
-        this.inFlight = undefined;
-        if (this.pending) {
-            this.arm();
-        }
-    }
-}
-function isRescheduledUploadFailure(statusCode) {
-    return statusCode === undefined || statusCode === 429 || RETRIABLE_HTTP_STATUSES.has(statusCode);
-}
-const traceUploadControllers = new WeakMap();
-export function installAgentTraceUpload(sessionManager, options) {
-    // Enabling export applies to live sessions, not an inherited outbox backlog.
-    let controller = traceUploadControllers.get(sessionManager);
-    if (controller) {
-        controller.update(options);
-        return;
-    }
-    controller = new AgentTraceUploadController(sessionManager, options);
-    traceUploadControllers.set(sessionManager, controller);
-    sessionManager.onPersist(controller.schedule);
-}
-//# sourceMappingURL=agent-traces.js.map