iteration-cli 0.9.1 → 0.10.0

package/dist/service.js

@@ -1,249 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
-import { connectNewDetectedSources, loadMachineConsent, } from "./auto-connect.js";
-import { collectorFetch } from "./collector-fetch.js";
-import { collectorTick, TraceUploadError } from "./collector.js";
-import { refreshTurnSummaries } from "./turn-summary.js";
-import { installCursorHooks } from "./cursor-hooks.js";
-import { collectorSource, collectorPaths, ensureClaudeHistoryBackfill, ensureCursorHistoryBackfill, ensureHistoryBackfill, ensurePrivateDirectory, healthSnapshot, loadConfig, saveHealth, } from "./storage.js";
-function errorCode(error) {
-    if (error instanceof Error && "code" in error)
-        return String(error.code);
-    return null;
-}
-class CollectorLockBusyError extends Error {
-}
-// Fetch reports network failures as a generic TypeError; the actionable
-// reason (DNS, TLS, reset, timeout) is only in its cause chain.
-function errorCauses(error) {
-    const causes = [];
-    let current = error instanceof Error ? error.cause : undefined;
-    while (current instanceof Error && causes.length < 4) {
-        causes.push({
-            name: current.name,
-            code: errorCode(current),
-            message: current.message.slice(0, 300),
-        });
-        current = current.cause;
-    }
-    return causes;
-}
-function collectorFailure(error) {
-    return {
-        atMs: Date.now(),
-        kind: error instanceof TraceUploadError ? error.kind : "collector",
-        status: error instanceof TraceUploadError ? error.status : null,
-    };
-}
-async function persistHealth(health, paths) {
-    try {
-        await saveHealth(health, paths);
-    }
-    catch {
-        console.error(JSON.stringify({
-            level: "warning",
-            operation: "save_collector_health",
-            message: "Local collector status could not be saved; collection continues.",
-        }));
-    }
-}
-export async function acquireCollectorLock(paths) {
-    await ensurePrivateDirectory(path.dirname(paths.lock));
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        try {
-            const handle = await fs.open(paths.lock, "wx", 0o600);
-            await handle.writeFile(`${process.pid}\n`, "utf8");
-            await handle.sync();
-            await handle.close();
-            return async () => {
-                const current = await fs.readFile(paths.lock, "utf8").catch(() => "");
-                if (current.trim() === String(process.pid)) {
-                    await fs.rm(paths.lock, { force: true });
-                }
-            };
-        }
-        catch (error) {
-            if (errorCode(error) !== "EEXIST")
-                throw error;
-            const lockContents = await fs
-                .readFile(paths.lock, "utf8")
-                .catch(() => "");
-            const lockPid = Number(lockContents.trim());
-            if (!Number.isSafeInteger(lockPid) || lockPid < 2) {
-                await fs.rm(paths.lock, { force: true });
-                continue;
-            }
-            try {
-                process.kill(lockPid, 0);
-                throw new CollectorLockBusyError("Collector is already running.");
-            }
-            catch (processError) {
-                if (errorCode(processError) !== "ESRCH")
-                    throw processError;
-                await fs.rm(paths.lock, { force: true });
-            }
-        }
-    }
-    throw new Error("Could not obtain the collector lock.");
-}
-export async function waitForCollectorLock(paths) {
-    for (let attempt = 0; attempt < 81; attempt += 1) {
-        try {
-            return await acquireCollectorLock(paths);
-        }
-        catch (error) {
-            if (!(error instanceof CollectorLockBusyError))
-                throw error;
-            if (attempt === 80) {
-                throw new Error("Collector did not stop within 20 seconds; history was not changed.", { cause: error });
-            }
-            await delay(250);
-        }
-    }
-    throw new Error("Could not obtain the collector lock.");
-}
-export async function runCollector(directory, expectedSource) {
-    const paths = collectorPaths(directory);
-    const releaseLock = await acquireCollectorLock(paths);
-    const controller = new AbortController();
-    const stop = () => controller.abort();
-    process.on("SIGTERM", stop);
-    process.on("SIGINT", stop);
-    let retryDelayMs = 5000;
-    try {
-        const config = await loadConfig(paths);
-        const source = collectorSource(config);
-        if (expectedSource !== undefined && expectedSource !== source) {
-            throw new Error(`Collector directory belongs to ${source}, not ${expectedSource}.`);
-        }
-        const loadedHealth = await healthSnapshot(paths);
-        let health = loadedHealth.health;
-        if (loadedHealth.kind === "unavailable") {
-            console.error(JSON.stringify({
-                level: "warning",
-                operation: "load_collector_health",
-                message: "Local collector status could not be read; collection continues.",
-            }));
-        }
-        if ("cursorHome" in config) {
-            await ensureCursorHistoryBackfill(config.cursorHome, paths);
-            await installCursorHooks(config.cursorHome, config.dataDirectory);
-        }
-        else if ("claudeHome" in config)
-            await ensureClaudeHistoryBackfill(config.claudeHome, paths);
-        else
-            await ensureHistoryBackfill(config.codexHome, paths);
-        const summariesRefreshedAt = new Map();
-        let lastAutoCheckAt = 0;
-        while (!controller.signal.aborted) {
-            if (Date.now() - lastAutoCheckAt >= 60_000) {
-                lastAutoCheckAt = Date.now();
-                try {
-                    const consent = await loadMachineConsent();
-                    if (consent?.anchorSource === source) {
-                        const connected = await connectNewDetectedSources(config, consent);
-                        if (connected.length > 0) {
-                            console.info(JSON.stringify({
-                                level: "info",
-                                operation: "auto_connect_sources",
-                                connected,
-                            }));
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(JSON.stringify({
-                        level: "error",
-                        operation: "auto_connect_sources",
-                        message: error instanceof Error
-                            ? error.message
-                            : "Automatic source connection failed.",
-                    }));
-                }
-            }
-            let acknowledgedAtMs = null;
-            try {
-                const result = await collectorTick(config, paths, collectorFetch, controller.signal, () => {
-                    acknowledgedAtMs = Date.now();
-                });
-                if (acknowledgedAtMs !== null ||
-                    health.lastFailure !== null ||
-                    (result.historyCaughtUp && health.historyCaughtUpAtMs === null)) {
-                    health = {
-                        lastUploadAtMs: acknowledgedAtMs ?? health.lastUploadAtMs,
-                        historyCaughtUpAtMs: health.historyCaughtUpAtMs ??
-                            (result.historyCaughtUp ? Date.now() : null),
-                        lastFailure: null,
-                    };
-                    await persistHealth(health, paths);
-                }
-                if (result.discovered > 0 || result.uploaded > 0) {
-                    console.info(JSON.stringify({
-                        level: "info",
-                        at: new Date().toISOString(),
-                        source,
-                        discovered: result.discovered,
-                        uploaded: result.uploaded,
-                        outboxBytes: result.outboxBytes,
-                    }));
-                }
-                retryDelayMs = 5000;
-            }
-            catch (error) {
-                if (controller.signal.aborted)
-                    break;
-                health = {
-                    lastUploadAtMs: acknowledgedAtMs ?? health.lastUploadAtMs,
-                    historyCaughtUpAtMs: health.historyCaughtUpAtMs,
-                    lastFailure: collectorFailure(error),
-                };
-                console.error(JSON.stringify({
-                    level: "error",
-                    at: new Date().toISOString(),
-                    source,
-                    operation: "collector_tick",
-                    errorName: error instanceof Error ? error.name : "UnknownError",
-                    causes: errorCauses(error),
-                    message: error instanceof Error
-                        ? error.message
-                        : "Unknown collector failure.",
-                }));
-                await persistHealth(health, paths);
-                retryDelayMs = Math.min(retryDelayMs * 2, 60_000);
-            }
-            try {
-                if (source !== "cursor")
-                    await refreshTurnSummaries(config, summariesRefreshedAt, Date.now(), collectorFetch, controller.signal);
-            }
-            catch (error) {
-                if (controller.signal.aborted)
-                    break;
-                console.error(JSON.stringify({
-                    level: "warning",
-                    at: new Date().toISOString(),
-                    source,
-                    operation: "refresh_turn_summaries",
-                    errorName: error instanceof Error ? error.name : "UnknownError",
-                    causes: errorCauses(error),
-                    message: error instanceof Error
-                        ? error.message
-                        : "Unknown turn summary failure.",
-                }));
-            }
-            try {
-                await delay(retryDelayMs, undefined, { signal: controller.signal });
-            }
-            catch (error) {
-                if (error instanceof Error && error.name === "AbortError")
-                    break;
-                throw error;
-            }
-        }
-    }
-    finally {
-        process.off("SIGTERM", stop);
-        process.off("SIGINT", stop);
-        await releaseLock();
-    }
-}

package/dist/status-view.d.ts

@@ -1,33 +0,0 @@
-import { type CollectorSource } from "iteration-trace-contracts";
-import type { CollectorHealth } from "./storage.js";
-type ScanProgress = Readonly<{
-    kind: "waiting";
-} | {
-    kind: "scanning";
-    scannedBytes: number;
-    totalBytes: number;
-}>;
-export type CliStatus = Readonly<{
-    kind: "not_connected";
-}> | Readonly<{
-    kind: "needs_repair";
-    pendingBytes: number;
-    configPath: string;
-}> | Readonly<{
-    kind: "connected";
-    workspaceName: string | null;
-    running: boolean;
-    scan: ScanProgress;
-    pendingEvents: number;
-    pendingBytes: number;
-    health: CollectorHealth;
-    healthAvailable: boolean;
-    turnSummaryNeedsApproval: boolean;
-    hookFailureAtMs?: number | null;
-    tracesUrl: string;
-    logPath: string;
-}>;
-export declare function safeWorkspaceName(value: string | null): string | null;
-export declare function renderHome(status: CliStatus, nowMs?: number, source?: CollectorSource): string;
-export declare function renderDetailedStatus(status: CliStatus, nowMs?: number, source?: CollectorSource): string;
-export {};

package/dist/status-view.js

@@ -1,257 +0,0 @@
-import { collectorSourceLabel, } from "iteration-trace-contracts";
-const CODEX_APPROVAL_STEP = "Friction summary is off: in Codex, type /hooks and approve Iteration.";
-function sourceName(source) {
-    return collectorSourceLabel(source);
-}
-export function safeWorkspaceName(value) {
-    const cleaned = value
-        ?.split("")
-        .map((character) => {
-        const code = character.charCodeAt(0);
-        return code < 32 || (code >= 127 && code <= 159) ? " " : character;
-    })
-        .join("")
-        .replace(/\s+/g, " ")
-        .trim();
-    return cleaned === undefined || cleaned === "" ? null : cleaned;
-}
-function readableBytes(bytes) {
-    if (bytes < 1_000)
-        return `${bytes} B`;
-    const units = ["KB", "MB", "GB", "TB"];
-    let amount = bytes;
-    let index = -1;
-    do {
-        amount /= 1_000;
-        index += 1;
-    } while (amount >= 1_000 && index < units.length - 1);
-    const precision = amount < 10 ? 1 : 0;
-    return `${amount.toFixed(precision).replace(/\.0$/, "")} ${units[index]}`;
-}
-function relativeTime(atMs, nowMs) {
-    const elapsedSeconds = Math.max(0, Math.floor((nowMs - atMs) / 1_000));
-    if (elapsedSeconds < 5)
-        return "just now";
-    if (elapsedSeconds < 60)
-        return `${elapsedSeconds} second${elapsedSeconds === 1 ? "" : "s"} ago`;
-    const elapsedMinutes = Math.floor(elapsedSeconds / 60);
-    if (elapsedMinutes < 60)
-        return `${elapsedMinutes} minute${elapsedMinutes === 1 ? "" : "s"} ago`;
-    const elapsedHours = Math.floor(elapsedMinutes / 60);
-    if (elapsedHours < 24)
-        return `${elapsedHours} hour${elapsedHours === 1 ? "" : "s"} ago`;
-    const elapsedDays = Math.floor(elapsedHours / 24);
-    return `${elapsedDays} day${elapsedDays === 1 ? "" : "s"} ago`;
-}
-function pendingDescription(status) {
-    return `${status.pendingEvents} event${status.pendingEvents === 1 ? "" : "s"} (${readableBytes(status.pendingBytes)}) waiting on this computer`;
-}
-function progressDescription(scan, source) {
-    if (scan.kind === "waiting")
-        return "Local history is preparing to scan.";
-    if (scan.totalBytes === 0)
-        return `No local ${sourceName(source)} sessions found yet.`;
-    if (scan.scannedBytes >= scan.totalBytes)
-        return `Local history scanned (${readableBytes(scan.totalBytes)}).`;
-    const remainingBytes = scan.totalBytes - scan.scannedBytes;
-    if (remainingBytes < 1_000_000)
-        return "Local scan is nearly caught up (less than 1 MB remains).";
-    const percentage = Math.min(99, Math.floor((scan.scannedBytes / scan.totalBytes) * 100));
-    return `About ${percentage}% of local history scanned (${readableBytes(scan.scannedBytes)} of ${readableBytes(scan.totalBytes)}).`;
-}
-function historyDescription(status, source) {
-    if (status.health.historyCaughtUpAtMs === null) {
-        return progressDescription(status.scan, source);
-    }
-    if (status.scan.kind === "waiting")
-        return "History is preparing to scan.";
-    const remainingBytes = status.scan.totalBytes - status.scan.scannedBytes;
-    if (remainingBytes <= 0)
-        return "History imported; local files are caught up.";
-    if (remainingBytes < 1_000_000)
-        return "History imported; scanning current activity.";
-    return `History imported; ${readableBytes(remainingBytes)} of new activity waiting to scan.`;
-}
-function failureDescription(status, source) {
-    const name = sourceName(source);
-    const failure = status.health.lastFailure;
-    if (failure === null) {
-        throw new Error("A collector failure is required to describe it.");
-    }
-    if (failure.kind === "http") {
-        const code = failure.status === null ? "HTTP error" : `HTTP ${failure.status}`;
-        if (failure.status === 401 || failure.status === 403) {
-            return {
-                heading: `${name} upload access needs attention`,
-                explanation: `Iteration denied this collector (${code}). Queued data stays on this computer. Contact Iteration support to reconnect it safely.`,
-            };
-        }
-        if (failure.status !== null &&
-            failure.status < 500 &&
-            failure.status !== 429) {
-            return {
-                heading: `${name} uploads need attention`,
-                explanation: `Iteration rejected an event batch (${code}). Check the collector log for details.`,
-            };
-        }
-        return {
-            heading: `${name} uploads are delayed`,
-            explanation: `Iteration could not accept an upload (${code}). Retrying automatically.`,
-        };
-    }
-    if (failure.kind === "network") {
-        return {
-            heading: `${name} uploads are delayed`,
-            explanation: "Could not reach Iteration. Retrying automatically.",
-        };
-    }
-    if (failure.kind === "response") {
-        return {
-            heading: `${name} uploads need attention`,
-            explanation: "Iteration returned an unexpected upload response. Retrying automatically.",
-        };
-    }
-    return {
-        heading: `${name} collector needs attention`,
-        explanation: `A local error interrupted collection. See iteration status ${source} for details.`,
-    };
-}
-export function renderHome(status, nowMs = Date.now(), source = "codex") {
-    const name = sourceName(source);
-    if (status.kind === "not_connected") {
-        return [
-            "Iteration",
-            "",
-            `${name} is not connected.`,
-            "Run iteration connect to import your existing sessions.",
-        ].join("\n");
-    }
-    if (status.kind === "needs_repair") {
-        return [
-            "Iteration",
-            "",
-            `${name} connection needs repair`,
-            "Local collector data exists, but its connection details are missing.",
-            status.pendingBytes > 0
-                ? `${readableBytes(status.pendingBytes)} of queued data remains on this computer.`
-                : "Existing local progress remains on this computer.",
-            `Run iteration status ${source} for recovery details.`,
-        ].join("\n");
-    }
-    const workspaceName = safeWorkspaceName(status.workspaceName);
-    const lines = [
-        workspaceName === null ? "Iteration" : `Iteration · ${workspaceName}`,
-        "",
-    ];
-    if (!status.running) {
-        lines.push(`${name} is stopped`, "New sessions are not being collected.");
-        if (status.pendingEvents > 0)
-            lines.push(`${pendingDescription(status)}.`);
-        lines.push(`Resume with iteration start ${source}.`);
-    }
-    else if (status.hookFailureAtMs !== null &&
-        status.hookFailureAtMs !== undefined) {
-        lines.push(`${name} hook capture needs attention`, `A Cursor hook failed ${relativeTime(status.hookFailureAtMs, nowMs)}. Some data may be missing. See iteration status cursor.`);
-    }
-    else if (!status.healthAvailable) {
-        lines.push(`${name} is running; local status needs attention`, "Upload history could not be read. Collection continues in the background.");
-        if (status.pendingEvents > 0)
-            lines.push(`${pendingDescription(status)}.`);
-        lines.push(`Details: iteration status ${source}`);
-    }
-    else if (status.health.lastFailure !== null) {
-        const failure = failureDescription(status, source);
-        lines.push(failure.heading, failure.explanation);
-        if (status.pendingEvents > 0)
-            lines.push(`${pendingDescription(status)}.`);
-        if (status.health.lastUploadAtMs !== null) {
-            lines.push(`Last successful upload ${relativeTime(status.health.lastUploadAtMs, nowMs)}.`);
-        }
-        lines.push(`Details: iteration status ${source}`);
-    }
-    else if (status.scan.kind === "waiting") {
-        lines.push(`${name} is preparing your history`, progressDescription(status.scan, source));
-    }
-    else if (status.scan.kind === "scanning" &&
-        status.scan.totalBytes > 0 &&
-        status.scan.scannedBytes < status.scan.totalBytes &&
-        status.health.historyCaughtUpAtMs === null) {
-        lines.push(`${name} is importing existing sessions`, historyDescription(status, source), "New activity is collected automatically.");
-    }
-    else if (status.scan.kind === "scanning" &&
-        status.scan.totalBytes - status.scan.scannedBytes >= 1_000_000) {
-        lines.push(`${name} is catching up with new activity`, historyDescription(status, source));
-        if (status.pendingEvents > 0)
-            lines.push(`${pendingDescription(status)}.`);
-    }
-    else if (status.pendingEvents > 0) {
-        lines.push(`${name} is uploading captured sessions`, `${pendingDescription(status)}.`);
-    }
-    else if (status.scan.totalBytes === 0) {
-        lines.push(`${name} is connected`, `Waiting for ${name} sessions on this computer.`);
-    }
-    else if (status.scan.kind === "scanning" &&
-        status.scan.scannedBytes < status.scan.totalBytes) {
-        lines.push(`${name} is collecting new activity`, "Local history is imported; current activity is being scanned.");
-    }
-    else {
-        lines.push(`${name} is collecting`, "Local scan is caught up and no uploads are waiting.", "New activity is collected automatically.");
-    }
-    if (status.running &&
-        status.health.lastFailure === null &&
-        status.health.lastUploadAtMs !== null) {
-        lines.push(`Last successful upload ${relativeTime(status.health.lastUploadAtMs, nowMs)}.`);
-    }
-    if (status.turnSummaryNeedsApproval)
-        lines.push("", CODEX_APPROVAL_STEP);
-    lines.push("", `Explore traces  ${status.tracesUrl}`);
-    return lines.join("\n");
-}
-export function renderDetailedStatus(status, nowMs = Date.now(), source = "codex") {
-    const name = sourceName(source);
-    if (status.kind === "not_connected") {
-        return `${name} is not connected. Run iteration connect to connect.`;
-    }
-    if (status.kind === "needs_repair") {
-        return [
-            `${name} connection needs repair`,
-            "Local collector data exists without its connection details.",
-            `Queued data: ${readableBytes(status.pendingBytes)}`,
-            `Restore the missing config from backup: ${status.configPath}`,
-            "If you do not have it, contact Iteration support before reconnecting; existing data has been kept.",
-        ].join("\n");
-    }
-    const workspaceName = safeWorkspaceName(status.workspaceName);
-    const lines = [
-        `${name} collector`,
-        ...(workspaceName === null ? [] : [`Workspace: ${workspaceName}`]),
-        `Background process: ${status.running ? "Running" : "Stopped"}`,
-        `History: ${historyDescription(status, source).replace(/^History /, "")}`,
-        `Uploads: ${status.pendingEvents === 0 ? "None waiting" : pendingDescription(status)}`,
-    ];
-    if (!status.healthAvailable) {
-        lines.push("Local status: unavailable; check collector file permissions", `Collector log: ${status.logPath}`);
-    }
-    if (status.health.lastUploadAtMs !== null) {
-        lines.push(`Last successful upload: ${relativeTime(status.health.lastUploadAtMs, nowMs)}`);
-    }
-    if (status.health.lastFailure !== null) {
-        const failure = status.health.lastFailure;
-        const label = failure.kind === "http" && failure.status !== null
-            ? `HTTP ${failure.status}`
-            : failure.kind === "network"
-                ? "Network unavailable"
-                : failure.kind === "response"
-                    ? "Unexpected upload response"
-                    : "Local collector error";
-        lines.push(`Last issue: ${label} (${relativeTime(failure.atMs, nowMs)})`, `Collector log: ${status.logPath}`);
-    }
-    if (status.hookFailureAtMs !== null && status.hookFailureAtMs !== undefined)
-        lines.push(`Last Cursor hook capture failure: ${relativeTime(status.hookFailureAtMs, nowMs)}. Some data may be missing; inspect Cursor hook logs.`);
-    if (status.turnSummaryNeedsApproval)
-        lines.push(CODEX_APPROVAL_STEP);
-    if (!status.running)
-        lines.push(`Resume: iteration start ${source}`);
-    lines.push(`Explore traces: ${status.tracesUrl}`);
-    return lines.join("\n");
-}

package/dist/storage.d.ts

@@ -1,94 +0,0 @@
-import { type CollectorSource, type TraceEvent } from "iteration-trace-contracts";
-type CollectorConnection = Readonly<{
-    endpoint: string;
-    token: string;
-    dataDirectory: string;
-    organizationId?: string;
-    organizationName?: string;
-}>;
-export type CollectorConfig = (CollectorConnection & Readonly<{
-    codexHome: string;
-}>) | (CollectorConnection & Readonly<{
-    source: "claude";
-    claudeHome: string;
-}>) | (CollectorConnection & Readonly<{
-    source: "cursor";
-    cursorHome: string;
-}>);
-export declare function collectorSource(config: CollectorConfig): CollectorSource;
-export declare function collectorSourceDirectory(config: CollectorConfig): string;
-export type CollectorState = Readonly<{
-    cursors: Readonly<Record<string, number>>;
-    skipping: readonly string[];
-    sourceDirectory: string | null;
-    initialized: boolean;
-}>;
-export type CollectorFailure = Readonly<{
-    atMs: number;
-    kind: "http" | "network" | "response" | "collector";
-    status: number | null;
-}>;
-export type CollectorHealth = Readonly<{
-    lastUploadAtMs: number | null;
-    historyCaughtUpAtMs: number | null;
-    lastFailure: CollectorFailure | null;
-}>;
-export type HealthSnapshot = Readonly<{
-    kind: "available";
-    health: CollectorHealth;
-} | {
-    kind: "unavailable";
-    health: CollectorHealth;
-}>;
-export type CollectorPaths = Readonly<{
-    config: string;
-    state: string;
-    outbox: string;
-    redactionMarker: string;
-    lock: string;
-    historyBackfill: string;
-    health: string;
-}>;
-export declare function defaultCollectorDirectory(source: CollectorSource): string;
-export declare function validateCollectorEndpoint(endpoint: string): URL;
-export declare function collectorPaths(directory?: string): CollectorPaths;
-export declare function assertFreshCollectorDirectory(paths: CollectorPaths, source?: CollectorSource): Promise<void>;
-export declare function ensurePrivateDirectory(directory: string): Promise<void>;
-export declare function saveConfig(config: CollectorConfig, paths: CollectorPaths): Promise<void>;
-export declare function loadHealth(paths: CollectorPaths): Promise<CollectorHealth>;
-export declare function healthSnapshot(paths: CollectorPaths): Promise<HealthSnapshot>;
-export declare function saveHealth(health: CollectorHealth, paths: CollectorPaths): Promise<void>;
-export declare function loadConfig(paths: CollectorPaths): Promise<CollectorConfig>;
-export declare function loadState(paths: CollectorPaths): Promise<CollectorState>;
-export declare function saveState(state: CollectorState, paths: CollectorPaths): Promise<void>;
-export declare function outboxSize(paths: CollectorPaths): Promise<number>;
-export declare function pendingEventIds(paths: CollectorPaths): Promise<Set<string>>;
-export declare function appendEvents(events: readonly TraceEvent[], paths: CollectorPaths): Promise<void>;
-export declare function redactPendingOutbox(paths: CollectorPaths): Promise<void>;
-export declare function nextBatch(paths: CollectorPaths, maxBytes: number): Promise<readonly TraceEvent[]>;
-export declare function acknowledgeEvents(acknowledgedIds: ReadonlySet<string>, paths: CollectorPaths): Promise<void>;
-export declare function initializeState(source: CollectorSource, home: string, paths: CollectorPaths, includeHistory: boolean): Promise<void>;
-export declare function prepareSourceInitialState(source: CollectorSource, home: string, includeHistory: boolean): Promise<CollectorState>;
-export declare function ensureStartableState(config: CollectorConfig, paths: CollectorPaths): Promise<boolean>;
-export declare function ensureHistoryBackfill(codexHome: string, paths: CollectorPaths): Promise<boolean>;
-export declare function ensureClaudeHistoryBackfill(claudeHome: string, paths: CollectorPaths): Promise<boolean>;
-export declare function ensureCursorHistoryBackfill(cursorHome: string, paths: CollectorPaths): Promise<boolean>;
-export declare function historyScanProgress(home: string, paths: CollectorPaths, source?: CollectorSource): Promise<Readonly<{
-    kind: "waiting";
-} | {
-    kind: "scanning";
-    scannedBytes: number;
-    totalBytes: number;
-}>>;
-export declare function resetHistoryCursors(home: string, paths: CollectorPaths, source?: CollectorSource): Promise<Readonly<{
-    files: number;
-    bytes: number;
-}>>;
-export declare function historyImportSize(home: string, source?: CollectorSource): Promise<Readonly<{
-    files: number;
-    bytes: number;
-}>>;
-export declare function claudeFiles(root: string): Promise<string[]>;
-export declare function sourceFiles(source: CollectorSource, home: string): Promise<string[]>;
-export declare function cursorFiles(root: string): Promise<string[]>;
-export {};