@groundtrack/hooks 0.1.8 → 0.1.10

package/dist/session-import/opencode.js

@@ -0,0 +1,230 @@
+import { isSessionRecord, sessionString, } from "./canonical.js";
+import { containsInternalInstructionText, redactCredentialText, sanitizeSessionValue, sanitizeWorkingDirectory, } from "./redaction.js";
+function unixMillisecondsDate(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function messageTimestamp(message) {
+    const info = isSessionRecord(message.info) ? message.info : {};
+    const time = isSessionRecord(info.time) ? info.time : {};
+    return (unixMillisecondsDate(time.completed)?.toISOString() ??
+        unixMillisecondsDate(time.created)?.toISOString() ??
+        null);
+}
+export function parseOpenCodeSessionExport(value) {
+    if (!isSessionRecord(value) || !isSessionRecord(value.info) || !Array.isArray(value.messages))
+        return null;
+    const externalSessionId = sessionString(value.info.id);
+    if (!externalSessionId)
+        return null;
+    const time = isSessionRecord(value.info.time) ? value.info.time : {};
+    const startedAt = unixMillisecondsDate(time.created);
+    const endedAt = unixMillisecondsDate(time.updated);
+    return {
+        metadata: {
+            externalSessionId,
+            timestamp: endedAt ?? startedAt,
+            cwd: sessionString(value.info.directory),
+            repositoryUrl: null,
+            repositoryBranch: null,
+            repositoryCommitSha: null,
+            originator: "opencode",
+            isSubagent: sessionString(value.info.parentID) !== null,
+            startedAt,
+            endedAt,
+        },
+        records: [
+            {
+                type: "opencode_session",
+                timestamp: startedAt?.toISOString() ?? null,
+                info: {
+                    id: value.info.id,
+                    directory: value.info.directory,
+                    model: value.info.model,
+                    version: value.info.version,
+                },
+            },
+            ...value.messages.map((message) => isSessionRecord(message)
+                ? {
+                    type: "opencode_message",
+                    timestamp: messageTimestamp(message),
+                    info: message.info,
+                    parts: message.parts,
+                }
+                : message),
+        ],
+    };
+}
+function timestampIso(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function modelName(value) {
+    if (typeof value === "string")
+        return value || null;
+    if (!isSessionRecord(value))
+        return null;
+    const provider = sessionString(value.providerID);
+    const model = sessionString(value.modelID) ?? sessionString(value.id);
+    return provider && model ? `${provider}/${model}` : model;
+}
+function containsInternalInstructions(value) {
+    if (typeof value === "string")
+        return containsInternalInstructionText(value);
+    if (Array.isArray(value))
+        return value.some(containsInternalInstructions);
+    if (!isSessionRecord(value))
+        return false;
+    return Object.values(value).some(containsInternalInstructions);
+}
+function redactHomePaths(value) {
+    if (typeof value === "string")
+        return value
+            .replace(/\/Users\/[^/\s"'`]+/g, "~")
+            .replace(/\/home\/[^/\s"'`]+/g, "~")
+            .replace(/[A-Za-z]:\\Users\\[^\\\s"'`]+/gi, "~");
+    if (Array.isArray(value))
+        return value.map(redactHomePaths);
+    if (!isSessionRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, redactHomePaths(nested)]));
+}
+function sanitizeOpenCodeValue(value) {
+    return redactHomePaths(sanitizeSessionValue(value));
+}
+function safeValue(value) {
+    return containsInternalInstructions(value)
+        ? "[REDACTED INTERNAL INSTRUCTIONS]"
+        : sanitizeOpenCodeValue(value);
+}
+function partTimestamp(part, key, fallback) {
+    const state = isSessionRecord(part.state) ? part.state : {};
+    const time = isSessionRecord(state.time) ? state.time : {};
+    return timestampIso(time[key]) ?? fallback;
+}
+function normalizeOpenCodeMessage(record, entryBudget) {
+    const info = isSessionRecord(record.info) ? record.info : null;
+    const role = info ? sessionString(info.role) : null;
+    if (!info || (role !== "user" && role !== "assistant") || !Array.isArray(record.parts))
+        return { entries: [], sensitive: false, unsupported: true };
+    const occurredAt = sessionString(record.timestamp);
+    const entries = [];
+    let sensitive = false;
+    let unsupported = false;
+    for (const part of record.parts) {
+        if (entries.length > entryBudget)
+            break;
+        if (!isSessionRecord(part)) {
+            unsupported = true;
+            continue;
+        }
+        const type = sessionString(part.type);
+        if (type === "reasoning" || type === "file" || type === "patch" || type === "snapshot") {
+            sensitive = true;
+            continue;
+        }
+        if (type === "text") {
+            const text = sessionString(part.text);
+            if (!text || part.ignored === true)
+                continue;
+            if (part.synthetic === true || containsInternalInstructionText(text))
+                sensitive = true;
+            else
+                entries.push({
+                    kind: role === "user" ? "user_message" : "assistant_message",
+                    occurredAt,
+                    payload: { text: sanitizeOpenCodeValue(text) },
+                });
+            continue;
+        }
+        if (type === "tool" && role === "assistant") {
+            const toolName = sessionString(part.tool);
+            const state = isSessionRecord(part.state) ? part.state : null;
+            if (!toolName || !state) {
+                unsupported = true;
+                continue;
+            }
+            const inputContainsInternalInstructions = containsInternalInstructions(state.input);
+            sensitive ||= inputContainsInternalInstructions;
+            entries.push({
+                kind: "tool_call",
+                occurredAt: partTimestamp(part, "start", occurredAt),
+                payload: {
+                    callId: sessionString(part.callID),
+                    toolName: redactCredentialText(toolName),
+                    input: inputContainsInternalInstructions
+                        ? "[REDACTED INTERNAL INSTRUCTIONS]"
+                        : sanitizeOpenCodeValue(state.input),
+                },
+            });
+            const status = sessionString(state.status);
+            if (status === "completed" || status === "error") {
+                const output = status === "completed" ? state.output : state.error;
+                const outputContainsInternalInstructions = containsInternalInstructions(output);
+                sensitive ||= outputContainsInternalInstructions;
+                entries.push({
+                    kind: "tool_result",
+                    occurredAt: partTimestamp(part, "end", occurredAt),
+                    payload: {
+                        callId: sessionString(part.callID),
+                        output: safeValue(output),
+                        ...(status === "error" ? { isError: true } : {}),
+                    },
+                });
+            }
+            continue;
+        }
+        if (type === "step-start" ||
+            type === "step-finish" ||
+            type === "retry" ||
+            type === "compaction")
+            continue;
+        if (type === "subtask" || type === "agent")
+            sensitive = true;
+        else
+            unsupported = true;
+    }
+    const overflowed = entries.length > entryBudget;
+    return {
+        entries: overflowed ? entries.slice(0, entryBudget) : entries,
+        sensitive,
+        unsupported,
+        overflowed,
+    };
+}
+export function createOpenCodeSessionNormalizer(metadata) {
+    let model = null;
+    return {
+        normalizeRecord: (record, entryBudget = Number.POSITIVE_INFINITY) => {
+            if (record.type === "opencode_session") {
+                const info = isSessionRecord(record.info) ? record.info : {};
+                model ??= modelName(info.model);
+                return { entries: [], sensitive: false, unsupported: false };
+            }
+            if (record.type !== "opencode_message")
+                return { entries: [], sensitive: false, unsupported: true };
+            const info = isSessionRecord(record.info) ? record.info : {};
+            const provider = sessionString(info.providerID);
+            const modelId = sessionString(info.modelID);
+            model ??= provider && modelId ? `${provider}/${modelId}` : modelId;
+            return normalizeOpenCodeMessage(record, entryBudget);
+        },
+        canonicalMetadata: () => metadata
+            ? {
+                type: "session",
+                version: 1,
+                externalSessionId: metadata.externalSessionId,
+                repositoryUrl: metadata.repositoryUrl,
+                repositoryBranch: metadata.repositoryBranch,
+                repositoryCommitSha: metadata.repositoryCommitSha,
+                workingDirectory: sanitizeWorkingDirectory(metadata.cwd),
+                originator: "opencode",
+                model: model ? redactCredentialText(model) : null,
+            }
+            : null,
+    };
+}

package/dist/session-import/prune.d.ts

@@ -0,0 +1,14 @@
+import type { SessionImportFormat } from "./format.js";
+import type { AgentSessionMetadata, AgentSessionPlan, PrunedAgentSession } from "./types.js";
+export declare function pruneSession(path: string, format: SessionImportFormat): Promise<PrunedAgentSession>;
+export declare function pruneSession(path: string, format: SessionImportFormat, options: Readonly<{
+    metadata: AgentSessionMetadata;
+}>): Promise<PrunedAgentSession>;
+export declare function pruneSession(path: string, format: SessionImportFormat, options: Readonly<{
+    emitBytes: false;
+    metadata?: AgentSessionMetadata;
+}>): Promise<AgentSessionPlan>;
+export declare function pruneSession(path: string, format: SessionImportFormat, options: Readonly<{
+    plan: AgentSessionPlan;
+    metadata?: AgentSessionMetadata;
+}>): Promise<PrunedAgentSession>;

package/dist/session-import/prune.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createInterface } from "node:readline";
+import { Transform } from "node:stream";
+import { CANONICAL_IMPORT_MAX_RECORD_BYTES } from "./canonical.js";
+import { createSessionNormalizationAccumulator } from "./normalize.js";
+async function scanSession(path, format, discoveryMetadata, onEntry) {
+    const before = await stat(path);
+    const hash = createHash("sha256");
+    if (discoveryMetadata && format.sourceHashSeed)
+        hash.update(`${format.sourceHashSeed(discoveryMetadata)}\0`);
+    const encoder = new TextEncoder();
+    let entryBytes = 0;
+    const accumulator = createSessionNormalizationAccumulator(format.createNormalizer(discoveryMetadata), {
+        discoveryMetadata,
+        onEntry: (entry) => {
+            const bytes = encoder.encode(`${JSON.stringify(entry)}\n`);
+            if (bytes.byteLength > CANONICAL_IMPORT_MAX_RECORD_BYTES)
+                throw new Error(`Canonical session record is too large: ${path}`);
+            onEntry?.(bytes);
+            entryBytes += bytes.byteLength;
+        },
+    });
+    const hashingStream = new Transform({
+        transform(chunk, _encoding, callback) {
+            hash.update(chunk);
+            callback(null, chunk);
+        },
+    });
+    const input = createReadStream(path);
+    input.pipe(hashingStream);
+    const lines = createInterface({ input: hashingStream, crlfDelay: Infinity });
+    for await (const line of lines) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            record = null;
+        }
+        accumulator.add(record);
+    }
+    const after = await stat(path);
+    if (before.size !== after.size || before.mtimeMs !== after.mtimeMs)
+        throw new Error(`Session changed while it was being read: ${path}`);
+    const header = accumulator.finish().metadata;
+    const headerBytes = encoder.encode(`${JSON.stringify(header)}\n`);
+    if (headerBytes.byteLength > CANONICAL_IMPORT_MAX_RECORD_BYTES)
+        throw new Error(`Canonical session metadata is too large: ${path}`);
+    return {
+        sourceContentHash: hash.digest("hex"),
+        originalBytes: before.size,
+        prunedBytes: headerBytes.byteLength + entryBytes,
+        metadata: header,
+    };
+}
+export async function pruneSession(path, format, options = {}) {
+    if (options.emitBytes === false)
+        return scanSession(path, format, options.metadata);
+    const plan = options.plan ?? (await scanSession(path, format, options.metadata));
+    const encoder = new TextEncoder();
+    const headerBytes = encoder.encode(`${JSON.stringify(plan.metadata)}\n`);
+    const bytes = new Uint8Array(plan.prunedBytes);
+    bytes.set(headerBytes);
+    let offset = headerBytes.byteLength;
+    const rendered = await scanSession(path, format, options.metadata, (entry) => {
+        if (offset + entry.byteLength > bytes.byteLength)
+            throw new Error(`Session changed after it was analyzed: ${path}`);
+        bytes.set(entry, offset);
+        offset += entry.byteLength;
+    });
+    if (offset !== bytes.byteLength ||
+        rendered.sourceContentHash !== plan.sourceContentHash ||
+        rendered.prunedBytes !== plan.prunedBytes ||
+        JSON.stringify(rendered.metadata) !== JSON.stringify(plan.metadata))
+        throw new Error(`Session changed after it was analyzed: ${path}`);
+    return {
+        sourceContentHash: plan.sourceContentHash,
+        originalBytes: plan.originalBytes,
+        prunedBytes: plan.prunedBytes,
+        bytes,
+    };
+}

package/dist/session-import/receipts.d.ts

@@ -0,0 +1,21 @@
+import type { SetupEnvironment } from "../setup/agents.js";
+import type { AgentSessionSource, ImportVisibility } from "./types.js";
+type Receipt = Readonly<{
+    sessionId: string;
+    importedAt: string;
+}>;
+type ReceiptFile = {
+    version: 1;
+    receipts: Record<string, Receipt>;
+};
+export declare function receiptPath(context: SetupEnvironment): string;
+export declare function readReceipts(context: SetupEnvironment): ReceiptFile;
+export declare function receiptKey(input: {
+    apiBaseUrl: string;
+    apiKey: string;
+    source: AgentSessionSource;
+    sourceContentHash: string;
+    visibility: ImportVisibility;
+}): string;
+export declare function saveReceipt(context: SetupEnvironment, file: ReceiptFile, key: string, sessionId: string): void;
+export {};

package/dist/session-import/receipts.js

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { readJson } from "../setup/config.js";
+import { readFile, writeAtomic } from "../setup/files.js";
+import { stateDir } from "../setup/agents.js";
+import { CANONICALIZATION_VERSION } from "./canonical.js";
+export function receiptPath(context) {
+    return join(stateDir(context), "session-import-receipts.json");
+}
+export function readReceipts(context) {
+    const text = readFile(receiptPath(context));
+    if (text === null)
+        return { version: 1, receipts: {} };
+    const value = readJson(text);
+    if (value.version !== 1 || !value.receipts || typeof value.receipts !== "object")
+        throw new Error("Groundtrack's session import receipt file is invalid.");
+    const receipts = {};
+    for (const [key, receipt] of Object.entries(value.receipts)) {
+        if (receipt &&
+            typeof receipt === "object" &&
+            "sessionId" in receipt &&
+            typeof receipt.sessionId === "string" &&
+            "importedAt" in receipt &&
+            typeof receipt.importedAt === "string")
+            receipts[key] = { sessionId: receipt.sessionId, importedAt: receipt.importedAt };
+    }
+    return { version: 1, receipts };
+}
+export function receiptKey(input) {
+    return createHash("sha256")
+        .update([
+        input.apiBaseUrl,
+        createHash("sha256").update(input.apiKey).digest("hex"),
+        input.source,
+        CANONICALIZATION_VERSION,
+        input.visibility,
+        input.sourceContentHash,
+    ].join("\0"))
+        .digest("hex");
+}
+export function saveReceipt(context, file, key, sessionId) {
+    file.receipts[key] = { sessionId, importedAt: new Date().toISOString() };
+    writeAtomic(receiptPath(context), `${JSON.stringify(file, null, 2)}\n`, 0o600);
+}

package/dist/session-import/redaction.d.ts

@@ -0,0 +1,6 @@
+export declare function redactCredentialText(value: string): string;
+export declare function sanitizeRepositoryUrl(value: unknown): string | null;
+export declare function sanitizeWorkingDirectory(value: unknown): string | null;
+export declare function sanitizeSessionValue(value: string): string;
+export declare function sanitizeSessionValue(value: unknown): unknown;
+export declare function containsInternalInstructionText(value: string): boolean;

package/dist/session-import/redaction.js

@@ -0,0 +1,61 @@
+const sensitiveKeyPattern = /(?:^|[_-])(?:api[_-]?key|token|authorization|auth|password|passwd|secret|private[_-]?key|cookie|credentials?)(?:$|[_-])/i;
+const internalInstructionMarkers = [
+    "<local-command-caveat>",
+    "<system-reminder>",
+    "<environment_context>",
+    "<recommended_plugins>",
+    "# AGENTS.md instructions",
+    "<permissions instructions>",
+    "<skills_instructions>",
+    "<app-context>",
+];
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isSensitiveKey(value) {
+    return sensitiveKeyPattern.test(value.replace(/([a-z0-9])([A-Z])/g, "$1_$2"));
+}
+export function redactCredentialText(value) {
+    return value
+        .replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "[REDACTED PRIVATE KEY]")
+        .replace(/\b(authorization\s*:\s*(?:bearer|basic)\s+)[^\s,;]+/gi, "$1[REDACTED]")
+        .replace(/\b((?:[a-z0-9_-]*(?:api[_-]?key|token|password|passwd|secret|private[_-]?key|credentials?))\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]")
+        .replace(/(?:^|\s)((?:--)?(?:api-key|token|password|secret)\s+)[^\s,;]+/gi, "$1$2[REDACTED]")
+        .replace(/\b(?:sk-[A-Za-z0-9_-]{16,}|ghp_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{12,})\b/g, "[REDACTED]");
+}
+export function sanitizeRepositoryUrl(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return null;
+    try {
+        const url = new URL(value);
+        url.username = "";
+        url.password = "";
+        return url.toString();
+    }
+    catch {
+        return redactCredentialText(value);
+    }
+}
+export function sanitizeWorkingDirectory(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return null;
+    return redactCredentialText(value)
+        .replace(/^\/Users\/[^/]+(?=\/|$)/, "~")
+        .replace(/^\/home\/[^/]+(?=\/|$)/, "~")
+        .replace(/^[A-Za-z]:\\Users\\[^\\]+(?=\\|$)/i, "~");
+}
+export function sanitizeSessionValue(value) {
+    if (typeof value === "string")
+        return redactCredentialText(value);
+    if (Array.isArray(value))
+        return value.map(sanitizeSessionValue);
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, nested]) => [
+        key,
+        isSensitiveKey(key) ? "[REDACTED]" : sanitizeSessionValue(nested),
+    ]));
+}
+export function containsInternalInstructionText(value) {
+    return internalInstructionMarkers.some((marker) => value.includes(marker));
+}

