@aiwg/cli 2026.10.1 → 2026.10.3

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

@@ -42,8 +42,9 @@
 import { opendir } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { z } from 'zod';
-import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
+import { SessionContractError, SessionErrorCodeSchema, assertSupportedSchemaMajor, } from '../contracts.js';
 import { readBoundedJson, readBoundedJsonLines, } from '../readers.js';
+import { MUSE_WORKSPACE_SCAN_LIMITS, museWorkspaceScanLines, parseMuseScanJson, } from './muse-workspace-scan.js';
 export const MUSE_ADAPTER_VERSION = '1.0.0';
 export const MUSE_EXPORT_SCHEMA_VERSION = '1.0.0';
 export const MUSE_EXPORT_SCHEMA_MAJOR = 1;
@@ -79,7 +80,9 @@ const MuseEnvelopeSchema = z.object({
     durability: z.string().optional(),
     payload_type: z.string().optional(),
     payload: z.object({
-        event: z.object({ kind: z.string().min(1) }).passthrough().optional(),
+        // Muse Code 1.4.3 runtime.session mode records carry an event without a
+        // kind; eventKindOf() falls back to payload_type for those.
+        event: z.object({ kind: z.string().min(1).optional() }).passthrough().optional(),
     }).passthrough().optional(),
 }).passthrough();
 /**
@@ -495,44 +498,80 @@ async function* museNativeSessionLogs(root) {
         }
     }
 }
-export async function museNativeSourceMatchesWorkspace(source, workspacePath) {
-    let input;
+export const MuseWorkspaceInspectionSchema = z.object({
+    outcome: z.enum(['matched', 'mismatch', 'inconclusive']),
+    reasonCode: z.string().nullable(),
+    recordsInspected: z.number().int().nonnegative(),
+    bytesInspected: z.number().int().nonnegative(),
+    completeInspection: z.boolean(),
+});
+/** Positive metadata evidence selects a source; import validates its full history. */
+export async function inspectMuseNativeWorkspace(source, workspacePath, limitsInput) {
+    const limits = { ...MUSE_WORKSPACE_SCAN_LIMITS, ...limitsInput };
+    const progress = { recordsInspected: 0, bytesInspected: 0 };
+    let sawWorkspaceEvidence = false;
+    let retainedChildren = 0;
+    const receipt = (outcome, reasonCode, completeInspection = false) => ({ outcome, reasonCode, ...progress, completeInspection });
     try {
-        input = await readBoundedJsonLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'complete', limits: { maxRecords: 100, maxRecordBytes: 8 * 1024 * 1024 } });
+        if (Object.values(limits).some((limit) => !Number.isSafeInteger(limit) || limit <= 0)) {
+            throw new SessionContractError('INVALID_ARGUMENT', 'Muse inspection limits must be positive safe integers');
+        }
+        for await (const value of museWorkspaceScanLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, limits, progress)) {
+            const envelopes = nativeEnvelopesFromLine(value, limits, (count) => {
+                retainedChildren += count;
+                if (retainedChildren > limits.maxRecords) {
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'Muse retained child inspection limit exceeded');
+                }
+            });
+            for (const envelope of envelopes) {
+                const candidate = workspaceEvidenceOf(envelope);
+                if (!candidate)
+                    continue;
+                sawWorkspaceEvidence = true;
+                if (workspacePathEquals(candidate, workspacePath))
+                    return receipt('matched', null);
+            }
+        }
+        return sawWorkspaceEvidence
+            ? receipt('mismatch', 'MUSE_WORKSPACE_MISMATCH', true)
+            : receipt('inconclusive', 'MUSE_WORKSPACE_EVIDENCE_ABSENT', true);
     }
