@aiwg/cli 2026.10.3 → 2026.10.4

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

@@ -1,11 +1,10 @@
-import { mkdir, readFile, rename, rm, stat, writeFile, } from 'node:fs/promises';
+import { mkdir, readFile, rename, rm, writeFile, } from 'node:fs/promises';
 import { hostname } from 'node:os';
 import { dirname } from 'node:path';
 const DEFAULTS = {
     waitMs: 5_000,
     pollMs: 50,
     heartbeatMs: 1_000,
-    staleMs: 30_000,
 };
 export class ImportLeaseContentionError extends Error {
     owner;
@@ -29,12 +28,13 @@ export async function acquireImportLease(databasePath, runId, options = {}) {
     const waitMs = options.waitMs ?? DEFAULTS.waitMs;
     const pollMs = options.pollMs ?? DEFAULTS.pollMs;
     const heartbeatMs = options.heartbeatMs ?? DEFAULTS.heartbeatMs;
-    const staleMs = options.staleMs ?? DEFAULTS.staleMs;
     const now = options.now ?? (() => new Date());
     const processAlive = options.processAlive ?? defaultProcessAlive;
+    const processStartId = options.processStartId ?? defaultProcessStartId;
     const lockPath = importLeasePath(databasePath);
     const ownerPath = `${lockPath}/owner.json`;
     const deadline = Date.now() + waitMs;
+    const startId = await processStartId(process.pid);
     await mkdir(dirname(databasePath), { recursive: true, mode: 0o700 });
     while (true) {
         try {
@@ -47,6 +47,7 @@ export async function acquireImportLease(databasePath, runId, options = {}) {
                 host: hostname(),
                 startedAt: observed,
                 heartbeatAt: observed,
+                ...(startId === null ? {} : { processStartId: startId }),
             };
             await writeOwner(ownerPath, owner);
             let heartbeatWrite = Promise.resolve();
@@ -78,10 +79,10 @@ export async function acquireImportLease(databasePath, runId, options = {}) {
             if (!isNodeError(error) || error.code !== 'EEXIST')
                 throw error;
             const existing = await readOwner(ownerPath);
-            if (await staleLease(lockPath, existing, staleMs, processAlive)) {
+            if (await staleLease(existing, processAlive, processStartId)) {
                 const confirmed = await readOwner(ownerPath);
                 if (sameLease(existing, confirmed)
-                    && await staleLease(lockPath, confirmed, staleMs, processAlive)) {
+                    && await staleLease(confirmed, processAlive, processStartId)) {
                     await rm(lockPath, { recursive: true, force: true });
                     continue;
                 }
@@ -103,8 +104,9 @@ async function readOwner(path) {
         const value = JSON.parse(await readFile(path, 'utf8'));
         if (value.contractVersion !== '1.0.0'
             || typeof value.runId !== 'string'
-            || typeof value.pid !== 'number'
+            || !Number.isSafeInteger(value.pid) || (value.pid ?? 0) <= 0
             || typeof value.host !== 'string'
+            || (value.processStartId !== undefined && typeof value.processStartId !== 'string')
             || typeof value.startedAt !== 'string'
             || typeof value.heartbeatAt !== 'string')
             return null;
@@ -114,20 +116,15 @@ async function readOwner(path) {
         return null;
     }
 }
-async function staleLease(lockPath, owner, staleMs, processAlive) {
+async function staleLease(owner, processAlive, processStartId) {
     if (!owner || owner.host !== hostname())
         return false;
-    if (processAlive(owner.pid))
-        return false;
-    const heartbeat = owner ? Date.parse(owner.heartbeatAt) : Number.NaN;
-    if (Number.isFinite(heartbeat))
-        return Date.now() - heartbeat > staleMs;
-    try {
-        return Date.now() - (await stat(lockPath)).mtimeMs > staleMs;
-    }
-    catch {
+    if (!processAlive(owner.pid))
+        return true;
+    if (!owner.processStartId)
         return false;
-    }
+    const current = await processStartId(owner.pid);
+    return current !== null && current !== owner.processStartId;
 }
 function sameLease(first, second) {
     if (!first || !second)
@@ -136,6 +133,7 @@ function sameLease(first, second) {
         && first.pid === second.pid
         && first.host === second.host
         && first.startedAt === second.startedAt
+        && first.processStartId === second.processStartId
         && first.heartbeatAt === second.heartbeatAt;
 }
 function defaultProcessAlive(pid) {
@@ -144,7 +142,25 @@ function defaultProcessAlive(pid) {
         return true;
     }
     catch (error) {
-        return isNodeError(error) && error.code === 'EPERM';
+        return !isNodeError(error) || error.code !== 'ESRCH';
+    }
+}
+async function defaultProcessStartId(pid) {
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        const [details, bootId] = await Promise.all([
+            readFile(`/proc/${pid}/stat`, 'utf8'),
+            readFile('/proc/sys/kernel/random/boot_id', 'utf8'),
+        ]);
+        // The command name may contain spaces and parentheses; field 22 is starttime.
+        const startTicks = details.slice(details.lastIndexOf(')') + 2).split(/\s+/)[19];
+        return startTicks && /^\d+$/.test(startTicks) && bootId.trim()
+            ? `${bootId.trim()}:${startTicks}`
+            : null;
+    }
+    catch {
+        return null;
     }
 }
 function isNodeError(error) {

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

@@ -0,0 +1,37 @@
+import { SessionContractError } from './contracts.js';
+export const DEFAULT_IMPORT_BYTE_LIMITS = Object.freeze({
+    maxRecordBytes: 64 * 1024 * 1024,
+    maxTotalBytes: 1024 * 1024 * 1024,
+});
+export function resolveImportLimits(config, flags, env = process.env) {
+    const resolve = (setting, flag, fallback) => {
+        const environmentValue = env[`AIWG_SESSIONS_IMPORT_${setting.toUpperCase()}`];
+        const origin = flag !== undefined ? 'flag' : environmentValue !== undefined ? 'env'
+            : config?.[setting] !== undefined ? 'config' : 'default';
+        const input = flag ?? environmentValue ?? config?.[setting] ?? fallback;
+        const value = typeof input === 'string' && /^\d+$/.test(input) ? Number(input) : input;
+        if (typeof value !== 'number' || !Number.isSafeInteger(value)
+            || value < (setting === 'max_source_bytes' ? 0 : 1)) {
+            throw new SessionContractError('INVALID_ARGUMENT', `sessions.import.${setting} (${origin}) must be ${setting === 'max_source_bytes' ? 'a non-negative' : 'a positive'} safe integer in bytes`);
+        }
+        return { value, origin };
+    };
+    const record = resolve('max_record_bytes', flags?.maxRecordBytes, DEFAULT_IMPORT_BYTE_LIMITS.maxRecordBytes);
+    const source = resolve('max_source_bytes', flags?.maxSourceBytes, DEFAULT_IMPORT_BYTE_LIMITS.maxTotalBytes);
+    return {
+        maxRecordBytes: record.value,
+        maxTotalBytes: source.value,
+        limitOrigins: { maxRecordBytes: record.origin, maxTotalBytes: source.origin },
+    };
+}
+export function assertImportByteLimit(limit, limits, observed) {
+    const configured = limits[limit];
+    if (limit === 'maxTotalBytes' && configured === 0)
+        return;
+    if (observed > configured) {
+        const setting = limit === 'maxRecordBytes' ? 'sessions.import.max_record_bytes' : 'sessions.import.max_source_bytes';
+        const origin = limits.limitOrigins?.[limit] ?? 'default';
+        throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', `${setting} exceeded (configured=${configured}, observed=${observed}, origin=${origin})`, { limit, setting, configured, observed, origin });
+    }
+}
+//# sourceMappingURL=import-limits.js.map

package/dist/src/sessions/importer.js

@@ -1,18 +1,20 @@
-import { SESSION_CONTRACT_VERSION, SessionEventSchema, SessionSchema, assertSupportedSchemaMajor, sha256, stableEventId, stableSessionId, SessionContractError, } from './contracts.js';
-import { redactSessionText, sanitizeNativeExtensions } from './policy.js';
+import { SESSION_CONTRACT_VERSION, SessionEventSchema, SessionSchema, assertSupportedSchemaMajor, sha256, stableEventId, stableSessionId, SessionContractError, schemaIssueDetail, assertSessionResourceLimit, } from './contracts.js';
+import { assertImportByteLimit, DEFAULT_IMPORT_BYTE_LIMITS, resolveImportLimits } from './import-limits.js';
+import { redactSessionValue, sanitizeSessionEvent, sanitizeNativeExtensions } from './policy.js';
 import { fingerprintSourcePrefix } from './readers.js';
+import { DEFAULT_INACTIVITY_THRESHOLD_MS } from './lifecycle.js';
 import { classifySessionEventOrigin, deriveSessionIntent, } from './origin.js';
-const DEFAULT_LIMITS = {
+export const DEFAULT_IMPORT_LIMITS = {
     maxRecords: 1_000_000,
-    maxRecordBytes: 8 * 1024 * 1024,
-    maxTotalBytes: 1024 * 1024 * 1024,
+    ...DEFAULT_IMPORT_BYTE_LIMITS,
     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');
+        super(cause instanceof SessionContractError ? cause.code : 'IMPORT_INTERRUPTED', cause instanceof Error ? cause.message : 'session import failed', cause instanceof SessionContractError ? cause.detail : undefined);
         this.failureReceipt = failureReceipt;
+        this.failureReceipt = redactSessionValue(failureReceipt).value;
         this.name = 'SessionImportFailure';
     }
 }
@@ -30,7 +32,9 @@ export class IncrementalSessionImporter {
         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 limits = { ...DEFAULT_IMPORT_LIMITS, ...resolveImportLimits(undefined, {
+                maxRecordBytes: request.limits?.maxRecordBytes, maxSourceBytes: request.limits?.maxTotalBytes,
+            }), ...request.limits };
         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);
@@ -40,17 +44,17 @@ export class IncrementalSessionImporter {
             : 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');
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source generation changed; explicit restart or migration is required', schemaIssueDetail('sourceGeneration'));
         }
         if (previous?.adapterVersion && previous.adapterVersion !== request.adapter.adapterVersion) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint adapter version changed; checkpoint migration is required');
+            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint adapter version changed; checkpoint migration is required', schemaIssueDetail('adapterVersion'));
         }
         if (previous?.sourceSchemaVersion
             && previous.sourceSchemaVersion !== request.source.sourceSchemaVersion) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint source schema changed; checkpoint migration is required');
+            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint source schema changed; checkpoint migration is required', schemaIssueDetail('sourceSchemaVersion'));
         }
         if (previous?.policyVersion && previous.policyVersion !== request.policyVersion) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint policy version changed; checkpoint migration is required');
+            throw new SessionContractError('SCHEMA_DRIFT', 'session checkpoint policy version changed; checkpoint migration is required', schemaIssueDetail('policyVersion'));
         }
         const checkpoint = {
             cursor: previous?.cursor ?? '',
@@ -76,6 +80,7 @@ export class IncrementalSessionImporter {
         };
         const receipts = [];
         let batch = [];
+        let batchBytes = 0;
         let batchStart = checkpoint.recordsRead;
         let durableCheckpoint = { ...checkpoint };
         const importStarted = performance.now();
@@ -87,12 +92,14 @@ export class IncrementalSessionImporter {
             if (request.signal?.aborted) {
                 throw new SessionContractError('IMPORT_INTERRUPTED', 'session import was cancelled at a durable batch boundary');
             }
+            const identities = batch.map(recordIdentity);
+            const batchDigests = identities.map(identity => identity.digest);
             const runId = sha256([
                 request.source.sourceId, request.adapter.adapterVersion,
                 batchStart, checkpoint.recordsRead,
-                ...batch.map((record) => sha256(JSON.stringify(record))),
+                ...batchDigests,
             ].join('\0'));
-            const normalized = normalizeBatch(request, batch, runId, sourceObservedAt);
+            const normalized = normalizeBatch(request, batch, batchDigests, runId, sourceObservedAt);
             const run = {
                 contractVersion: SESSION_CONTRACT_VERSION,
                 importRunId: runId,
@@ -123,7 +130,7 @@ export class IncrementalSessionImporter {
             receipt.metrics = {
                 records: batch.length,
                 normalizedEvents: normalized.events.length,
-                normalizedBytes: batch.reduce((total, record) => total + Buffer.byteLength(JSON.stringify(record)), 0),
+                normalizedBytes: identities.reduce((bytes, identity) => bytes + identity.bytes, 0),
                 durationMs: performance.now() - importStarted,
                 batchLatencyMs: performance.now() - flushStarted,
                 heapUsedBytes: peakHeap,
@@ -133,20 +140,26 @@ export class IncrementalSessionImporter {
             receipts.push(receipt);
             durableCheckpoint = { ...checkpoint };
             batch = [];
+            batchBytes = 0;
             batchStart = checkpoint.recordsRead;
         };
         try {
+            if (continuity)
+                assertImportByteLimit('maxTotalBytes', limits, continuity.size);
             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
-                    || checkpoint.recordsRead + 1 > limits.maxRecords) {
-                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'session import exceeded an authorized resource limit');
-                }
+                const bytes = recordBytes(record);
+                assertImportByteLimit('maxRecordBytes', limits, bytes);
+                if (!continuity)
+                    assertImportByteLimit('maxTotalBytes', limits, checkpoint.bytesRead + bytes);
+                assertSessionResourceLimit('maxRecords', limits.maxRecords, checkpoint.recordsRead + 1);
+                // Bound batches by bytes as well as record count for large records.
+                if (batchBytes + bytes > 4 * 1024 * 1024)
+                    flush();
                 batch.push(record);
+                batchBytes += bytes;
                 checkpoint.recordsRead += 1;
                 if (record.sourceCursor?.startsWith('byte:')) {
                     checkpoint.positionKind = 'byte-offset';
@@ -195,6 +208,7 @@ export class IncrementalSessionImporter {
                     : durableCheckpoint,
                 errorCode: error instanceof SessionContractError
                     ? error.code : 'IMPORT_INTERRUPTED',
+                detail: error instanceof SessionContractError ? error.detail : undefined,
             }, error);
         }
         if (request.publish !== false && request.source.consistency === 'complete') {
@@ -207,20 +221,30 @@ export class IncrementalSessionImporter {
         return receipts;
     }
 }
-function normalizeBatch(request, records, importRunId, sourceObservedAt) {
+/** Keep large temporary JSON strings out of the asynchronous import frame. */
+function recordBytes(record) {
+    return Buffer.byteLength(JSON.stringify(record));
+}
+/** Compute flush-time identity once, preserving adapters that mutate yielded objects. */
+function recordIdentity(record) {
+    const serialized = JSON.stringify(record);
+    return { bytes: Buffer.byteLength(serialized), digest: sha256(serialized) };
+}
+function normalizeBatch(request, records, digests, importRunId, sourceObservedAt) {
     const sessions = new Map();
-    const events = records.map((record) => {
+    const events = records.map((record, index) => {
         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 lineage = request.source.provider === 'codex' && native.value.lineage
+            ? { lineage: native.value.lineage } : {};
+        const digest = digests[index];
         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,
+            [`native.${request.source.provider}`]: record.extensions ?? {},
         };
-        const event = SessionEventSchema.parse({
+        const event = sanitizeSessionEvent(SessionEventSchema.parse({
             contractVersion: SESSION_CONTRACT_VERSION,
             eventId: stableEventId(request.source.provider, request.source.sourceId, record, digest),
             sessionId, sourceId: request.source.sourceId, importRunId,
@@ -238,17 +262,13 @@ function normalizeBatch(request, records, importRunId, sourceObservedAt) {
             model: record.model ?? null,
             entities: record.entities ?? [],
             extractionState: record.extractionState ?? null,
-            searchableText: redacted.text, digest, rawReference: record.rawReference,
+            searchableText: record.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(),
-            },
+            sensitivity: { classification: 'none', classes: [] },
             opaque: !isKnownEventKind(record.kind),
             extensions,
-        });
+        }));
         if (!sessions.has(sessionId)) {
             sessions.set(sessionId, SessionSchema.parse({
                 contractVersion: SESSION_CONTRACT_VERSION,
@@ -260,6 +280,7 @@ function normalizeBatch(request, records, importRunId, sourceObservedAt) {
                 sourceDigest: sha256(`${sourceGenerationDigest(request)}\0${record.nativeSessionId}`),
                 extensions: {
                     [`native.${request.source.provider}`]: {
+                        ...lineage,
                         lifecycleEvidence,
                     },
                 },
@@ -279,6 +300,7 @@ function normalizeBatch(request, records, importRunId, sourceObservedAt) {
             session.lifecycle = selected.lifecycle;
             session.extensions[nativeKey] = {
                 ...nativeRecord,
+                ...lineage,
                 lifecycleEvidence: selected.evidence,
             };
         }
@@ -287,7 +309,7 @@ function normalizeBatch(request, records, importRunId, sourceObservedAt) {
     for (const session of sessions.values()) {
         session.intent = deriveSessionIntent(events.filter((event) => event.sessionId === session.sessionId));
     }
-    return { sessions: [...sessions.values()], events };
+    return { sessions: redactSessionValue([...sessions.values()]).value, events };
 }
 const KNOWN_EVENT_KINDS = new Set(['message', 'tool-call', 'tool-result', 'artifact', 'attachment', 'summary']);
 function isKnownEventKind(kind) {
@@ -363,6 +385,7 @@ function sessionLifecycleEvidence(request, record, sourceObservedAt) {
         state: 'active',
         observedAt: observedAt ?? request.source.authorizedAt,
         confidence: 'provisional',
+        thresholdMs,
     };
 }
 function nativeLifecycle(extensions) {
@@ -416,7 +439,6 @@ 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;
 }
@@ -454,15 +476,15 @@ async function sourceContinuity(request, previous) {
     const metadata = await fingerprintSourcePrefix(authorization, 0);
     if (!isSnapshot && previous?.sourceSize !== undefined) {
         if (metadata.size < previous.sourceSize) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'session source was truncated before its durable checkpoint');
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source was truncated before its durable checkpoint', schemaIssueDetail('sourceSize'));
         }
         if (previous.sourceFileIdentity
             && previous.sourceFileIdentity !== metadata.fileIdentity) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'session source file generation was replaced or rotated');
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source file generation was replaced or rotated', schemaIssueDetail('sourceFileIdentity'));
         }
         const priorPrefix = await fingerprintSourcePrefix(authorization, previous.sourceSize, skipPrefixBytes);
         if (previous.prefixDigest && priorPrefix.digest !== previous.prefixDigest) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'session source prefix was rewritten before its durable checkpoint');
+            throw new SessionContractError('SCHEMA_DRIFT', 'session source prefix was rewritten before its durable checkpoint', schemaIssueDetail('prefixDigest'));
         }
     }
     const current = await fingerprintSourcePrefix(authorization, metadata.size, skipPrefixBytes);

package/dist/src/sessions/lifecycle.js

@@ -0,0 +1,45 @@
+export const DEFAULT_INACTIVITY_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+export function effectiveSessionLifecycle(session) {
+    if (session.lifecycle !== 'active' && session.lifecycle !== 'inactive')
+        return session;
+    const nativeKey = `native.${session.provider}`;
+    const native = objectRecord(session.extensions[nativeKey]);
+    const evidence = objectRecord(native.lifecycleEvidence);
+    if (evidence.basis !== 'open-provisional-source'
+        && evidence.basis !== 'inactivity-threshold')
+        return session;
+    const observedAt = session.updatedAt ?? evidence.observedAt;
+    const timestamp = typeof observedAt === 'string' ? Date.parse(observedAt) : NaN;
+    if (!Number.isFinite(timestamp))
+        return session;
+    const thresholdMs = typeof evidence.thresholdMs === 'number'
+        && Number.isFinite(evidence.thresholdMs)
+        && evidence.thresholdMs >= 0
+        ? evidence.thresholdMs : DEFAULT_INACTIVITY_THRESHOLD_MS;
+    const inactive = Date.now() - timestamp > thresholdMs;
+    const lifecycle = inactive ? 'inactive' : 'active';
+    return {
+        ...session,
+        lifecycle,
+        extensions: {
+            ...session.extensions,
+            [nativeKey]: {
+                ...native,
+                lifecycleEvidence: {
+                    ...evidence,
+                    basis: inactive ? 'inactivity-threshold' : 'open-provisional-source',
+                    state: lifecycle,
+                    observedAt,
+                    confidence: inactive ? 'medium' : 'provisional',
+                    thresholdMs,
+                },
+            },
+        },
+    };
+}
+function objectRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+//# sourceMappingURL=lifecycle.js.map