@aiwg/cli 2026.10.3 → 2026.10.4

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

@@ -1,7 +1,7 @@
 import { basename } from 'node:path';
 import { z } from 'zod';
-import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
-import { readBoundedJsonLines, streamBoundedJsonLines, } from '../readers.js';
+import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
+import { streamBoundedJsonLines, } from '../readers.js';
 export const DEVIN_DESKTOP_ADAPTER_VERSION = '1.1.0';
 export const DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION = '1.0.0';
 /** @deprecated Compatibility export. */
@@ -38,19 +38,14 @@ export class DevinDesktopSessionAdapter {
         // Deliberately empty: hook enablement and transcript selection are explicit user actions.
     }
     async inspect(source) {
-        const parsed = await this.readSource(source);
-        return {
-            sourceSchemaVersion: parsed.schemaVersion,
-            consistency: 'provisional',
-            operationalState: 'available',
-        };
+        const records = this.stream(source);
+        let result = await records.next();
+        while (!result.done)
+            result = await records.next();
+        return result.value;
     }
     async *stream(source, cursor) {
-        if (!isCurrentHookLocator(source.locatorClass)) {
-            // Preserve the precise unsupported-operation diagnostics.
-            await this.readSource(source);
-            return;
-        }
+        this.assertSupportedLocator(source);
         const start = parseCursor(cursor?.value);
         const input = await streamBoundedJsonLines({
             selectedPath: source.locator,
@@ -62,12 +57,12 @@ export class DevinDesktopSessionAdapter {
         for await (const line of input) {
             const parsed = StepSchema.safeParse(line.value);
             if (!parsed.success) {
-                throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript step is malformed');
+                throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript step is malformed', schemaRejectionDetail(parsed.error));
             }
             const step = parsed.data;
             const currentVersion = step.schema_version ?? DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION;
             if (schemaVersion && schemaVersion !== currentVersion) {
-                throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf transcript schemas');
+                throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf transcript schemas', schemaIssueDetail('schema_version'));
             }
             schemaVersion = currentVersion;
             assertSupportedSchemaMajor(schemaVersion);
@@ -75,7 +70,7 @@ export class DevinDesktopSessionAdapter {
                 ?? nativeSessionId
                 ?? basename(source.locator, '.jsonl');
             if (step.trajectory_id && nativeSessionId && step.trajectory_id !== nativeSessionId) {
-                throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf trajectory identities');
+                throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf trajectory identities', schemaIssueDetail('trajectory_id'));
             }
             nativeSessionId = currentSession;
             if (seen++ < start)
@@ -83,45 +78,21 @@ export class DevinDesktopSessionAdapter {
             yield normalizeStep(step, currentSession, line.sequence, line.byteOffset, canonicalLocatorClass(source.locatorClass), schemaVersion);
         }
         if (seen === 0) {
-            throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript is empty or malformed');
+            throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript is empty or malformed', schemaIssueDetail('<root>'));
         }
+        return {
+            sourceSchemaVersion: schemaVersion,
+            consistency: 'provisional',
+            operationalState: 'available',
+        };
     }
-    async readSource(source) {
+    assertSupportedLocator(source) {
         if (isLegacyLocator(source.locatorClass)) {
             throw new SessionContractError('UNSUPPORTED_OPERATION', 'legacy Devin Desktop/Windsurf protobuf stores are unsupported; enable post_cascade_response_with_transcript and select its JSONL output');
         }
         if (!isCurrentHookLocator(source.locatorClass)) {
             throw new SessionContractError('UNSUPPORTED_OPERATION', 'Devin Desktop (Windsurf compatibility) requires an explicitly selected post_cascade_response_with_transcript JSONL file');
         }
-        const input = await readBoundedJsonLines({
-            selectedPath: source.locator,
-            allowedRoots: source.authorizedScope.allowedRoots,
-        }, { consistency: 'provisional', limits: this.limits });
-        if (input.records.length === 0) {
-            throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript is empty or malformed');
-        }
-        const steps = input.records.map((record) => {
-            const parsed = StepSchema.safeParse(record.value);
-            if (!parsed.success) {
-                throw new SessionContractError('MALFORMED_SOURCE', 'Windsurf transcript step is malformed');
-            }
-            return { ...record, value: parsed.data };
-        });
-        const versions = new Set(steps.map(({ value }) => value.schema_version ?? DEVIN_DESKTOP_TRANSCRIPT_SCHEMA_VERSION));
-        if (versions.size !== 1) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf transcript schemas');
-        }
-        const schemaVersion = [...versions][0];
-        assertSupportedSchemaMajor(schemaVersion);
-        const trajectoryIds = new Set(steps.flatMap(({ value }) => value.trajectory_id ? [value.trajectory_id] : []));
-        if (trajectoryIds.size > 1) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'mixed Windsurf trajectory identities');
-        }
-        const nativeSessionId = [...trajectoryIds][0] ?? basename(source.locator, '.jsonl');
-        return {
-            schemaVersion,
-            records: steps.map(({ value, sequence, byteOffset }) => normalizeStep(value, nativeSessionId, sequence, byteOffset, canonicalLocatorClass(source.locatorClass), schemaVersion)),
-        };
     }
 }
 /** @deprecated Use DevinDesktopSessionAdapter; retained through the alias window. */
@@ -206,7 +177,7 @@ function parseCursor(value) {
     if (!value)
         return 0;
     if (!/^\d+$/.test(value))
-        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Windsurf cursor');
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Windsurf cursor', schemaIssueDetail('cursor'));
     return Number(value);
 }
 //# sourceMappingURL=windsurf.js.map

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

@@ -1,6 +1,6 @@
 import { reconcileCoveragePreflight } from './coverage-preflight.js';
-export const BATCH_IMPORT_VERSION = '1.0.0';
-export const COVERAGE_VERSION = '1.0.0';
+export const BATCH_IMPORT_VERSION = '2.0.0';
+export const COVERAGE_VERSION = '2.0.0';
 export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 * 60 * 60 * 1_000) {
     if (!run)
         return unknownCoverage();
@@ -9,6 +9,7 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
     ]);
     const accepted = run.sources.filter((source) => source.status === 'committed').length;
     const rejected = run.sources.filter((source) => source.status === 'rejected').length;
