om-memory-system 3.5.0 → 3.6.0-next.38

package/dist/importer/claude-reader.js

@@ -0,0 +1,292 @@
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { extractScopeFromContainerTag } from "../services/memory-scope.js";
+import { getTags } from "../services/tags.js";
+import { extractClaudeConversationWindows, parseClaudeTranscript, parseClaudeTranscriptLine, } from "./claude-conversation.js";
+import { resolveImportProject } from "./import-project.js";
+import { countImportableUnits, projectFilterTag, selectImportWindows, } from "./importer.js";
+/**
+ * Discovery and loading of Claude Code transcripts for the history import.
+ * Read-only: transcripts are never written.
+ *
+ * Claude Code keeps one folder per project under `~/.claude/projects/` and one
+ * `<session-id>.jsonl` file per session in it. Subagent transcripts sit one
+ * level lower (`<session-id>/subagents/*.jsonl`) and are not sessions, so the
+ * walk reads only the root and its direct sub-folders. The root may also be a
+ * single project folder or one `.jsonl` file. Symlinks are never followed.
+ *
+ * Discovery reads each file only up to its first user entry, which carries
+ * the working directory and date; units are parsed later, one session at a
+ * time.
+ */
+export const CLAUDE_HEADER_READ_LIMIT = 1024 * 1024;
+const READ_CHUNK = 64 * 1024;
+export function defaultClaudeProjectsRoot() {
+    return join(homedir(), ".claude", "projects");
+}
+/** A missing folder is an empty history. Any other read error is reported, not hidden. */
+function readEntries(dir, unreadable) {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT")
+            unreadable.push({ file: dir, reason: `unreadable: ${code ?? "error"}` });
+        return [];
+    }
+}
+function jsonlCandidate(dir, entry, keyPrefix) {
+    if (!entry.name.endsWith(".jsonl"))
+        return null;
+    const file = join(dir, entry.name);
+    if (!entry.isFile())
+        return { file, reason: "not a regular file" };
+    return { file, key: keyPrefix + entry.name };
+}
+/** `.jsonl` files in the root and in its direct sub-folders, sorted by key. */
+function listCandidates(root) {
+    const candidates = [];
+    for (const entry of readEntries(root, candidates)) {
+        if (entry.isDirectory()) {
+            const dir = join(root, entry.name);
+            for (const child of readEntries(dir, candidates)) {
+                const candidate = jsonlCandidate(dir, child, `${entry.name}/`);
+                if (candidate)
+                    candidates.push(candidate);
+            }
+            continue;
+        }
+        const candidate = jsonlCandidate(root, entry, "");
+        if (candidate)
+            candidates.push(candidate);
+    }
+    return candidates.sort((a, b) => a.file.localeCompare(b.file));
+}
+/** Read lines from the start of a file until `visit` returns true or the limit is reached. */
+function scanLines(file, visit, limit) {
+    const fd = openSync(file, "r");
+    try {
+        const decoder = new StringDecoder("utf8");
+        const buffer = Buffer.alloc(READ_CHUNK);
+        let pending = "";
+        let offset = 0;
+        while (offset < limit) {
+            const read = readSync(fd, buffer, 0, Math.min(READ_CHUNK, limit - offset), offset);
+            if (read === 0)
+                break;
+            offset += read;
+            const lines = (pending + decoder.write(buffer.subarray(0, read))).split("\n");
+            pending = lines.pop() ?? "";
+            if (lines.some(visit))
+                return;
+        }
+        if (offset < limit)
+            visit(pending + decoder.end());
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Read one file's first user entry, or say why the file is not a usable session. */
+export function readClaudeSessionHead(file, key) {
+    let head = null;
+    try {
+        scanLines(file, (line) => {
+            const parsed = parseClaudeTranscriptLine(line);
+            if (parsed.status !== "entry")
+                return false;
+            const entry = parsed.entry;
+            if (entry.type !== "user" || entry.isSidechain === true)
+                return false;
+            const timestamp = Date.parse(entry.timestamp ?? "");
+            head = {
+                file,
+                key,
+                sessionId: typeof entry.sessionId === "string" ? entry.sessionId : basename(file, ".jsonl"),
+                cwd: typeof entry.cwd === "string" ? entry.cwd : null,
+                timestamp: Number.isNaN(timestamp) ? null : timestamp,
+            };
+            return true;
+        }, CLAUDE_HEADER_READ_LIMIT);
+    }
+    catch (error) {
+        return { file, reason: `unreadable: ${error.code ?? "error"}` };
+    }
+    return head ?? { file, reason: "no user entry" };
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function discoverClaudeSessions(options = {}) {
+    const root = options.root ?? defaultClaudeProjectsRoot();
+    const sessions = [];
+    const unrecognized = [];
+    if (!existsSync(root))
+        return { sessions, unrecognized };
+    const candidates = isFile(root) ? [{ file: root, key: basename(root) }] : listCandidates(root);
+    for (const candidate of candidates) {
+        if ("reason" in candidate) {
+            unrecognized.push(candidate);
+            continue;
+        }
+        const result = readClaudeSessionHead(candidate.file, candidate.key);
+        if ("reason" in result)
+            unrecognized.push(result);
+        else
+            sessions.push(result);
+    }
+    // Chronological order, oldest first; files without a timestamp sort last.
+    sessions.sort((a, b) => (a.timestamp ?? Infinity) - (b.timestamp ?? Infinity));
+    const limited = options.maxSessions !== undefined && options.maxSessions >= 0
+        ? sessions.slice(0, options.maxSessions)
+        : sessions;
+    return { sessions: limited, unrecognized };
+}
+/** Parse one transcript into capture windows. Throws when the file cannot be read. */
+export function loadClaudeSession(file) {
+    const parsed = parseClaudeTranscript(readFileSync(file, "utf8"));
+    const first = parsed.entries.find((entry) => entry.type === "user" && entry.isSidechain !== true);
+    const withId = parsed.entries.find((entry) => typeof entry.sessionId === "string");
+    return {
+        sessionId: withId?.sessionId ?? basename(file, ".jsonl"),
+        sourceFile: file,
+        cwd: typeof first?.cwd === "string" ? first.cwd : null,
+        windows: extractClaudeConversationWindows(parsed.entries),
+        unreadableLines: parsed.unreadableLines,
+        unknownTypes: parsed.unknownTypes,
+    };
+}
+/** Let the web server and live capture run between sessions of a long read. */
+const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Discover Claude Code sessions and return them as a `LazyImportSource`. A
+ * counting pass loads each selected session once for the totals and the
+ * per-project report; `open()` loads them again one at a time, so a large
+ * history never holds every turn at once.
+ */
+export async function openClaudeHistorySource(options = {}, deps = {}) {
+    const loadSession = deps.loadSession ?? loadClaudeSession;
+    const discovery = discoverClaudeSessions({
+        ...(options.root !== undefined ? { root: options.root } : {}),
+        ...(options.maxSessions !== undefined ? { maxSessions: options.maxSessions } : {}),
+    });
+    const selectedKeys = options.selectionKeys ? new Set(options.selectionKeys) : null;
+    const projectTag = options.project ? projectFilterTag(options.project) : null;
+    const source = {
+        total: 0,
+        open: () => sessions(),
+        sessionsDiscovered: discovery.sessions.length,
+        sessionsLoaded: 0,
+        sessionsFilteredOut: 0,
+        unrecognized: discovery.unrecognized,
+        unresolvableSessions: [],
+        loadErrors: [],
+        projects: [],
+        unitsKept: 0,
+        unitsHeldBack: 0,
+        unitsUntimed: 0,
+        unreadableLines: 0,
+        unknownTypes: 0,
+    };
+    const selected = [];
+    for (const discovered of discovery.sessions) {
+        if (selectedKeys && !selectedKeys.has(discovered.key)) {
+            source.sessionsFilteredOut++;
+            continue;
+        }
+        if (options.session &&
+            discovered.sessionId !== options.session &&
+            discovered.file !== options.session) {
+            source.sessionsFilteredOut++;
+            continue;
+        }
+        const { directory } = resolveImportProject(discovered.cwd, options.pathMaps ?? []);
+        if (!directory) {
+            source.unresolvableSessions.push({ file: discovered.file, cwd: discovered.cwd });
+            continue;
+        }
+        if (projectTag && projectFilterTag(directory) !== projectTag) {
+            source.sessionsFilteredOut++;
+            continue;
+        }
+        selected.push({ file: discovered.file, directory });
+    }
+    const build = (session, directory) => {
+        const windows = selectImportWindows(session.windows, options);
+        const built = {
+            sessionId: session.sessionId,
+            directory,
+            sourceFile: session.sourceFile,
+            units: windows.kept,
+        };
+        return { built, windows };
+    };
+    // Counting pass: totals for progress and the report, one session in memory at a time.
+    const projects = new Map();
+    const counted = [];
+    for (const item of selected) {
+        if (options.signal?.aborted)
+            break;
+        let session;
+        try {
+            session = loadSession(item.file);
+        }
+        catch (error) {
+            source.loadErrors.push({ file: item.file, error: errorMessage(error) });
+            continue;
+        }
+        const { built, windows } = build(session, item.directory);
+        const tag = getTags(item.directory).project.tag;
+        const project = projects.get(tag) ?? {
+            tag,
+            hash: extractScopeFromContainerTag(tag).hash,
+            directory: item.directory,
+            sessions: 0,
+            units: 0,
+            sessionIds: new Set(),
+        };
+        project.sessionIds.add(session.sessionId);
+        project.sessions = project.sessionIds.size;
+        project.units += windows.kept.length;
+        projects.set(tag, project);
+        source.total += countImportableUnits(built, "claude-code", options);
+        source.unitsKept += windows.kept.length;
+        source.unitsHeldBack += windows.heldBack;
+        source.unitsUntimed += windows.untimed;
+        source.unreadableLines += session.unreadableLines;
+        source.unknownTypes += session.unknownTypes;
+        source.sessionsLoaded++;
+        counted.push(item);
+        await yieldToEventLoop();
+    }
+    source.projects = [...projects.values()].map(({ sessionIds: _ids, ...project }) => project);
+    async function* sessions() {
+        for (const item of counted) {
+            if (options.signal?.aborted)
+                return;
+            await yieldToEventLoop();
+            let session;
+            try {
+                session = loadSession(item.file);
+            }
+            catch (error) {
+                // The file changed or vanished after the counting pass.
+                source.loadErrors.push({ file: item.file, error: errorMessage(error) });
+                continue;
+            }
+            yield build(session, item.directory).built;
+        }
+    }
+    return source;
+}

package/dist/importer/external-backfill-models.js

@@ -1,10 +1,10 @@
 import { externalModelIssues } from "../services/ai/live-model-choice.js";
+import { hostLabel } from "../types/host-label.js";
 /** A backfill set to `external`: the external API, or an error naming the missing settings. */
 export async function resolveExternalBackfillModels(host, config, externalModels) {
     const issues = externalModelIssues(config);
-    const label = host === "pi" ? "Pi" : "OpenCode";
     if (issues.length > 0)
-        throw new Error(`${label} backfill: ${issues.join("; ")}`);
+        throw new Error(`${hostLabel(host)} backfill: ${issues.join("; ")}`);
     const select = externalModels ?? (await import("./model-selection.js")).selectImportModel;
     const external = select({});
     return {

package/dist/importer/import-args.d.ts

@@ -6,7 +6,7 @@ import type { ImportPathMap } from "./importer.js";
  * model is chosen (a session uses its host's sign-in; the CLI uses an
  * external API and key).
  */
-export type ImportHost = "pi" | "opencode";
+export type ImportHost = "pi" | "opencode" | "claude-code";
 export type ImportSurface = "session" | "cli" | "web";
 export interface HistoryImportArgs {
     help: boolean;

package/dist/importer/import-args.js

@@ -1,4 +1,8 @@
-export const SOURCE_FLAG = { pi: "--root", opencode: "--db" };
+export const SOURCE_FLAG = {
+    pi: "--root",
+    opencode: "--db",
+    "claude-code": "--root",
+};
 const CLI_ONLY_FLAGS = new Set(["--provider", "--api-url", "--api-key-env"]);
 const BOOLEAN_FLAGS = new Set([
     "--help",
@@ -209,13 +213,16 @@ export function importNeedsModel(args) {
     return !args.dryRun && (!args.skipMemories || !args.skipProfile);
 }
 export function historyImportUsage(host, surface) {
-    const name = host === "pi" ? "pi" : "opencode";
-    const invoke = surface === "session"
+    const name = host === "claude-code" ? "claude" : host;
+    // Claude Code has no session command surface, so its usage names the terminal command.
+    const invoke = surface === "session" && host !== "claude-code"
         ? `/memory-import-${name}-history`
         : `om-memory-system import-${name}-history`;
     const source = host === "pi"
         ? "  --root <dir>              Pi session root (default ~/.pi/agent/sessions)"
-        : "  --db <path>               OpenCode database (default ~/.local/share/opencode/opencode.db)";
+        : host === "claude-code"
+            ? "  --root <dir>              Claude Code transcripts folder (default ~/.claude/projects)"
+            : "  --db <path>               OpenCode database (default ~/.local/share/opencode/opencode.db)";
     const model = surface === "session"
         ? `  --model <provider/id>     Use another signed-in model (default: this session's model)`
         : `  --model <id>              Model id (default: saved memoryModel)

package/dist/importer/import-readiness.d.ts

@@ -1,3 +1,4 @@
+import type { ImportHost } from "./import-args.js";
 /**
  * What a real web import could use right now, checked inside the OpenCode
  * process that runs it. `env://` and `file://` keys were resolved when the
@@ -23,6 +24,16 @@ export interface ImportReadiness {
         available: boolean;
         reason?: string;
     };
+    /**
+     * The Claude Code reader ships with OMMS, so it is always available. Its
+     * imports have no session model and always use the external API.
+     */
+    claudeCode: {
+        available: true;
+        defaultRoot: string;
+        defaultRootFound: boolean;
+        modelChoices: ["external"];
+    };
 }
 export interface ReadinessDeps {
     supportedProviders?: () => Promise<string[]>;
@@ -35,13 +46,14 @@ export interface ReadinessDeps {
         }>;
     }>;
     loadPiSdk?: () => Promise<unknown>;
+    claudeRoot?: () => string;
 }
 /** Mirrors the checks in `selectImportModel`, without building a provider. */
 export declare function externalApiState(supportedProviders?: () => Promise<string[]>): Promise<ExternalApiState>;
 export declare function importReadiness(deps?: ReadinessDeps): Promise<ImportReadiness>;
 /** Why a job cannot start, or `null` when it can. */
 export declare function importBlockedReason(readiness: ImportReadiness, request: {
-    host: "pi" | "opencode";
+    host: ImportHost;
     needsModel: boolean;
     modelChoice?: string;
 }): string | null;

package/dist/importer/import-readiness.js

@@ -1,4 +1,6 @@
+import { existsSync } from "node:fs";
 import { CONFIG } from "../config.js";
+import { defaultClaudeSourcePath } from "./import-sources.js";
 const EXTERNAL_REASONS = {
     "missing-model": "The external API has no memoryModel in the global config",
     "missing-url": "The external API has no memoryApiUrl in the global config",
@@ -35,6 +37,15 @@ export async function importReadiness(deps = {}) {
         external: { state, provider: CONFIG.memoryProvider, model: CONFIG.memoryModel ?? null },
         opencode: { available: opencode.available, models: opencode.models ?? [] },
         piReader,
+        claudeCode: claudeReadiness(deps.claudeRoot?.() ?? defaultClaudeSourcePath()),
+    };
+}
+function claudeReadiness(defaultRoot) {
+    return {
+        available: true,
+        defaultRoot,
+        defaultRootFound: existsSync(defaultRoot),
+        modelChoices: ["external"],
     };
 }
 /** Why a job cannot start, or `null` when it can. */
@@ -44,6 +55,14 @@ export function importBlockedReason(readiness, request) {
     }
     if (!request.needsModel)
         return null;
+    if (request.host === "claude-code") {
+        // Claude Code has no host models to offer.
+        if (request.modelChoice !== undefined && request.modelChoice !== "external") {
+            return "Claude Code imports use the external API";
+        }
+        const state = readiness.external.state;
+        return state === "ready" ? null : EXTERNAL_REASONS[state];
+    }
     if (!request.modelChoice)
         return "Choose an import model";
     if (request.modelChoice === "external") {

package/dist/importer/import-runs.js

@@ -16,7 +16,7 @@ async function table(storagePath) {
     samples TEXT, paused INTEGER NOT NULL DEFAULT 0
   )`);
     // A row per host keeps every later statement a plain UPDATE.
-    await db.run("INSERT OR IGNORE INTO import_runs (host) VALUES ('pi'), ('opencode')");
+    await db.run("INSERT OR IGNORE INTO import_runs (host) VALUES ('pi'), ('opencode'), ('claude-code')");
     return db;
 }
 const count = (value) => (Number.isSafeInteger(value) && value >= 0 ? value : 0);

package/dist/importer/import-sessions.d.ts

@@ -9,7 +9,10 @@ import type { ImportPathMap } from "./importer.js";
  */
 export declare const MAX_SELECTED_KEYS = 1000;
 export interface ImportSessionRow {
-    /** Selection key: the OpenCode session ID, or the Pi file path relative to the source. */
+    /**
+     * Selection key: the OpenCode session ID, or the Pi or Claude Code file path
+     * relative to the source.
+     */
     key: string;
     sessionId: string | null;
     createdAt: number | null;

package/dist/importer/import-sessions.js

@@ -27,6 +27,17 @@ async function readRows(identity, options, snapshotMode) {
             ...resolveImportProject(session.cwd, options.pathMaps),
         }));
     }
+    if (options.host === "claude-code") {
+        // The reader loads the storage engine, so it stays out of this module's static imports.
+        const { discoverClaudeSessions } = await import("./claude-reader.js");
+        return discoverClaudeSessions({ root: identity.realPath }).sessions.map((session) => ({
+            key: session.key,
+            sessionId: session.sessionId,
+            createdAt: session.timestamp,
+            recordedDirectory: session.cwd,
+            ...resolveImportProject(session.cwd, options.pathMaps),
+        }));
+    }
     const { openOpencodeHistory } = await import("./opencode-reader.js");
     const history = await openOpencodeHistory(identity.realPath, {}, { shared: { key: importSourceKey(identity), mode: snapshotMode } });
     try {
@@ -87,8 +98,9 @@ export function validateSessionListRequest(value) {
     const input = value;
     if (!input || typeof input !== "object")
         throw new Error("Invalid session list request");
-    if (input.host !== "pi" && input.host !== "opencode")
-        throw new Error("Choose Pi or OpenCode");
+    if (input.host !== "pi" && input.host !== "opencode" && input.host !== "claude-code") {
+        throw new Error("Choose Pi, OpenCode, or Claude Code");
+    }
     const scope = input.scope ?? "current-project";
     if (scope !== "current-project" && scope !== "all-projects")
         throw new Error("Invalid scope");

package/dist/importer/import-sources.d.ts

@@ -4,7 +4,7 @@ import type { ImportHost } from "./import-args.js";
  * file: it names a server-side path, the server checks it once, and later
  * requests carry a signed token that pins the real path, device, and inode.
  */
-export type ImportSourceKind = "pi-folder" | "pi-file" | "opencode-db";
+export type ImportSourceKind = "pi-folder" | "pi-file" | "opencode-db" | "claude-projects";
 export interface ImportSourceIdentity {
     host: ImportHost;
     kind: ImportSourceKind;
@@ -22,6 +22,12 @@ export declare function readImportSourceToken(token: unknown, host: ImportHost):
 export declare function importSourceKey(identity: ImportSourceIdentity): string;
 /** Refuse a source whose path now names another file, such as a swapped-in symlink. */
 export declare function assertImportSourceUnchanged(identity: ImportSourceIdentity): void;
+/**
+ * Same folder as `defaultClaudeProjectsRoot()` in `claude-reader.ts`. That
+ * module loads the storage engine, so this light module keeps its own copy;
+ * `tests/import-sources.test.ts` checks that the two agree.
+ */
+export declare function defaultClaudeSourcePath(): string;
 export declare function defaultImportSourcePath(host: ImportHost): string;
 export interface ValidatedImportSource {
     kind: ImportSourceKind;
@@ -37,7 +43,7 @@ export interface BrowseEntry {
 }
 /**
  * One folder at a time, with no recursion: subfolders and files the host can
- * import. Symlinked entries are hidden. Only offered on loopback binds.
+ * import. A Claude Code source is always a folder, so it lists folders only. Symlinked entries are hidden. Only offered on loopback binds.
  */
 export declare function browseImportSources(host: ImportHost, path?: unknown): {
     path: string;

package/dist/importer/import-sources.js

@@ -32,7 +32,7 @@ export function readImportSourceToken(token, host) {
     }
     const identity = JSON.parse(Buffer.from(payload, "base64url").toString());
     if (identity.host !== host)
-        throw new ImportSourceError("The source belongs to the other host");
+        throw new ImportSourceError("The source belongs to another host");
     return identity;
 }
 /** Stable key for sharing snapshots and computing revisions. */
@@ -79,8 +79,20 @@ function isSqliteFile(path) {
         closeSync(fd);
     }
 }
+/**
+ * Same folder as `defaultClaudeProjectsRoot()` in `claude-reader.ts`. That
+ * module loads the storage engine, so this light module keeps its own copy;
+ * `tests/import-sources.test.ts` checks that the two agree.
+ */
+export function defaultClaudeSourcePath() {
+    return join(homedir(), ".claude", "projects");
+}
 export function defaultImportSourcePath(host) {
-    return host === "pi" ? DEFAULT_PI_SESSION_ROOT : DEFAULT_OPENCODE_DB;
+    if (host === "pi")
+        return DEFAULT_PI_SESSION_ROOT;
+    if (host === "claude-code")
+        return defaultClaudeSourcePath();
+    return DEFAULT_OPENCODE_DB;
 }
 /** Check an absolute path's kind and format; never returns file contents. */
 export function validateImportSource(host, path) {
@@ -99,6 +111,11 @@ export function validateImportSource(host, path) {
         else
             throw new ImportSourceError("Choose a Pi sessions folder or one .jsonl session file");
     }
+    else if (host === "claude-code") {
+        if (!info.isDirectory())
+            throw new ImportSourceError("Choose a Claude Code transcripts folder");
+        kind = "claude-projects";
+    }
     else {
         if (!info.isFile() || !isSqliteFile(realPath)) {
             throw new ImportSourceError("Choose an OpenCode database file");
@@ -111,12 +128,12 @@ export function validateImportSource(host, path) {
 const BROWSE_LIMIT = 500;
 /**
  * One folder at a time, with no recursion: subfolders and files the host can
- * import. Symlinked entries are hidden. Only offered on loopback binds.
+ * import. A Claude Code source is always a folder, so it lists folders only. Symlinked entries are hidden. Only offered on loopback binds.
  */
 export function browseImportSources(host, path) {
     let start = path;
     if (start === undefined || start === null || start === "") {
-        const preferred = host === "pi" ? DEFAULT_PI_SESSION_ROOT : dirname(DEFAULT_OPENCODE_DB);
+        const preferred = host === "opencode" ? dirname(DEFAULT_OPENCODE_DB) : defaultImportSourcePath(host);
         start = existsSync(preferred) ? preferred : homedir();
     }
     const folder = checkedPath(start);

package/dist/importer/map-suggestions.d.ts

@@ -36,4 +36,5 @@ export declare function directoryMapsView(options?: {
     saved: import("./importer.js").ImportPathMap[];
     pi: SuggestedDirectory[];
     opencode: SuggestedDirectory[];
+    "claude-code": SuggestedDirectory[];
 }>;

package/dist/importer/map-suggestions.js

@@ -129,5 +129,10 @@ export async function directoryMapsView(options = {}) {
             ...(name === "opencode" ? { opencodeWorktree: (dir) => worktrees.get(dir) } : {}),
         });
     };
-    return { saved: CONFIG.importPathMaps, pi: await host("pi"), opencode: await host("opencode") };
+    return {
+        saved: CONFIG.importPathMaps,
+        pi: await host("pi"),
+        opencode: await host("opencode"),
+        "claude-code": await host("claude-code"),
+    };
 }

package/dist/importer/run-import.js

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { hostLabel } from "../types/host-label.js";
 const dryRunCapture = {
     summarize: async () => {
         throw new Error("A dry-run cannot call the capture model");
@@ -7,7 +8,7 @@ const dryRunCapture = {
 /** Another process or surface holds this host's import lock. */
 export class ImportAlreadyRunningError extends Error {
     constructor(host) {
-        super(`${host === "pi" ? "A Pi" : "An OpenCode"} import is already running`);
+        super(`${host === "opencode" ? "An" : "A"} ${hostLabel(host)} import is already running`);
         this.name = "ImportAlreadyRunningError";
     }
 }
@@ -120,10 +121,7 @@ async function runUntracked(host, args, run) {
             ...(run.models.profile ? { profileModel: run.models.profile } : {}),
         });
     }
-    const { importPiHistory } = await import("./importer.js");
-    const { loadPiSessionForImport } = await import("./session-loader.js");
-    return importPiHistory({
-        loadSession: loadPiSessionForImport,
+    const deps = {
         provider: capture,
         ...(run.onProgress ? { onProgress: run.onProgress } : {}),
         ...(run.signal ? { signal: run.signal } : {}),
@@ -135,7 +133,8 @@ async function runUntracked(host, args, run) {
                 },
             }
             : {}),
-    }, {
+    };
+    const filters = {
         scope: args.scope,
         currentDirectory: project ?? run.cwd,
         ...(args.session ? { session: args.session } : {}),
@@ -148,13 +147,18 @@ async function runUntracked(host, args, run) {
         dryRun: args.dryRun,
         skipMemories: args.skipMemories,
         pathMaps,
-    });
+    };
+    if (host === "claude-code") {
+        const { importClaudeHistory } = await import("./claude-import.js");
+        return importClaudeHistory(deps, filters);
+    }
+    const { importPiHistory } = await import("./importer.js");
+    const { loadPiSessionForImport } = await import("./session-loader.js");
+    return importPiHistory({ ...deps, loadSession: loadPiSessionForImport }, filters);
 }
 /** The same plain-text report for every host and surface. */
 export function formatHistoryImportReport(host, report, model) {
-    const lines = [
-        `${host === "pi" ? "Pi" : "OpenCode"} history import${report.dryRun ? " (dry-run)" : ""}`,
-    ];
+    const lines = [`${hostLabel(host)} history import${report.dryRun ? " (dry-run)" : ""}`];
     if (model)
         lines.push(`  model: ${model}`);
     lines.push(`  sessions: ${report.sessionsLoaded}/${report.sessionsDiscovered} loaded, ${report.sessionsFilteredOut} filtered out` +