@aiwg/cli 2026.7.20 → 2026.7.23

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

@@ -0,0 +1,121 @@
+export const BATCH_IMPORT_VERSION = '1.0.0';
+export const COVERAGE_VERSION = '1.0.0';
+export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 * 60 * 60 * 1_000) {
+    if (!run)
+        return unknownCoverage();
+    const coveredStatuses = new Set([
+        'committed', 'duplicate', 'previously-committed',
+    ]);
+    const accepted = run.sources.filter((source) => source.status === 'committed').length;
+    const rejected = run.sources.filter((source) => source.status === 'rejected').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;
+    const pending = run.sources.filter((source) => source.status === 'pending' || source.status === 'running').length;
+    const checked = providerNames(run, 'checked');
+    const unavailable = providerNames(run, 'unavailable');
+    const exportRequired = providerNames(run, 'export-required');
+    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
+        || exportRequired.length > 0 || notChecked.length > 0;
+    const rejectionCounts = {};
+    for (const source of run.sources) {
+        if (source.status !== 'rejected')
+            continue;
+        const code = source.errorCode ?? 'UNKNOWN_REJECTION';
+        rejectionCounts[code] = (rejectionCounts[code] ?? 0) + 1;
+    }
+    const sourceTimestamps = run.providers.flatMap((provider) => [
+        provider.dateRange.earliest,
+        provider.dateRange.latest,
+    ]).filter((value) => value !== null).sort();
+    const importedTimestamps = run.sources
+        .filter((source) => coveredStatuses.has(source.status))
+        .map((source) => source.updatedAt)
+        .sort();
+    const remediation = [
+        ...(rejected > 0
+            ? ['Run `aiwg sessions import-discovered --resume --confirm` after correcting rejected sources.']
+            : []),
+        ...(exportRequired.length > 0
+            ? ['Export and explicitly authorize providers marked export-required, then run discovery again.']
+            : []),
+        ...(isStale ? ['Run `aiwg sessions discover` to refresh the stale manifest.'] : []),
+    ];
+    return {
+        schemaVersion: COVERAGE_VERSION,
+        status: isStale ? 'stale' : incomplete ? 'partial' : 'complete',
+        workspaceId: run.workspaceId,
+        manifestId: run.manifestId,
+        batchRunId: run.runId,
+        manifestCreatedAt: run.manifestCreatedAt,
+        manifestAgeMs,
+        providers: { checked, unavailable, exportRequired, notChecked },
+        sources: {
+            discovered: run.sources.length,
+            accepted,
+            rejected,
+            skipped,
+            duplicated,
+            previouslyCommitted,
+            pending,
+        },
+        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
+            ? null
+            : (accepted + duplicated + previouslyCommitted) / run.sources.length,
+        rejectionCounts,
+        sourceDateRange: {
+            earliest: sourceTimestamps.at(0) ?? null,
+            latest: sourceTimestamps.at(-1) ?? null,
+        },
+        importedDateRange: {
+            earliest: importedTimestamps.at(0) ?? null,
+            latest: importedTimestamps.at(-1) ?? null,
+        },
+        remediation,
+    };
+}
+function providerNames(run, status) {
+    return run.providers
+        .filter((provider) => provider.status === status)
+        .map((provider) => provider.provider)
+        .sort();
+}
+function unknownCoverage() {
+    return {
+        schemaVersion: COVERAGE_VERSION,
+        status: 'unknown',
+        workspaceId: '',
+        manifestId: null,
+        batchRunId: null,
+        manifestCreatedAt: null,
+        manifestAgeMs: null,
+        providers: {
+            checked: [],
+            unavailable: [],
+            exportRequired: [],
+            notChecked: [],
+        },
+        sources: {
+            discovered: 0,
+            accepted: 0,
+            rejected: 0,
+            skipped: 0,
+            duplicated: 0,
+            previouslyCommitted: 0,
+            pending: 0,
+        },
+        sessionsAccepted: 0,
+        eventsAccepted: 0,
+        coverageRatio: null,
+        rejectionCounts: {},
+        sourceDateRange: { earliest: null, latest: null },
+        importedDateRange: { earliest: null, latest: null },
+        remediation: ['Run `aiwg sessions discover --workspace <path>` to establish coverage.'],
+    };
+}
+//# sourceMappingURL=batch-contracts.js.map

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/candidates.js

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+import { IntelligenceCandidateSchema, IntelligenceCandidateTypeSchema, SESSION_CONTRACT_VERSION, SessionContractError, sha256, } from './contracts.js';
+export const ExtractedCandidateDraftSchema = z.object({
+    type: IntelligenceCandidateTypeSchema,
+    assertion: z.string().min(1),
+    subject: z.string().min(1).nullable(),
+    predicate: z.string().min(1).nullable(),
+    object: z.string().min(1).nullable(),
+    evidence: z.array(z.object({
+        eventId: z.string().min(1),
+        start: z.number().int().nonnegative(),
+        end: z.number().int().positive(),
+    }).strict()).min(1),
+    confidence: z.number().min(0).max(1),
+    conflictsWith: z.array(z.string().min(1)).default([]),
+    supersedes: z.array(z.string().min(1)).default([]),
+}).strict().superRefine((candidate, context) => {
+    if (candidate.type === 'relationship'
+        && (!candidate.subject || !candidate.predicate || !candidate.object)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'relationship candidates require subject, predicate, and object',
+        });
+    }
+});
+export class CandidateExtractionService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async extract(input) {
+        const evidenceById = new Map(input.documents.map((document) => [document.eventId, document]));
+        const raw = await input.extractor.extract(input.documents.map((document) => Object.freeze({
+            eventId: document.eventId,
+            text: document.searchableText,
+            role: document.role,
+        })));
+        const drafts = z.array(ExtractedCandidateDraftSchema).parse(raw);
+        const candidates = drafts
+            .filter((draft) => draft.confidence >= input.policy.minimumConfidence)
+            .map((draft) => {
+            const evidence = draft.evidence.map((span) => {
+                const document = evidenceById.get(span.eventId);
+                if (!document) {
+                    throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'candidate cites evidence outside the authorized extraction scope');
+                }
+                if (span.start >= span.end || span.end > document.searchableText.length) {
+                    throw new SessionContractError('MALFORMED_SOURCE', 'candidate evidence span is invalid');
+                }
+                const quote = document.searchableText.slice(span.start, span.end);
+                if (!quote.trim()) {
+                    throw new SessionContractError('MALFORMED_SOURCE', 'candidate evidence span must contain redacted source text');
+                }
+                return {
+                    ...span,
+                    quoteDigest: sha256(quote),
+                    quote,
+                };
+            });
+            const sensitivity = evidence.some((span) => evidenceById.get(span.eventId)?.sensitivity === 'sensitive') ? 'sensitive' : 'none';
+            if (!evidence.some((span) => evidenceSupportsAssertion(draft.assertion, span.quote))) {
+                throw new SessionContractError('MALFORMED_SOURCE', 'candidate assertion is not supported by its cited redacted evidence span');
+            }
+            const security = classifyCandidateSecurity({
+                assertion: draft.assertion,
+                subject: draft.subject,
+                predicate: draft.predicate,
+                object: draft.object,
+            });
+            return IntelligenceCandidateSchema.parse({
+                contractVersion: SESSION_CONTRACT_VERSION,
+                candidateId: stableCandidateId(draft),
+                version: 1,
+                type: draft.type,
+                assertion: draft.assertion,
+                subject: draft.subject,
+                predicate: draft.predicate,
+                object: draft.object,
+                evidence,
+                confidence: draft.confidence,
+                temporalScope: input.policy.temporalScope,
+                projectScope: input.policy.projectScope,
+                extractionMethod: input.extractor.method,
+                extractionVersion: input.extractor.version,
+                extractionPolicyVersion: input.policy.version,
+                model: input.extractor.model,
+                sensitivity,
+                security,
+                reviewState: 'pending',
+                conflictsWith: draft.conflictsWith,
+                supersedes: draft.supersedes,
+                createdAt: new Date().toISOString(),
+            });
+        });
+        return this.store.saveCandidates(candidates);
+    }
+}
+export class StructuralCandidateExtractor {
+    method = 'structural-labels';
+    version = '1.0.0';
+    model = null;
+    extract(evidence) {
+        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);
+                    const type = STRUCTURAL_TYPES[label];
+                    const relationship = type === 'relationship'
+                        ? parseRelationship(assertion)
+                        : { subject: null, predicate: null, object: null };
+                    if (type && (type !== 'relationship' || relationship.subject)) {
+                        drafts.push({
+                            type,
+                            assertion,
+                            ...relationship,
+                            evidence: [{ eventId: item.eventId, start, end: start + assertion.length }],
+                            confidence: 0.8,
+                            conflictsWith: [],
+                            supersedes: [],
+                        });
+                    }
+                }
+                offset += line.length + 1;
+            }
+        }
+        return drafts;
+    }
+}
+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;
+const CONFUSABLE_SCRIPT_PATTERN = /[\p{Script=Cyrillic}\p{Script=Greek}]/u;
+export function classifyCandidateSecurity(input) {
+    const text = [input.assertion, input.subject, input.predicate, input.object]
+        .filter((value) => Boolean(value))
+        .join('\n');
+    const warnings = [];
+    if (INSTRUCTION_PATTERN.test(text))
+        warnings.push('instruction-like');
+    if (STRUCTURE_PATTERN.test(text))
+        warnings.push('structure-breaking');
+    if (CONTROL_PATTERN.test(text))
+        warnings.push('control-character');
+    if (BIDI_PATTERN.test(text))
+        warnings.push('bidi-control');
+    if (LATIN_PATTERN.test(text) && CONFUSABLE_SCRIPT_PATTERN.test(text)) {
+        warnings.push('unicode-confusable');
+    }
+    if (/(?:javascript|data|vbscript):|<\s*(?:script|iframe|object|embed)\b/i.test(text)) {
+        warnings.push('active-content');
+    }
+    if (SECRET_PATTERN.test(text))
+        warnings.push('secret-bearing');
+    return {
+        disposition: warnings.length === 0 ? 'clear' : 'suspicious',
+        warnings: [...new Set(warnings)],
+        requiresAcknowledgement: warnings.length > 0,
+        acknowledged: false,
+        policyVersion: SECURITY_POLICY_VERSION,
+    };
+}
+function evidenceSupportsAssertion(assertion, quote) {
+    const tokens = (value) => new Set(value.normalize('NFKC').toLocaleLowerCase('en-US')
+        .match(/[\p{L}\p{N}]{3,}/gu) ?? []);
+    const assertionTokens = tokens(assertion);
+    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;
+const STRUCTURAL_TYPES = {
+    decision: 'decision',
+    requirement: 'requirement',
+    constraint: 'constraint',
+    preference: 'preference',
+    task: 'task',
+    discovery: 'discovery',
+    fix: 'fix',
+    'failed approach': 'failed-approach',
+    procedure: 'procedure',
+    risk: 'risk',
+    contradiction: 'contradiction',
+    question: 'question',
+    entity: 'entity',
+    relationship: 'relationship',
+};
+function parseRelationship(assertion) {
+    const parts = assertion.split('|').map((part) => part.trim());
+    return parts.length === 3 && parts.every(Boolean)
+        ? { subject: parts[0], predicate: parts[1], object: parts[2] }
+        : { subject: null, predicate: null, object: null };
+}
+function stableCandidateId(draft) {
+    return sha256(JSON.stringify({
+        type: draft.type,
+        evidenceEventIds: [...new Set(draft.evidence.map((span) => span.eventId))].sort(),
+        subject: draft.subject,
+        predicate: draft.predicate,
+        object: draft.object,
+    }));
+}
+//# sourceMappingURL=candidates.js.map