package/dist/session-import/types.d.ts

@@ -0,0 +1,42 @@
+import type { AgentSessionSource, SessionImportAgent } from "../agents.js";
+import type { CanonicalSessionMetadata } from "./canonical.js";
+export type ImportVisibility = "private" | "organization";
+export type ImportAgent = SessionImportAgent;
+export type { AgentSessionSource };
+export type AgentSessionMetadata = Readonly<{
+    externalSessionId: string;
+    timestamp: Date | null;
+    cwd: string | null;
+    repositoryUrl: string | null;
+    repositoryBranch: string | null;
+    repositoryCommitSha: string | null;
+    originator: string | null;
+    isSubagent: boolean;
+    startedAt?: Date | null;
+    endedAt?: Date | null;
+}>;
+export type AgentSessionCandidate = Readonly<{
+    path: string;
+    metadata: AgentSessionMetadata;
+    modifiedAt?: Date;
+}>;
+export type DiscoverySkipReason = "invalid_metadata" | "live" | "subagent" | "before_since" | "other_repository" | "unscoped" | "empty_trace" | "missing_metadata" | "workspace_mismatch" | "conflicting_duplicates";
+export type SkippedAgentSession = Readonly<{
+    path: string;
+    reason: DiscoverySkipReason;
+}>;
+export type FailedAgentSession = Readonly<{
+    path: string;
+    error: string;
+}>;
+export type AgentSessionAnalysis = Readonly<{
+    sourceContentHash: string;
+    originalBytes: number;
+    prunedBytes: number;
+}>;
+export type AgentSessionPlan = AgentSessionAnalysis & Readonly<{
+    metadata: CanonicalSessionMetadata;
+}>;
+export type PrunedAgentSession = AgentSessionAnalysis & Readonly<{
+    bytes: Uint8Array<ArrayBuffer>;
+}>;

