@aiwg/cli 2026.10.1 → 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,5 +1,6 @@
-export const BATCH_IMPORT_VERSION = '1.0.0';
-export const COVERAGE_VERSION = '1.0.0';
+import { reconcileCoveragePreflight } from './coverage-preflight.js';
+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();
@@ -8,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;
@@ -18,7 +20,13 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
     const notChecked = providerNames(run, 'not-checked');
     const manifestAgeMs = Math.max(0, now.getTime() - Date.parse(run.manifestCreatedAt));
     const isStale = manifestAgeMs > staleAfterMs;
-    const incomplete = rejected > 0 || pending > 0 || skipped > 0
+    const preflight = run.preflight ? reconcileCoveragePreflight(run.preflight, run.sources) : undefined;
+    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) {
@@ -36,6 +44,9 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
         .map((source) => source.updatedAt)
         .sort();
     const remediation = [
+        ...(preflight?.ledger.flatMap((entry) => entry.remediation ? [entry.remediation] : []) ?? ['Legacy receipt lacks provider/runtime preflight; rediscover with --expected-providers.']),
+        ...(preflight && ['mismatch', 'stale', 'unknown'].includes(preflight.runtime.installationState)
+            ? ['Inspect the recorded runtime identity and deliberately select a compatible installation; then rediscover. No automatic switch is performed.'] : []),
         ...(rejected > 0
             ? ['Run `aiwg sessions import-discovered --resume --confirm` after correcting rejected sources.']
             : []),
@@ -47,6 +58,10 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
     return {
         schemaVersion: COVERAGE_VERSION,
         status: isStale ? 'stale' : incomplete ? 'partial' : 'complete',
+        acquisitionStatus: acquisitionIncomplete ? 'partial' : 'complete',
+        unresolvedProviders,
+        preflight,
+        semanticReview: 'not-assessed',
         workspaceId: run.workspaceId,
         manifestId: run.manifestId,
         batchRunId: run.runId,
@@ -57,6 +72,7 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
             discovered: run.sources.length,
             accepted,
             rejected,
+            excluded,
             skipped,
             duplicated,
             previouslyCommitted,
@@ -64,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,
@@ -89,6 +105,9 @@ function unknownCoverage() {
     return {
         schemaVersion: COVERAGE_VERSION,
         status: 'unknown',
+        acquisitionStatus: 'unknown',
+        unresolvedProviders: [],
+        semanticReview: 'not-assessed',
         workspaceId: '',
         manifestId: null,
         batchRunId: null,
@@ -104,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,16 +1,17 @@
-import { OmpSessionAdapter, OMP_ADAPTER_VERSION } from './adapters/omp.js';
-import { DeepSeekHarnessSessionAdapter, DEEPSEEK_HARNESS_ADAPTER_VERSION } from './adapters/deepseek-harness.js';
 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 { MUSE_ADAPTER_VERSION, MuseSessionAdapter, } from './adapters/muse.js';
-import { SESSION_CONTRACT_VERSION, SessionContractError, SessionSourceSchema, sha256, } from './contracts.js';
+import { createSessionAdapterRegistry } from './adapter-registry.js';
+import { coveragePreflight, sessionRuntimeIdentity } from './coverage-preflight.js';
+import { SESSION_CONTRACT_VERSION, SessionContractError, schemaIssueDetail, SessionSourceSchema, sha256, } from './contracts.js';
 import { 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',
@@ -22,6 +23,13 @@ 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',
+        runtime: options.runtime ?? sessionRuntimeIdentity(),
+        reports: options.manifest.providers,
+    });
     run.status = 'running';
     run.updatedAt = now().toISOString();
     run.completedAt = null;
@@ -32,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();
@@ -47,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 {
@@ -61,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,
@@ -73,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);
@@ -88,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();
@@ -100,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 = run.providers.some((provider) => provider.status === 'export-required' || provider.status === 'not-checked');
+    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);
@@ -127,9 +145,26 @@ 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);
-    return receiptFor(run, 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',
+            reports: manifest.providers,
+        }),
+    }, now);
 }
 function newBatchRun(manifest, runId, now) {
     const timestamp = now.toISOString();
@@ -143,11 +178,14 @@ function newBatchRun(manifest, runId, now) {
         startedAt: timestamp,
         updatedAt: timestamp,
         completedAt: null,
+        preflight: manifest.preflight,
+        discoveryRuntime: manifest.preflight?.runtime,
         providers: manifest.providers,
         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,
@@ -163,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,
@@ -176,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);
@@ -186,35 +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) {
-    if (provider === 'deepseek-harness')
-        return new DeepSeekHarnessSessionAdapter();
-    if (provider === 'omp')
-        return new OmpSessionAdapter();
-    if (provider === 'claude')
-        return new ClaudeSessionAdapter();
-    if (provider === 'codex')
-        return new CodexSessionAdapter();
-    if (provider === 'cursor')
-        return new CursorSessionAdapter();
-    if (provider === 'factory')
-        return new FactorySessionAdapter();
-    if (provider === 'muse')
-        return new MuseSessionAdapter();
-    throw new SessionContractError('UNSUPPORTED_OPERATION', `batch discovery import is not implemented for ${provider}`);
+function adapterFor(provider, limits) {
+    return createSessionAdapterRegistry(limits).get(provider);
 }
 async function sessionSource(selected, adapter) {
     const probe = await adapter.inspect(selected);
@@ -225,7 +261,7 @@ async function sessionSource(selected, adapter) {
         providerProfile: providerProfile(selected.provider, selected.locatorClass),
         locatorClass: selected.locatorClass,
         redactedLocator: '<discovered-session-source>',
-        adapterVersion: adapterVersion(selected.provider),
+        adapterVersion: adapter.adapterVersion,
         sourceSchemaVersion: probe.sourceSchemaVersion,
         disposition: 'implemented',
         operationalState: probe.operationalState,
@@ -234,23 +270,6 @@ async function sessionSource(selected, adapter) {
         extensions: { [`native.${selected.provider}`]: {} },
     });
 }
-function adapterVersion(provider) {
-    if (provider === 'deepseek-harness')
-        return DEEPSEEK_HARNESS_ADAPTER_VERSION;
-    if (provider === 'omp')
-        return OMP_ADAPTER_VERSION;
-    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;
-    if (provider === 'muse')
-        return MUSE_ADAPTER_VERSION;
-    return '1.0.0';
-}
 function providerProfile(provider, locatorClass) {
     if (provider === 'deepseek-harness')
         return 'native-session-v2-jsonl';
@@ -269,6 +288,8 @@ function providerProfile(provider, locatorClass) {
         return 'documented-project-jsonl';
     if (provider === 'muse')
         return 'muse-native-session-log-v1';
+    if (provider === 'grokbot')
+        return 'grokbot-native-transcript-replica-v1';
     return 'manual-interchange';
 }
 function importErrorCode(error) {

package/dist/src/sessions/candidates.js

@@ -103,17 +103,21 @@ export class StructuralCandidateExtractor {
         const drafts = [];
         for (const item of evidence) {
             let offset = 0;
-            for (const line of item.text.split(/\n/)) {
-                const match = STRUCTURAL_PATTERN.exec(line);
-                if (match) {
-                    const label = match[1].toLowerCase();
-                    const assertion = match[2].trim();
-                    const start = offset + line.indexOf(assertion);
+            for (const rawLine of item.text.split(/\n/)) {
+                const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+                const separator = line.indexOf(':');
+                const label = line.slice(0, separator).normalize('NFKC').toLowerCase();
+                const remainder = line.slice(separator + 1);
+                const content = remainder.trimStart();
+                if (separator >= 0 && Object.hasOwn(STRUCTURAL_TYPES, label)
+                    && remainder.length > 0 && !/[\r\u2028\u2029]/u.test(content || remainder.slice(-1))) {
+                    const assertion = content.trim();
+                    const start = offset + separator + 1 + remainder.length - content.length;
                     const type = STRUCTURAL_TYPES[label];
                     const relationship = type === 'relationship'
                         ? parseRelationship(assertion)
                         : { subject: null, predicate: null, object: null };
-                    if (type && (type !== 'relationship' || relationship.subject)) {
+                    if (type && assertion && (type !== 'relationship' || relationship.subject)) {
                         drafts.push({
                             type,
                             assertion,
@@ -125,7 +129,7 @@ export class StructuralCandidateExtractor {
                         });
                     }
                 }
-                offset += line.length + 1;
+                offset += rawLine.length + 1;
             }
         }
         return drafts;
@@ -134,7 +138,6 @@ export class StructuralCandidateExtractor {
 const SECURITY_POLICY_VERSION = '1.0.0';
 const INSTRUCTION_PATTERN = /\b(?:ignore|override|disregard)\b.{0,40}\b(?:instruction|prompt|policy|rule)s?\b|\b(?:system|developer)\s+(?:message|instruction|prompt)\b|\b(?:execute|invoke|run)\b.{0,30}\b(?:tool|command|shell|script)\b/i;
 const SECRET_PATTERN = /\b(?:api[_-]?key|access[_-]?token|password|passwd|private[_-]?key|authorization|cookie|secret)\b\s*(?:[:=]|\bis\b)/i;
-const STRUCTURE_PATTERN = /(?:^|\n)\s*(?:---|\.\.\.)\s*(?:\n|$)|```|~~~|<[/!?A-Za-z]|!\[[^\]]*\]\(|\[[^\]]+\]\([^)]*\)|\{\{|\{%/;
 const CONTROL_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/;
 const BIDI_PATTERN = /[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/u;
 const LATIN_PATTERN = /\p{Script=Latin}/u;
@@ -146,7 +149,7 @@ export function classifyCandidateSecurity(input) {
     const warnings = [];
     if (INSTRUCTION_PATTERN.test(text))
         warnings.push('instruction-like');
-    if (STRUCTURE_PATTERN.test(text))
+    if (hasStructureBreakingContent(text))
         warnings.push('structure-breaking');
     if (CONTROL_PATTERN.test(text))
         warnings.push('control-character');
@@ -175,7 +178,40 @@ function evidenceSupportsAssertion(assertion, quote) {
     const quoteTokens = tokens(quote);
     return [...assertionTokens].some((token) => quoteTokens.has(token));
 }
-const STRUCTURAL_PATTERN = /^(Decision|Requirement|Constraint|Preference|Task|Discovery|Fix|Failed approach|Procedure|Risk|Contradiction|Question|Entity|Relationship):\s*(.+)$/i;
+function hasStructureBreakingContent(text) {
+    if (/```|~~~|<[/!?A-Za-z]|\{\{|\{%/.test(text))
+        return true;
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '---' || trimmed === '...')
+            return true;
+    }
+    let bracket = -1;
+    let image = false;
+    let link = false;
+    for (let index = 0; index < text.length; index++) {
+        if (text[index] === '[') {
+            if (bracket < 0)
+                bracket = index;
+            if (index > 0 && text[index - 1] === '!')
+                image = true;
+        }
+        else if (text[index] === ']') {
+            if (text[index + 1] === '(') {
+                if (image)
+                    return true;
+                if (bracket >= 0 && index > bracket + 1)
+                    link = true;
+            }
+            bracket = -1;
+            image = false;
+        }
+        else if (text[index] === ')' && link) {
+            return true;
+        }
+    }
+    return false;
+}
 const STRUCTURAL_TYPES = {
     decision: 'decision',
     requirement: 'requirement',