@aiwg/cli 2026.7.20 → 2026.7.21

package/dist/src/sessions/adapters/openhuman.js

@@ -0,0 +1,315 @@
+import { z } from 'zod';
+import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
+import { readBoundedJsonLines, streamBoundedJsonLines, } from '../readers.js';
+export const OPENHUMAN_ADAPTER_VERSION = '1.0.0';
+export const OPENHUMAN_SOURCE_SCHEMA_VERSION = '1.0.0';
+const MetadataSchema = z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    profile: z.string().optional(),
+    nestedAgentId: z.string().optional(),
+    parentAgentId: z.string().optional(),
+}).passthrough();
+const AttachmentSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().optional(),
+    mime: z.string().optional(),
+    uri: z.string().optional(),
+    state: z.enum(['present', 'expired']),
+    expiredAt: z.union([z.string(), z.number()]).optional(),
+}).passthrough();
+const RawSchema = z.object({
+    schemaVersion: z.union([z.string(), z.number()]),
+    recordType: z.literal('session_raw'),
+    session_id: z.string().min(1),
+    event_id: z.string().min(1),
+    thread_id: z.string().min(1),
+    request_id: z.string().optional(),
+    parent_event_id: z.string().nullable().optional(),
+    type: z.string().min(1),
+    role: z.string().optional(),
+    content: z.unknown().optional(),
+    timestamp: z.union([z.string(), z.number()]).optional(),
+    metadata: MetadataSchema.optional(),
+    input_tokens: z.number().optional(),
+    cached_input_tokens: z.number().optional(),
+    output_tokens: z.number().optional(),
+    charged_amount_usd: z.number().optional(),
+    compacted: z.boolean().optional(),
+    interrupted: z.boolean().optional(),
+    tool: z.record(z.unknown()).optional(),
+    attachment: AttachmentSchema.optional(),
+    active: z.boolean().optional(),
+    raw_transcript_deleted_at: z.union([z.string(), z.number()]).nullable().optional(),
+}).passthrough();
+const ThreadStateSchema = z.object({
+    schemaVersion: z.union([z.string(), z.number()]),
+    recordType: z.literal('thread_state'),
+    thread_id: z.string().min(1),
+    title: z.string().optional(),
+    state: z.string().optional(),
+    deleted_at: z.union([z.string(), z.number()]).nullable().optional(),
+}).passthrough();
+const TurnStateSchema = z.object({
+    schemaVersion: z.union([z.string(), z.number()]),
+    recordType: z.literal('turn_state'),
+    thread_id: z.string().min(1),
+    request_id: z.string().min(1),
+    state: z.string().min(1),
+    interrupted: z.boolean().optional(),
+    completed_at: z.union([z.string(), z.number()]).nullable().optional(),
+}).passthrough();
+const RecordSchema = z.discriminatedUnion('recordType', [
+    RawSchema, ThreadStateSchema, TurnStateSchema,
+]);
+export class OpenHumanSessionAdapter {
+    limits;
+    provider = 'openhuman';
+    adapterVersion = OPENHUMAN_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['inspect', 'stream'];
+    acquisitionModes = ['jsonl'];
+    constructor(limits) {
+        this.limits = limits;
+    }
+    async *discover(_scope) {
+        // session_raw and enrichment bundles require explicit selection.
+    }
+    async inspect(source) {
+        const parsed = await this.readSource(source);
+        return {
+            sourceSchemaVersion: parsed.schemaVersion,
+            consistency: parsed.consistency,
+            operationalState: 'available',
+        };
+    }
+    async *stream(source, cursor) {
+        if (source.locatorClass !== 'openhuman-session-raw-jsonl'
+            && source.locatorClass !== 'openhuman-enriched-jsonl') {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'unsupported OpenHuman source class');
+        }
+        const start = parseCursor(cursor?.value);
+        const input = await streamBoundedJsonLines({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, { consistency: 'provisional', limits: this.limits });
+        const threads = new Map();
+        const turns = new Map();
+        const maxJoinStates = Math.min(this.limits?.maxRecords ?? 1_000_000, 10_000);
+        let schemaVersion = null;
+        let outputIndex = 0;
+        let sawRaw = false;
+        for await (const line of input) {
+            const parsed = RecordSchema.safeParse(line.value);
+            if (!parsed.success) {
+                throw new SessionContractError('MALFORMED_SOURCE', 'OpenHuman transcript record is malformed');
+            }
+            const value = parsed.data;
+            const currentVersion = version(value.schemaVersion);
+            if (schemaVersion && schemaVersion !== currentVersion) {
+                throw new SessionContractError('SCHEMA_DRIFT', 'mixed OpenHuman schema versions');
+            }
+            schemaVersion = currentVersion;
+            assertSupportedSchemaMajor(schemaVersion);
+            if (value.recordType === 'thread_state') {
+                threads.set(value.thread_id, value);
+            }
+            else if (value.recordType === 'turn_state') {
+                turns.set(`${value.thread_id}\0${value.request_id}`, value);
+            }
+            else {
+                sawRaw = true;
+                const record = normalize(value, line, source.locatorClass, threads.get(value.thread_id), value.request_id ? turns.get(`${value.thread_id}\0${value.request_id}`) : undefined);
+                if (outputIndex++ >= start)
+                    yield record;
+            }
+            if (threads.size + turns.size > maxJoinStates) {
+                throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'OpenHuman enrichment join state exceeds the bounded streaming limit');
+            }
+        }
+        if (!sawRaw) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'OpenHuman source contains no session_raw records');
+        }
+    }
+    async readSource(source) {
+        if (source.locatorClass !== 'openhuman-session-raw-jsonl'
+            && source.locatorClass !== 'openhuman-enriched-jsonl') {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'unsupported OpenHuman source class');
+        }
+        const result = await readBoundedJsonLines({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, { consistency: 'provisional', limits: this.limits });
+        if (result.records.length === 0) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'OpenHuman transcript source is empty');
+        }
+        const parsed = result.records.map(({ value, ...line }) => {
+            const record = RecordSchema.safeParse(value);
+            if (!record.success)
+                throw new SessionContractError('MALFORMED_SOURCE', 'OpenHuman transcript record is malformed');
+            return { value: record.data, ...line };
+        });
+        const versions = new Set(parsed.map(({ value }) => version(value.schemaVersion)));
+        if (versions.size !== 1)
+            throw new SessionContractError('SCHEMA_DRIFT', 'mixed OpenHuman schema versions');
+        assertSupportedSchemaMajor([...versions][0]);
+        const raw = parsed.filter((item) => item.value.recordType === 'session_raw');
+        if (raw.length === 0) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'OpenHuman source contains no session_raw records');
+        }
+        const threads = new Map();
+        const turns = new Map();
+        for (const item of parsed) {
+            if (item.value.recordType === 'thread_state')
+                threads.set(item.value.thread_id, item.value);
+            if (item.value.recordType === 'turn_state') {
+                turns.set(`${item.value.thread_id}\0${item.value.request_id}`, item.value);
+            }
+        }
+        const sessions = new Map();
+        for (const item of raw) {
+            const values = sessions.get(item.value.session_id) ?? [];
+            values.push(item.value);
+            sessions.set(item.value.session_id, values);
+        }
+        return {
+            schemaVersion: OPENHUMAN_SOURCE_SCHEMA_VERSION,
+            consistency: result.incompleteTail || [...sessions.values()].some((events) => events.at(-1)?.active !== false && events.at(-1)?.type !== 'session_end')
+                ? 'provisional' : 'complete',
+            records: raw.map(({ value, ...line }) => normalize(value, line, source.locatorClass, threads.get(value.thread_id), value.request_id ? turns.get(`${value.thread_id}\0${value.request_id}`) : undefined)),
+        };
+    }
+}
+function normalize(value, line, locatorClass, thread, turn) {
+    const lifecycle = value.raw_transcript_deleted_at
+        ? 'deleted'
+        : value.active === false || value.type === 'session_end' ? 'complete' : 'active';
+    return {
+        nativeSessionId: value.session_id,
+        nativeEventId: value.event_id,
+        sequence: line.sequence,
+        kind: recordKind(value),
+        role: value.role,
+        occurredAt: timestamp(value.timestamp),
+        text: extractText(value.content, value.tool),
+        rawReference: { locatorClass, offset: line.byteOffset },
+        extensions: {
+            lifecycle,
+            relationship: {
+                threadId: value.thread_id,
+                requestId: value.request_id,
+                parentEventId: value.parent_event_id,
+            },
+            repeatedMetadata: value.metadata,
+            usage: {
+                inputTokens: value.input_tokens,
+                cachedInputTokens: value.cached_input_tokens,
+                outputTokens: value.output_tokens,
+                chargedAmountUsd: value.charged_amount_usd,
+            },
+            compaction: { compacted: value.compacted === true },
+            interruption: {
+                interrupted: value.interrupted === true || turn?.interrupted === true,
+                turnState: turn?.state,
+                turnCompletedAt: timestamp(turn?.completed_at),
+            },
+            tool: value.tool,
+            attachment: value.attachment ? {
+                id: value.attachment.id,
+                name: value.attachment.name,
+                mime: value.attachment.mime,
+                state: value.attachment.state,
+                uriPresent: Boolean(value.attachment.uri),
+                expiredAt: timestamp(value.attachment.expiredAt),
+            } : undefined,
+            thread: thread ? {
+                title: thread.title,
+                state: thread.state,
+                deletedAt: timestamp(thread.deleted_at),
+            } : undefined,
+            deletion: {
+                threadDeletedAt: timestamp(thread?.deleted_at),
+                rawTranscriptDeletedAt: timestamp(value.raw_transcript_deleted_at),
+                threadDeletionDoesNotImplyRawDeletion: true,
+                aiwgDeletionDoesNotDeleteProviderData: true,
+            },
+            opaqueContent: typeof value.content !== 'string',
+            provenance: {
+                acquisition: locatorClass,
+                schema: version(value.schemaVersion),
+                rawTranscriptAuthoritative: true,
+                enrichmentJoined: Boolean(thread || turn),
+            },
+            unknownFields: unknownFields(value, RAW_KEYS),
+            threadUnknownFields: thread ? unknownFields(thread, THREAD_KEYS) : {},
+            turnUnknownFields: turn ? unknownFields(turn, TURN_KEYS) : {},
+        },
+    };
+}
+function recordKind(value) {
+    if (value.attachment)
+        return 'attachment';
+    if (value.tool) {
+        const status = String(value.tool.status ?? '');
+        return ['failed', 'error', 'completed'].includes(status) ? 'tool-result' : 'tool-call';
+    }
+    if (value.compacted)
+        return 'compaction';
+    if (value.interrupted)
+        return 'interruption';
+    if (value.type === 'message')
+        return 'message';
+    return `openhuman.${value.type}`;
+}
+function extractText(content, tool) {
+    if (typeof content === 'string')
+        return content;
+    if (tool && typeof tool.output === 'string')
+        return tool.output;
+    if (Array.isArray(content)) {
+        return content.map((item) => {
+            const record = item && typeof item === 'object' ? item : {};
+            return typeof record.text === 'string' ? record.text : '';
+        }).filter(Boolean).join('\n');
+    }
+    return '';
+}
+function version(value) {
+    if (typeof value === 'number')
+        return `${value}.0.0`;
+    return /^\d+$/.test(value) ? `${value}.0.0` : value;
+}
+function timestamp(value) {
+    if (typeof value === 'string') {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    if (typeof value !== 'number')
+        return undefined;
+    const date = new Date(value < 10_000_000_000 ? value * 1_000 : value);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function unknownFields(value, keys) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !keys.has(key)).sort(([a], [b]) => a.localeCompare(b)));
+}
+function parseCursor(value) {
+    if (!value)
+        return 0;
+    if (!/^\d+$/.test(value))
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid OpenHuman cursor');
+    return Number(value);
+}
+const RAW_KEYS = new Set([
+    'schemaVersion', 'recordType', 'session_id', 'event_id', 'thread_id', 'request_id',
+    'parent_event_id', 'type', 'role', 'content', 'timestamp', 'metadata', 'input_tokens',
+    'cached_input_tokens', 'output_tokens', 'charged_amount_usd', 'compacted',
+    'interrupted', 'tool', 'attachment', 'active', 'raw_transcript_deleted_at',
+]);
+const THREAD_KEYS = new Set([
+    'schemaVersion', 'recordType', 'thread_id', 'title', 'state', 'deleted_at',
+]);
+const TURN_KEYS = new Set([
+    'schemaVersion', 'recordType', 'thread_id', 'request_id', 'state', 'interrupted',
+    'completed_at',
+]);
+//# sourceMappingURL=openhuman.js.map