package/dist/session-import/types.js

@@ -0,0 +1 @@
+export {};

package/dist/setup/agents.d.ts

@@ -25,6 +25,15 @@ export declare function discoverAgents(context: SetupEnvironment, url?: string):
     aliases: readonly ["claude-code"];
     source: "claude_code";
     enrichment: "command";
+    sessionImport: {
+        readonly cli: true;
+        readonly web: {
+            readonly extension: ".jsonl";
+            readonly accept: ".jsonl";
+            readonly fileLabel: "Claude Code session JSONL";
+            readonly location: "~/.claude/projects/<project>/*.jsonl";
+        };
+    };
     detected: boolean;
     configured: boolean;
     issue: string | null;
@@ -34,6 +43,15 @@ export declare function discoverAgents(context: SetupEnvironment, url?: string):
     aliases: readonly [];
     source: "codex";
     enrichment: "command";
+    sessionImport: {
+        readonly cli: true;
+        readonly web: {
+            readonly extension: ".jsonl";
+            readonly accept: ".jsonl";
+            readonly fileLabel: "Codex rollout JSONL";
+            readonly location: "~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl";
+        };
+    };
     detected: boolean;
     configured: boolean;
     issue: string | null;
@@ -43,6 +61,10 @@ export declare function discoverAgents(context: SetupEnvironment, url?: string):
     aliases: readonly [];
     source: "cursor";
     enrichment: "command";