-    catch {
-        return false;
+    catch (error) {
+        return receipt('inconclusive', error instanceof SessionContractError
+            ? error.code : 'MUSE_SOURCE_UNREADABLE');
     }
-    for (const line of input.records) {
-        for (const envelope of nativeEnvelopesFromLine(line.value)) {
-            const candidate = workspaceEvidenceOf(envelope);
-            if (!candidate)
-                continue;
-            if (workspacePathEquals(candidate, workspacePath))
-                return true;
-        }
+}
+export async function museNativeSourceMatchesWorkspace(source, workspacePath) {
+    const result = await inspectMuseNativeWorkspace(source, workspacePath);
+    if (result.outcome === 'inconclusive') {
+        const code = SessionErrorCodeSchema.safeParse(result.reasonCode);
+        throw new SessionContractError(code.success ? code.data : 'SCHEMA_DRIFT', `Muse workspace inspection inconclusive: ${result.reasonCode}`);
     }
-    return false;
+    return result.outcome === 'matched';
 }
-function nativeEnvelopesFromLine(value) {
+function nativeEnvelopesFromLine(value, limits, countChildren) {
     if (isOmissionMarker(value))
         return [];
-    const event = recordEventFromEnvelope(value);
-    if (event)
-        return [event.envelope];
     const retained = MuseRetainedFrameSchema.safeParse(value);
-    if (!retained.success)
-        return [];
+    if (!retained.success) {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Muse inspection encountered a non-object native record');
+        }
+        // Native logs carry record kinds the envelope schema does not model (for
+        // example runtime.session mode changes without payload.event.kind). They
+        // hold no workspace evidence, so skip them rather than fail the source.
+        const event = recordEventFromEnvelope(value);
+        return event ? [event.envelope] : [];
+    }
+    countChildren(retained.data.children.length);
     const envelopes = [];
     for (const child of retained.data.children) {
-        try {
-            const childEvent = recordEventFromEnvelope(JSON.parse(child.record_json));
-            if (childEvent)
-                envelopes.push(childEvent.envelope);
-        }
-        catch {
-            return [];
+        if (Buffer.byteLength(child.record_json) > limits.maxRecordBytes) {
+            throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'Muse retained child inspection byte limit exceeded');
         }
+        const childEvent = recordEventFromEnvelope(parseMuseScanJson(child.record_json, limits.maxNestingDepth));
+        if (childEvent)
+            envelopes.push(childEvent.envelope);
     }
     return envelopes;
 }

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

@@ -13,6 +13,7 @@ export class PiSessionAdapter {
     limits;
     maxFiles;
     provider = 'pi';
+    sourceSchemaMajor = 3;
     adapterVersion = PI_ADAPTER_VERSION;
     disposition = 'implemented';
     supportedOperations = ['discover', 'inspect', 'stream'];

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

@@ -1,3 +1,4 @@
+import { reconcileCoveragePreflight } from './coverage-preflight.js';
 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) {
@@ -18,7 +19,10 @@ 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 incomplete = !preflight || preflight.status !== 'complete'
+        || unavailable.length > 0 || accepted + duplicated + previouslyCommitted === 0
+        || rejected > 0 || pending > 0 || skipped > 0
         || exportRequired.length > 0 || notChecked.length > 0;
     const rejectionCounts = {};
     for (const source of run.sources) {
@@ -36,6 +40,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 +54,9 @@ export function coverageFromBatchRun(run, now = new Date(), staleAfterMs = 24 *
     return {
         schemaVersion: COVERAGE_VERSION,
         status: isStale ? 'stale' : incomplete ? 'partial' : 'complete',
+        acquisitionStatus: incomplete ? 'partial' : 'complete',
+        preflight,
+        semanticReview: 'not-assessed',
         workspaceId: run.workspaceId,
         manifestId: run.manifestId,
         batchRunId: run.runId,
@@ -89,6 +99,8 @@ function unknownCoverage() {
     return {
         schemaVersion: COVERAGE_VERSION,
         status: 'unknown',
+        acquisitionStatus: 'unknown',
+        semanticReview: 'not-assessed',
         workspaceId: '',
         manifestId: null,
         batchRunId: null,

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

@@ -1,11 +1,6 @@
-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 { createSessionAdapterRegistry } from './adapter-registry.js';
+import { coveragePreflight, sessionRuntimeIdentity } from './coverage-preflight.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';
@@ -22,6 +17,12 @@ 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.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;
@@ -100,7 +101,7 @@ 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 providerGap = coverageFromBatchRun(run, now()).acquisitionStatus !== 'complete';
     const publishable = run.sources
         .filter((source) => isAccepted(source.status))
         .map((source) => source.sourceId);
@@ -129,7 +130,14 @@ function injectFault(options, run, boundary, sourceId) {
 }
 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);
+    return receiptFor({
+        ...run,
+        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,6 +151,8 @@ 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,
@@ -200,21 +210,7 @@ async function assertManifestSourceUnchanged(source) {
     }
 }
 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}`);
+    return createSessionAdapterRegistry().get(provider);
 }
 async function sessionSource(selected, adapter) {
     const probe = await adapter.inspect(selected);
@@ -225,7 +221,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 +230,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 +248,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',

package/dist/src/sessions/contracts.js

@@ -6,6 +6,41 @@ export const SESSION_PROVIDER_IDS = [
     'opencode', 'openclaw', 'openhuman', 'grokbot', 'grok-build', 'pi', 'omp', 'deepseek-harness', 'warp', 'devin-desktop', 'muse', 'generic',
 ];
 export const SessionProviderIdSchema = z.enum(SESSION_PROVIDER_IDS);
+// Expected scope must also represent providers unknown to this runtime.
+export const ExpectedSessionProviderSchema = z.string().regex(/^[a-z][a-z0-9-]*$/);
+export const SessionRuntimeIdentitySchema = z.object({
+    packageName: z.string(),
+    version: z.string(),
+    packageRoot: z.string(),
+    executable: z.string(),
+    nodeVersion: z.string(),
+    installationMethod: z.string(),
+    installationState: z.enum(['aligned', 'mismatch', 'stale', 'unrecorded', 'unknown']),
+    canonicalRoot: z.string().nullable(),
+    diagnostics: z.array(z.string()),
+});
+export const SessionCoveragePreflightSchema = z.object({
+    expectedProviders: z.array(ExpectedSessionProviderSchema).min(1),
+    expectedProviderBasis: z.enum(['explicit', 'declared-default', 'legacy']),
+    supportedProviders: z.array(ExpectedSessionProviderSchema),
+    runtime: SessionRuntimeIdentitySchema,
+    status: z.enum(['partial', 'complete']),
+    unresolvedProviders: z.array(ExpectedSessionProviderSchema),
+    ledger: z.array(z.object({
+        provider: ExpectedSessionProviderSchema,
+        disposition: z.enum([
+            'missing-adapter', 'unsupported', 'authorization-required', 'export-required',
+            'unavailable', 'no-sources', 'not-checked', 'pending-import', 'import-incomplete',
+            'scope-incomplete', 'acquired',
+        ]),
+        adapterVersion: z.string().nullable(),
+        supportedOperations: z.array(z.string()),
+        acquisitionModes: z.array(z.string()),
+        sourceCount: z.number().int().nonnegative(),
+        boundaries: z.array(z.string()),
+        remediation: z.string().nullable(),
+    })),
+});
 export const SESSION_PROVIDER_ALIASES = Object.freeze({
     windsurf: 'devin-desktop',
     dsh: 'deepseek-harness',

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

@@ -0,0 +1,134 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findPackageRoot } from '../cli/find-package-root.js';
+import { inspectInstallation } from '../installation/manager.mjs';
+import { ExpectedSessionProviderSchema, SESSION_PROVIDER_ALIASES, SESSION_PROVIDER_IDS, SessionContractError, SessionCoveragePreflightSchema, SessionRuntimeIdentitySchema, } from './contracts.js';
+import { createSessionAdapterRegistry } from './adapter-registry.js';
+export function expectedSessionProviders(values) {
+    const providers = values.map((value) => {
+        const canonical = SESSION_PROVIDER_ALIASES[value.trim()]
+            ?? value.trim();
+        if (!ExpectedSessionProviderSchema.safeParse(canonical).success) {
+            throw new SessionContractError('INVALID_ARGUMENT', `invalid expected provider: ${value}`);
+        }
+        return canonical;
+    });
+    if (providers.length === 0) {
+        throw new SessionContractError('INVALID_ARGUMENT', 'expected providers must not be empty');
+    }
+    return [...new Set(providers)].sort();
+}
+/** Resolve the code actually loaded, independently of cwd, AIWG_ROOT and corpus redirects. */
+export function sessionRuntimeIdentity() {
+    const packageRoot = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+    if (!packageRoot)
+        throw new SessionContractError('INVALID_ARGUMENT', 'cannot locate the running AIWG package');
+    const pkg = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+    const executable = process.argv[1] ?? process.execPath;
+    const base = {
+        packageName: pkg.name, version: pkg.version, packageRoot: realpathSync(packageRoot),
+        executable, nodeVersion: process.version,
+    };
+    try {
+        const installation = inspectInstallation({ actualRoot: packageRoot, createIfMissing: false });
+        return SessionRuntimeIdentitySchema.parse({
+            ...base,
+            installationMethod: installation.actualMethod,
+            installationState: installation.state,
+            canonicalRoot: installation.identity?.root ?? null,
+            diagnostics: [
+                ...installation.drift,
+                ...(['mismatch', 'stale'].includes(installation.state)
+                    ? ['Deliberately select a compatible runtime, inspect `aiwg installation show`, and rediscover. No automatic upgrade or installation switch is performed.'] : []),
+            ],
+        });
+    }
+    catch (error) {
+        return SessionRuntimeIdentitySchema.parse({
+            ...base, installationMethod: 'unknown', installationState: 'unknown', canonicalRoot: null,
+            diagnostics: [
+                error instanceof Error ? error.message : String(error),
+                'Inspect `aiwg installation show` and deliberately select a compatible runtime before claiming complete coverage.',
+            ],
+        });
+    }
+}
+export function coveragePreflight(options = {}) {
+    const expectedProviders = expectedSessionProviders(options.expectedProviders ?? SESSION_PROVIDER_IDS);
+    const adapters = (options.registry ?? createSessionAdapterRegistry()).list();
+    const runtime = options.runtime ?? sessionRuntimeIdentity();
+    const ledger = expectedProviders.map((provider) => {
+        const adapter = adapters.find((item) => item.provider === provider);
+        const report = options.reports?.find((item) => item.provider === provider);
+        const entry = {
+            provider, disposition: 'not-checked', adapterVersion: adapter?.adapterVersion ?? null,
+            supportedOperations: [...(adapter?.supportedOperations ?? [])],
+            acquisitionModes: [...(adapter?.acquisitionModes ?? [])],
+            sourceCount: report?.sourceCount ?? 0, boundaries: [],
+            remediation: report?.remediation ?? 'Run authorized workspace discovery or select a supported export.',
+        };
+        if (!adapter) {
+            entry.disposition = 'missing-adapter';
+            entry.remediation = `Running ${runtime.packageName} ${runtime.version} at ${runtime.packageRoot} has no ${provider} adapter. Deliberately select a compatible runtime or use an explicitly authorized supported export; no installation is switched automatically.`;
+        }
+        else if (adapter.disposition === 'unsupported' || !adapter.supportedOperations.includes('stream')) {
+            entry.disposition = 'unsupported';
+        }
+        else if (report?.reasonCode === 'SHARED_ROOT_AUTHORIZATION_REQUIRED') {
+            entry.disposition = 'authorization-required';
+        }
+        else if (report?.status === 'export-required' || !adapter.supportedOperations.includes('discover')) {
+            entry.disposition = 'export-required';
+        }
+        else if (report?.status === 'unavailable') {
+            entry.disposition = 'unavailable';
+        }
+        else if (report?.reasonCode === 'MUSE_SOURCE_INSPECTION_INCOMPLETE') {
+            entry.disposition = report.sourceCount > 0 ? 'pending-import' : 'not-checked';
+            entry.boundaries.push('Some Muse sources could not be fully inspected; see museSourceInspections in the discovery manifest.');
+            entry.remediation = report.remediation;
+        }
+        else if (report?.status === 'checked') {
+            entry.disposition = report.sourceCount > 0 ? 'pending-import' : 'no-sources';
+            entry.remediation = report.sourceCount > 0
+                ? 'Import the exact authorized manifest and inspect source dispositions.'
+                : 'Zero matching sources does not establish no activity; verify scope, authorization and export availability.';
+        }
+        if (provider === 'muse') {
+            entry.boundaries.push('Native discovery includes parent session.jsonl logs only; nested subagent logs and approval-review scope are not established.');
+        }
+        return entry;
+    });
+    return SessionCoveragePreflightSchema.parse({
+        expectedProviders,
+        expectedProviderBasis: options.expectedProviderBasis ?? (options.expectedProviders ? 'explicit' : 'declared-default'),
+        supportedProviders: adapters.map((adapter) => adapter.provider), runtime,
+        status: 'partial', unresolvedProviders: expectedProviders, ledger,
+    });
+}
+export function reconcileCoveragePreflight(preflight, sources) {
+    const accepted = new Set(['committed', 'duplicate', 'previously-committed']);
+    const ledger = preflight.ledger.map((entry) => {
+        if (!['pending-import', 'import-incomplete', 'scope-incomplete', 'acquired'].includes(entry.disposition))
+            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);
+        return {
+            ...entry,
+            disposition: !imported ? 'import-incomplete'
+                : entry.boundaries.length > 0 ? 'scope-incomplete' : 'acquired',
+            remediation: !imported ? 'Resolve pending, rejected, skipped or empty imports before claiming acquisition coverage.'
+                : entry.boundaries.length > 0 ? 'Declare the parent-only boundary and separately authorize supported exports for omitted scope.' : null,
+        };
+    });
+    const unresolvedProviders = ledger.filter((entry) => entry.disposition !== 'acquired').map((entry) => entry.provider);
+    const runtimeGap = ['mismatch', 'stale', 'unknown'].includes(preflight.runtime.installationState);
+    return {
+        ...preflight, ledger, unresolvedProviders,
+        status: unresolvedProviders.length > 0 || runtimeGap || preflight.expectedProviderBasis !== 'explicit'
+            ? 'partial' : 'complete',
+    };
+}
+//# sourceMappingURL=coverage-preflight.js.map

package/dist/src/sessions/discovery.js

@@ -1,6 +1,9 @@
 import { SessionContractError, assertSessionProviderId, } from './contracts.js';
 export class SessionSourceAdapterRegistry {
     adapters = new Map();
+    list() {
+        return [...this.adapters.values()].sort((a, b) => a.provider.localeCompare(b.provider));
+    }
     register(adapter) {
         const provider = assertSessionProviderId(adapter.provider);
         if (this.adapters.has(provider))