package/dist/src/sessions/adapters/warp.js

@@ -0,0 +1,160 @@
+import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
+import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
+import { readBoundedText } from '../readers.js';
+export const WARP_ADAPTER_VERSION = '1.0.0';
+export const WARP_MARKDOWN_SCHEMA_VERSION = '1.0.0';
+export class WarpSessionAdapter {
+    limits;
+    provider = 'warp';
+    adapterVersion = WARP_ADAPTER_VERSION;
+    disposition = 'manual-only';
+    supportedOperations = ['inspect', 'stream'];
+    acquisitionModes = ['manual-export'];
+    constructor(limits) {
+        this.limits = limits;
+    }
+    async *discover(_scope) {
+        // Deliberately no internal store discovery. Users select a Markdown export.
+    }
+    async inspect(source) {
+        if (source.locatorClass === 'warp-internal-store'
+            || source.locatorClass === 'warp-sqlite'
+            || source.locatorClass === 'warp-protobuf') {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'Warp internal store discovery is unsupported; use /export-to-file and select the Markdown export');
+        }
+        const parsed = await this.readSource(source);
+        return {
+            sourceSchemaVersion: parsed.schemaVersion,
+            consistency: 'complete',
+            operationalState: 'available',
+        };
+    }
+    async *stream(source, cursor) {
+        const parsed = await this.readSource(source);
+        const start = parseCursor(cursor?.value);
+        for (const record of parsed.records.slice(start))
+            yield record;
+    }
+    async readSource(source) {
+        if (source.locatorClass !== 'warp-markdown-export') {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'Warp supports only an explicitly selected Markdown conversation export');
+        }
+        const { value } = await readBoundedText({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, this.limits);
+        const schemaVersion = declaredSchema(value);
+        assertSupportedSchemaMajor(schemaVersion);
+        const blocks = parseBlocks(value);
+        if (blocks.length === 0) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Warp Markdown export contains no recognized user or assistant conversation blocks');
+        }
+        const stableSessionId = `manual:${createHash('sha256').update(value).digest('hex').slice(0, 32)}`;
+        const lifecycleEvidence = /<!--\s*warp-lifecycle:\s*complete\s*-->/i.test(value)
+            ? 'completed-at-import' : 'unknown-at-import';
+        const title = /^#\s+(.+)$/m.exec(value)?.[1]?.trim();
+        return {
+            schemaVersion: WARP_MARKDOWN_SCHEMA_VERSION,
+            records: blocks.map((block, sequence) => ({
+                nativeSessionId: stableSessionId,
+                nativeEventId: undefined,
+                sequence,
+                kind: 'message',
+                role: block.role,
+                occurredAt: undefined,
+                text: block.text,
+                rawReference: { locatorClass: source.locatorClass, sequence },
+                extensions: {
+                    lifecycle: lifecycleEvidence,
+                    manualImport: true,
+                    title,
+                    heading: block.heading,
+                    identity: {
+                        nativeSessionIdKnown: false,
+                        nativeEventIdKnown: false,
+                        derivedSessionIdentity: true,
+                    },
+                    lossReport: {
+                        lossless: false,
+                        sourceFormat: 'markdown',
+                        unknownFields: [
+                            'nativeSessionId',
+                            'nativeEventId',
+                            'timestamp',
+                            'model',
+                            'toolStructure',
+                            'attachmentStructure',
+                            'tokenUsage',
+                            'cost',
+                            'workspace',
+                            'lineage',
+                        ],
+                        roleInference: 'heading-based',
+                        lifecycleEvidence,
+                    },
+                    provenance: {
+                        acquisition: 'user-selected-markdown-export',
+                        schema: schemaVersion,
+                        exportCommand: '/export-to-file',
+                        internalStoreInspected: false,
+                        originalFilename: basename(source.locator),
+                    },
+                    deletion: {
+                        aiwgDeletionDoesNotDeleteWarpConversation: true,
+                        exportDeletionDoesNotDeleteWarpConversation: true,
+                        providerDeletionStateUnknown: true,
+                    },
+                },
+            })),
+        };
+    }
+}
+function declaredSchema(value) {
+    const match = /<!--\s*warp-conversation-export:\s*([^\s]+)\s*-->/i.exec(value);
+    if (!match)
+        return WARP_MARKDOWN_SCHEMA_VERSION;
+    const version = match[1];
+    return /^\d+$/.test(version) ? `${version}.0.0` : version;
+}
+function parseBlocks(value) {
+    const lines = value.replace(/\r\n/g, '\n').split('\n');
+    const blocks = [];
+    let current;
+    const flush = () => {
+        if (!current)
+            return;
+        const text = current.lines.join('\n').trim();
+        if (text)
+            blocks.push({ role: current.role, heading: current.heading, text });
+    };
+    for (const line of lines) {
+        const heading = /^#{2,6}\s+(.+?)\s*$/.exec(line);
+        const role = heading ? headingRole(heading[1]) : undefined;
+        if (role) {
+            flush();
+            current = { role, heading: heading[1].trim(), lines: [] };
+        }
+        else if (current && !/^<!--\s*warp-(?:conversation-export|lifecycle):/i.test(line)) {
+            current.lines.push(line);
+        }
+    }
+    flush();
+    return blocks;
+}
+function headingRole(heading) {
+    const normalized = heading.trim().toLowerCase().replace(/[:：]\s*$/, '');
+    if (/^(user|you|human|prompt|query)(?:\s+\d+)?$/.test(normalized))
+        return 'user';
+    if (/^(warp|assistant|agent|response|answer)(?:\s+\d+)?$/.test(normalized))
+        return 'assistant';
+    return undefined;
+}
+function parseCursor(value) {
+    if (!value)
+        return 0;
+    if (!/^\d+$/.test(value))
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Warp cursor');
+    return Number(value);
+}
+//# sourceMappingURL=warp.js.map