+    const excluded = run.sources.filter(source => source.status === 'excluded').length;
     const skipped = run.sources.filter((source) => source.status === 'skipped').length;
     const duplicated = run.sources.filter((source) => source.status === 'duplicate').length;
     const previouslyCommitted = run.sources.filter((source) => source.status === 'previously-committed').length;
@@ -20,9 +21,12 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
     const manifestAgeMs = Math.max(0, now.getTime() - Date.parse(run.manifestCreatedAt));
     const isStale = manifestAgeMs > staleAfterMs;
     const preflight = run.preflight ? reconcileCoveragePreflight(run.preflight, run.sources) : undefined;
-    const incomplete = !preflight || preflight.status !== 'complete'
-        || unavailable.length > 0 || accepted + duplicated + previouslyCommitted === 0
-        || rejected > 0 || pending > 0 || skipped > 0
+    const unresolvedProviders = preflight?.unresolvedProviders
+        ?? [...new Set([...unavailable, ...exportRequired, ...notChecked])].sort();
+    const acquisitionIncomplete = rejected > 0 || pending > 0 || skipped > 0
+        || (preflight?.expectedProviderBasis === 'explicit' && unresolvedProviders.length > 0);
+    const incomplete = acquisitionIncomplete || !preflight || preflight.status !== 'complete'
+        || unavailable.length > 0 || accepted + duplicated + previouslyCommitted + excluded === 0
         || exportRequired.length > 0 || notChecked.length > 0;
     const rejectionCounts = {};
     for (const source of run.sources) {
@@ -54,7 +58,8 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
     return {
         schemaVersion: COVERAGE_VERSION,
         status: isStale ? 'stale' : incomplete ? 'partial' : 'complete',
-        acquisitionStatus: incomplete ? 'partial' : 'complete',
+        acquisitionStatus: acquisitionIncomplete ? 'partial' : 'complete',
+        unresolvedProviders,
         preflight,
         semanticReview: 'not-assessed',
         workspaceId: run.workspaceId,
@@ -67,6 +72,7 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
             discovered: run.sources.length,
             accepted,
             rejected,
+            excluded,
             skipped,
             duplicated,
             previouslyCommitted,
@@ -74,9 +80,9 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
         },
         sessionsAccepted: run.sources.reduce((sum, source) => sum + source.sessionsAccepted, 0),
         eventsAccepted: run.sources.reduce((sum, source) => sum + source.eventsAccepted, 0),
-        coverageRatio: run.sources.length === 0
+        coverageRatio: run.sources.length === excluded
             ? null
-            : (accepted + duplicated + previouslyCommitted) / run.sources.length,
+            : (accepted + duplicated + previouslyCommitted) / (run.sources.length - excluded),
         rejectionCounts,
         sourceDateRange: {
             earliest: sourceTimestamps.at(0) ?? null,
@@ -100,6 +106,7 @@ function unknownCoverage() {
         schemaVersion: COVERAGE_VERSION,
         status: 'unknown',
         acquisitionStatus: 'unknown',
+        unresolvedProviders: [],
         semanticReview: 'not-assessed',
         workspaceId: '',
         manifestId: null,
@@ -116,6 +123,7 @@ function unknownCoverage() {
             discovered: 0,
             accepted: 0,
             rejected: 0,
+            excluded: 0,
             skipped: 0,
             duplicated: 0,
             previouslyCommitted: 0,

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

@@ -1,11 +1,17 @@
 import { stat } from 'node:fs/promises';
 import { createSessionAdapterRegistry } from './adapter-registry.js';
 import { coveragePreflight, sessionRuntimeIdentity } from './coverage-preflight.js';
-import { SESSION_CONTRACT_VERSION, SessionContractError, SessionSourceSchema, sha256, } from './contracts.js';
+import { SESSION_CONTRACT_VERSION, SessionContractError, schemaIssueDetail, SessionSourceSchema, sha256, } 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';
 export async function importDiscoveryManifest(options) {
+    const exclusions = resolveImportExclusions(undefined, options.exclude);
+    const limits = { ...resolveImportLimits(undefined, {
+            maxRecordBytes: options.limits?.maxRecordBytes, maxSourceBytes: options.limits?.maxTotalBytes,
+        }), ...options.limits };
     const now = options.now ?? (() => new Date());
     const runId = sha256([
         'workspace-import-v1',
@@ -17,6 +23,7 @@ export async function importDiscoveryManifest(options) {
     if (run.runId !== runId) {
         throw new SessionContractError('IMPORT_CONFLICT', 'discovery manifest is already associated with a different batch run');
     }
+    run.schemaVersion = BATCH_IMPORT_VERSION;
     run.preflight = coveragePreflight({
         expectedProviders: options.manifest.preflight?.expectedProviders,
         expectedProviderBasis: options.manifest.preflight?.expectedProviderBasis ?? 'legacy',
@@ -33,6 +40,12 @@ export async function importDiscoveryManifest(options) {
         if (!disposition) {
             throw new SessionContractError('IMPORT_CONFLICT', `batch run is missing discovered source ${manifestSource.sourceId}`);
         }
+        const exclusion = matchImportExclusion(manifestSource, exclusions) ?? manifestSource.exclusion;
+        if (exclusion) {
+            excludeSource(disposition, exclusion, now());
+            continue;
+        }
+        delete disposition.exclusion;
         if (isAccepted(disposition.status)) {
             disposition.status = 'previously-committed';
             disposition.updatedAt = now().toISOString();
@@ -48,6 +61,7 @@ export async function importDiscoveryManifest(options) {
         disposition.attempts += 1;
         disposition.errorCode = null;
         disposition.diagnostic = null;
+        disposition.detail = null;
         disposition.updatedAt = now().toISOString();
         persistProgress(options.repository, run, now());
         try {
@@ -62,7 +76,7 @@ export async function importDiscoveryManifest(options) {
                     allowedRoots: [manifestSource.authorizedRoot],
                 },
             };
-            const adapter = adapterFor(manifestSource.provider);
+            const adapter = adapterFor(manifestSource.provider, limits);
             const source = await sessionSource(selectedSource, adapter);
             const receipts = await new IncrementalSessionImporter(options.repository).import({
                 source,
@@ -74,6 +88,7 @@ export async function importDiscoveryManifest(options) {
                 publish: false,
                 signal: options.signal,
                 inactivityThresholdMs: options.inactivityThresholdMs,
+                limits,
             });
             await assertManifestSourceUnchanged(manifestSource);
             const totals = options.repository.sourceImportTotals(manifestSource.sourceId, run.runId);
@@ -89,10 +104,12 @@ export async function importDiscoveryManifest(options) {
         catch (error) {
             disposition.status = 'rejected';
             disposition.errorCode = importErrorCode(error);
+            disposition.detail = error instanceof SessionContractError ? error.detail ?? null : null;
             disposition.diagnostic = [
                 `provider=${manifestSource.provider}`,
                 `source=${manifestSource.sourceId}`,
                 `code=${disposition.errorCode}`,
+                ...(disposition.detail ? [`detail=${JSON.stringify(disposition.detail)}`] : []),
             ].join(' ');
         }
         disposition.updatedAt = now().toISOString();
@@ -101,14 +118,14 @@ export async function importDiscoveryManifest(options) {
     }
     const rejected = run.sources.some((source) => source.status === 'rejected');
     const pending = run.sources.some((source) => source.status === 'pending' || source.status === 'running');
-    const providerGap = coverageFromBatchRun(run, now()).acquisitionStatus !== 'complete';
+    const acquisitionIncomplete = coverageFromBatchRun(run, now()).acquisitionStatus !== 'complete';
     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.status = pending ? 'interrupted' : rejected || acquisitionIncomplete ? 'partial' : 'complete';
     run.updatedAt = now().toISOString();
     run.completedAt = pending ? null : run.updatedAt;
     options.repository.saveBatchImportRun(run);
@@ -128,10 +145,20 @@ function injectFault(options, run, boundary, sourceId) {
         throw error;
     }
 }
-export function previewDiscoveryImport(manifest, existing, now = new Date()) {
+export function previewDiscoveryImport(manifest, existing, now = new Date(), exclude = []) {
     const run = existing ?? newBatchRun(manifest, sha256(['workspace-import-v1', manifest.manifestId, manifest.workspaceId].join('\0')), now);
+    const exclusions = resolveImportExclusions(undefined, exclude);
     return receiptFor({
         ...run,
+        sources: run.sources.map(source => {
+            const manifestSource = manifest.sources.find(candidate => candidate.sourceId === source.sourceId);
+            const exclusion = matchImportExclusion(manifestSource, exclusions) ?? manifestSource.exclusion;
+            if (!exclusion)
+                return source;
+            const disposition = { ...source };
+            excludeSource(disposition, exclusion, now);
+            return disposition;
+        }),
         preflight: coveragePreflight({
             expectedProviders: manifest.preflight?.expectedProviders,
             expectedProviderBasis: manifest.preflight?.expectedProviderBasis ?? 'legacy',
@@ -157,7 +184,8 @@ function newBatchRun(manifest, runId, now) {
         sources: manifest.sources.map((source) => ({
             sourceId: source.sourceId,
             provider: source.provider,
-            status: 'pending',
+            status: source.status ?? 'pending',
+            ...(source.exclusion ? { exclusion: source.exclusion } : {}),
             attempts: 0,
             sessionsAccepted: 0,
             eventsAccepted: 0,
@@ -173,10 +201,12 @@ function receiptFor(run, now) {
         schemaVersion: BATCH_IMPORT_VERSION,
         run,
         coverage,
+        interruptedRuns: [],
         totals: {
             discovered: coverage.sources.discovered,
             accepted: coverage.sources.accepted,
             rejected: coverage.sources.rejected,
+            excluded: coverage.sources.excluded,
             skipped: coverage.sources.skipped,
             duplicated: coverage.sources.duplicated,
             previouslyCommitted: coverage.sources.previouslyCommitted,
@@ -186,6 +216,16 @@ function receiptFor(run, now) {
         },
     };
 }
+function excludeSource(source, exclusion, now) {
+    source.status = 'excluded';
+    source.exclusion = exclusion;
+    source.errorCode = null;
+    source.diagnostic = null;
+    source.detail = null;
+    source.sessionsAccepted = 0;
+    source.eventsAccepted = 0;
+    source.updatedAt = now.toISOString();
+}
 function persistProgress(repository, run, now) {
     run.updatedAt = now.toISOString();
     repository.saveBatchImportRun(run);
@@ -196,21 +236,21 @@ async function assertManifestSourceUnchanged(source) {
         details = await stat(source.locator);
     }
     catch {
-        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source is no longer available; run discovery again');
+        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source is no longer available; run discovery again', schemaIssueDetail('locator'));
     }
     if (details.size !== source.sizeBytes || details.mtime.toISOString() !== source.modifiedAt) {
-        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source changed after manifest creation; run discovery again');
+        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source changed after manifest creation; run discovery again', schemaIssueDetail(details.size !== source.sizeBytes ? 'sizeBytes' : 'modifiedAt'));
     }
     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');
+        throw new SessionContractError('SCHEMA_DRIFT', 'discovered source content changed after manifest creation; run discovery again', schemaIssueDetail('digest'));
     }
 }
-function adapterFor(provider) {
-    return createSessionAdapterRegistry().get(provider);
+function adapterFor(provider, limits) {
+    return createSessionAdapterRegistry(limits).get(provider);
 }
 async function sessionSource(selected, adapter) {
     const probe = await adapter.inspect(selected);

package/dist/src/sessions/contracts.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
+import { redactSessionText, redactSessionValue } from './policy.js';
 export const SESSION_CONTRACT_VERSION = '1.0.0';
 export const SESSION_PROVIDER_IDS = [
     'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
@@ -362,11 +363,48 @@ export function sha256(value) {
 function stableId(prefix, ...parts) {
     return `${prefix}_${createHash('sha256').update(parts.join('\0')).digest('hex')}`;
 }
+export const SessionRejectionDetailSchema = z.union([
+    z.object({ limit: z.string(), configured: z.number(), observed: z.number(),
+        setting: z.string().optional(), origin: z.enum(['flag', 'env', 'config', 'default']).optional() }),
+    z.object({ issues: z.array(z.object({ path: z.string(), code: z.string() })) }),
+]);
+export function schemaIssueDetail(path, code = 'custom') {
+    return { issues: [{ path, code }] };
+}
+export function assertSessionResourceLimit(limit, configured, observed) {
+    if (observed > configured) {
+        throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'session resource limit exceeded', {
+            limit, configured, observed,
+        });
+    }
+}
+/** Extract schema locations and validator codes without messages or input values. */
+export function schemaRejectionDetail(error) {
+    const issues = [];
+    const visit = (entries) => {
+        for (const issue of entries) {
+            if (issues.length >= 20)
+                return;
+            if (issue.code === 'invalid_union') {
+                for (const branch of issue.unionErrors)
+                    visit(branch.issues);
+            }
+            else {
+                issues.push({ path: issue.path.join('.') || '<root>', code: issue.code });
+            }
+        }
+    };
+    visit(error.issues);
+    return redactSessionValue({ issues }).value;
+}
 export class SessionContractError extends Error {
     code;
-    constructor(code, message) {
-        super(message);
+    detail;
+    constructor(code, message, detail) {
+        super(redactSessionText(message).text);
         this.code = code;
+        this.detail = detail;
+        this.detail = redactSessionValue(detail).value;
         this.name = 'SessionContractError';
     }
 }

package/dist/src/sessions/coverage-preflight.js

@@ -114,7 +114,7 @@ export function reconcileCoveragePreflight(preflight, sources) {
             return entry;
         const selected = sources.filter((source) => source.provider === entry.provider);
         const imported = selected.length === entry.sourceCount && selected.length > 0
-            && selected.every((source) => accepted.has(source.status) && source.eventsAccepted > 0);
+            && selected.every((source) => source.status === 'excluded' || (accepted.has(source.status) && source.eventsAccepted > 0));
         return {
             ...entry,
             disposition: !imported ? 'import-incomplete'

package/dist/src/sessions/export-plan.js

@@ -13,6 +13,7 @@ import { SessionContractError } from './contracts.js';
 import { buildSessionAiwgFortemiIndexExport, SESSION_EXPORT_INDEX_SCHEMA_VERSION, } from './fortemi-export-mapping.js';
 import { discoverSessionOutputCandidates } from './output-lineage.js';
 import { FilesystemDerivedOutputIndex } from './output-registration.js';
+import { redactSessionValue } from './policy.js';
 export const SESSION_EXPORT_PLAN_SCHEMA_VERSION = '1.1.0';
 function eventDigestSummary(events) {
     const hash = createHash('sha256');
@@ -43,7 +44,7 @@ function localEventAttachment(event, projectRoot) {
         && value.dataBytes.every((item) => Number.isInteger(item) && Number(item) >= 0 && Number(item) <= 255)) {
         return { filename, mediaType, bytes: Uint8Array.from(value.dataBytes) };
     }
-    if (typeof value.dataUrl === 'string') {
+    if (typeof value.dataUrl === 'string' && !value.dataUrl.startsWith('[REDACTED:')) {
         const match = /^data:([^;,]*)(;base64)?,(.*)$/s.exec(value.dataUrl);
         if (!match)
             throw new SessionContractError('MALFORMED_SOURCE', `invalid data URL attachment: ${event.eventId}`);
@@ -52,7 +53,7 @@ function localEventAttachment(event, projectRoot) {
             : Buffer.from(decodeURIComponent(match[3]), 'utf8');
         return { filename, mediaType: match[1] || mediaType, bytes };
     }
-    if (typeof value.fileUrl === 'string') {
+    if (typeof value.fileUrl === 'string' && !value.fileUrl.startsWith('[REDACTED:')) {
         if (!projectRoot)
             throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'project root is required for file attachments');
         const root = realpathSync(projectRoot);
@@ -157,7 +158,7 @@ export function buildSessionExportPlan(repository, options) {
             sampleRecordIds: index.items.slice(0, sampleSize).map((item) => item.id),
         },
     };
-    return { plan, sessions, eventsBySessionId };
+    return { plan: redactSessionValue(plan).value, sessions, eventsBySessionId };
 }
 /**
  * Re-selects the plan's sessions from the repository and compares digests

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

@@ -0,0 +1,72 @@
+import { homedir } from 'node:os';
+import { basename, dirname, extname, isAbsolute } from 'node:path';
+import { SessionContractError } from './contracts.js';
+import { grokbotConversationIdFromLocator } from './adapters/grokbot-locator.js';
+export function validateImportExclusions(value) {
+    if (!Array.isArray(value) || !value.every(entry => typeof entry === 'string' && entry.trim().length > 0)) {
+        throw new SessionContractError('INVALID_ARGUMENT', 'sessions.import.exclude must be an array of non-empty strings');
+    }
+    for (const entry of value) {
+        if (!isAbsolute(entry) && entry !== '~' && !entry.startsWith('~/') && /[/*?\\~]/.test(entry)) {
+            throw new SessionContractError('INVALID_ARGUMENT', 'sessions.import.exclude path globs must be absolute or ~/ prefixed');
+        }
+    }
+}
+export function resolveImportExclusions(config, flags = [], env = process.env) {
+    const configured = config?.exclude === undefined ? [] : config.exclude;
+    validateImportExclusions(configured);
+    const entries = [...configured, ...(env.AIWG_SESSIONS_IMPORT_EXCLUDE === undefined
+            ? [] : env.AIWG_SESSIONS_IMPORT_EXCLUDE.split(',').map(entry => entry.trim())), ...flags];
+    validateImportExclusions(entries);
+    return [...new Set(entries)];
+}
+/** Use only discovery metadata and locator names; never inspect source content. */
+export function matchImportExclusion(source, entries) {
+    const ids = [source.nativeSessionId, nativeSessionIdFromLocator(source)];
+    for (const entry of entries) {
+        if (isAbsolute(entry) || entry === '~' || entry.startsWith('~/')) {
+            const pattern = entry.startsWith('~') ? homedir() + entry.slice(1) : entry;
+            if (globExpression(pattern).test(source.locator))
+                return { entry, kind: 'path-glob' };
+        }
+        else if (ids.includes(entry))
+            return { entry, kind: 'session-id' };
+    }
+    return undefined;
+}
+export function nativeSessionIdFromLocator(source) {
+    if (source.provider === 'grokbot')
+        return grokbotConversationIdFromLocator(source.locator) ?? undefined;
+    if (source.provider === 'muse')
+        return basename(dirname(source.locator));
+    const name = basename(source.locator, extname(source.locator));
+    if (source.provider === 'codex' || source.provider === 'pi') {
+        return /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i.exec(name)?.[1] ?? name;
+    }
+    return name;
+}
+function globExpression(pattern) {
+    let expression = '^';
+    for (let index = 0; index < pattern.length; index++) {
+        const character = pattern[index];
+        if (character === '*') {
+            if (pattern[index + 1] === '*') {
+                index++;
+                if (pattern[index + 1] === '/') {
+                    expression += '(?:.*/)?';
+                    index++;
+                }
+                else
+                    expression += '.*';
+            }
+            else
+                expression += '[^/]*';
+        }
+        else if (character === '?')
+            expression += '[^/]';
+        else
+            expression += character.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(expression + '$');
+}
+//# sourceMappingURL=import-exclusions.js.map