@groundtrack/hooks 0.1.9 → 0.1.11

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

@@ -1,5 +1,14 @@
-import type { CodexSessionAnalysis, PrunedCodexSession } from "./types.js";
-export declare function pruneCodexSession(path: string): Promise<PrunedCodexSession>;
-export declare function pruneCodexSession(path: string, options: Readonly<{
+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;
-}>): Promise<CodexSessionAnalysis>;
+    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

@@ -3,28 +3,25 @@ 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 = {}) {
+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();
-    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 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);
@@ -37,84 +34,53 @@ export async function pruneCodexSession(path, options = {}) {
     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;
+            record = null;
         }
-        else if (!isKnownSkippedCodexRecord(record) && !sensitive)
-            unsupportedRecordCount += 1;
+        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}`);
-    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 header = accumulator.finish().metadata;
     const headerBytes = encoder.encode(`${JSON.stringify(header)}\n`);
-    if (headerBytes.byteLength > CODEX_CANONICAL_IMPORT_MAX_RECORD_BYTES)
+    if (headerBytes.byteLength > CANONICAL_IMPORT_MAX_RECORD_BYTES)
         throw new Error(`Canonical session metadata is too large: ${path}`);
-    const analysis = {
+    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 analysis;
-    const bytes = new Uint8Array(analysis.prunedBytes);
+        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;
-    for (const chunk of entryChunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return { ...analysis, bytes };
+    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

@@ -1,5 +1,5 @@
 import type { SetupEnvironment } from "../setup/agents.js";
-import type { ImportVisibility } from "./types.js";
+import type { AgentSessionSource, ImportVisibility } from "./types.js";
 type Receipt = Readonly<{
     sessionId: string;
     importedAt: string;
@@ -13,6 +13,7 @@ export declare function readReceipts(context: SetupEnvironment): ReceiptFile;
 export declare function receiptKey(input: {
     apiBaseUrl: string;
     apiKey: string;
+    source: AgentSessionSource;
     sourceContentHash: string;
     visibility: ImportVisibility;
 }): string;

package/dist/session-import/receipts.js

@@ -3,7 +3,7 @@ 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";
+import { CANONICALIZATION_VERSION } from "./canonical.js";
 export function receiptPath(context) {
     return join(stateDir(context), "session-import-receipts.json");
 }
@@ -31,8 +31,8 @@ export function receiptKey(input) {
         .update([
         input.apiBaseUrl,
         createHash("sha256").update(input.apiKey).digest("hex"),
-        "codex_cli",
-        CODEX_CANONICALIZATION_VERSION,
+        input.source,
+        CANONICALIZATION_VERSION,
         input.visibility,
         input.sourceContentHash,
     ].join("\0"))

package/dist/session-import/redaction.js

@@ -1,4 +1,4 @@
-const sensitiveKeyPattern = /(?:^|[_-])(?:api[_-]?key|token|authorization|auth|password|passwd|secret|private[_-]?key|cookie|credentials?)(?:$|[_-])/i;
+const sensitiveKeyPattern = /(?:^|[_-])(?:api[_-]?key|access[_-]?key(?:[_-]?id)?|token|authorization|auth|password|passwd|secret|private[_-]?key|cookie|credentials?|database[_-]?url)(?:$|[_-])/i;
 const internalInstructionMarkers = [
     "<local-command-caveat>",
     "<system-reminder>",
@@ -19,9 +19,11 @@ 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(/\b((?:[a-z0-9_-]*(?:api[_-]?key|access[_-]?key(?:[_-]?id)?|token|password|passwd|secret|private[_-]?key|credentials?|database[_-]?url))\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]");
+        .replace(/\b(?:sk-[A-Za-z0-9_-]{16,}|ghp_[A-Za-z0-9]{8,}|github_pat_[A-Za-z0-9_]{8,}|glpat-[A-Za-z0-9_-]{12,}|npm_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{12,}|(?:AKIA|ASIA)[A-Z0-9]{16}|AIza[A-Za-z0-9_-]{20,})\b/g, "[REDACTED]")
+        .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[REDACTED]")
+        .replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/:@]+:[^\s/@]+@/gi, "$1[REDACTED]@");
 }
 export function sanitizeRepositoryUrl(value) {
     if (typeof value !== "string" || value.length === 0)

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

@@ -1,5 +1,9 @@
+import type { AgentSessionSource, SessionImportAgent } from "../agents.js";
+import type { CanonicalSessionMetadata } from "./canonical.js";
 export type ImportVisibility = "private" | "organization";
-export type CodexSessionMetadata = Readonly<{
+export type ImportAgent = SessionImportAgent;
+export type { AgentSessionSource };
+export type AgentSessionMetadata = Readonly<{
     externalSessionId: string;
     timestamp: Date | null;
     cwd: string | null;
@@ -8,21 +12,31 @@ export type CodexSessionMetadata = Readonly<{
     repositoryCommitSha: string | null;
     originator: string | null;
     isSubagent: boolean;
+    startedAt?: Date | null;
+    endedAt?: Date | null;
 }>;
-export type CodexSessionCandidate = Readonly<{
+export type AgentSessionCandidate = Readonly<{
     path: string;
-    metadata: CodexSessionMetadata;
+    metadata: AgentSessionMetadata;
+    modifiedAt?: Date;
 }>;
-export type DiscoverySkipReason = "invalid_metadata" | "live" | "subagent" | "before_since" | "other_repository" | "unscoped";
-export type SkippedCodexSession = Readonly<{
+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 CodexSessionAnalysis = Readonly<{
+export type FailedAgentSession = Readonly<{
+    path: string;
+    error: string;
+}>;
+export type AgentSessionAnalysis = Readonly<{
     sourceContentHash: string;
     originalBytes: number;
     prunedBytes: number;
 }>;
-export type PrunedCodexSession = CodexSessionAnalysis & Readonly<{
+export type AgentSessionPlan = AgentSessionAnalysis & Readonly<{
+    metadata: CanonicalSessionMetadata;
+}>;
+export type PrunedAgentSession = AgentSessionAnalysis & Readonly<{
     bytes: Uint8Array<ArrayBuffer>;
 }>;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groundtrack/hooks",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Lifecycle hook utilities for Groundtrack MCP clients.",
   "keywords": [
     "claude-code",
@@ -55,6 +55,34 @@
       "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": {