@aiwg/cli 2026.7.20 → 2026.7.21

package/dist/src/sessions/importer.js

@@ -0,0 +1,315 @@
+import { SESSION_CONTRACT_VERSION, SessionEventSchema, SessionSchema, assertSupportedSchemaMajor, sha256, stableEventId, stableSessionId, SessionContractError, } from './contracts.js';
+import { redactSessionText, sanitizeNativeExtensions } from './policy.js';
+import { fingerprintSourcePrefix } from './readers.js';
+const DEFAULT_LIMITS = {
+    maxRecords: 1_000_000,
+    maxRecordBytes: 4 * 1024 * 1024,
+    maxTotalBytes: 1024 * 1024 * 1024,
+    batchSize: 1_000,
+};
+export class SessionImportFailure extends SessionContractError {
+    failureReceipt;
+    constructor(failureReceipt, cause) {
+        super(cause instanceof SessionContractError ? cause.code : 'IMPORT_INTERRUPTED', cause instanceof Error ? cause.message : 'session import failed');
+        this.failureReceipt = failureReceipt;
+        this.name = 'SessionImportFailure';
+    }
+}
+export class IncrementalSessionImporter {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async import(request) {
+        assertSupportedSchemaMajor(request.source.sourceSchemaVersion);
+        if (request.workspaceId !== request.selectedSource.authorizedScope.workspaceId) {
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'session import workspace is outside the authorized source scope');
+        }
+        const limits = { ...DEFAULT_LIMITS, ...request.limits };
+        const previous = this.repository.getCheckpoint(request.source.sourceId, request.adapter.adapterVersion);
+        const continuity = await sourceContinuity(request, previous);
+        const sourceGeneration = continuity?.sourceGeneration ?? sourceGenerationDigest(request);
+        if (previous?.sourceGeneration && previous.sourceGeneration !== sourceGeneration) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source generation changed; explicit restart or migration is required');
+        }
+        if (previous?.adapterVersion && previous.adapterVersion !== request.adapter.adapterVersion) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint adapter version changed; checkpoint migration is required');
+        }
+        if (previous?.sourceSchemaVersion
+            && previous.sourceSchemaVersion !== request.source.sourceSchemaVersion) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint source schema changed; checkpoint migration is required');
+        }
+        if (previous?.policyVersion && previous.policyVersion !== request.policyVersion) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint policy version changed; checkpoint migration is required');
+        }
+        const checkpoint = {
+            cursor: previous?.cursor ?? '',
+            recordsRead: previous?.recordsRead ?? 0,
+            bytesRead: previous?.bytesRead ?? 0,
+            checkpointVersion: '2',
+            positionKind: previous?.positionKind ?? 'record-index',
+            sourceGeneration,
+            locatorClass: request.selectedSource.locatorClass,
+            adapterVersion: request.adapter.adapterVersion,
+            sourceSchemaVersion: request.source.sourceSchemaVersion,
+            policyVersion: request.policyVersion,
+            continuity: continuity
+                ? (!previous || previous.positionKind === 'byte-offset'
+                    ? continuity.outcome
+                    : 'unverified')
+                : (previous ? 'unverified' : 'new-generation'),
+            sourceSize: continuity?.size,
+            sourceMtimeMs: continuity?.mtimeMs,
+            sourceFileIdentity: continuity?.fileIdentity,
+            prefixDigest: continuity?.prefixDigest,
+        };
+        const receipts = [];
+        let batch = [];
+        let batchStart = checkpoint.recordsRead;
+        let durableCheckpoint = { ...checkpoint };
+        const importStarted = performance.now();
+        let peakHeap = process.memoryUsage().heapUsed;
+        let peakRss = process.memoryUsage().rss;
+        const flush = () => {
+            if (batch.length === 0)
+                return;
+            const runId = sha256([
+                request.source.sourceId, request.adapter.adapterVersion,
+                batchStart, checkpoint.recordsRead,
+                ...batch.map((record) => sha256(JSON.stringify(record))),
+            ].join('\0'));
+            const normalized = normalizeBatch(request, batch, runId);
+            const run = {
+                contractVersion: SESSION_CONTRACT_VERSION,
+                importRunId: runId,
+                sourceId: request.source.sourceId,
+                parserVersion: request.adapter.adapterVersion,
+                policyVersion: request.policyVersion,
+                sourceSchemaVersion: request.source.sourceSchemaVersion,
+                consistency: request.source.consistency,
+                status: 'running',
+                checkpoint: { ...checkpoint },
+                startedAt: new Date().toISOString(),
+                completedAt: null,
+                errorCode: null,
+            };
+            const flushStarted = performance.now();
+            const sanitizedSource = {
+                ...request.source,
+                extensions: sanitizeNativeExtensions(request.source.extensions).value,
+            };
+            const receipt = this.repository.applyImport({
+                source: sanitizedSource, run,
+                sessions: normalized.sessions, events: normalized.events,
+            }, { ...checkpoint }, request.source.consistency !== 'complete');
+            const memory = process.memoryUsage();
+            peakHeap = Math.max(peakHeap, memory.heapUsed);
+            peakRss = Math.max(peakRss, memory.rss);
+            receipt.metrics = {
+                records: batch.length,
+                normalizedEvents: normalized.events.length,
+                normalizedBytes: batch.reduce((total, record) => total + Buffer.byteLength(JSON.stringify(record)), 0),
+                durationMs: performance.now() - importStarted,
+                batchLatencyMs: performance.now() - flushStarted,
+                heapUsedBytes: peakHeap,
+                rssBytes: peakRss,
+                checkpointDurable: true,
+            };
+            receipts.push(receipt);
+            durableCheckpoint = { ...checkpoint };
+            batch = [];
+            batchStart = checkpoint.recordsRead;
+        };
+        try {
+            for await (const record of request.adapter.stream(request.selectedSource, previous ? { value: previous.cursor } : undefined)) {
+                const bytes = Buffer.byteLength(JSON.stringify(record));
+                if (bytes > limits.maxRecordBytes
+                    || checkpoint.bytesRead + bytes > limits.maxTotalBytes
+                    || checkpoint.recordsRead + 1 > limits.maxRecords) {
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'session import exceeded an authorized resource limit');
+                }
+                batch.push(record);
+                checkpoint.recordsRead += 1;
+                if (record.sourceCursor?.startsWith('byte:')) {
+                    checkpoint.positionKind = 'byte-offset';
+                    checkpoint.cursor = record.sourceCursor;
+                    checkpoint.bytesRead = Number(record.sourceCursor.slice(5));
+                }
+                else {
+                    checkpoint.bytesRead += bytes;
+                    checkpoint.cursor = String(checkpoint.recordsRead);
+                }
+                if (batch.length >= limits.batchSize)
+                    flush();
+            }
+            flush();
+        }
+        catch (error) {
+            const committed = request.source.consistency === 'complete' ? [] : receipts;
+            throw new SessionImportFailure({
+                contractVersion: '1.0.0',
+                outcome: 'terminal-failure',
+                sourceId: request.source.sourceId,
+                sourceGeneration,
+                consistency: request.source.consistency,
+                committedPrefix: {
+                    batches: committed.length,
+                    records: committed.reduce((total, receipt) => total + (receipt.metrics?.records ?? 0), 0),
+                    events: committed.reduce((total, receipt) => total + receipt.eventsInserted, 0),
+                },
+                resumableCheckpoint: request.source.consistency === 'complete'
+                    ? {
+                        ...durableCheckpoint,
+                        cursor: '',
+                        recordsRead: 0,
+                        bytesRead: 0,
+                        continuity: 'new-generation',
+                    }
+                    : durableCheckpoint,
+                errorCode: error instanceof SessionContractError
+                    ? error.code : 'IMPORT_INTERRUPTED',
+            }, error);
+        }
+        if (request.source.consistency === 'complete') {
+            this.repository.commitStagedImports(request.source.sourceId, request.adapter.adapterVersion);
+            for (const receipt of receipts) {
+                if (receipt.outcome === 'staged')
+                    receipt.outcome = 'committed';
+            }
+        }
+        return receipts;
+    }
+}
+function normalizeBatch(request, records, importRunId) {
+    const sessions = new Map();
+    const events = records.map((record) => {
+        const sessionId = stableSessionId(request.source.provider, request.source.sourceId, record.nativeSessionId);
+        const redacted = redactSessionText(record.text);
+        const native = sanitizeNativeExtensions(record.extensions ?? {});
+        const digest = sha256(JSON.stringify(record));
+        const extensions = {
+            [`native.${request.source.provider}`]: native.value,
+        };
+        const event = SessionEventSchema.parse({
+            contractVersion: SESSION_CONTRACT_VERSION,
+            eventId: stableEventId(request.source.sourceId, record, digest),
+            sessionId, sourceId: request.source.sourceId, importRunId,
+            nativeId: record.nativeEventId ?? null, sequence: record.sequence,
+            kind: record.kind, role: record.role ?? null, occurredAt: record.occurredAt ?? null,
+            participant: record.participant ?? null,
+            toolName: record.toolName ?? null,
+            toolCallId: record.toolCallId ?? null,
+            model: record.model ?? null,
+            entities: record.entities ?? [],
+            extractionState: record.extractionState ?? null,
+            searchableText: redacted.text, digest, rawReference: record.rawReference,
+            adapterVersion: request.adapter.adapterVersion,
+            consistency: request.source.consistency,
+            sensitivity: {
+                classification: redacted.sensitivity === 'sensitive' || native.sensitivity === 'sensitive'
+                    ? 'sensitive' : 'none',
+                classes: [...new Set([...redacted.classes, ...native.classes])].sort(),
+            },
+            opaque: !KNOWN_EVENT_KINDS.has(record.kind),
+            extensions,
+        });
+        if (!sessions.has(sessionId)) {
+            sessions.set(sessionId, SessionSchema.parse({
+                contractVersion: SESSION_CONTRACT_VERSION,
+                sessionId, sourceId: request.source.sourceId, provider: request.source.provider,
+                nativeSessionId: record.nativeSessionId, workspaceId: request.workspaceId,
+                startedAt: record.occurredAt ?? null, updatedAt: record.occurredAt ?? null,
+                consistency: request.source.consistency,
+                lifecycle: request.source.consistency === 'complete' ? 'complete' : 'active',
+                sourceDigest: sha256(`${sourceGenerationDigest(request)}\0${record.nativeSessionId}`),
+                extensions: { [`native.${request.source.provider}`]: {} },
+            }));
+        }
+        else {
+            const session = sessions.get(sessionId);
+            session.startedAt = earlierTimestamp(session.startedAt, record.occurredAt ?? null);
+            session.updatedAt = laterTimestamp(session.updatedAt, record.occurredAt ?? null);
+            session.consistency = strongerConsistency(session.consistency, request.source.consistency);
+            if (session.lifecycle !== 'tombstoned' && request.source.consistency === 'complete') {
+                session.lifecycle = 'complete';
+            }
+        }
+        return event;
+    });
+    return { sessions: [...sessions.values()], events };
+}
+const KNOWN_EVENT_KINDS = new Set(['message', 'tool-call', 'tool-result', 'artifact', 'attachment', 'summary']);
+function earlierTimestamp(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return Date.parse(left) <= Date.parse(right) ? left : right;
+}
+function laterTimestamp(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return Date.parse(left) >= Date.parse(right) ? left : right;
+}
+function strongerConsistency(left, right) {
+    const rank = {
+        provisional: 0,
+        'consistent-snapshot': 1,
+        complete: 2,
+    };
+    return rank[left] >= rank[right] ? left : right;
+}
+function sourceGenerationDigest(request) {
+    return sha256([
+        request.source.sourceId,
+        request.source.provider,
+        request.selectedSource.locatorClass,
+        request.source.sourceSchemaVersion,
+        request.adapter.adapterVersion,
+    ].join('\0'));
+}
+async function sourceContinuity(request, previous) {
+    if (request.selectedSource.authorizedScope.allowedRoots.length === 0
+        || /^[a-z][a-z0-9+.-]*:\/\//i.test(request.selectedSource.locator)
+        || request.selectedSource.locator.startsWith('<')) {
+        return null;
+    }
+    const authorization = {
+        selectedPath: request.selectedSource.locator,
+        allowedRoots: request.selectedSource.authorizedScope.allowedRoots,
+    };
+    const metadata = await fingerprintSourcePrefix(authorization, 0);
+    if (previous?.sourceSize !== undefined) {
+        if (metadata.size < previous.sourceSize) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source was truncated before its durable checkpoint');
+        }
+        if (previous.sourceFileIdentity
+            && previous.sourceFileIdentity !== metadata.fileIdentity) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source file generation was replaced or rotated');
+        }
+        const priorPrefix = await fingerprintSourcePrefix(authorization, previous.sourceSize);
+        if (previous.prefixDigest && priorPrefix.digest !== previous.prefixDigest) {
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source prefix was rewritten before its durable checkpoint');
+        }
+    }
+    const current = await fingerprintSourcePrefix(authorization, metadata.size);
+    const generation = previous?.sourceGeneration ?? sha256([
+        sourceGenerationDigest(request),
+        metadata.fileIdentity,
+    ].join('\0'));
+    return {
+        sourceGeneration: generation,
+        outcome: !previous
+            ? 'new-generation'
+            : metadata.size === previous.sourceSize
+                && current.digest === previous.prefixDigest
+                ? 'unchanged-replay' : 'validated-append',
+        size: metadata.size,
+        mtimeMs: metadata.mtimeMs,
+        fileIdentity: metadata.fileIdentity,
+        prefixDigest: current.digest,
+    };
+}
+//# sourceMappingURL=importer.js.map

