@aiwg/cli 2026.7.21 → 2026.7.23

package/dist/src/sessions/importer.js

@@ -1,9 +1,10 @@
 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';
+import { classifySessionEventOrigin, deriveSessionIntent, } from './origin.js';
 const DEFAULT_LIMITS = {
     maxRecords: 1_000_000,
-    maxRecordBytes: 4 * 1024 * 1024,
+    maxRecordBytes: 8 * 1024 * 1024,
     maxTotalBytes: 1024 * 1024 * 1024,
     batchSize: 1_000,
 };
@@ -22,12 +23,21 @@ export class IncrementalSessionImporter {
     }
     async import(request) {
         assertSupportedSchemaMajor(request.source.sourceSchemaVersion);
+        if (request.inactivityThresholdMs !== undefined
+            && (!Number.isFinite(request.inactivityThresholdMs) || request.inactivityThresholdMs < 0)) {
+            throw new SessionContractError('INVALID_ARGUMENT', 'session inactivity threshold must be a non-negative duration');
+        }
         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 previous = request.batchRunId
+            ? this.repository.getBatchCheckpoint(request.source.sourceId, request.adapter.adapterVersion, request.batchRunId) ?? this.repository.getCheckpoint(request.source.sourceId, request.adapter.adapterVersion)
+            : this.repository.getCheckpoint(request.source.sourceId, request.adapter.adapterVersion);
         const continuity = await sourceContinuity(request, previous);
+        const sourceObservedAt = continuity
+            ? new Date(continuity.mtimeMs).toISOString()
+            : undefined;
         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');
@@ -73,12 +83,15 @@ export class IncrementalSessionImporter {
         const flush = () => {
             if (batch.length === 0)
                 return;
+            if (request.signal?.aborted) {
+                throw new SessionContractError('IMPORT_INTERRUPTED', 'session import was cancelled at a durable batch boundary');
+            }
             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 normalized = normalizeBatch(request, batch, runId, sourceObservedAt);
             const run = {
                 contractVersion: SESSION_CONTRACT_VERSION,
                 importRunId: runId,
@@ -101,7 +114,8 @@ export class IncrementalSessionImporter {
             const receipt = this.repository.applyImport({
                 source: sanitizedSource, run,
                 sessions: normalized.sessions, events: normalized.events,
-            }, { ...checkpoint }, request.source.consistency !== 'complete');
+                batchRunId: request.batchRunId,
+            }, { ...checkpoint }, request.publish ?? request.source.consistency !== 'complete');
             const memory = process.memoryUsage();
             peakHeap = Math.max(peakHeap, memory.heapUsed);
             peakRss = Math.max(peakRss, memory.rss);
@@ -122,6 +136,9 @@ export class IncrementalSessionImporter {
         };
         try {
             for await (const record of request.adapter.stream(request.selectedSource, previous ? { value: previous.cursor } : undefined)) {
+                if (request.signal?.aborted) {
+                    throw new SessionContractError('IMPORT_INTERRUPTED', 'session import was cancelled and can resume from its durable checkpoint');
+                }
                 const bytes = Buffer.byteLength(JSON.stringify(record));
                 if (bytes > limits.maxRecordBytes
                     || checkpoint.bytesRead + bytes > limits.maxTotalBytes
@@ -145,7 +162,8 @@ export class IncrementalSessionImporter {
             flush();
         }
         catch (error) {
-            const committed = request.source.consistency === 'complete' ? [] : receipts;
+            const published = request.publish ?? request.source.consistency !== 'complete';
+            const committed = published ? receipts : [];
             throw new SessionImportFailure({
                 contractVersion: '1.0.0',
                 outcome: 'terminal-failure',
@@ -157,7 +175,7 @@ export class IncrementalSessionImporter {
                     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'
+                resumableCheckpoint: !published
                     ? {
                         ...durableCheckpoint,
                         cursor: '',
@@ -170,7 +188,7 @@ export class IncrementalSessionImporter {
                     ? error.code : 'IMPORT_INTERRUPTED',
             }, error);
         }
-        if (request.source.consistency === 'complete') {
+        if (request.publish !== false && request.source.consistency === 'complete') {
             this.repository.commitStagedImports(request.source.sourceId, request.adapter.adapterVersion);
             for (const receipt of receipts) {
                 if (receipt.outcome === 'staged')
@@ -180,22 +198,31 @@ export class IncrementalSessionImporter {
         return receipts;
     }
 }
-function normalizeBatch(request, records, importRunId) {
+function normalizeBatch(request, records, importRunId, sourceObservedAt) {
     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 origin = classifySessionEventOrigin(request.source.provider, record);
+        const lifecycle = sessionLifecycle(request, record, sourceObservedAt);
+        const lifecycleEvidence = sessionLifecycleEvidence(request, record, sourceObservedAt);
         const extensions = {
             [`native.${request.source.provider}`]: native.value,
         };
         const event = SessionEventSchema.parse({
             contractVersion: SESSION_CONTRACT_VERSION,
-            eventId: stableEventId(request.source.sourceId, record, digest),
+            eventId: stableEventId(request.source.provider, 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,
+            activityBoundary: record.activityBoundary ?? null,
+            activityBoundaryBasis: record.activityBoundaryBasis ?? null,
+            activityBoundaryConfidence: record.activityBoundaryConfidence ?? null,
+            origin: origin.origin,
+            originRule: origin.rule,
+            originClassifierVersion: origin.classifierVersion,
             participant: record.participant ?? null,
             toolName: record.toolName ?? null,
             toolCallId: record.toolCallId ?? null,
@@ -220,9 +247,13 @@ function normalizeBatch(request, records, importRunId) {
                 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',
+                lifecycle,
                 sourceDigest: sha256(`${sourceGenerationDigest(request)}\0${record.nativeSessionId}`),
-                extensions: { [`native.${request.source.provider}`]: {} },
+                extensions: {
+                    [`native.${request.source.provider}`]: {
+                        lifecycleEvidence,
+                    },
+                },
             }));
         }
         else {
@@ -230,12 +261,23 @@ function normalizeBatch(request, records, importRunId) {
             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';
-            }
+            const nativeKey = `native.${request.source.provider}`;
+            const nativeEnvelope = session.extensions[nativeKey];
+            const nativeRecord = nativeEnvelope && typeof nativeEnvelope === 'object' && !Array.isArray(nativeEnvelope)
+                ? nativeEnvelope
+                : {};
+            const selected = selectLifecycleTransition(session.lifecycle, nativeRecord.lifecycleEvidence, lifecycle, lifecycleEvidence);
+            session.lifecycle = selected.lifecycle;
+            session.extensions[nativeKey] = {
+                ...nativeRecord,
+                lifecycleEvidence: selected.evidence,
+            };
         }
         return event;
     });
+    for (const session of sessions.values()) {
+        session.intent = deriveSessionIntent(events.filter((event) => event.sessionId === session.sessionId));
+    }
     return { sessions: [...sessions.values()], events };
 }
 const KNOWN_EVENT_KINDS = new Set(['message', 'tool-call', 'tool-result', 'artifact', 'attachment', 'summary']);
@@ -261,6 +303,113 @@ function strongerConsistency(left, right) {
     };
     return rank[left] >= rank[right] ? left : right;
 }
+function sessionLifecycle(request, record, sourceObservedAt) {
+    const explicit = nativeLifecycle(record.extensions);
+    if (explicit)
+        return explicit;
+    if (request.source.consistency === 'complete')
+        return 'complete';
+    const observedAt = record.occurredAt ?? sourceObservedAt;
+    if (observedAt && isStaleHistoricalTimestamp(observedAt, inactivityThresholdMs(request)))
+        return 'inactive';
+    return 'active';
+}
+function sessionLifecycleEvidence(request, record, sourceObservedAt) {
+    const observedAt = record.occurredAt ?? sourceObservedAt;
+    const explicit = nativeLifecycle(record.extensions);
+    if (explicit) {
+        return {
+            basis: 'provider-explicit-event',
+            state: explicit,
+            observedAt: observedAt ?? request.source.authorizedAt,
+            confidence: 'high',
+        };
+    }
+    if (request.source.consistency === 'complete') {
+        return {
+            basis: 'complete-source',
+            state: 'complete',
+            observedAt: observedAt ?? request.source.authorizedAt,
+            confidence: 'high',
+        };
+    }
+    const thresholdMs = inactivityThresholdMs(request);
+    if (observedAt && isStaleHistoricalTimestamp(observedAt, thresholdMs)) {
+        return {
+            basis: 'inactivity-threshold',
+            state: 'inactive',
+            observedAt,
+            confidence: 'medium',
+            thresholdMs,
+        };
+    }
+    return {
+        basis: 'open-provisional-source',
+        state: 'active',
+        observedAt: observedAt ?? request.source.authorizedAt,
+        confidence: 'provisional',
+    };
+}
+function nativeLifecycle(extensions) {
+    const raw = typeof extensions?.lifecycle === 'string' ? extensions.lifecycle : undefined;
+    if (!raw)
+        return null;
+    const normalized = {
+        active: 'active',
+        inactive: 'inactive',
+        paused: 'paused',
+        complete: 'complete',
+        completed: 'complete',
+        archived: 'archived',
+        deleted: 'tombstoned',
+        cancelled: 'interrupted',
+        canceled: 'interrupted',
+        failed: 'interrupted',
+        interrupted: 'interrupted',
+        unknown: 'unknown',
+        'unknown-at-import': 'unknown',
+        'completed-at-import': 'complete',
+    };
+    return normalized[raw] ?? null;
+}
+function selectLifecycleTransition(leftLifecycle, left, rightLifecycle, right) {
+    const leftEvidence = asLifecycleEvidence(left);
+    if (leftLifecycle === 'tombstoned') {
+        return { lifecycle: leftLifecycle, evidence: leftEvidence ?? right };
+    }
+    if (!leftEvidence)
+        return { lifecycle: rightLifecycle, evidence: right };
+    const rank = {
+        'open-provisional-source': 1,
+        'inactivity-threshold': 1,
+        'complete-source': 2,
+        'provider-explicit-event': 3,
+    };
+    const leftRank = rank[String(leftEvidence.basis)] ?? 0;
+    const rightRank = rank[String(right.basis)] ?? 0;
+    const rightIsNewer = evidenceTimestamp(right) > evidenceTimestamp(leftEvidence);
+    return rightRank > leftRank || (rightRank === leftRank && rightIsNewer)
+        ? { lifecycle: rightLifecycle, evidence: right }
+        : { lifecycle: leftLifecycle, evidence: leftEvidence };
+}
+function asLifecycleEvidence(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function evidenceTimestamp(value) {
+    const parsed = Date.parse(String(value.observedAt ?? ''));
+    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+}
+const DEFAULT_INACTIVITY_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function inactivityThresholdMs(request) {
+    return request.inactivityThresholdMs ?? DEFAULT_INACTIVITY_THRESHOLD_MS;
+}
+function isStaleHistoricalTimestamp(value, thresholdMs) {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp)
+        && Date.now() - timestamp > thresholdMs;
+}
 function sourceGenerationDigest(request) {
     return sha256([
         request.source.sourceId,

package/dist/src/sessions/index.js

@@ -10,6 +10,12 @@ export * from './knowledge-shard.js';
 export * from './candidates.js';
 export * from './promotion.js';
 export * from './importer.js';
+export * from './import-lease.js';
+export * from './batch-contracts.js';
+export * from './batch-import.js';
+export * from './workspace-discovery.js';
+export * from './timeline.js';
+export * from './origin.js';
 export * from './adapters/generic.js';
 export * from './adapters/claude.js';
 export * from './adapters/codex.js';

package/dist/src/sessions/origin.js

@@ -0,0 +1,117 @@
+export const ORIGIN_CLASSIFIER_VERSION = '1.0.0';
+export function classifySessionEventOrigin(provider, record) {
+    const envelope = classifyWholeEnvelope(record.text);
+    if (envelope)
+        return envelope;
+    const kind = record.kind.toLowerCase();
+    if (isProviderBootstrap(provider, kind)) {
+        return classified('provider-bootstrap', `${provider}:structured-bootstrap`);
+    }
+    if (isToolControl(kind, record.role)) {
+        return classified('tool-control', `${provider}:structured-control`);
+    }
+    if (record.role === 'assistant') {
+        return classified('assistant-generated', `${provider}:assistant-role`);
+    }
+    if (record.role === 'user' && kind === 'message' && record.text.trim().length > 0) {
+        return classified('user-authored', `${provider}:user-message`);
+    }
+    return classified('unknown', `${provider}:insufficient-authorship-evidence`);
+}
+export function isControlOrigin(origin) {
+    return origin === 'provider-bootstrap'
+        || origin === 'workspace-instruction'
+        || origin === 'tool-control';
+}
+export function deriveSessionIntent(events) {
+    const eligible = events
+        .filter((event) => event.origin === 'user-authored'
+        && event.kind === 'message'
+        && event.searchableText.trim().length > 0)
+        .sort((left, right) => left.sequence - right.sequence || left.eventId.localeCompare(right.eventId));
+    const selected = eligible[0];
+    if (selected) {
+        const summary = normalizeExcerpt(selected.searchableText, 240);
+        return {
+            status: 'selected',
+            eventId: selected.eventId,
+            sequence: selected.sequence,
+            title: normalizeExcerpt(summary.split('\n')[0], 80),
+            summary,
+        };
+    }
+    const uncertain = events.some((event) => event.origin === 'unknown' && event.searchableText.trim().length > 0);
+    return {
+        status: uncertain ? 'unknown' : 'absent',
+        eventId: null,
+        sequence: null,
+        title: null,
+        summary: null,
+    };
+}
+function classifyWholeEnvelope(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    if (/^# AGENTS\.md instructions for [^\n]+\n+<INSTRUCTIONS>\n[\s\S]*\n<\/INSTRUCTIONS>$/.test(trimmed)) {
+        return classified('workspace-instruction', 'envelope:agents-instructions');
+    }
+    for (const tag of [
+        'recommended_plugins',
+        'codex_internal_context',
+        'environment_context',
+    ]) {
+        if (wholeTag(trimmed, tag)) {
+            return classified('provider-bootstrap', `envelope:${tag}`);
+        }
+    }
+    if (wholeTag(trimmed, 'local-command-caveat')) {
+        return classified('tool-control', 'envelope:local-command-caveat');
+    }
+    if (/^<[A-Za-z_][\w.-]*(?:\s[^>]*)?>[\s\S]*<\/[A-Za-z_][\w.-]*>$/.test(trimmed)) {
+        return classified('unknown', 'envelope:unrecognized');
+    }
+    return null;
+}
+function wholeTag(value, tag) {
+    const escaped = tag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^<${escaped}(?:\\s[^>]*)?>[\\s\\S]*<\\/${escaped}>$`).test(value);
+}
+function isProviderBootstrap(provider, kind) {
+    if (provider === 'codex') {
+        return kind === 'codex.session_meta'
+            || kind === 'codex.turn_context'
+            || kind === 'codex.thread-state';
+    }
+    if (provider === 'factory') {
+        return kind === 'factory.session_start' || kind === 'factory.settings';
+    }
+    if (provider === 'cursor')
+        return kind === 'system';
+    return false;
+}
+function isToolControl(kind, role) {
+    return role === 'tool'
+        || role === 'system'
+        || kind === 'lifecycle-hook'
+        || kind === 'tool-call'
+        || kind === 'tool-result'
+        || kind === 'summary'
+        || kind.includes('lifecycle')
+        || kind.startsWith('tool.')
+        || kind.startsWith('cursor.cloud.')
+        || kind === 'cursor.agent.turn_ended'
+        || kind === 'factory.session_end';
+}
+function classified(origin, rule) {
+    return {
+        origin,
+        rule,
+        classifierVersion: ORIGIN_CLASSIFIER_VERSION,
+    };
+}
+function normalizeExcerpt(value, max) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    return normalized.length <= max ? normalized : `${normalized.slice(0, max - 1)}…`;
+}
+//# sourceMappingURL=origin.js.map

package/dist/src/sessions/readers.js

@@ -6,7 +6,7 @@ import { SessionContractError } from './contracts.js';
 import { authorizeSourceFile } from './policy.js';
 export const DEFAULT_READER_LIMITS = Object.freeze({
     maxRecords: 1_000_000,
-    maxRecordBytes: 4 * 1024 * 1024,
+    maxRecordBytes: 8 * 1024 * 1024,
     maxTotalBytes: 1024 * 1024 * 1024,
     maxNestingDepth: 64,
 });