@aiwg/cli 2026.7.21 → 2026.7.24

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

@@ -0,0 +1,265 @@
+import { stat } from 'node:fs/promises';
+import { CLAUDE_ADAPTER_VERSION, ClaudeSessionAdapter, } from './adapters/claude.js';
+import { CODEX_ADAPTER_VERSION, CodexSessionAdapter, } from './adapters/codex.js';
+import { CURSOR_ADAPTER_VERSION, CursorSessionAdapter, } from './adapters/cursor.js';
+import { FACTORY_ADAPTER_VERSION, FactorySessionAdapter, } from './adapters/factory.js';
+import { SESSION_CONTRACT_VERSION, SessionContractError, SessionSourceSchema, sha256, } from './contracts.js';
+import { BATCH_IMPORT_VERSION, coverageFromBatchRun, } from './batch-contracts.js';
+import { IncrementalSessionImporter, SessionImportFailure } from './importer.js';
+import { fingerprintSourceFile } from './readers.js';
+export async function importDiscoveryManifest(options) {
+    const now = options.now ?? (() => new Date());
+    const runId = sha256([
+        'workspace-import-v1',
+        options.manifest.manifestId,
+        options.manifest.workspaceId,
+    ].join('\0'));
+    const prior = options.repository.getBatchImportRunForManifest(options.manifest.manifestId, options.manifest.workspaceId);
+    const run = prior ?? newBatchRun(options.manifest, runId, now());
+    if (run.runId !== runId) {
+        throw new SessionContractError('IMPORT_CONFLICT', 'discovery manifest is already associated with a different batch run');
+    }
+    run.status = 'running';
+    run.updatedAt = now().toISOString();
+    run.completedAt = null;
+    options.repository.saveBatchImportRun(run);
+    injectFault(options, run, 'run-saved');
+    for (const manifestSource of options.manifest.sources) {
+        const disposition = run.sources.find((candidate) => candidate.sourceId === manifestSource.sourceId);
+        if (!disposition) {
+            throw new SessionContractError('IMPORT_CONFLICT', `batch run is missing discovered source ${manifestSource.sourceId}`);
+        }
+        if (isAccepted(disposition.status)) {
+            disposition.status = 'previously-committed';
+            disposition.updatedAt = now().toISOString();
+            continue;
+        }
+        if (options.signal?.aborted) {
+            run.status = 'interrupted';
+            run.updatedAt = now().toISOString();
+            options.repository.saveBatchImportRun(run);
+            throw new SessionContractError('IMPORT_INTERRUPTED', 'workspace batch import was cancelled and can be resumed');
+        }
+        disposition.status = 'running';
+        disposition.attempts += 1;
+        disposition.errorCode = null;
+        disposition.diagnostic = null;
+        disposition.updatedAt = now().toISOString();
+        persistProgress(options.repository, run, now());
+        try {
+            await assertManifestSourceUnchanged(manifestSource);
+            const selectedSource = {
+                provider: manifestSource.provider,
+                locator: manifestSource.locator,
+                locatorClass: manifestSource.locatorClass,
+                sourceId: manifestSource.sourceId,
+                authorizedScope: {
+                    workspaceId: options.manifest.workspaceId,
+                    allowedRoots: [manifestSource.authorizedRoot],
+                },
+            };
+            const adapter = adapterFor(manifestSource.provider);
+            const source = await sessionSource(selectedSource, adapter);
+            const receipts = await new IncrementalSessionImporter(options.repository).import({
+                source,
+                selectedSource,
+                adapter,
+                workspaceId: options.manifest.workspaceId,
+                policyVersion: '1.0.0',
+                batchRunId: run.runId,
+                publish: false,
+                signal: options.signal,
+                inactivityThresholdMs: options.inactivityThresholdMs,
+            });
+            await assertManifestSourceUnchanged(manifestSource);
+            const totals = options.repository.sourceImportTotals(manifestSource.sourceId, run.runId);
+            disposition.sessionsAccepted = totals.sessions;
+            disposition.eventsAccepted = totals.events;
+            disposition.status = receipts.length > 0
+                && receipts.every((receipt) => receipt.outcome === 'duplicate')
+                ? 'duplicate'
+                : receipts.length === 0
+                    ? 'previously-committed'
+                    : 'committed';
+        }
+        catch (error) {
+            disposition.status = 'rejected';
+            disposition.errorCode = importErrorCode(error);
+            disposition.diagnostic = [
+                `provider=${manifestSource.provider}`,
+                `source=${manifestSource.sourceId}`,
+                `code=${disposition.errorCode}`,
+            ].join(' ');
+        }
+        disposition.updatedAt = now().toISOString();
+        persistProgress(options.repository, run, now());
+        injectFault(options, run, 'source-staged', manifestSource.sourceId);
+    }
+    const rejected = run.sources.some((source) => source.status === 'rejected');
+    const pending = run.sources.some((source) => source.status === 'pending' || source.status === 'running');
+    const providerGap = run.providers.some((provider) => provider.status === 'export-required' || provider.status === 'not-checked');
+    const publishable = run.sources
+        .filter((source) => isAccepted(source.status))
+        .map((source) => source.sourceId);
+    injectFault(options, run, 'before-publication');
+    options.repository.commitStagedBatch(run.runId, publishable);
+    injectFault(options, run, 'after-publication');
+    run.status = pending ? 'interrupted' : rejected || providerGap ? 'partial' : 'complete';
+    run.updatedAt = now().toISOString();
+    run.completedAt = pending ? null : run.updatedAt;
+    options.repository.saveBatchImportRun(run);
+    return receiptFor(run, now());
+}
+function injectFault(options, run, boundary, sourceId) {
+    if (!options.fault)
+        return;
+    try {
+        options.fault(boundary, sourceId);
+    }
+    catch (error) {
+        run.status = 'interrupted';
+        run.updatedAt = (options.now ?? (() => new Date()))().toISOString();
+        run.completedAt = null;
+        options.repository.saveBatchImportRun(run);
+        throw error;
+    }
+}
+export function previewDiscoveryImport(manifest, existing, now = new Date()) {
+    const run = existing ?? newBatchRun(manifest, sha256(['workspace-import-v1', manifest.manifestId, manifest.workspaceId].join('\0')), now);
+    return receiptFor(run, now);
+}
+function newBatchRun(manifest, runId, now) {
+    const timestamp = now.toISOString();
+    return {
+        schemaVersion: BATCH_IMPORT_VERSION,
+        runId,
+        manifestId: manifest.manifestId,
+        manifestCreatedAt: manifest.createdAt,
+        workspaceId: manifest.workspaceId,
+        status: 'running',
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        completedAt: null,
+        providers: manifest.providers,
+        sources: manifest.sources.map((source) => ({
+            sourceId: source.sourceId,
+            provider: source.provider,
+            status: 'pending',
+            attempts: 0,
+            sessionsAccepted: 0,
+            eventsAccepted: 0,
+            errorCode: null,
+            diagnostic: null,
+            updatedAt: timestamp,
+        })),
+    };
+}
+function receiptFor(run, now) {
+    const coverage = coverageFromBatchRun(run, now);
+    return {
+        schemaVersion: BATCH_IMPORT_VERSION,
+        run,
+        coverage,
+        totals: {
+            discovered: coverage.sources.discovered,
+            accepted: coverage.sources.accepted,
+            rejected: coverage.sources.rejected,
+            skipped: coverage.sources.skipped,
+            duplicated: coverage.sources.duplicated,
+            previouslyCommitted: coverage.sources.previouslyCommitted,
+            pending: coverage.sources.pending,
+            sessionsAccepted: coverage.sessionsAccepted,
+            eventsAccepted: coverage.eventsAccepted,
+        },
+    };
+}
+function persistProgress(repository, run, now) {
+    run.updatedAt = now.toISOString();
+    repository.saveBatchImportRun(run);
+}
+async function assertManifestSourceUnchanged(source) {
+    let details;
+    try {
+        details = await stat(source.locator);
+    }
+    catch {
+        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source is no longer available; run discovery again');
+    }
+    if (details.size !== source.sizeBytes || details.mtime.toISOString() !== source.modifiedAt) {
+        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source changed after manifest creation; run discovery again');
+    }
+    const fingerprint = await fingerprintSourceFile({
+        selectedPath: source.locator,
+        allowedRoots: [source.authorizedRoot],
+    });
+    if (fingerprint.digest !== source.digest || fingerprint.size !== source.sizeBytes) {
+        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source content changed after manifest creation; run discovery again');
+    }
+}
+function adapterFor(provider) {
+    if (provider === 'claude')
+        return new ClaudeSessionAdapter();
+    if (provider === 'codex')
+        return new CodexSessionAdapter();
+    if (provider === 'cursor')
+        return new CursorSessionAdapter();
+    if (provider === 'factory')
+        return new FactorySessionAdapter();
+    throw new SessionContractError('UNSUPPORTED_OPERATION', `batch discovery import is not implemented for ${provider}`);
+}
+async function sessionSource(selected, adapter) {
+    const probe = await adapter.inspect(selected);
+    return SessionSourceSchema.parse({
+        contractVersion: SESSION_CONTRACT_VERSION,
+        sourceId: selected.sourceId,
+        provider: selected.provider,
+        providerProfile: providerProfile(selected.provider, selected.locatorClass),
+        locatorClass: selected.locatorClass,
+        redactedLocator: '<discovered-session-source>',
+        adapterVersion: adapterVersion(selected.provider),
+        sourceSchemaVersion: probe.sourceSchemaVersion,
+        disposition: 'implemented',
+        operationalState: probe.operationalState,
+        consistency: probe.consistency,
+        authorizedAt: new Date().toISOString(),
+        extensions: { [`native.${selected.provider}`]: {} },
+    });
+}
+function adapterVersion(provider) {
+    if (provider === 'claude')
+        return CLAUDE_ADAPTER_VERSION;
+    if (provider === 'codex')
+        return CODEX_ADAPTER_VERSION;
+    if (provider === 'cursor')
+        return CURSOR_ADAPTER_VERSION;
+    if (provider === 'factory')
+        return FACTORY_ADAPTER_VERSION;
+    return '1.0.0';
+}
+function providerProfile(provider, locatorClass) {
+    if (provider === 'claude')
+        return 'documented-local-jsonl';
+    if (provider === 'codex')
+        return 'app-server-v2-rollout-fallback';
+    if (provider === 'cursor') {
+        return locatorClass === 'cursor-agent-transcript-jsonl'
+            ? 'agent-transcript-jsonl'
+            : 'cli-stream-json';
+    }
+    if (provider === 'factory')
+        return 'documented-project-jsonl';
+    return 'manual-interchange';
+}
+function importErrorCode(error) {
+    if (error instanceof SessionImportFailure)
+        return error.failureReceipt.errorCode;
+    if (error instanceof SessionContractError)
+        return error.code;
+    return 'IMPORT_INTERRUPTED';
+}
+function isAccepted(status) {
+    return status === 'committed'
+        || status === 'duplicate'
+        || status === 'previously-committed';
+}
+//# sourceMappingURL=batch-import.js.map