package/dist/src/sessions/index.js

@@ -0,0 +1,25 @@
+export * from './contracts.js';
+export * from './fixtures.js';
+export * from './policy.js';
+export * from './discovery.js';
+export * from './readers.js';
+export * from './repository.js';
+export * from './ports.js';
+export * from './optional-backends.js';
+export * from './knowledge-shard.js';
+export * from './candidates.js';
+export * from './promotion.js';
+export * from './importer.js';
+export * from './adapters/generic.js';
+export * from './adapters/claude.js';
+export * from './adapters/codex.js';
+export * from './adapters/copilot.js';
+export * from './adapters/cursor.js';
+export * from './adapters/factory.js';
+export * from './adapters/hermes.js';
+export * from './adapters/opencode.js';
+export * from './adapters/openclaw.js';
+export * from './adapters/openhuman.js';
+export * from './adapters/warp.js';
+export * from './adapters/windsurf.js';
+//# sourceMappingURL=index.js.map

package/dist/src/sessions/knowledge-shard.js

@@ -0,0 +1,61 @@
+export function convertSessionEventsToKnowledgeShard(source, events) {
+    const losses = [];
+    const records = events.map((event) => {
+        if (Object.values(event.extensions).some(hasPortableValue)) {
+            losses.push({
+                code: 'NATIVE_EXTENSION_NOT_PORTABLE',
+                eventId: event.eventId,
+                field: 'extensions',
+                reason: 'Knowledge Shard v1 has no canonical provider-native extension field',
+            });
+        }
+        if (event.rawReference.offset !== undefined) {
+            losses.push({
+                code: 'RAW_OFFSET_NOT_PORTABLE',
+                eventId: event.eventId,
+                field: 'rawReference.offset',
+                reason: 'Knowledge Shard v1 preserves locator class but not byte offsets',
+            });
+        }
+        if (event.rawReference.sequence !== undefined) {
+            losses.push({
+                code: 'RAW_SEQUENCE_NOT_PORTABLE',
+                eventId: event.eventId,
+                field: 'rawReference.sequence',
+                reason: 'Knowledge Shard v1 preserves event identity but not provider sequence locators',
+            });
+        }
+        return {
+            id: event.eventId,
+            content: event.searchableText,
+            metadata: {
+                provider: source.provider,
+                sessionId: event.sessionId,
+                eventId: event.eventId,
+                importRunId: event.importRunId,
+                sourceId: event.sourceId,
+                locatorClass: source.locatorClass,
+                role: event.role,
+                occurredAt: event.occurredAt,
+                sensitivity: event.sensitivity.classification,
+            },
+        };
+    });
+    return {
+        contractVersion: '1.0.0',
+        target: 'knowledge-shard-v1',
+        records,
+        losses,
+        lossless: losses.length === 0,
+    };
+}
+function hasPortableValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length > 0;
+    return true;
+}
+//# sourceMappingURL=knowledge-shard.js.map

