@groundtrack/hooks 0.1.8 → 0.1.9

package/README.md

@@ -87,6 +87,26 @@ The lower-level `runDoctor` API remains for existing consumers. New setup uses
 client-specific plans for MCP, hooks/plugins, and instructions, so it can preview
 and repair several selected agents safely.
 
+## Import Codex sessions
+
+Import completed Codex sessions from `CODEX_HOME` (default `~/.codex`) with an API key
+created in Groundtrack Settings. The default scope is the current Git repository;
+subagents and files modified in the last five minutes are excluded.
+
+```sh
+GROUNDTRACK_API_KEY=... groundtrack import --dry-run
+GROUNDTRACK_API_KEY=... groundtrack import --yes
+GROUNDTRACK_API_KEY=... groundtrack import --all-repos --include-unscoped --yes
+```
+
+The command streams source files through a deterministic privacy filter before upload.
+Reasoning, system/developer instructions, turn context other than the model name, and
+recognized credentials are removed locally. Uploads are sequential and retry only
+transient failures. Successful imports are recorded atomically under
+`$XDG_CONFIG_HOME/groundtrack`; receipts are scoped to the endpoint, API-key fingerprint,
+visibility, source hash, and canonicalization version. Use `--json` for one machine-readable
+result object and `--url` for a preview or self-hosted deployment.
+
 `templates/AGENTS.md` is the source of truth for the managed repository policy.
 After changing it, run `pnpm sync:agent-instructions`; tests reject drift between
 the setup guide, this repository's managed `AGENTS.md` block, and the packaged template.