+    sessionImport: {
+        readonly cli: true;
+        readonly web: null;
+    };
     detected: boolean;
     configured: boolean;
     issue: string | null;
@@ -52,6 +74,16 @@ export declare function discoverAgents(context: SetupEnvironment, url?: string):
     aliases: readonly [];
     source: "opencode";
     enrichment: "plugin";
+    sessionImport: {
+        readonly cli: true;
+        readonly web: {
+            readonly extension: ".json";
+            readonly accept: ".json,application/json";
+            readonly fileLabel: "OpenCode session export JSON";
+            readonly location: "opencode export <session-id> --pure > opencode-session.json";
+            readonly note: "Use direct file redirection as shown. Do not add --sanitize; Groundtrack removes sensitive records during import.";
+        };
+    };
     detected: boolean;
     configured: boolean;
     issue: string | null;

package/dist/setup/cli.js

@@ -17,6 +17,7 @@ Usage:
   groundtrack setup --all-detected --yes     Configure detected agents
   groundtrack status                       Check selected agents
   groundtrack doctor [--fix]                Check or repair using the same flow
+  groundtrack import [options]              Import local coding-agent sessions
   groundtrack version
 
 Options:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groundtrack/hooks",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Lifecycle hook utilities for Groundtrack MCP clients.",
   "keywords": [
     "claude-code",
@@ -41,6 +41,48 @@
       "workerd": "./src/agents.ts",
       "development": "./src/agents.ts",
       "default": "./dist/agents.js"
+    },
+    "./session-import/redaction": {
+      "types": "./src/session-import/redaction.ts",
+      "browser": "./src/session-import/redaction.ts",
+      "workerd": "./src/session-import/redaction.ts",
+      "development": "./src/session-import/redaction.ts",
+      "default": "./dist/session-import/redaction.js"
+    },
+    "./session-import/codex": {
+      "types": "./src/session-import/codex.ts",
+      "browser": "./src/session-import/codex.ts",
+      "workerd": "./src/session-import/codex.ts",
+      "development": "./src/session-import/codex.ts",
+      "default": "./dist/session-import/codex.js"
+    },
+    "./session-import/canonical": {
+      "types": "./src/session-import/canonical.ts",
+      "browser": "./src/session-import/canonical.ts",
+      "workerd": "./src/session-import/canonical.ts",
+      "development": "./src/session-import/canonical.ts",
+      "default": "./dist/session-import/canonical.js"
+    },
+    "./session-import/claude": {
+      "types": "./src/session-import/claude.ts",
+      "browser": "./src/session-import/claude.ts",
+      "workerd": "./src/session-import/claude.ts",
+      "development": "./src/session-import/claude.ts",
+      "default": "./dist/session-import/claude.js"
+    },
+    "./session-import/opencode": {
+      "types": "./src/session-import/opencode.ts",
+      "browser": "./src/session-import/opencode.ts",
+      "workerd": "./src/session-import/opencode.ts",
+      "development": "./src/session-import/opencode.ts",
+      "default": "./dist/session-import/opencode.js"
+    },
+    "./session-import/normalize": {
+      "types": "./src/session-import/normalize.ts",
+      "browser": "./src/session-import/normalize.ts",
+      "workerd": "./src/session-import/normalize.ts",
+      "development": "./src/session-import/normalize.ts",
+      "default": "./dist/session-import/normalize.js"
     }
   },
   "publishConfig": {