package/dist/src/sessions/optional-backends.js

@@ -0,0 +1,238 @@
+import { sha256, SessionContractError } from './contracts.js';
+export class FortemiSessionRepositoryBackend {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    previewImport(batch) {
+        const workspaceIds = [...new Set(batch.sessions.map((session) => session.workspaceId))];
+        if (workspaceIds.length !== 1) {
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'optional backend import must contain exactly one workspace scope');
+        }
+        return repositoryPreview({
+            operation: 'upsert',
+            workspaceId: workspaceIds[0],
+            sourceId: batch.source.sourceId,
+            eventIdentities: batch.events.map((event) => `${event.eventId}:${event.digest}`),
+            transfersApprovedText: true,
+        });
+    }
+    async applyImport(batch, checkpoint, authorization) {
+        this.assertCapabilities();
+        const preview = this.previewImport(batch);
+        assertRepositoryAuthorization(preview, authorization);
+        const result = await this.options.client.callTool('upsert_external_notes', {
+            source_namespace: `aiwg.sessions.${batch.source.provider}`,
+            source_id: batch.source.sourceId,
+            source_schema_version: batch.source.sourceSchemaVersion,
+            import_run_id: batch.run.importRunId,
+            workspace_id: preview.workspaceId,
+            items: batch.events.map((event) => ({
+                external_id: event.eventId,
+                content: event.searchableText,
+                content_digest: event.digest,
+                metadata: {
+                    session_id: event.sessionId,
+                    import_run_id: event.importRunId,
+                    locator_class: batch.source.locatorClass,
+                    role: event.role,
+                    sensitivity: event.sensitivity.classification,
+                },
+            })),
+        });
+        return {
+            operationId: batch.run.importRunId,
+            outcome: result?.outcome ?? 'committed',
+            sessionsInserted: result?.sessions_inserted ?? batch.sessions.length,
+            eventsInserted: result?.events_inserted ?? batch.events.length,
+            checkpoint,
+        };
+    }
+    previewTombstone(workspaceId, sessionId, eventIds) {
+        return repositoryPreview({
+            operation: 'tombstone',
+            workspaceId,
+            sessionId,
+            eventIdentities: eventIds,
+            transfersApprovedText: false,
+        });
+    }
+    async tombstone(workspaceId, sessionId, eventIds, authorization) {
+        this.assertCapabilities(true);
+        const preview = this.previewTombstone(workspaceId, sessionId, eventIds);
+        assertRepositoryAuthorization(preview, authorization);
+        const result = await this.options.client.callTool('purge_external_notes', {
+            workspace_id: workspaceId,
+            session_id: sessionId,
+            external_ids: [...eventIds],
+            mode: 'tombstone',
+        });
+        return {
+            operationId: preview.operationId,
+            outcome: 'committed',
+            affected: result?.affected ?? eventIds.length,
+        };
+    }
+    assertCapabilities(requireGraphPurge = false) {
+        if (!this.options.capabilities.sourceAddressedUpsert
+            || !this.options.capabilities.typedMetadataPredicates
+            || !this.options.capabilities.evidenceLocators
+            || (requireGraphPurge && !this.options.capabilities.graphPurge)) {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'Fortemi session repository requires source upsert, typed predicates, evidence locators, and graph purge for deletion');
+        }
+    }
+}
+export class FortemiSessionBackend {
+    options;
+    id = 'fortemi';
+    requiresNetwork = true;
+    requiresModel = true;
+    constructor(options) {
+        this.options = options;
+    }
+    async rank(request) {
+        if (!this.options.capabilities.sourceAddressedUpsert
+            || !this.options.capabilities.typedMetadataPredicates
+            || !this.options.capabilities.evidenceLocators) {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'Fortemi session integration requires source upsert, typed predicates, and evidence locators');
+        }
+        const result = await this.options.client.callTool('search', {
+            query: request.query,
+            mode: 'hybrid',
+            predicates: [{ path: 'workspace_id', op: 'eq', value: request.workspaceId }],
+            candidates: request.documents.map((document) => ({
+                external_id: document.eventId,
+                content: document.text,
+                citation: document.citation,
+            })),
+        });
+        return (result?.results ?? [])
+            .filter((entry) => typeof entry.external_id === 'string' && typeof entry.score === 'number')
+            .map((entry) => ({ eventId: entry.external_id, score: entry.score }));
+    }
+}
+export class SessionSearchService {
+    lexical;
+    constructor(lexical) {
+        this.lexical = lexical;
+    }
+    preview(options, backend) {
+        const documents = this.documents(options);
+        return createPreview(options, backend, documents);
+    }
+    async search(request) {
+        if ((request.mode ?? 'lexical') === 'lexical' || !request.backend) {
+            return this.lexical.search(request.options);
+        }
+        const documents = this.documents(request.options);
+        const preview = createPreview(request.options, request.backend, documents);
+        if (!request.authorization?.approved
+            || request.authorization.operationId !== preview.operationId) {
+            throw new SessionContractError(request.backend.requiresNetwork ? 'NETWORK_NOT_AUTHORIZED' : 'OPERATION_NOT_AUTHORIZED', 'optional semantic/backend search requires approval of the exact preview operation');
+        }
+        const ranked = await request.backend.rank({
+            query: request.options.query,
+            workspaceId: request.options.workspaceId,
+            documents: documents.map((document) => ({
+                eventId: document.eventId,
+                text: document.searchableText,
+                citation: document.citation,
+            })),
+        });
+        const authorized = new Map(documents.map((document) => [document.eventId, document]));
+        const semanticByEvent = new Map();
+        for (const candidate of ranked) {
+            if (!Number.isFinite(candidate.score) || !authorized.has(candidate.eventId))
+                continue;
+            semanticByEvent.set(candidate.eventId, Math.max(semanticByEvent.get(candidate.eventId) ?? Number.NEGATIVE_INFINITY, candidate.score));
+        }
+        const semantic = [...semanticByEvent.entries()]
+            .map(([eventId, score]) => ({ eventId, score }))
+            .sort((left, right) => right.score - left.score || left.eventId.localeCompare(right.eventId));
+        const lexical = this.lexical.search({
+            ...request.options,
+            limit: Math.min(500, Math.max(request.options.limit * 2, request.options.limit)),
+            cursor: undefined,
+        }).items;
+        const scores = new Map();
+        lexical.forEach((hit, index) => scores.set(hit.eventId, 1 / (60 + index + 1)));
+        semantic.forEach((hit, index) => {
+            scores.set(hit.eventId, (scores.get(hit.eventId) ?? 0) + 1 / (60 + index + 1));
+        });
+        const publicHits = new Map([
+            ...documents.map(({ searchableText: _text, ...hit }) => [hit.eventId, hit]),
+            ...lexical.map((hit) => [hit.eventId, hit]),
+        ]);
+        const items = [...scores.entries()]
+            .map(([eventId, score]) => ({ hit: publicHits.get(eventId), score }))
+            .filter((entry) => Boolean(entry.hit))
+            .sort((left, right) => right.score - left.score
+            || left.hit.eventId.localeCompare(right.hit.eventId))
+            .slice(0, request.options.limit)
+            .map(({ hit, score }) => ({ ...hit, score }));
+        return { items, nextCursor: null };
+    }
+    documents(options) {
+        const { query: _query, cursor: _cursor, ...scope } = options;
+        return this.lexical.authorizedSearchDocuments({
+            ...scope,
+            limit: Math.min(500, Math.max(100, options.limit * 20)),
+        });
+    }
+}
+function createPreview(options, backend, documents) {
+    const operationId = sha256(JSON.stringify({
+        backend: backend.id,
+        mode: 'hybrid',
+        workspaceId: options.workspaceId,
+        queryDigest: sha256(options.query),
+        scopeDigest: sha256(JSON.stringify({
+            providers: options.providers ?? [],
+            dateFrom: options.dateFrom ?? null,
+            dateTo: options.dateTo ?? null,
+            participant: options.participant ?? null,
+            model: options.model ?? null,
+            role: options.role ?? null,
+            tool: options.tool ?? null,
+            tag: options.tag ?? null,
+            entity: options.entity ?? null,
+            sensitivity: options.sensitivity ?? null,
+            extractionState: options.extractionState ?? null,
+            limit: options.limit,
+        })),
+        eventIds: documents.map((document) => document.eventId),
+        requiresNetwork: backend.requiresNetwork,
+        requiresModel: backend.requiresModel,
+    }));
+    return {
+        contractVersion: '1.0.0',
+        operationId,
+        backend: backend.id,
+        mode: 'hybrid',
+        workspaceId: options.workspaceId,
+        candidateCount: documents.length,
+        transfersApprovedText: true,
+        requiresNetwork: backend.requiresNetwork,
+        requiresModel: backend.requiresModel,
+    };
+}
+function repositoryPreview(input) {
+    return {
+        contractVersion: '1.0.0',
+        operationId: sha256(JSON.stringify(input)),
+        backend: 'fortemi',
+        operation: input.operation,
+        workspaceId: input.workspaceId,
+        sourceId: input.sourceId,
+        sessionId: input.sessionId,
+        eventCount: input.eventIdentities.length,
+        transfersApprovedText: input.transfersApprovedText,
+        requiresNetwork: true,
+    };
+}
+function assertRepositoryAuthorization(preview, authorization) {
+    if (!authorization?.approved || authorization.operationId !== preview.operationId) {
+        throw new SessionContractError('NETWORK_NOT_AUTHORIZED', 'optional repository operation requires approval of the exact preview operation');
+    }
+}
+//# sourceMappingURL=optional-backends.js.map