package/dist/groundtrack.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import { runCli } from "./setup/cli.js";
-runCli(process.argv.slice(2)).catch((error) => {
-    const message = error instanceof Error ? error.message : "Groundtrack setup failed.";
+import { runImportCli } from "./session-import/cli.js";
+const argv = process.argv.slice(2);
+const operation = argv[0] === "import" ? runImportCli(argv.slice(1)) : runCli(argv);
+operation.catch((error) => {
+    const message = error instanceof Error ? error.message : "Groundtrack command failed.";
     if (process.argv.includes("--json"))
         process.stdout.write(`${JSON.stringify({ error: message, applied: false })}\n`);
     else

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

@@ -0,0 +1,21 @@
+import type { ImportVisibility } from "./types.js";
+export declare const IMPORT_USAGE = "Usage:\n  groundtrack import [--agent codex] [--repo PATH | --all-repos] [--since DATE]\n                     [--include-subagents] [--include-unscoped]\n                     [--visibility private|organization] [--dry-run] [--yes] [--json]\n\nImport options:\n  --agent codex          Session format to discover (default: codex)\n  --repo PATH            Import sessions for this Git repository (default: current repository)\n  --all-repos            Import sessions carrying repository metadata\n  --include-unscoped     With --all-repos, also import sessions without repository metadata\n  --since DATE           Import sessions at or after an ISO timestamp or local YYYY-MM-DD\n  --include-subagents    Include subagent, forked-agent, and guardian sessions\n  --visibility VALUE     private (default) or organization\n  --api-key KEY          API key; prefer the GROUNDTRACK_API_KEY environment variable\n  --url URL              Groundtrack app or API URL (default: https://app.groundtrack.dev)\n  --dry-run              Discover and prune without authentication or network calls\n  --yes, -y              Upload without another confirmation\n  --json                 Emit exactly one machine-readable result object\n";
+type ImportArguments = Readonly<{
+    repoDir?: string;
+    homeDir?: string;
+    allRepositories: boolean;
+    includeUnscoped: boolean;
+    includeSubagents: boolean;
+    visibility: ImportVisibility;
+    since: Date | null;
+    dryRun: boolean;
+    yes: boolean;
+    json: boolean;
+    apiKey?: string;
+    apiBaseUrl: string;
+    help: boolean;
+}>;
+export declare function normalizeApiBaseUrl(value: string): string;
+export declare function parseImportArguments(argv: readonly string[]): ImportArguments;
+export declare function runImportCli(argv: readonly string[]): Promise<void>;
+export {};

package/dist/session-import/cli.js

@@ -0,0 +1,335 @@
+import { resolve } from "node:path";
+import * as prompts from "@clack/prompts";
+import { environment } from "../setup/agents.js";
+import { uploadCodexSession } from "./client.js";
+import { discoverCodexSessions, normalizeRepositoryUrl, repositoryIdentity } from "./discovery.js";
+import { pruneCodexSession } from "./prune.js";
+import { readReceipts, receiptKey, saveReceipt } from "./receipts.js";
+import { CODEX_CANONICAL_IMPORT_MAX_BYTES } from "./codex.js";
+export const IMPORT_USAGE = `Usage:
+  groundtrack import [--agent codex] [--repo PATH | --all-repos] [--since DATE]
+                     [--include-subagents] [--include-unscoped]
+                     [--visibility private|organization] [--dry-run] [--yes] [--json]
+
+Import options:
+  --agent codex          Session format to discover (default: codex)
+  --repo PATH            Import sessions for this Git repository (default: current repository)
+  --all-repos            Import sessions carrying repository metadata
+  --include-unscoped     With --all-repos, also import sessions without repository metadata
+  --since DATE           Import sessions at or after an ISO timestamp or local YYYY-MM-DD
+  --include-subagents    Include subagent, forked-agent, and guardian sessions
+  --visibility VALUE     private (default) or organization
+  --api-key KEY          API key; prefer the GROUNDTRACK_API_KEY environment variable
+  --url URL              Groundtrack app or API URL (default: https://app.groundtrack.dev)
+  --dry-run              Discover and prune without authentication or network calls
+  --yes, -y              Upload without another confirmation
+  --json                 Emit exactly one machine-readable result object
+`;
+function parseDate(value) {
+    const date = /^\d{4}-\d{2}-\d{2}$/.test(value) ? new Date(`${value}T00:00:00`) : new Date(value);
+    if (Number.isNaN(date.getTime()))
+        throw new Error(`Invalid --since date: ${value}`);
+    return date;
+}
+export function normalizeApiBaseUrl(value) {
+    const url = new URL(value);
+    if ((url.protocol !== "https:" &&
+        !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash)
+        throw new Error("Use an HTTPS Groundtrack URL (or local HTTP), without credentials or query parameters.");
+    url.pathname = url.pathname.replace(/\/(?:api(?:\/mcp)?)\/?$/, "");
+    return `${url.href.replace(/\/$/, "")}/api`;
+}
+export function parseImportArguments(argv) {
+    const args = [...argv];
+    const valueAfter = (index, flag) => {
+        const value = args[index + 1];
+        if (!value || value.startsWith("-"))
+            throw new Error(`${flag} requires a value.`);
+        return value;
+    };
+    let repoDir;
+    let homeDir;
+    let allRepositories = false;
+    let includeUnscoped = false;
+    let includeSubagents = false;
+    let visibility = "private";
+    let since = null;
+    let dryRun = false;
+    let yes = false;
+    let json = false;
+    let apiKey;
+    let apiBaseUrl = normalizeApiBaseUrl("https://app.groundtrack.dev");
+    let help = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--agent") {
+            const agent = valueAfter(index++, arg);
+            if (agent !== "codex")
+                throw new Error("Session import currently supports --agent codex.");
+        }
+        else if (arg === "--repo")
+            repoDir = valueAfter(index++, arg);
+        else if (arg === "--home")
+            homeDir = valueAfter(index++, arg);
+        else if (arg === "--all-repos")
+            allRepositories = true;
+        else if (arg === "--include-unscoped")
+            includeUnscoped = true;
+        else if (arg === "--include-subagents")
+            includeSubagents = true;
+        else if (arg === "--visibility") {
+            const value = valueAfter(index++, arg);
+            if (value !== "private" && value !== "organization")
+                throw new Error("--visibility must be private or organization.");
+            visibility = value;
+        }
+        else if (arg === "--since")
+            since = parseDate(valueAfter(index++, arg));
+        else if (arg === "--api-key")
+            apiKey = valueAfter(index++, arg);
+        else if (arg === "--url")
+            apiBaseUrl = normalizeApiBaseUrl(valueAfter(index++, arg));
+        else if (arg === "--dry-run")
+            dryRun = true;
+        else if (arg === "--yes" || arg === "-y")
+            yes = true;
+        else if (arg === "--json")
+            json = true;
+        else if (arg === "--help" || arg === "-h")
+            help = true;
+        else
+            throw new Error(`Unknown import option: ${arg}. Run groundtrack import --help.`);
+    }
+    if (allRepositories && repoDir)
+        throw new Error("Choose --repo or --all-repos, not both.");
+    if (includeUnscoped && !allRepositories)
+        throw new Error("Use --include-unscoped together with --all-repos.");
+    return {
+        repoDir,
+        homeDir,
+        allRepositories,
+        includeUnscoped,
+        includeSubagents,
+        visibility,
+        since,
+        dryRun,
+        yes,
+        json,
+        apiKey,
+        apiBaseUrl,
+        help,
+    };
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 ** 2)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 ** 3)
+        return `${(bytes / 1024 ** 2).toFixed(1)} MB`;
+    return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
+}
+function skippedCounts(skipped) {
+    const result = {};
+    for (const item of skipped)
+        result[item.reason] = (result[item.reason] ?? 0) + 1;
+    return result;
+}
+function printPlan(input) {
+    const originalBytes = input.sessions.reduce((sum, session) => sum + session.originalBytes, 0);
+    const prunedBytes = input.sessions.reduce((sum, session) => sum + session.prunedBytes, 0);
+    const skippedByReason = skippedCounts(input.skipped);
+    const repositories = sessionRepositoryCounts(input.sessions);
+    const timestamps = input.sessions
+        .map((item) => item.candidate.metadata.timestamp?.getTime())
+        .filter((value) => value !== undefined);
+    process.stdout.write([
+        `\nGroundtrack · import Codex sessions`,
+        `Scope: ${input.scope}`,
+        `Sessions: ${input.sessions.length} (${input.sessions.filter((item) => item.alreadyImported).length} in local receipts)`,
+        ...(timestamps.length
+            ? [
+                `Date range: ${new Date(Math.min(...timestamps)).toISOString()} to ${new Date(Math.max(...timestamps)).toISOString()}`,
+            ]
+            : []),
+        ...Object.entries(repositories).map(([repository, count]) => `  ${repository}: ${count}`),
+        `Upload size: ${formatBytes(prunedBytes)} after pruning (${formatBytes(originalBytes)} raw)`,
+        `Skipped: ${input.skipped.length}${Object.entries(skippedByReason)
+            .map(([reason, count]) => ` · ${reason} ${count}`)
+            .join("")}`,
+        ...(input.failed ? [`Unreadable/oversized: ${input.failed}`] : []),
+        "",
+    ].join("\n"));
+}
+function sessionRepositoryCounts(sessions) {
+    const result = {};
+    for (const session of sessions) {
+        const repository = session.candidate.metadata.repositoryUrl
+            ? normalizeRepositoryUrl(session.candidate.metadata.repositoryUrl)
+            : null;
+        const label = repository ?? session.candidate.metadata.cwd ?? "(no repository)";
+        result[label] = (result[label] ?? 0) + 1;
+    }
+    return result;
+}
+function sessionDateRange(sessions) {
+    const timestamps = sessions
+        .map((item) => item.candidate.metadata.timestamp?.getTime())
+        .filter((value) => value !== undefined);
+    return timestamps.length
+        ? {
+            from: new Date(Math.min(...timestamps)).toISOString(),
+            to: new Date(Math.max(...timestamps)).toISOString(),
+        }
+        : null;
+}
+export async function runImportCli(argv) {
+    const args = parseImportArguments(argv);
+    if (args.help) {
+        process.stdout.write(IMPORT_USAGE);
+        return;
+    }
+    const context = environment({ repoDir: args.repoDir, homeDir: args.homeDir });
+    const codexHome = resolve(context.env.CODEX_HOME || resolve(context.homeDir, ".codex"));
+    const repository = args.allRepositories ? undefined : repositoryIdentity(context.repoDir);
+    const discovery = discoverCodexSessions({
+        codexHome,
+        repository,
+        allRepositories: args.allRepositories,
+        includeUnscoped: args.includeUnscoped,
+        includeSubagents: args.includeSubagents,
+        since: args.since,
+    });
+    const apiKey = args.apiKey ?? context.env.GROUNDTRACK_API_KEY;
+    const receipts = apiKey ? readReceipts(context) : { version: 1, receipts: {} };
+    const prepared = [];
+    const preparationErrors = [];
+    for (const candidate of discovery.included) {
+        try {
+            const pruned = await pruneCodexSession(candidate.path, { emitBytes: false });
+            if (pruned.prunedBytes > CODEX_CANONICAL_IMPORT_MAX_BYTES)
+                throw new Error(`Pruned session exceeds ${formatBytes(CODEX_CANONICAL_IMPORT_MAX_BYTES)}`);
+            const key = apiKey
+                ? receiptKey({
+                    apiBaseUrl: args.apiBaseUrl,
+                    apiKey,
+                    sourceContentHash: pruned.sourceContentHash,
+                    visibility: args.visibility,
+                })
+                : null;
+            prepared.push({
+                candidate,
+                sourceContentHash: pruned.sourceContentHash,
+                prunedBytes: pruned.prunedBytes,
+                originalBytes: pruned.originalBytes,
+                receiptKey: key,
+                alreadyImported: Boolean(key && receipts.receipts[key]),
+            });
+        }
+        catch (error) {
+            preparationErrors.push({
+                path: candidate.path,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    const scope = args.allRepositories ? "all repositories" : repository.root;
+    const plan = {
+        scope,
+        selected: prepared.length,
+        alreadyImported: prepared.filter((item) => item.alreadyImported).length,
+        originalBytes: prepared.reduce((sum, item) => sum + item.originalBytes, 0),
+        prunedBytes: prepared.reduce((sum, item) => sum + item.prunedBytes, 0),
+        repositories: sessionRepositoryCounts(prepared),
+        dateRange: sessionDateRange(prepared),
+        skipped: skippedCounts(discovery.skipped),
+        failed: preparationErrors,
+    };
+    if (args.dryRun) {
+        if (args.json)
+            process.stdout.write(`${JSON.stringify({ dryRun: true, plan }, null, 2)}\n`);
+        else
+            printPlan({
+                scope,
+                sessions: prepared,
+                skipped: discovery.skipped,
+                failed: preparationErrors.length,
+            });
+        if (preparationErrors.length)
+            process.exitCode = 1;
+        return;
+    }
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && !args.json);
+    if (!args.json)
+        printPlan({
+            scope,
+            sessions: prepared,
+            skipped: discovery.skipped,
+            failed: preparationErrors.length,
+        });
+    if (!apiKey)
+        throw new Error("Set GROUNDTRACK_API_KEY or pass --api-key before uploading.");
+    if (!args.yes && !interactive)
+        throw new Error("Import needs confirmation. Use --yes, or run it in an interactive terminal.");
+    if (!args.yes) {
+        const approved = await prompts.confirm({
+            message: `Upload ${prepared.filter((item) => !item.alreadyImported).length} Codex sessions?`,
+            initialValue: false,
+        });
+        if (prompts.isCancel(approved) || !approved) {
+            prompts.cancel("Nothing uploaded.");
+            return;
+        }
+    }
+    let imported = 0;
+    let duplicate = 0;
+    let receiptSkipped = 0;
+    const failures = [...preparationErrors];
+    for (const item of prepared) {
+        if (item.alreadyImported) {
+            receiptSkipped += 1;
+            continue;
+        }
+        try {
+            const session = await pruneCodexSession(item.candidate.path);
+            if (session.sourceContentHash !== item.sourceContentHash ||
+                session.prunedBytes !== item.prunedBytes)
+                throw new Error("Session changed after the import plan was created.");
+            const result = await uploadCodexSession({
+                apiBaseUrl: args.apiBaseUrl,
+                apiKey,
+                session,
+                visibility: args.visibility,
+            });
+            if (result.duplicate)
+                duplicate += 1;
+            else
+                imported += 1;
+            saveReceipt(context, receipts, item.receiptKey, result.sessionId);
+        }
+        catch (error) {
+            failures.push({
+                path: item.candidate.path,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    const result = {
+        imported,
+        duplicate,
+        skipped: receiptSkipped + discovery.skipped.length,
+        failed: failures,
+        sessionsUrl: args.apiBaseUrl.replace(/\/api$/, "/sessions"),
+        plan,
+    };
+    if (args.json)
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    else
+        process.stdout.write(`Imported ${imported}; duplicates ${duplicate}; skipped ${result.skipped}; failed ${failures.length}.\n${result.sessionsUrl}\n`);
+    if (failures.length)
+        process.exitCode = 1;
+}

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

@@ -0,0 +1,13 @@
+import type { ImportVisibility, PrunedCodexSession } from "./types.js";
+type ImportResponse = Readonly<{
+    duplicate: boolean;
+    sessionId: string;
+}>;
+export declare function uploadCodexSession(input: {
+    apiBaseUrl: string;
+    apiKey: string;
+    session: PrunedCodexSession;
+    visibility: ImportVisibility;
+    fetch?: typeof globalThis.fetch;
+}): Promise<ImportResponse>;
+export {};

package/dist/session-import/client.js

@@ -0,0 +1,73 @@
+import { CODEX_CANONICALIZATION_VERSION } from "./codex.js";
+function retryable(status) {
+    return status === 408 || status === 429 || status >= 500;
+}
+function retryDelay(response, attempt) {
+    const retryAfter = response.headers.get("retry-after");
+    if (retryAfter && /^\d+$/.test(retryAfter))
+        return Math.min(Number(retryAfter) * 1000, 10_000);
+    return 250 * 2 ** attempt;
+}
+function wait(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function responseError(response) {
+    try {
+        const body = await response.json();
+        if (body && typeof body === "object" && "error" in body && typeof body.error === "string")
+            return body.error;
+    }
+    catch {
+        // Fall through to the status text.
+    }
+    return response.statusText || `HTTP ${response.status}`;
+}
+export async function uploadCodexSession(input) {
+    const request = input.fetch ?? globalThis.fetch;
+    let lastError = null;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            const response = await request(`${input.apiBaseUrl}/sessions/imports`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/vnd.groundtrack.session+jsonl; version=1",
+                    "x-api-key": input.apiKey,
+                    "x-groundtrack-canonicalization": String(CODEX_CANONICALIZATION_VERSION),
+                    "x-groundtrack-content-hash": input.session.sourceContentHash,
+                    "x-groundtrack-visibility": input.visibility,
+                },
+                body: input.session.bytes,
+                signal: AbortSignal.timeout(300_000),
+            });
+            if (!response.ok) {
+                const error = new Error(`Import failed (${response.status}): ${await responseError(response)}`);
+                if (!retryable(response.status) || attempt === 2)
+                    throw error;
+                await wait(retryDelay(response, attempt));
+                lastError = error;
+                continue;
+            }
+            const body = await response.json();
+            if (!body ||
+                typeof body !== "object" ||
+                !("duplicate" in body) ||
+                typeof body.duplicate !== "boolean" ||
+                !("session" in body) ||
+                !body.session ||
+                typeof body.session !== "object" ||
+                !("id" in body.session) ||
+                typeof body.session.id !== "string")
+                throw new Error("Import endpoint returned an invalid response.");
+            return { duplicate: body.duplicate, sessionId: body.session.id };
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt === 2 ||
+                (lastError.message.startsWith("Import failed") &&
+                    !/\((408|429|5\d\d)\)/.test(lastError.message)))
+                throw lastError;
+            await wait(250 * 2 ** attempt);
+        }
+    }
+    throw lastError ?? new Error("Import failed.");
+}

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

@@ -0,0 +1,37 @@
+type UnknownRecord = Record<string, unknown>;
+export declare const CODEX_CANONICALIZATION_VERSION = 1;
+export declare const CODEX_CANONICAL_IMPORT_MAX_BYTES: number;
+export declare const CODEX_CANONICAL_IMPORT_MAX_RECORD_BYTES: number;
+export type CanonicalSessionEntry = Readonly<{
+    kind: "user_message" | "assistant_message" | "tool_call" | "tool_result";
+    occurredAt: string | null;
+    payload: Record<string, unknown>;
+}>;
+export type CanonicalCodexMetadata = Readonly<{
+    type: "session";
+    version: 1;
+    externalSessionId: string;
+    repositoryUrl: string | null;
+    repositoryBranch: string | null;
+    repositoryCommitSha: string | null;
+    workingDirectory: string | null;
+    originator: string | null;
+    model: string | null;
+    startedAt: string | null;
+    endedAt: string | null;
+    statistics: {
+        totalRecordCount: number;
+        importedEntryCount: number;
+        skippedRecordCount: number;
+        unsupportedRecordCount: number;
+        malformedRecordCount: number;
+        sensitiveRecordCount: number;
+    };
+}>;
+export declare function isSessionRecord(value: unknown): value is UnknownRecord;
+export declare function sessionString(value: unknown): string | null;
+export declare function isSensitiveCodexRecord(record: UnknownRecord): boolean;
+export declare function isKnownSkippedCodexRecord(record: UnknownRecord): boolean;
+export declare function normalizeCodexResponseItem(record: UnknownRecord): CanonicalSessionEntry | null;
+export declare function codexSessionMetadata(record: UnknownRecord): Omit<CanonicalCodexMetadata, "model" | "startedAt" | "endedAt" | "statistics"> | null;
+export {};

package/dist/session-import/codex.js

@@ -0,0 +1,134 @@
+import { containsInternalInstructionText, redactCredentialText, sanitizeRepositoryUrl, sanitizeSessionValue, sanitizeWorkingDirectory, } from "./redaction.js";
+export const CODEX_CANONICALIZATION_VERSION = 1;
+export const CODEX_CANONICAL_IMPORT_MAX_BYTES = 50 * 1024 * 1024;
+export const CODEX_CANONICAL_IMPORT_MAX_RECORD_BYTES = 4 * 1024 * 1024;
+export function isSessionRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function sessionString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function messageText(content) {
+    if (!Array.isArray(content))
+        return null;
+    const text = content
+        .filter(isSessionRecord)
+        .filter((part) => part.type === "input_text" || part.type === "output_text")
+        .map((part) => sessionString(part.text))
+        .filter((part) => part !== null)
+        .join("\n");
+    return text ? sanitizeSessionValue(text) : null;
+}
+function messageContainsInternalInstructions(payload) {
+    if (!Array.isArray(payload.content))
+        return false;
+    return payload.content
+        .filter(isSessionRecord)
+        .map((part) => sessionString(part.text) ?? "")
+        .some(containsInternalInstructionText);
+}
+export function isSensitiveCodexRecord(record) {
+    const type = sessionString(record.type);
+    const payload = isSessionRecord(record.payload) ? record.payload : {};
+    const payloadType = sessionString(payload.type);
+    const role = sessionString(payload.role);
+    return (type === "turn_context" ||
+        type === "world_state" ||
+        type === "compacted" ||
+        type === "inter_agent_communication_metadata" ||
+        payloadType === "reasoning" ||
+        payloadType === "agent_reasoning" ||
+        payloadType === "agent_message" ||
+        role === "system" ||
+        role === "developer" ||
+        (type === "response_item" &&
+            payloadType === "message" &&
+            messageContainsInternalInstructions(payload)));
+}
+export function isKnownSkippedCodexRecord(record) {
+    const type = sessionString(record.type);
+    const payload = isSessionRecord(record.payload) ? record.payload : {};
+    return (type === "session_meta" ||
+        type === "token_usage_record" ||
+        type === "event_msg" ||
+        sessionString(payload.type) === "reasoning");
+}
+function structuredValue(value) {
+    if (typeof value !== "string")
+        return sanitizeSessionValue(value);
+    try {
+        return sanitizeSessionValue(JSON.parse(value));
+    }
+    catch {
+        return sanitizeSessionValue(value);
+    }
+}
+export function normalizeCodexResponseItem(record) {
+    if (record.type !== "response_item" || !isSessionRecord(record.payload))
+        return null;
+    const payload = record.payload;
+    const payloadType = sessionString(payload.type);
+    const role = sessionString(payload.role);
+    const occurredAt = sessionString(record.timestamp);
+    if (payloadType === "message") {
+        if ((role !== "user" && role !== "assistant") || messageContainsInternalInstructions(payload))
+            return null;
+        const text = messageText(payload.content);
+        if (!text)
+            return null;
+        const phase = role === "assistant" ? sessionString(payload.phase) : null;
+        return {
+            kind: role === "user" ? "user_message" : "assistant_message",
+            occurredAt,
+            payload: {
+                text,
+                ...(phase ? { phase } : {}),
+            },
+        };
+    }
+    if (payloadType === "custom_tool_call" || payloadType === "function_call") {
+        const toolName = sessionString(payload.name);
+        if (!toolName)
+            return null;
+        return {
+            kind: "tool_call",
+            occurredAt,
+            payload: {
+                callId: sessionString(payload.call_id),
+                toolName,
+                input: structuredValue(payload.input ?? payload.arguments),
+            },
+        };
+    }
+    if (payloadType === "custom_tool_call_output" || payloadType === "function_call_output") {
+        return {
+            kind: "tool_result",
+            occurredAt,
+            payload: {
+                callId: sessionString(payload.call_id),
+                output: structuredValue(payload.output),
+            },
+        };
+    }
+    return null;
+}
+export function codexSessionMetadata(record) {
+    if (record.type !== "session_meta" || !isSessionRecord(record.payload))
+        return null;
+    const payload = record.payload;
+    const git = isSessionRecord(payload.git) ? payload.git : {};
+    const externalSessionId = sessionString(payload.session_id) ?? sessionString(payload.id);
+    if (!externalSessionId)
+        return null;
+    const originator = sessionString(payload.originator);
+    return {
+        type: "session",
+        version: 1,
+        externalSessionId,
+        repositoryUrl: sanitizeRepositoryUrl(git.repository_url),
+        repositoryBranch: sessionString(git.branch),
+        repositoryCommitSha: sessionString(git.commit_hash),
+        workingDirectory: sanitizeWorkingDirectory(payload.cwd),
+        originator: originator ? redactCredentialText(originator) : null,
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { CodexSessionCandidate, CodexSessionMetadata, SkippedCodexSession } from "./types.js";
+export declare function parseCodexMetadata(line: string): CodexSessionMetadata | null;
+export declare function normalizeRepositoryUrl(value: string): string | null;
+export type RepositoryIdentity = Readonly<{
+    root: string;
+    remotes: ReadonlySet<string>;
+}>;
+export declare function repositoryIdentity(path: string): RepositoryIdentity;
+export type DiscoverCodexSessionsOptions = Readonly<{
+    codexHome: string;
+    repository?: RepositoryIdentity;
+    allRepositories: boolean;
+    includeUnscoped: boolean;
+    includeSubagents: boolean;
+    since: Date | null;
+    nowMs?: number;
+    liveWindowMs?: number;
+}>;
+export declare function discoverCodexSessions(options: DiscoverCodexSessionsOptions): {
+    included: CodexSessionCandidate[];
+    skipped: SkippedCodexSession[];
+};

package/dist/session-import/discovery.js

@@ -0,0 +1,188 @@
+import { execFileSync } from "node:child_process";
+import { closeSync, existsSync, lstatSync, openSync, readSync, readdirSync, realpathSync, } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function firstLine(path, maxBytes = 1024 * 1024) {
+    const file = openSync(path, "r");
+    try {
+        const chunks = [];
+        let offset = 0;
+        while (offset < maxBytes) {
+            const chunk = Buffer.alloc(Math.min(64 * 1024, maxBytes - offset));
+            const read = readSync(file, chunk, 0, chunk.length, offset);
+            if (read === 0)
+                break;
+            const bytes = chunk.subarray(0, read);
+            const newline = bytes.indexOf(10);
+            chunks.push(newline >= 0 ? bytes.subarray(0, newline) : bytes);
+            offset += newline >= 0 ? newline : read;
+            if (newline >= 0)
+                break;
+        }
+        return Buffer.concat(chunks).toString("utf8").replace(/\r$/, "");
+    }
+    finally {
+        closeSync(file);
+    }
+}
+function isSubagentMetadata(payload) {
+    if (stringValue(payload.parent_thread_id) || stringValue(payload.agent_path))
+        return true;
+    if (isRecord(payload.source) && "subagent" in payload.source)
+        return true;
+    return ["subagent", "agent_forked_thread", "guardian_review"].includes(stringValue(payload.thread_source) ?? "");
+}
+export function parseCodexMetadata(line) {
+    try {
+        const record = JSON.parse(line);
+        if (!isRecord(record) || record.type !== "session_meta" || !isRecord(record.payload))
+            return null;
+        const payload = record.payload;
+        const git = isRecord(payload.git) ? payload.git : {};
+        const externalSessionId = stringValue(payload.session_id) ?? stringValue(payload.id);
+        if (!externalSessionId)
+            return null;
+        const timestampValue = stringValue(payload.timestamp) ?? stringValue(record.timestamp);
+        const timestamp = timestampValue ? new Date(timestampValue) : null;
+        return {
+            externalSessionId,
+            timestamp: timestamp && !Number.isNaN(timestamp.getTime()) ? timestamp : null,
+            cwd: stringValue(payload.cwd),
+            repositoryUrl: stringValue(git.repository_url),
+            repositoryBranch: stringValue(git.branch),
+            repositoryCommitSha: stringValue(git.commit_hash),
+            originator: stringValue(payload.originator),
+            isSubagent: isSubagentMetadata(payload),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function walkJsonl(root) {
+    if (!existsSync(root))
+        return [];
+    const result = [];
+    const visit = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const path = resolve(directory, entry.name);
+            if (entry.isDirectory())
+                visit(path);
+            else if (entry.isFile() && entry.name.toLowerCase().endsWith(".jsonl"))
+                result.push(path);
+        }
+    };
+    visit(root);
+    return result.sort();
+}
+export function normalizeRepositoryUrl(value) {
+    const trimmed = value
+        .trim()
+        .replace(/\.git\/?$/i, "")
+        .replace(/\/$/, "");
+    const scp = trimmed.match(/^[^@\s]+@([^:\s]+):(.+)$/);
+    const path = scp?.[2] ??
+        (() => {
+            try {
+                return new URL(trimmed).pathname;
+            }
+            catch {
+                return trimmed.includes("/") ? trimmed : null;
+            }
+        })();
+    if (!path)
+        return null;
+    const parts = path.split("/").filter(Boolean);
+    if (parts.length < 2)
+        return null;
+    return parts.slice(-2).join("/").toLowerCase();
+}
+export function repositoryIdentity(path) {
+    const root = realpathSync(execFileSync("git", ["-C", path, "rev-parse", "--show-toplevel"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5_000,
+    }).trim());
+    const names = execFileSync("git", ["-C", root, "remote"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5_000,
+    })
+        .split(/\r?\n/)
+        .filter(Boolean);
+    const remotes = new Set();
+    for (const name of names) {
+        const urls = execFileSync("git", ["-C", root, "remote", "get-url", "--all", name], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5_000,
+        }).split(/\r?\n/);
+        for (const url of urls) {
+            const normalized = normalizeRepositoryUrl(url);
+            if (normalized)
+                remotes.add(normalized);
+        }
+    }
+    return { root, remotes };
+}
+function isInside(candidate, root) {
+    if (!isAbsolute(candidate))
+        return false;
+    const child = relative(root, resolve(candidate));
+    return child === "" || (!child.startsWith(`..${sep}`) && child !== "..");
+}
+export function discoverCodexSessions(options) {
+    const nowMs = options.nowMs ?? Date.now();
+    const liveWindowMs = options.liveWindowMs ?? 5 * 60_000;
+    const roots = [
+        resolve(options.codexHome, "sessions"),
+        resolve(options.codexHome, "archived_sessions"),
+    ];
+    const included = [];
+    const skipped = [];
+    for (const path of roots.flatMap(walkJsonl)) {
+        const metadata = parseCodexMetadata(firstLine(path));
+        if (!metadata) {
+            skipped.push({ path, reason: "invalid_metadata" });
+            continue;
+        }
+        const stat = lstatSync(path);
+        if (!stat.isFile())
+            continue;
+        if (nowMs - stat.mtimeMs < liveWindowMs) {
+            skipped.push({ path, reason: "live" });
+            continue;
+        }
+        if (!options.includeSubagents && metadata.isSubagent) {
+            skipped.push({ path, reason: "subagent" });
+            continue;
+        }
+        if (options.since && (!metadata.timestamp || metadata.timestamp < options.since)) {
+            skipped.push({ path, reason: "before_since" });
+            continue;
+        }
+        const normalizedRemote = metadata.repositoryUrl
+            ? normalizeRepositoryUrl(metadata.repositoryUrl)
+            : null;
+        const matchesCurrentRepository = options.repository
+            ? normalizedRemote
+                ? options.repository.remotes.has(normalizedRemote)
+                : Boolean(metadata.cwd && isInside(metadata.cwd, options.repository.root))
+            : false;
+        if (!options.allRepositories && !matchesCurrentRepository) {
+            skipped.push({ path, reason: "other_repository" });
+            continue;
+        }
+        if (options.allRepositories && !normalizedRemote && !options.includeUnscoped) {
+            skipped.push({ path, reason: "unscoped" });
+            continue;
+        }
+        included.push({ path, metadata });
+    }
+    return { included, skipped };
+}

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

@@ -0,0 +1,5 @@
+import type { CodexSessionAnalysis, PrunedCodexSession } from "./types.js";
+export declare function pruneCodexSession(path: string): Promise<PrunedCodexSession>;
+export declare function pruneCodexSession(path: string, options: Readonly<{
+    emitBytes: false;
+}>): Promise<CodexSessionAnalysis>;

package/dist/session-import/prune.js

@@ -0,0 +1,120 @@
+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 { CODEX_CANONICAL_IMPORT_MAX_RECORD_BYTES, codexSessionMetadata, isSessionRecord, isKnownSkippedCodexRecord, isSensitiveCodexRecord, normalizeCodexResponseItem, sessionString, } from "./codex.js";
+function recordTimestamp(record) {
+    const value = sessionString(record.timestamp);
+    if (!value)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+export async function pruneCodexSession(path, options = {}) {
+    const before = await stat(path);
+    const hash = createHash("sha256");
+    const encoder = new TextEncoder();
+    const entryChunks = [];
+    let entryBytes = 0;
+    let entryCount = 0;
+    const timestamps = [];
+    let metadata = null;
+    let model = null;
+    let originalRecords = 0;
+    let malformedRecordCount = 0;
+    let sensitiveRecordCount = 0;
+    let unsupportedRecordCount = 0;
+    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;
+        originalRecords += 1;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            malformedRecordCount += 1;
+            continue;
+        }
+        if (!isSessionRecord(record)) {
+            malformedRecordCount += 1;
+            continue;
+        }
+        metadata ??= codexSessionMetadata(record);
+        const timestamp = recordTimestamp(record);
+        if (timestamp)
+            timestamps.push(timestamp);
+        if (record.type === "turn_context" && isSessionRecord(record.payload))
+            model ??= sessionString(record.payload.model);
+        const sensitive = isSensitiveCodexRecord(record);
+        if (sensitive)
+            sensitiveRecordCount += 1;
+        const entry = normalizeCodexResponseItem(record);
+        if (entry) {
+            const chunk = encoder.encode(`${JSON.stringify(entry)}\n`);
+            if (chunk.byteLength > CODEX_CANONICAL_IMPORT_MAX_RECORD_BYTES)
+                throw new Error(`Canonical session record is too large: ${path}`);
+            if (options.emitBytes !== false)
+                entryChunks.push(chunk);
+            entryBytes += chunk.byteLength;
+            entryCount += 1;
+        }
+        else if (!isKnownSkippedCodexRecord(record) && !sensitive)
+            unsupportedRecordCount += 1;
+    }
+    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}`);
+    if (!metadata)
+        throw new Error(`Session metadata is missing: ${path}`);
+    if (entryCount === 0)
+        throw new Error(`Session has no supported trace entries: ${path}`);
+    const startedAt = timestamps.length
+        ? new Date(Math.min(...timestamps.map((timestamp) => timestamp.getTime()))).toISOString()
+        : null;
+    const endedAt = timestamps.length
+        ? new Date(Math.max(...timestamps.map((timestamp) => timestamp.getTime()))).toISOString()
+        : null;
+    const header = {
+        ...metadata,
+        model,
+        startedAt,
+        endedAt,
+        statistics: {
+            totalRecordCount: originalRecords,
+            importedEntryCount: entryCount,
+            skippedRecordCount: originalRecords - entryCount,
+            unsupportedRecordCount,
+            malformedRecordCount,
+            sensitiveRecordCount,
+        },
+    };
+    const headerBytes = encoder.encode(`${JSON.stringify(header)}\n`);
+    if (headerBytes.byteLength > CODEX_CANONICAL_IMPORT_MAX_RECORD_BYTES)
+        throw new Error(`Canonical session metadata is too large: ${path}`);
+    const analysis = {
+        sourceContentHash: hash.digest("hex"),
+        originalBytes: before.size,
+        prunedBytes: headerBytes.byteLength + entryBytes,
+    };
+    if (options.emitBytes === false)
+        return analysis;
+    const bytes = new Uint8Array(analysis.prunedBytes);
+    bytes.set(headerBytes);
+    let offset = headerBytes.byteLength;
+    for (const chunk of entryChunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { ...analysis, bytes };
+}

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

@@ -0,0 +1,20 @@
+import type { SetupEnvironment } from "../setup/agents.js";
+import type { 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;
+    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 { CODEX_CANONICALIZATION_VERSION } from "./codex.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"),
+        "codex_cli",
+        CODEX_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,28 @@
+export type ImportVisibility = "private" | "organization";
+export type CodexSessionMetadata = Readonly<{
+    externalSessionId: string;
+    timestamp: Date | null;
+    cwd: string | null;
+    repositoryUrl: string | null;
+    repositoryBranch: string | null;
+    repositoryCommitSha: string | null;
+    originator: string | null;
+    isSubagent: boolean;
+}>;
+export type CodexSessionCandidate = Readonly<{
+    path: string;
+    metadata: CodexSessionMetadata;
+}>;
+export type DiscoverySkipReason = "invalid_metadata" | "live" | "subagent" | "before_since" | "other_repository" | "unscoped";
+export type SkippedCodexSession = Readonly<{
+    path: string;
+    reason: DiscoverySkipReason;
+}>;
+export type CodexSessionAnalysis = Readonly<{
+    sourceContentHash: string;
+    originalBytes: number;
+    prunedBytes: number;
+}>;
+export type PrunedCodexSession = CodexSessionAnalysis & Readonly<{
+    bytes: Uint8Array<ArrayBuffer>;
+}>;

package/dist/session-import/types.js

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

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.9",
   "description": "Lifecycle hook utilities for Groundtrack MCP clients.",
   "keywords": [
     "claude-code",
@@ -41,6 +41,20 @@
       "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"
     }
   },
   "publishConfig": {