@aiwg/cli 2026.10.4 → 2026.10.6

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

@@ -1,24 +1,25 @@
 import { z } from 'zod';
+import { number } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { readBoundedJson, streamBoundedJsonLines, } from '../readers.js';
 export const OPENCODE_ADAPTER_VERSION = '1.0.0';
 export const OPENCODE_EXPORT_SCHEMA_VERSION = '1.0.0';
-const SessionInfoSchema = z.object({
+const SessionInfoSchema = z.looseObject({
     id: z.string().min(1),
     projectID: z.string().optional(),
     directory: z.string().optional(),
     parentID: z.string().optional(),
     title: z.string().optional(),
     version: z.string().optional(),
-    time: z.object({
-        created: z.number().optional(),
-        updated: z.number().optional(),
-        compacting: z.number().nullable().optional(),
-        archived: z.number().nullable().optional(),
-    }).passthrough().optional(),
-    share: z.object({ url: z.string().optional() }).passthrough().optional(),
-}).passthrough();
-const MessageInfoSchema = z.object({
+    time: z.looseObject({
+        created: number().optional(),
+        updated: number().optional(),
+        compacting: number().nullable().optional(),
+        archived: number().nullable().optional(),
+    }).optional(),
+    share: z.looseObject({ url: z.string().optional() }).optional(),
+});
+const MessageInfoSchema = z.looseObject({
     id: z.string().min(1),
     sessionID: z.string().min(1),
     role: z.string().min(1),
@@ -26,13 +27,12 @@ const MessageInfoSchema = z.object({
     modelID: z.string().optional(),
     providerID: z.string().optional(),
     model: z.object({ providerID: z.string(), modelID: z.string() }).optional(),
-    cost: z.number().optional(),
-    tokens: z.record(z.unknown()).optional(),
-    time: z.object({ created: z.number().optional(), completed: z.number().optional() })
-        .passthrough().optional(),
+    cost: number().optional(),
+    tokens: z.record(z.string(), z.unknown()).optional(),
+    time: z.looseObject({ created: number().optional(), completed: number().optional() }).optional(),
     error: z.unknown().optional(),
-}).passthrough();
-const PartSchema = z.object({
+});
+const PartSchema = z.looseObject({
     id: z.string().min(1),
     sessionID: z.string().min(1),
     messageID: z.string().min(1),
@@ -45,27 +45,27 @@ const PartSchema = z.object({
     filename: z.string().optional(),
     url: z.string().optional(),
     time: z.unknown().optional(),
-}).passthrough();
-const MessageSchema = z.object({
+});
+const MessageSchema = z.looseObject({
     info: MessageInfoSchema,
     parts: z.array(PartSchema),
-}).passthrough();
-const ExportSchema = z.object({
+});
+const ExportSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     info: SessionInfoSchema,
     messages: z.array(MessageSchema),
     sanitized: z.boolean().optional(),
-    sanitization: z.record(z.unknown()).optional(),
+    sanitization: z.record(z.string(), z.unknown()).optional(),
     shared: z.boolean().optional(),
-    providerDeletedAt: z.number().nullable().optional(),
-}).passthrough();
-const EventSchema = z.object({
+    providerDeletedAt: number().nullable().optional(),
+});
+const EventSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     type: z.string().min(1),
-    properties: z.record(z.unknown()),
+    properties: z.record(z.string(), z.unknown()),
     sanitized: z.boolean().optional(),
     shared: z.boolean().optional(),
-}).passthrough();
+});
 export class OpenCodeSessionAdapter {
     limits;
     transports;

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

@@ -1,25 +1,26 @@
 import { z } from 'zod';
+import { number } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { 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({
+const MetadataSchema = z.looseObject({
     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({
+});
+const AttachmentSchema = z.looseObject({
     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()]),
+    expiredAt: z.union([z.string(), number()]).optional(),
+});
+const RawSchema = z.looseObject({
+    schemaVersion: z.union([z.string(), number()]),
     recordType: z.literal('session_raw'),
     session_id: z.string().min(1),
     event_id: z.string().min(1),
@@ -29,36 +30,36 @@ const RawSchema = z.object({
     type: z.string().min(1),
     role: z.string().optional(),
     content: z.unknown().optional(),
-    timestamp: z.union([z.string(), z.number()]).optional(),
+    timestamp: z.union([z.string(), 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(),
+    input_tokens: number().optional(),
+    cached_input_tokens: number().optional(),
+    output_tokens: number().optional(),
+    charged_amount_usd: number().optional(),
     compacted: z.boolean().optional(),
     interrupted: z.boolean().optional(),
-    tool: z.record(z.unknown()).optional(),
+    tool: z.record(z.string(), 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()]),
+    raw_transcript_deleted_at: z.union([z.string(), number()]).nullable().optional(),
+});
+const ThreadStateSchema = z.looseObject({
+    schemaVersion: z.union([z.string(), 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()]),
+    deleted_at: z.union([z.string(), number()]).nullable().optional(),
+});
+const TurnStateSchema = z.looseObject({
+    schemaVersion: z.union([z.string(), 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();
+    completed_at: z.union([z.string(), number()]).nullable().optional(),
+});
 const RecordSchema = z.discriminatedUnion('recordType', [
     RawSchema, ThreadStateSchema, TurnStateSchema,
 ]);

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

@@ -1,14 +1,15 @@
 import { opendir } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { z } from 'zod';
+import { integer, dateTime } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, } from '../contracts.js';
 import { streamBoundedJsonLines } from '../readers.js';
 export const PI_ADAPTER_VERSION = '1.0.0';
 export const PI_SOURCE_SCHEMA_VERSION = '3.0.0';
-const Header = z.object({ type: z.literal('session'), version: z.number().int(), id: z.string().min(1),
-    timestamp: z.string().datetime({ offset: true }), cwd: z.string(), parentSession: z.string().optional() }).passthrough();
-const Entry = z.object({ type: z.string().min(1), id: z.string().min(1),
-    parentId: z.string().nullable(), timestamp: z.string().datetime({ offset: true }) }).passthrough();
+const Header = z.looseObject({ type: z.literal('session'), version: integer(), id: z.string().min(1),
+    timestamp: dateTime({ offset: true }), cwd: z.string(), parentSession: z.string().optional() });
+const Entry = z.looseObject({ type: z.string().min(1), id: z.string().min(1),
+    parentId: z.string().nullable(), timestamp: dateTime({ offset: true }) });
 export class PiSessionAdapter {
     limits;
     maxFiles;

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

@@ -8,7 +8,7 @@ export const DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION = '1.0.0';
 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({
+const StepSchema = z.looseObject({
     schema_version: z.string().optional(),
     type: z.string().min(1),
     status: z.string().min(1),
@@ -17,13 +17,13 @@ const StepSchema = z.object({
     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();
+    model: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+    sensitive_content_warning: z.union([z.boolean(), z.string(), z.record(z.string(), z.unknown())]).optional(),
+    user_input: z.record(z.string(), z.unknown()).optional(),
+    planner_response: z.record(z.string(), z.unknown()).optional(),
+    code_action: z.record(z.string(), z.unknown()).optional(),
+    tool_info: z.record(z.string(), z.unknown()).optional(),
+});
 export class DevinDesktopSessionAdapter {
     limits;
     provider = 'devin-desktop';

package/dist/src/sessions/analytics.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { integer, dateTime } from '../schema/zod-validation.mjs';
 import { sha256 } from './contracts.js';
 export const SESSION_ANALYTICS_VERSION = '1.0.0';
 export const SessionAnalyticsCategorySchema = z.enum([
@@ -21,7 +22,7 @@ export const SessionAnalyticsStatusSchema = z.enum([
     'provider-unknown',
     'observed',
 ]);
-export const SessionAnalyticsFactSchema = z.object({
+export const SessionAnalyticsFactSchema = z.strictObject({
     analyticsVersion: z.literal(SESSION_ANALYTICS_VERSION),
     factId: z.string().min(1),
     category: SessionAnalyticsCategorySchema,
@@ -32,33 +33,33 @@ export const SessionAnalyticsFactSchema = z.object({
     eventId: z.string().min(1),
     sourceId: z.string().min(1),
     importRunId: z.string().min(1),
-    occurredAt: z.string().datetime({ offset: true }).nullable(),
-    sequence: z.number().int().nonnegative(),
+    occurredAt: dateTime({ offset: true }).nullable(),
+    sequence: integer().nonnegative(),
     actor: z.string().min(1).nullable(),
     participant: z.string().min(1).nullable(),
     toolName: z.string().min(1).nullable(),
     toolCallId: z.string().min(1).nullable(),
     retryGroupId: z.string().min(1).nullable(),
-    retryOrdinal: z.number().int().positive().nullable(),
+    retryOrdinal: integer().positive().nullable(),
     errorClass: z.string().min(1).nullable(),
     capability: z.string().min(1).nullable(),
     decision: z.string().min(1).nullable(),
     promptType: z.string().min(1).nullable(),
-    latencyMs: z.number().int().nonnegative().nullable(),
+    latencyMs: integer().nonnegative().nullable(),
     transition: z.string().min(1).nullable(),
     indicator: z.string().min(1).nullable(),
     sensitivity: z.enum(['none', 'sensitive']),
     extractionState: z.string().min(1).nullable(),
-    sourceCitation: z.object({
+    sourceCitation: z.strictObject({
         provider: z.string().min(1),
         sessionId: z.string().min(1),
         eventId: z.string().min(1),
         importRunId: z.string().min(1),
         sourceId: z.string().min(1),
         locatorClass: z.string().min(1),
-        sequence: z.number().int().nonnegative(),
-    }).strict(),
-}).strict();
+        sequence: integer().nonnegative(),
+    }),
+});
 /**
  * Derive content-free analytics facts from normalized session events.
  *

package/dist/src/sessions/batch-contracts.js

@@ -24,7 +24,7 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
     const unresolvedProviders = preflight?.unresolvedProviders
         ?? [...new Set([...unavailable, ...exportRequired, ...notChecked])].sort();
     const acquisitionIncomplete = rejected > 0 || pending > 0 || skipped > 0
-        || (preflight?.expectedProviderBasis === 'explicit' && unresolvedProviders.length > 0);
+        || (preflight && ['explicit', 'workspace-config'].includes(preflight.expectedProviderBasis) && unresolvedProviders.length > 0);
     const incomplete = acquisitionIncomplete || !preflight || preflight.status !== 'complete'
         || unavailable.length > 0 || accepted + duplicated + previouslyCommitted + excluded === 0
         || exportRequired.length > 0 || notChecked.length > 0;

package/dist/src/sessions/batch-import.js

@@ -1,13 +1,21 @@
-import { stat } from 'node:fs/promises';
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { createSessionAdapterRegistry } from './adapter-registry.js';
 import { coveragePreflight, sessionRuntimeIdentity } from './coverage-preflight.js';
-import { SESSION_CONTRACT_VERSION, SessionContractError, schemaIssueDetail, SessionSourceSchema, sha256, } from './contracts.js';
+import { SESSION_CONTRACT_VERSION, SessionContractError, schemaIssueDetail, SessionSourceSchema, sha256, stableSessionId, stableEventId, } from './contracts.js';
 import { BATCH_IMPORT_VERSION, coverageFromBatchRun, } from './batch-contracts.js';
 import { IncrementalSessionImporter, SessionImportFailure } from './importer.js';
 import { matchImportExclusion, resolveImportExclusions } from './import-exclusions.js';
 import { resolveImportLimits } from './import-limits.js';
 import { fingerprintSourceFile } from './readers.js';
+import { SessionRepository } from './repository.js';
+import { redactSessionValue, sanitizeSessionEvent } from './policy.js';
+import { deriveSessionIntent } from './origin.js';
+import { recoverCodexRolloutIdentity } from './adapters/codex.js';
 export async function importDiscoveryManifest(options) {
+    if (options.carryForward)
+        return rebuildFromCatalog(options);
     const exclusions = resolveImportExclusions(undefined, options.exclude);
     const limits = { ...resolveImportLimits(undefined, {
             maxRecordBytes: options.limits?.maxRecordBytes, maxSourceBytes: options.limits?.maxTotalBytes,
@@ -25,6 +33,8 @@ export async function importDiscoveryManifest(options) {
     }
     run.schemaVersion = BATCH_IMPORT_VERSION;
     run.preflight = coveragePreflight({
+        configuredProviders: options.manifest.preflight?.configuredProviders,
+        scopeWarnings: options.manifest.preflight?.scopeWarnings,
         expectedProviders: options.manifest.preflight?.expectedProviders,
         expectedProviderBasis: options.manifest.preflight?.expectedProviderBasis ?? 'legacy',
         runtime: options.runtime ?? sessionRuntimeIdentity(),
@@ -160,6 +170,8 @@ export function previewDiscoveryImport(manifest, existing, now = new Date(), exc
             return disposition;
         }),
         preflight: coveragePreflight({
+            configuredProviders: manifest.preflight?.configuredProviders,
+            scopeWarnings: manifest.preflight?.scopeWarnings,
             expectedProviders: manifest.preflight?.expectedProviders,
             expectedProviderBasis: manifest.preflight?.expectedProviderBasis ?? 'legacy',
             reports: manifest.providers,
@@ -202,6 +214,7 @@ function receiptFor(run, now) {
         run,
         coverage,
         interruptedRuns: [],
+        ...(run.carryForward ? { carryForward: run.carryForward } : {}),
         totals: {
             discovered: coverage.sources.discovered,
             accepted: coverage.sources.accepted,
@@ -304,4 +317,191 @@ function isAccepted(status) {
         || status === 'duplicate'
         || status === 'previously-committed';
 }
+/** Reuse source import and normalized repository gates, without copying FTS/analytics. */
+async function rebuildFromCatalog(options) {
+    const previous = options.carryForward;
+    if (previous === options.repository) {
+        throw new SessionContractError('INVALID_ARGUMENT', 'carry-forward requires a separate destination catalog');
+    }
+    const workspaceId = options.manifest.workspaceId;
+    const exclusions = resolveImportExclusions(undefined, options.exclude);
+    const byProvider = {};
+    const counts = (provider) => byProvider[provider] ??= {
+        reimported: 0, carried: 0, droppedAsDuplicate: 0, excluded: 0,
+    };
+    const oldSessions = catalogSessions(previous, workspaceId);
+    const available = [];
+    const present = new Set();
+    const excludedSources = new Set();
+    for (const source of options.manifest.sources) {
+        if (matchImportExclusion(source, exclusions) ?? source.exclusion) {
+            excludedSources.add(source.sourceId);
+            continue;
+        }
+        let details;
+        try {
+            details = await stat(source.locator);
+        }
+        catch (error) {
+            if (['ENOENT', 'ENOTDIR'].includes(error.code ?? ''))
+                continue;
+            throw error;
+        }
+        // Refresh the snapshot, but retain the explicitly saved authorization and source identity.
+        const fingerprint = await fingerprintSourceFile({ selectedPath: source.locator,
+            allowedRoots: [source.authorizedRoot] });
+        available.push({ ...source, sizeBytes: details.size, modifiedAt: details.mtime.toISOString(),
+            digest: fingerprint.digest });
+        present.add(source.sourceId);
+    }
+    const manifest = { ...options.manifest, sources: available,
+        manifestId: sha256(JSON.stringify(['carry-forward-v1', options.manifest.manifestId, available])) };
+    const stagingDirectory = await mkdtemp(join(tmpdir(), 'aiwg-session-rebuild-'));
+    let staged;
+    try {
+        staged = new SessionRepository(join(stagingDirectory, 'staging.sqlite'));
+        const receipt = await importDiscoveryManifest({ ...options, manifest, repository: staged,
+            carryForward: undefined, fault: undefined });
+        const identities = new Set();
+        const destinationCodex = new Map(catalogSessions(options.repository, workspaceId)
+            .filter(session => session.provider === 'codex').map(session => [session.nativeSessionId, session.sourceId]));
+        const transfer = (repository, sessions, category) => {
+            // A legacy Codex rollout may have split replayed parent events into phantom rows.
+            // Recover the first session_meta ID for the whole source before grouping events.
+            const sourceGroups = new Map();
+            for (const session of sessions) {
+                const group = sourceGroups.get(session.sourceId) ?? [];
+                group.push(session);
+                sourceGroups.set(session.sourceId, group);
+            }
+            for (const [sourceId, group] of sourceGroups) {
+                if (options.signal?.aborted)
+                    throw new SessionContractError('IMPORT_INTERRUPTED', 'catalog rebuild interrupted');
+                const source = repository.getSource(sourceId, workspaceId);
+                if (!source)
+                    throw new SessionContractError('IMPORT_CONFLICT', 'catalog session has no authorized source');
+                const allEvents = group.flatMap(session => repository.listEvents(session.sessionId, workspaceId))
+                    .sort((a, b) => a.sequence - b.sequence || a.eventId.localeCompare(b.eventId));
+                const rollout = source.provider === 'codex' ? recoverCodexRolloutIdentity(allEvents) : undefined;
+                const childId = rollout?.nativeSessionId;
+                // Prefer the child's aggregate when the legacy source also has phantom parent aggregates.
+                group.sort((a, b) => Number(b.nativeSessionId === childId) - Number(a.nativeSessionId === childId));
+                const canonical = new Map();
+                for (const session of group) {
+                    const nativeId = childId ?? session.nativeSessionId;
+                    const locator = options.manifest.sources.find(item => item.sourceId === sourceId)?.locator
+                        ?? source.redactedLocator;
+                    if (excludedSources.has(sourceId) || matchImportExclusion({ provider: session.provider,
+                        locator, locatorClass: source.locatorClass, nativeSessionId: nativeId }, exclusions)) {
+                        counts(session.provider).excluded++;
+                        continue;
+                    }
+                    const key = session.provider === 'codex' ? `${session.provider}\0${nativeId}` : session.sessionId;
+                    if (identities.has(key)) {
+                        counts(session.provider).droppedAsDuplicate++;
+                        continue;
+                    }
+                    const existing = canonical.get(key);
+                    if (existing) {
+                        counts(session.provider).droppedAsDuplicate++;
+                        existing.events.push(...repository.listEvents(session.sessionId, workspaceId));
+                    }
+                    else
+                        canonical.set(key, { session: { ...session, nativeSessionId: nativeId },
+                            events: repository.listEvents(session.sessionId, workspaceId) });
+                }
+                for (const [key, entry] of canonical) {
+                    if (source.provider === 'codex' && destinationCodex.has(entry.session.nativeSessionId)
+                        && destinationCodex.get(entry.session.nativeSessionId) !== sourceId) {
+                        throw new SessionContractError('IMPORT_CONFLICT', 'destination has a different source for this Codex identity; select a fresh catalog');
+                    }
+                    const session = redactSessionValue({ ...entry.session,
+                        sessionId: stableSessionId(source.provider, sourceId, entry.session.nativeSessionId),
+                    }).value;
+                    // Hash only sanitized content; receipts and IDs must never retain old plaintext.
+                    const sanitized = entry.events.map(sanitizeSessionEvent);
+                    const runId = sha256(JSON.stringify(['catalog-carry-v1', session.sessionId, sanitized]));
+                    const events = sanitized.map(event => {
+                        const digest = event.digest;
+                        return { ...event, sessionId: session.sessionId, importRunId: runId, digest,
+                            eventId: stableEventId(source.provider, sourceId, {
+                                nativeSessionId: session.nativeSessionId, nativeEventId: event.nativeId ?? event.eventId,
+                                sequence: event.sequence, kind: event.kind, text: event.searchableText,
+                                rawReference: event.rawReference,
+                            }, digest) };
+                    });
+                    if (rollout && Object.keys(rollout.lineage).length > 0) {
+                        session.extensions['native.codex'] = { lineage: rollout.lineage };
+                    }
+                    session.intent = deriveSessionIntent(events);
+                    const checkpoint = repository.getCheckpoint(sourceId, source.adapterVersion)
+                        ?? { cursor: '', recordsRead: events.length, bytesRead: Buffer.byteLength(JSON.stringify(events)) };
+                    options.repository.applyImport({ source, sessions: [session], events,
+                        run: { contractVersion: SESSION_CONTRACT_VERSION, importRunId: runId, sourceId,
+                            parserVersion: source.adapterVersion, policyVersion: '1.0.0',
+                            sourceSchemaVersion: source.sourceSchemaVersion, consistency: source.consistency,
+                            status: 'running', checkpoint, startedAt: (options.now?.() ?? new Date()).toISOString(),
+                            completedAt: null, errorCode: null } }, checkpoint);
+                    for (const old of group.filter(item => (childId ?? item.nativeSessionId) === entry.session.nativeSessionId)) {
+                        for (const tag of repository.listTags(old.sessionId, workspaceId)) {
+                            options.repository.tagSession(session.sessionId, tag, workspaceId);
+                        }
+                    }
+                    identities.add(key);
+                    counts(source.provider)[category]++;
+                }
+            }
+        };
+        const reimported = catalogSessions(staged, workspaceId);
+        transfer(staged, reimported, 'reimported');
+        for (const sourceId of present) {
+            const old = oldSessions.filter(session => session.sourceId === sourceId && session.provider === 'codex');
+            const imported = reimported.filter(session => session.sourceId === sourceId);
+            // Account for phantom rows eliminated by current source parsing, separately from copied duplicates.
+            if (imported.length > 0 && old.length > imported.length) {
+                counts('codex').droppedAsDuplicate += old.length - imported.length;
+            }
+        }
+        transfer(previous, oldSessions.filter(session => !present.has(session.sourceId)), 'carried');
+        options.repository.reindex(workspaceId);
+        const finalSessions = catalogSessions(options.repository, workspaceId);
+        const sourceIds = new Set([...receipt.run.sources.map(item => item.sourceId),
+            ...oldSessions.map(session => session.sourceId)]);
+        for (const sourceId of sourceIds) {
+            const accepted = finalSessions.filter(session => session.sourceId === sourceId);
+            let disposition = receipt.run.sources.find(item => item.sourceId === sourceId);
+            if (!disposition) {
+                const old = oldSessions.find(session => session.sourceId === sourceId);
+                const excluded = excludedSources.has(sourceId) || matchImportExclusion({
+                    provider: old.provider, nativeSessionId: old.nativeSessionId,
+                    locator: previous.getSource(sourceId, workspaceId)?.redactedLocator ?? '', locatorClass: 'catalog',
+                }, exclusions);
+                disposition = { sourceId, provider: old.provider,
+                    status: excluded ? 'excluded' : accepted.length > 0 ? 'committed' : 'duplicate',
+                    attempts: 1, sessionsAccepted: 0, eventsAccepted: 0,
+                    errorCode: null, diagnostic: null, updatedAt: receipt.run.updatedAt };
+                receipt.run.sources.push(disposition);
+            }
+            disposition.sessionsAccepted = accepted.length;
+            disposition.eventsAccepted = accepted.reduce((sum, session) => sum + options.repository.listEvents(session.sessionId, workspaceId).length, 0);
+        }
+        receipt.run.carryForward = { byProvider };
+        options.repository.saveBatchImportRun(receipt.run);
+        return redactSessionValue(receiptFor(receipt.run, options.now?.() ?? new Date())).value;
+    }
+    finally {
+        staged?.close();
+        await rm(stagingDirectory, { recursive: true, force: true });
+    }
+}
+function catalogSessions(repository, workspaceId) {
+    const sessions = [];
+    let cursor;
+    do {
+        const page = repository.listSessions({ workspaceId, limit: 500, cursor });
+        sessions.push(...page.items);
+        cursor = page.nextCursor ?? undefined;
+    } while (cursor);
+    return sessions;
+}
 //# sourceMappingURL=batch-import.js.map

package/dist/src/sessions/candidates.js

@@ -1,20 +1,21 @@
 import { z } from 'zod';
+import { integer } from '../schema/zod-validation.mjs';
 import { IntelligenceCandidateSchema, IntelligenceCandidateTypeSchema, SESSION_CONTRACT_VERSION, SessionContractError, sha256, } from './contracts.js';
-export const ExtractedCandidateDraftSchema = z.object({
+export const ExtractedCandidateDraftSchema = z.strictObject({
     type: IntelligenceCandidateTypeSchema,
     assertion: z.string().min(1),
     subject: z.string().min(1).nullable(),
     predicate: z.string().min(1).nullable(),
     object: z.string().min(1).nullable(),
-    evidence: z.array(z.object({
+    evidence: z.array(z.strictObject({
         eventId: z.string().min(1),
-        start: z.number().int().nonnegative(),
-        end: z.number().int().positive(),
-    }).strict()).min(1),
+        start: integer().nonnegative(),
+        end: integer().positive(),
+    })).min(1),
     confidence: z.number().min(0).max(1),
     conflictsWith: z.array(z.string().min(1)).default([]),
     supersedes: z.array(z.string().min(1)).default([]),
-}).strict().superRefine((candidate, context) => {
+}).superRefine((candidate, context) => {
     if (candidate.type === 'relationship'
         && (!candidate.subject || !candidate.predicate || !candidate.object)) {
         context.addIssue({