package/dist/src/sessions/adapters/windsurf.js

@@ -0,0 +1,212 @@
+import { basename } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
+import { readBoundedJsonLines, streamBoundedJsonLines, } from '../readers.js';
+export const DEVIN_DESKTOP_ADAPTER_VERSION = '1.1.0';
+export const DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION = '1.0.0';
+/** @deprecated Compatibility export. */
+export const WINDSURF_ADAPTER_VERSION = DEVIN_DESKTOP_ADAPTER_VERSION;
+/** @deprecated Compatibility export. */
+export const WINDSURF_TRANSCRIPT_SCHEMA_VERSION = DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION;
+const StepSchema = z.object({
+    schema_version: z.string().optional(),
+    type: z.string().min(1),
+    status: z.string().min(1),
+    trajectory_id: z.string().min(1).optional(),
+    execution_id: z.string().min(1).optional(),
+    event_id: z.string().min(1).optional(),
+    timestamp: z.string().optional(),
+    model_name: z.string().optional(),
+    model: z.union([z.string(), z.record(z.unknown())]).optional(),
+    sensitive_content_warning: z.union([z.boolean(), z.string(), z.record(z.unknown())]).optional(),
+    user_input: z.record(z.unknown()).optional(),
+    planner_response: z.record(z.unknown()).optional(),
+    code_action: z.record(z.unknown()).optional(),
+    tool_info: z.record(z.unknown()).optional(),
+}).passthrough();
+export class DevinDesktopSessionAdapter {
+    limits;
+    provider = 'devin-desktop';
+    adapterVersion = DEVIN_DESKTOP_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['inspect', 'stream'];
+    acquisitionModes = ['hook', 'jsonl'];
+    constructor(limits) {
+        this.limits = limits;
+    }
+    async *discover(_scope) {
+        // Deliberately empty: hook enablement and transcript selection are explicit user actions.
+    }
+    async inspect(source) {
+        const parsed = await this.readSource(source);
+        return {
+            sourceSchemaVersion: parsed.schemaVersion,
+            consistency: 'provisional',
+            operationalState: 'available',
+        };
+    }
+    async *stream(source, cursor) {
+        if (!isCurrentHookLocator(source.locatorClass)) {
+            // Preserve the precise unsupported-operation diagnostics.
+            await this.readSource(source);
+            return;
+        }
+        const start = parseCursor(cursor?.value);
+        const input = await streamBoundedJsonLines({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, { consistency: 'provisional', limits: this.limits });
+        let schemaVersion = null;
+        let nativeSessionId = null;
+        let seen = 0;
+        for await (const line of input) {
+            const parsed = StepSchema.safeParse(line.value);
+            if (!parsed.success) {
+                throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript step is malformed');
+            }
+            const step = parsed.data;
+            const currentVersion = step.schema_version ?? DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION;
+            if (schemaVersion && schemaVersion !== currentVersion) {
+                throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf transcript schemas');
+            }
+            schemaVersion = currentVersion;
+            assertSupportedSchemaMajor(schemaVersion);
+            const currentSession = step.trajectory_id
+                ?? nativeSessionId
+                ?? basename(source.locator, '.jsonl');
+            if (step.trajectory_id && nativeSessionId && step.trajectory_id !== nativeSessionId) {
+                throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf trajectory identities');
+            }
+            nativeSessionId = currentSession;
+            if (seen++ < start)
+                continue;
+            yield normalizeStep(step, currentSession, line.sequence, line.byteOffset, canonicalLocatorClass(source.locatorClass), schemaVersion);
+        }
+        if (seen === 0) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript is empty or malformed');
+        }
+    }
+    async readSource(source) {
+        if (isLegacyLocator(source.locatorClass)) {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'legacy Devin Desktop/Windsurf protobuf stores are unsupported; enable post_cascade_response_with_transcript and select its JSONL output');
+        }
+        if (!isCurrentHookLocator(source.locatorClass)) {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'Devin Desktop (Windsurf compatibility) requires an explicitly selected post_cascade_response_with_transcript JSONL file');
+        }
+        const input = await readBoundedJsonLines({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, { consistency: 'provisional', limits: this.limits });
+        if (input.records.length === 0) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript is empty or malformed');
+        }
+        const steps = input.records.map((record) => {
+            const parsed = StepSchema.safeParse(record.value);
+            if (!parsed.success) {
+                throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript step is malformed');
+            }
+            return { ...record, value: parsed.data };
+        });
+        const versions = new Set(steps.map(({ value }) => value.schema_version ?? DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION));
+        if (versions.size !== 1) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf transcript schemas');
+        }
+        const schemaVersion = [...versions][0];
+        assertSupportedSchemaMajor(schemaVersion);
+        const trajectoryIds = new Set(steps.flatMap(({ value }) => value.trajectory_id ? [value.trajectory_id] : []));
+        if (trajectoryIds.size > 1) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf trajectory identities');
+        }
+        const nativeSessionId = [...trajectoryIds][0] ?? basename(source.locator, '.jsonl');
+        return {
+            schemaVersion,
+            records: steps.map(({ value, sequence, byteOffset }) => normalizeStep(value, nativeSessionId, sequence, byteOffset, canonicalLocatorClass(source.locatorClass), schemaVersion)),
+        };
+    }
+}
+/** @deprecated Use DevinDesktopSessionAdapter; retained through the alias window. */
+export class WindsurfSessionAdapter extends DevinDesktopSessionAdapter {
+}
+function isCurrentHookLocator(value) {
+    return value === 'devin-desktop-cascade-hook-jsonl'
+        || value === 'windsurf-cascade-hook-jsonl';
+}
+function isLegacyLocator(value) {
+    return value === 'devin-desktop-legacy-protobuf'
+        || value === 'windsurf-legacy-protobuf';
+}
+function canonicalLocatorClass(value) {
+    return value.startsWith('windsurf-')
+        ? `devin-desktop-${value.slice('windsurf-'.length)}`
+        : value;
+}
+function normalizeStep(step, nativeSessionId, sequence, offset, locatorClass, schemaVersion) {
+    const text = stepText(step);
+    return {
+        nativeSessionId,
+        nativeEventId: step.event_id ?? (step.execution_id
+            ? `${step.execution_id}:${sequence}` : `${nativeSessionId}:${sequence}`),
+        sequence,
+        kind: `devin-desktop.${step.type}`,
+        role: step.type === 'user_input' ? 'user'
+            : step.type === 'planner_response' ? 'assistant' : 'tool',
+        participant: step.type === 'user_input' ? 'user'
+            : step.type === 'planner_response' ? 'assistant' : 'tool',
+        model: step.model_name ?? (typeof step.model === 'string' ? step.model : undefined),
+        occurredAt: timestamp(step.timestamp),
+        text,
+        rawReference: { locatorClass, offset, sequence },
+        extensions: {
+            status: step.status,
+            trajectoryId: step.trajectory_id ?? nativeSessionId,
+            executionId: step.execution_id,
+            model: step.model_name ?? step.model,
+            sensitiveContentWarning: step.sensitive_content_warning ?? true,
+            nativeStep: step,
+            provenance: {
+                acquisition: 'user-enabled-post_cascade_response_with_transcript',
+                product: 'Devin Desktop',
+                providerId: 'devin-desktop',
+                compatibilityProviderId: 'windsurf',
+                captureBoundary: 'completed-cascade-response',
+                schema: schemaVersion,
+                optInRequired: true,
+                hookConfiguredByAiWG: false,
+                credentialsInspected: false,
+                environmentSecretsInspected: false,
+                liveTokenCapture: false,
+                completeHistoricalCapture: false,
+                providerRetention: { maximumFiles: 100, evictionOrder: 'oldest-mtime' },
+            },
+            deletion: {
+                aiwgDeletionDoesNotDeleteWindsurfTranscript: true,
+                providerConversationDeletionStateUnknown: true,
+            },
+        },
+    };
+}
+function stepText(step) {
+    const candidate = step.type === 'user_input'
+        ? step.user_input?.user_response
+        : step.type === 'planner_response'
+            ? step.planner_response?.response
+            : step.code_action?.new_content ?? step.tool_info?.response;
+    return typeof candidate === 'string' ? candidate : '';
+}
+function timestamp(value) {
+    if (!value)
+        return undefined;
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        throw new SessionContractError('AMBIGUOUS_TIMESTAMP', 'invalid Windsurf timestamp');
+    }
+    return date.toISOString();
+}
+function parseCursor(value) {
+    if (!value)
+        return 0;
+    if (!/^\d+$/.test(value))
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Windsurf cursor');
+    return Number(value);
+}
+//# sourceMappingURL=windsurf.js.map