iteration-cli 0.4.4 → 0.6.0

package/dist/status-view.js

@@ -1,4 +1,8 @@
-function safeWorkspaceName(value) {
+import { collectorSourceLabel, } from "iteration-trace-contracts";
+function sourceName(source) {
+    return collectorSourceLabel(source);
+}
+export function safeWorkspaceName(value) {
     const cleaned = value
         ?.split("")
         .map((character) => {
@@ -41,11 +45,11 @@ function relativeTime(atMs, nowMs) {
 function pendingDescription(status) {
     return `${status.pendingEvents} event${status.pendingEvents === 1 ? "" : "s"} (${readableBytes(status.pendingBytes)}) waiting on this Mac`;
 }
-function progressDescription(scan) {
+function progressDescription(scan, source) {
     if (scan.kind === "waiting")
         return "Local history is preparing to scan.";
     if (scan.totalBytes === 0)
-        return "No local Codex sessions found yet.";
+        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;
@@ -54,9 +58,9 @@ function progressDescription(scan) {
     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) {
+function historyDescription(status, source) {
     if (status.health.historyCaughtUpAtMs === null) {
-        return progressDescription(status.scan);
+        return progressDescription(status.scan, source);
     }
     if (status.scan.kind === "waiting")
         return "History is preparing to scan.";
@@ -67,7 +71,8 @@ function historyDescription(status) {
         return "History imported; scanning current activity.";
     return `History imported; ${readableBytes(remainingBytes)} of new activity waiting to scan.`;
 }
-function failureDescription(status) {
+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.");
@@ -76,7 +81,7 @@ function failureDescription(status) {
         const code = failure.status === null ? "HTTP error" : `HTTP ${failure.status}`;
         if (failure.status === 401 || failure.status === 403) {
             return {
-                heading: "Codex upload access needs attention",
+                heading: `${name} upload access needs attention`,
                 explanation: `Iteration denied this collector (${code}). Queued data stays on this Mac. Contact Iteration support to reconnect it safely.`,
             };
         }
@@ -84,51 +89,52 @@ function failureDescription(status) {
             failure.status < 500 &&
             failure.status !== 429) {
             return {
-                heading: "Codex uploads need attention",
+                heading: `${name} uploads need attention`,
                 explanation: `Iteration rejected an event batch (${code}). Check the collector log for details.`,
             };
         }
         return {
-            heading: "Codex uploads are delayed",
+            heading: `${name} uploads are delayed`,
             explanation: `Iteration could not accept an upload (${code}). Retrying automatically.`,
         };
     }
     if (failure.kind === "network") {
         return {
-            heading: "Codex uploads are delayed",
+            heading: `${name} uploads are delayed`,
             explanation: "Could not reach Iteration. Retrying automatically.",
         };
     }
     if (failure.kind === "response") {
         return {
-            heading: "Codex uploads need attention",
+            heading: `${name} uploads need attention`,
             explanation: "Iteration returned an unexpected upload response. Retrying automatically.",
         };
     }
     return {
-        heading: "Codex collector needs attention",
-        explanation: "A local error interrupted collection. See iteration status codex for details.",
+        heading: `${name} collector needs attention`,
+        explanation: `A local error interrupted collection. See iteration status ${source} for details.`,
     };
 }
-export function renderHome(status, nowMs = Date.now()) {
+export function renderHome(status, nowMs = Date.now(), source = "codex") {
+    const name = sourceName(source);
     if (status.kind === "not_connected") {
         return [
             "Iteration",
             "",
-            "Codex is not connected.",
-            "Run iteration connect codex to import your existing sessions.",
+            `${name} is not connected.`,
+            "Run iteration connect to import your existing sessions.",
         ].join("\n");
     }
     if (status.kind === "needs_repair") {
         return [
             "Iteration",
             "",
-            "Codex connection needs repair",
+            `${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 Mac.`
                 : "Existing local progress remains on this Mac.",
-            "Run iteration status codex for recovery details.",
+            `Run iteration status ${source} for recovery details.`,
         ].join("\n");
     }
     const workspaceName = safeWorkspaceName(status.workspaceName);
@@ -137,54 +143,54 @@ export function renderHome(status, nowMs = Date.now()) {
         "",
     ];
     if (!status.running) {
-        lines.push("Codex is stopped", "New sessions are not being collected.");
+        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 codex.");
+        lines.push(`Resume with iteration start ${source}.`);
     }
     else if (!status.healthAvailable) {
-        lines.push("Codex is running; local status needs attention", "Upload history could not be read. Collection continues in the background.");
+        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 codex");
+        lines.push(`Details: iteration status ${source}`);
     }
     else if (status.health.lastFailure !== null) {
-        const failure = failureDescription(status);
+        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 codex");
+        lines.push(`Details: iteration status ${source}`);
     }
     else if (status.scan.kind === "waiting") {
-        lines.push("Codex is preparing your history", progressDescription(status.scan));
+        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("Codex is importing existing sessions", historyDescription(status), "New activity is collected automatically.");
+        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("Codex is catching up with new activity", historyDescription(status));
+        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("Codex is uploading captured sessions", `${pendingDescription(status)}.`);
+        lines.push(`${name} is uploading captured sessions`, `${pendingDescription(status)}.`);
     }
     else if (status.scan.totalBytes === 0) {
-        lines.push("Codex is connected", "Waiting for Codex sessions on this Mac.");
+        lines.push(`${name} is connected`, `Waiting for ${name} sessions on this Mac.`);
     }
     else if (status.scan.kind === "scanning" &&
         status.scan.scannedBytes < status.scan.totalBytes) {
-        lines.push("Codex is collecting new activity", "Local history is imported; current activity is being scanned.");
+        lines.push(`${name} is collecting new activity`, "Local history is imported; current activity is being scanned.");
     }
     else {
-        lines.push("Codex is collecting", "Local scan is caught up and no uploads are waiting.", "New activity is collected automatically.");
+        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 &&
@@ -194,13 +200,14 @@ export function renderHome(status, nowMs = Date.now()) {
     lines.push("", `Explore traces  ${status.tracesUrl}`);
     return lines.join("\n");
 }
-export function renderDetailedStatus(status, nowMs = Date.now()) {
+export function renderDetailedStatus(status, nowMs = Date.now(), source = "codex") {
+    const name = sourceName(source);
     if (status.kind === "not_connected") {
-        return "Codex is not connected. Run iteration connect codex to connect.";
+        return `${name} is not connected. Run iteration connect to connect.`;
     }
     if (status.kind === "needs_repair") {
         return [
-            "Codex connection needs repair",
+            `${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}`,
@@ -209,10 +216,10 @@ export function renderDetailedStatus(status, nowMs = Date.now()) {
     }
     const workspaceName = safeWorkspaceName(status.workspaceName);
     const lines = [
-        "Codex collector",
+        `${name} collector`,
         ...(workspaceName === null ? [] : [`Workspace: ${workspaceName}`]),
         `Background process: ${status.running ? "Running" : "Stopped"}`,
-        `History: ${historyDescription(status).replace(/^History /, "")}`,
+        `History: ${historyDescription(status, source).replace(/^History /, "")}`,
         `Uploads: ${status.pendingEvents === 0 ? "None waiting" : pendingDescription(status)}`,
     ];
     if (!status.healthAvailable) {
@@ -233,7 +240,7 @@ export function renderDetailedStatus(status, nowMs = Date.now()) {
         lines.push(`Last issue: ${label} (${relativeTime(failure.atMs, nowMs)})`, `Collector log: ${status.logPath}`);
     }
     if (!status.running)
-        lines.push("Resume: iteration start codex");
+        lines.push(`Resume: iteration start ${source}`);
     lines.push(`Explore traces: ${status.tracesUrl}`);
     return lines.join("\n");
 }

package/dist/storage.d.ts

@@ -1,11 +1,19 @@
-import { type TraceEvent } from "iteration-trace-contracts";
-export type CollectorConfig = Readonly<{
+import { type CollectorSource, type TraceEvent } from "iteration-trace-contracts";
+type CollectorConnection = Readonly<{
     endpoint: string;
     token: string;
-    codexHome: string;
     dataDirectory: string;
+    organizationId?: string;
     organizationName?: string;
 }>;
+export type CollectorConfig = (CollectorConnection & Readonly<{
+    codexHome: string;
+}>) | (CollectorConnection & Readonly<{
+    source: "claude";
+    claudeHome: 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[];
@@ -37,9 +45,10 @@ export type CollectorPaths = Readonly<{
     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): Promise<void>;
+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>;
@@ -53,23 +62,26 @@ export declare function pendingEventIds(paths: CollectorPaths): Promise<Set<stri
 export declare function appendEvents(events: readonly TraceEvent[], 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(codexHome: string, paths: CollectorPaths, includeHistory: boolean): Promise<void>;
-export declare function prepareInitialState(codexHome: string, includeHistory: boolean): Promise<CollectorState>;
+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 historyScanProgress(codexHome: string, paths: CollectorPaths): Promise<Readonly<{
+export declare function ensureClaudeHistoryBackfill(claudeHome: 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(codexHome: string, paths: CollectorPaths): Promise<Readonly<{
+export declare function resetHistoryCursors(home: string, paths: CollectorPaths, source?: CollectorSource): Promise<Readonly<{
     files: number;
     bytes: number;
 }>>;
-export declare function historyImportSize(codexHome: string): Promise<Readonly<{
+export declare function historyImportSize(home: string, source?: CollectorSource): Promise<Readonly<{
     files: number;
     bytes: number;
 }>>;
-export declare function rolloutFiles(root: string): Promise<string[]>;
+export declare function claudeFiles(root: string): Promise<string[]>;
+export declare function sourceFiles(source: CollectorSource, home: string): Promise<string[]>;
+export {};

package/dist/storage.js

@@ -1,20 +1,34 @@
+import { once } from "node:events";
 import { createWriteStream, promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { once } from "node:events";
 import { createInterface } from "node:readline";
-import * as z from "zod";
 import { MAX_TRACE_EVENTS_PER_BATCH, parseTraceEventBatch, } from "iteration-trace-contracts";
+import * as z from "zod";
 const MAX_OUTBOX_BYTES = 64 * 1024 * 1024;
-const configSchema = z
-    .object({
+export function collectorSource(config) {
+    return "claudeHome" in config ? "claude" : "codex";
+}
+export function collectorSourceDirectory(config) {
+    return "claudeHome" in config ? config.claudeHome : config.codexHome;
+}
+const connectionSchema = {
     endpoint: z.string(),
     token: z.string(),
-    codexHome: z.string(),
     dataDirectory: z.string(),
+    organizationId: z.uuid().optional(),
     organizationName: z.string().min(1).max(160).optional(),
-})
-    .strict();
+};
+const configSchema = z.union([
+    z.object({ ...connectionSchema, codexHome: z.string() }).strict(),
+    z
+        .object({
+        ...connectionSchema,
+        source: z.literal("claude"),
+        claudeHome: z.string(),
+    })
+        .strict(),
+]);
 const stateSchema = z
     .object({
     cursors: z.record(z.string(), z.number().int().min(0).max(Number.MAX_SAFE_INTEGER)),
@@ -55,8 +69,8 @@ function parseOutboxEvent(line) {
         throw new Error("Trace outbox event is missing.");
     return event;
 }
-function defaultDirectory() {
-    return path.join(os.homedir(), ".config", "iteration", "codex-collector");
+export function defaultCollectorDirectory(source) {
+    return path.join(os.homedir(), ".config", "iteration", `${source}-collector`);
 }
 export function validateCollectorEndpoint(endpoint) {
     let parsed;
@@ -82,7 +96,7 @@ export function validateCollectorEndpoint(endpoint) {
     }
     return parsed;
 }
-export function collectorPaths(directory = defaultDirectory()) {
+export function collectorPaths(directory = defaultCollectorDirectory("codex")) {
     return {
         config: path.join(directory, "config.json"),
         state: path.join(directory, "state.json"),
@@ -92,7 +106,7 @@ export function collectorPaths(directory = defaultDirectory()) {
         health: path.join(directory, "health.json"),
     };
 }
-export async function assertFreshCollectorDirectory(paths) {
+export async function assertFreshCollectorDirectory(paths, source = "codex") {
     const state = await loadState(paths);
     const configExists = await fs
         .access(paths.config)
@@ -103,7 +117,7 @@ export async function assertFreshCollectorDirectory(paths) {
         throw error;
     });
     if (configExists) {
-        throw new Error("This collector data directory is already configured. Run iteration status codex or iteration start codex to repair startup. Use a different --data-directory for another workspace, or iteration import-history codex for earlier sessions.");
+        throw new Error(`This collector data directory is already configured. Run iteration status ${source} or iteration start ${source} to repair startup. Use a different --data-directory for another workspace, or iteration import-history ${source} for earlier sessions.`);
     }
     if (state.initialized || (await outboxSize(paths)) > 0) {
         throw new Error("Collector state or pending events exist without a config. Use a different --data-directory; this data cannot be safely assigned to a new workspace.");
@@ -202,12 +216,12 @@ export async function loadConfig(paths) {
         throw new Error("Collector config has an invalid shape.", {
             cause: parsed.error,
         });
-    const { endpoint, token, codexHome, dataDirectory, organizationName } = parsed.data;
-    validateCollectorEndpoint(endpoint);
+    validateCollectorEndpoint(parsed.data.endpoint);
+    const { token } = parsed.data;
     if (token.length !== 43 || !/^[A-Za-z0-9_-]+$/.test(token)) {
         throw new Error("Collector token has an invalid format.");
     }
-    return { endpoint, token, codexHome, dataDirectory, organizationName };
+    return parsed.data;
 }
 export async function loadState(paths) {
     let contents;
@@ -372,24 +386,23 @@ export async function acknowledgeEvents(acknowledgedIds, paths) {
         throw error;
     }
 }
-export async function initializeState(codexHome, paths, includeHistory) {
+export async function initializeState(source, home, paths, includeHistory) {
     const state = await loadState(paths);
-    const sourceDirectory = path.resolve(codexHome);
+    const sourceDirectory = path.resolve(home);
     if (state.initialized && state.sourceDirectory !== sourceDirectory) {
-        throw new Error("Collector state belongs to another Codex directory; use a separate --data-directory.");
+        throw new Error(`Collector state belongs to another ${source} directory; use a separate --data-directory.`);
     }
     if (state.initialized && state.sourceDirectory === sourceDirectory) {
         if (includeHistory) {
-            throw new Error("Codex is already connected. Run iteration import-history codex to import existing sessions.");
+            throw new Error(`${source} is already connected. Run iteration import-history ${source} to import existing sessions.`);
         }
         return;
     }
-    await saveState(await prepareInitialState(codexHome, includeHistory), paths);
+    await saveState(await prepareSourceInitialState(source, home, includeHistory), paths);
 }
-export async function prepareInitialState(codexHome, includeHistory) {
-    const sourceDirectory = path.resolve(codexHome);
-    const sessionsRoot = path.join(sourceDirectory, "sessions");
-    const files = await rolloutFiles(sessionsRoot);
+export async function prepareSourceInitialState(source, home, includeHistory) {
+    const sourceDirectory = path.resolve(home);
+    const files = await sourceFiles(source, sourceDirectory);
     const cursors = {};
     if (!includeHistory) {
         for (const filename of files) {
@@ -404,20 +417,26 @@ export async function prepareInitialState(codexHome, includeHistory) {
     };
 }
 export async function ensureStartableState(config, paths) {
+    const source = collectorSource(config);
+    const directory = collectorSourceDirectory(config);
     const state = await loadState(paths);
     if (state.initialized) {
-        if (state.sourceDirectory !== path.resolve(config.codexHome)) {
-            throw new Error("Collector state belongs to another Codex directory; use a separate --data-directory.");
+        if (state.sourceDirectory !== path.resolve(directory)) {
+            throw new Error(`Collector state belongs to another ${source} directory; use a separate --data-directory.`);
         }
         return false;
     }
     if ((await outboxSize(paths)) > 0) {
         throw new Error("Pending events exist without an initialized checkpoint; repair the collector state before starting uploads.");
     }
-    await initializeState(config.codexHome, paths, true);
+    await saveState(await prepareSourceInitialState(source, directory, true), paths);
     return true;
 }
-async function hasHistoryBackfillMarker(paths) {
+const HISTORY_BACKFILL_VERSION = 4;
+const historyBackfillMarkerSchema = z
+    .object({ version: z.number().int().min(1).max(HISTORY_BACKFILL_VERSION) })
+    .strict();
+async function readHistoryBackfillVersion(paths) {
     let marker;
     try {
         marker = await fs.readFile(paths.historyBackfill, "utf8");
@@ -425,18 +444,28 @@ async function hasHistoryBackfillMarker(paths) {
     catch (error) {
         if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
             throw error;
-        marker = null;
+        return null;
     }
-    if (marker !== null) {
-        if (marker !== '{"version":1}\n') {
-            throw new Error("Collector history backfill marker has an invalid shape.");
-        }
-        return true;
+    let decoded;
+    try {
+        decoded = JSON.parse(marker);
+    }
+    catch (error) {
+        throw new Error("Collector history backfill marker is not valid JSON.", {
+            cause: error,
+        });
     }
-    return false;
+    const parsed = historyBackfillMarkerSchema.safeParse(decoded);
+    if (!parsed.success) {
+        throw new Error("Collector history backfill marker has an invalid shape.", {
+            cause: parsed.error,
+        });
+    }
+    return parsed.data.version;
 }
 export async function ensureHistoryBackfill(codexHome, paths) {
-    if (await hasHistoryBackfillMarker(paths))
+    const version = await readHistoryBackfillVersion(paths);
+    if (version !== null && version >= HISTORY_BACKFILL_VERSION)
         return false;
     const state = await loadState(paths);
     if (!state.initialized || state.sourceDirectory !== path.resolve(codexHome)) {
@@ -444,17 +473,33 @@ export async function ensureHistoryBackfill(codexHome, paths) {
     }
     await rolloutFiles(path.join(codexHome, "sessions"));
     await saveState({ ...state, cursors: {}, skipping: [] }, paths);
+    await writeJsonAtomic(paths.historyBackfill, {
+        version: HISTORY_BACKFILL_VERSION,
+    });
+    return true;
+}
+export async function ensureClaudeHistoryBackfill(claudeHome, paths) {
+    const version = await readHistoryBackfillVersion(paths);
+    if (version !== null && version >= 1)
+        return false;
+    const state = await loadState(paths);
+    if (!state.initialized ||
+        state.sourceDirectory !== path.resolve(claudeHome)) {
+        throw new Error("Collector state does not match the Claude directory; reconnect Claude before uploading.");
+    }
+    await claudeFiles(path.join(claudeHome, "projects"));
+    await saveState({ ...state, cursors: {}, skipping: [] }, paths);
     await writeJsonAtomic(paths.historyBackfill, { version: 1 });
     return true;
 }
-export async function historyScanProgress(codexHome, paths) {
-    if (!(await hasHistoryBackfillMarker(paths)))
+export async function historyScanProgress(home, paths, source = "codex") {
+    if ((await readHistoryBackfillVersion(paths)) === null)
         return { kind: "waiting" };
     const state = await loadState(paths);
-    if (!state.initialized || state.sourceDirectory !== path.resolve(codexHome)) {
-        throw new Error("Collector state does not match CODEX_HOME.");
+    if (!state.initialized || state.sourceDirectory !== path.resolve(home)) {
+        throw new Error(`Collector state does not match the ${source} directory.`);
     }
-    const files = await rolloutFiles(path.join(codexHome, "sessions"));
+    const files = await sourceFiles(source, home);
     let scannedBytes = 0;
     let totalBytes = 0;
     for (let start = 0; start < files.length; start += 64) {
@@ -482,26 +527,26 @@ export async function historyScanProgress(codexHome, paths) {
             scannedBytes += cursor <= size ? cursor : 0;
             if (!Number.isSafeInteger(totalBytes) ||
                 !Number.isSafeInteger(scannedBytes)) {
-                throw new Error("Codex history size exceeds the supported limit.");
+                throw new Error(`${source} history size exceeds the supported limit.`);
             }
         }
     }
     return { kind: "scanning", scannedBytes, totalBytes };
 }
-export async function resetHistoryCursors(codexHome, paths) {
+export async function resetHistoryCursors(home, paths, source = "codex") {
     const state = await loadState(paths);
-    const sourceDirectory = path.resolve(codexHome);
+    const sourceDirectory = path.resolve(home);
     if (!state.initialized || state.sourceDirectory !== sourceDirectory) {
-        throw new Error("Connect the Codex source before importing its history.");
+        throw new Error(`Connect the ${source} source before importing its history.`);
     }
-    const files = await rolloutFiles(path.join(sourceDirectory, "sessions"));
+    const files = await sourceFiles(source, sourceDirectory);
     const cursors = {};
     let bytes = 0;
     for (const filename of files) {
         cursors[filename] = 0;
         bytes += (await fs.stat(filename)).size;
         if (!Number.isSafeInteger(bytes)) {
-            throw new Error("Codex history size exceeds the supported limit.");
+            throw new Error(`${source} history size exceeds the supported limit.`);
         }
     }
     const localHealth = await healthSnapshot(paths);
@@ -517,13 +562,13 @@ export async function resetHistoryCursors(codexHome, paths) {
     }, paths);
     return { files: files.length, bytes };
 }
-export async function historyImportSize(codexHome) {
-    const files = await rolloutFiles(path.join(path.resolve(codexHome), "sessions"));
+export async function historyImportSize(home, source = "codex") {
+    const files = await sourceFiles(source, home);
     let bytes = 0;
     for (const filename of files) {
         bytes += (await fs.stat(filename)).size;
         if (!Number.isSafeInteger(bytes)) {
-            throw new Error("Codex history size exceeds the supported limit.");
+            throw new Error(`${source} history size exceeds the supported limit.`);
         }
     }
     return { files: files.length, bytes };
@@ -557,7 +602,7 @@ async function lastCompleteRecordOffset(filename, size) {
         await handle.close();
     }
 }
-export async function rolloutFiles(root) {
+async function rolloutFiles(root) {
     const files = [];
     const pending = [root];
     while (pending.length > 0) {
@@ -587,3 +632,51 @@ export async function rolloutFiles(root) {
     }
     return files.sort();
 }
+async function directoryEntries(directory) {
+    try {
+        return await fs.readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return [];
+        throw new Error(`Could not scan Claude session directory ${directory}.`, {
+            cause: error,
+        });
+    }
+}
+export async function claudeFiles(root) {
+    const files = [];
+    for (const project of await directoryEntries(root)) {
+        if (!project.isDirectory())
+            continue;
+        const projectDirectory = path.join(root, project.name);
+        for (const entry of await directoryEntries(projectDirectory)) {
+            const filename = path.join(projectDirectory, entry.name);
+            if (entry.isFile() &&
+                /^[^/]+\.jsonl$/.test(entry.name) &&
+                !entry.name.includes(".orphaned-") &&
+                !entry.name.includes(".superseded-")) {
+                files.push(filename);
+            }
+            else if (entry.isDirectory()) {
+                const subagents = path.join(filename, "subagents");
+                for (const agent of await directoryEntries(subagents)) {
+                    if (agent.isFile() && /^agent-.+\.jsonl$/.test(agent.name))
+                        files.push(path.join(subagents, agent.name));
+                }
+            }
+            if (files.length > 10_000)
+                throw new Error("Claude session file count exceeds the scan limit.");
+        }
+    }
+    return files.sort();
+}
+export function sourceFiles(source, home) {
+    const directory = path.resolve(home);
+    if (source === "codex")
+        return rolloutFiles(path.join(directory, "sessions"));
+    if (source === "claude")
+        return claudeFiles(path.join(directory, "projects"));
+    const unhandled = source;
+    throw new Error(`Unsupported collector source: ${unhandled}`);
+}

package/dist/turn-summary.d.ts

@@ -0,0 +1,21 @@
+import { type CollectorFrictionSummary } from "iteration-trace-contracts";
+import { type CollectorConfig } from "./storage.js";
+export type TurnSummaryPaths = Readonly<{
+    directory: string;
+    script: string;
+    requests: string;
+    lines: string;
+    shown: string;
+}>;
+export declare function turnSummaryPaths(dataDirectory: string): TurnSummaryPaths;
+export declare function installTurnSummary(config: CollectorConfig): Promise<void>;
+export declare function uninstallTurnSummary(config: CollectorConfig): Promise<void>;
+export declare function turnSummaryMessage(summary: CollectorFrictionSummary): string | null;
+export declare class TurnSummaryRefreshError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare function refreshTurnSummaries(config: CollectorConfig, refreshedAt: Map<string, Readonly<{
+    directory: string;
+    atMs: number;
+}>>, nowMs: number, fetcher?: typeof fetch, signal?: AbortSignal): Promise<number>;
+export declare function turnSummaryApprovalHint(config: CollectorConfig): string;