package/dist/src/sessions/contracts.js

@@ -30,7 +30,7 @@ export const SessionErrorCodeSchema = z.enum([
     'IMPORT_CONFLICT', 'IMPORT_INTERRUPTED', 'MALFORMED_SOURCE',
     'DUPLICATE_NATIVE_ID', 'AMBIGUOUS_TIMESTAMP', 'TRUNCATED_SOURCE',
     'UNSUPPORTED_OPERATION',
-    'INVALID_SEARCH_QUERY',
+    'INVALID_SEARCH_QUERY', 'INVALID_ARGUMENT',
 ]);
 const VersionSchema = z.string().regex(/^\d+\.\d+\.\d+(?:[-+].+)?$/);
 const DigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
@@ -73,6 +73,15 @@ export const SessionEventSchema = z.object({
     entities: z.array(z.string().min(1)).default([]),
     extractionState: z.string().min(1).nullable().default(null),
     occurredAt: z.string().datetime({ offset: true }).nullable(),
+    activityBoundary: z.enum(['pause', 'resume', 'continuation', 'end']).nullable().default(null),
+    activityBoundaryBasis: z.string().min(1).nullable().default(null),
+    activityBoundaryConfidence: z.enum(['low', 'medium', 'high']).nullable().default(null),
+    origin: z.enum([
+        'user-authored', 'assistant-generated', 'provider-bootstrap',
+        'workspace-instruction', 'tool-control', 'unknown',
+    ]).default('unknown'),
+    originRule: z.string().min(1).default('legacy:unknown'),
+    originClassifierVersion: VersionSchema.default('1.0.0'),
     searchableText: z.string(),
     digest: DigestSchema,
     rawReference: z.object({
@@ -99,7 +108,23 @@ export const SessionSchema = z.object({
     startedAt: z.string().datetime({ offset: true }).nullable(),
     updatedAt: z.string().datetime({ offset: true }).nullable(),
     consistency: ConsistencyStateSchema,
-    lifecycle: z.enum(['active', 'complete', 'tombstoned']),
+    lifecycle: z.enum([
+        'active', 'inactive', 'paused', 'complete', 'interrupted', 'archived',
+        'unknown', 'tombstoned',
+    ]),
+    intent: z.object({
+        status: z.enum(['selected', 'absent', 'unknown']),
+        eventId: z.string().min(1).nullable(),
+        sequence: z.number().int().nonnegative().nullable(),
+        title: z.string().nullable(),
+        summary: z.string().nullable(),
+    }).default({
+        status: 'unknown',
+        eventId: null,
+        sequence: null,
+        title: null,
+        summary: null,
+    }),
     sourceDigest: DigestSchema,
     extensions: NativeExtensionsSchema.default({}),
 });
@@ -288,10 +313,12 @@ export function stableSessionId(provider, sourceId, nativeSessionId) {
     const identitySeed = canonical === 'devin-desktop' ? 'windsurf' : canonical;
     return stableId('session', identitySeed, sourceId, nativeSessionId);
 }
-export function stableEventId(sourceId, record, digest) {
+export function stableEventId(provider, sourceId, record, digest) {
+    const canonical = assertSessionProviderId(provider);
+    const identityScheme = 'event-v2-native-scope';
     return record.nativeEventId
-        ? stableId('event', sourceId, record.nativeEventId)
-        : stableId('event', sourceId, record.nativeSessionId, record.sequence, record.kind, digest);
+        ? stableId('event', identityScheme, canonical, sourceId, record.nativeSessionId, record.nativeEventId, record.sequence)
+        : stableId('event', identityScheme, canonical, sourceId, record.nativeSessionId, record.sequence, record.kind, digest);
 }
 export function sha256(value) {
     return `sha256:${createHash('sha256').update(value).digest('hex')}`;

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

@@ -0,0 +1,152 @@
+import { mkdir, readFile, rename, rm, stat, 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;
+    waitMs;
+    code = 'IMPORT_LOCKED';
+    constructor(owner, waitMs) {
+        const identity = owner
+            ? `run ${owner.runId} (pid ${owner.pid} on ${owner.host}, heartbeat ${owner.heartbeatAt})`
+            : 'an unreadable owner';
+        super(`session import lease is held by ${identity}; waited ${waitMs}ms. `
+            + 'Wait for that run to finish, or remove the lease only after confirming the owner is no longer active.');
+        this.owner = owner;
+        this.waitMs = waitMs;
+        this.name = 'ImportLeaseContentionError';
+    }
+}
+export function importLeasePath(databasePath) {
+    return `${databasePath}.import.lock`;
+}
+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 lockPath = importLeasePath(databasePath);
+    const ownerPath = `${lockPath}/owner.json`;
+    const deadline = Date.now() + waitMs;
+    await mkdir(dirname(databasePath), { recursive: true, mode: 0o700 });
+    while (true) {
+        try {
+            await mkdir(lockPath, { mode: 0o700 });
+            const observed = now().toISOString();
+            const owner = {
+                contractVersion: '1.0.0',
+                runId,
+                pid: process.pid,
+                host: hostname(),
+                startedAt: observed,
+                heartbeatAt: observed,
+            };
+            await writeOwner(ownerPath, owner);
+            const timer = setInterval(() => {
+                owner.heartbeatAt = now().toISOString();
+                void writeOwner(ownerPath, owner).catch(() => undefined);
+            }, heartbeatMs);
+            timer.unref();
+            let released = false;
+            return {
+                owner,
+                lockPath,
+                async release() {
+                    if (released)
+                        return;
+                    released = true;
+                    clearInterval(timer);
+                    const current = await readOwner(ownerPath);
+                    if (current?.runId === owner.runId) {
+                        await rm(lockPath, { recursive: true, force: true });
+                    }
+                },
+            };
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== 'EEXIST')
+                throw error;
+            const existing = await readOwner(ownerPath);
+            if (await staleLease(lockPath, existing, staleMs, processAlive)) {
+                const confirmed = await readOwner(ownerPath);
+                if (sameLease(existing, confirmed)
+                    && await staleLease(lockPath, confirmed, staleMs, processAlive)) {
+                    await rm(lockPath, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            if (Date.now() >= deadline) {
+                throw new ImportLeaseContentionError(existing, waitMs);
+            }
+            await delay(Math.min(pollMs, Math.max(1, deadline - Date.now())));
+        }
+    }
+}
+async function writeOwner(path, owner) {
+    const temporary = `${path}.tmp-${process.pid}`;
+    await writeFile(temporary, `${JSON.stringify(owner)}\n`, { mode: 0o600 });
+    await rename(temporary, path);
+}
+async function readOwner(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        if (value.contractVersion !== '1.0.0'
+            || typeof value.runId !== 'string'
+            || typeof value.pid !== 'number'
+            || typeof value.host !== 'string'
+            || typeof value.startedAt !== 'string'
+            || typeof value.heartbeatAt !== 'string')
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+async function staleLease(lockPath, owner, staleMs, processAlive) {
+    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 {
+        return false;
+    }
+}
+function sameLease(first, second) {
+    if (!first || !second)
+        return first === second;
+    return first.runId === second.runId
+        && first.pid === second.pid
+        && first.host === second.host
+        && first.startedAt === second.startedAt
+        && first.heartbeatAt === second.heartbeatAt;
+}
+function defaultProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return isNodeError(error) && error.code === 'EPERM';
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=import-lease.js.map