@aiwg/cli 2026.9.21 → 2026.10.0

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

@@ -1,5 +1,5 @@
 /**
- * Muse Code session adapter — manual export only, trajectory-first.
+ * Muse Code session adapter — explicit export plus evidence-gated native logs.
  *
  * Muse Code journals model calls, tool runs, and approvals to an append-only
  * session log and projects it into a self-contained JSON document via
@@ -9,12 +9,10 @@
  * fail closed with `UNKNOWN_SCHEMA_MAJOR`, as with peer native-export
  * adapters.
  *
- * Auto-discovery is unsupported and must never scrape home directories or
- * invent session roots. The documented candidate native root
- * (`$XDG_DATA_HOME/muse/sessions/YYYY/MM/DD/<session-id>/session.jsonl`,
- * default `~/.local/share/muse/sessions`) is NOT authorized or implemented
- * here; a future evidence-gated `--muse-root` discover path remains the
- * route to native discovery (#222 PR B).
+ * Auto-discovery must never scrape home directories or invent session roots.
+ * Native discovery is available only when the operator explicitly authorizes
+ * a Muse sessions root with `--muse-root`; the adapter then enumerates only
+ * `$root/YYYY/MM/DD/<session-id>/session.jsonl`.
  *
  * Trajectory shape follows the documented export format at
  * https://dev.meta.ai/docs/cookbook/audit-agent-sessions: top-level
@@ -41,13 +39,17 @@
  * @see docs/providers/muse-sessions.md
  * @issue #232
  */
+import { opendir } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { z } from 'zod';
 import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
-import { readBoundedJson } from '../readers.js';
+import { readBoundedJson, readBoundedJsonLines, } from '../readers.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;
 export const MUSE_LOCATOR_CLASS = 'manual-export';
+export const MUSE_NATIVE_LOCATOR_CLASS = 'muse-native-session-log';
+export const MUSE_NATIVE_SCHEMA_VERSION = '1.0.0';
 const Rfc3339Schema = z.string().refine((value) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value)
     && !Number.isNaN(Date.parse(value)), 'timestamp must be RFC 3339 with an explicit UTC offset');
 /**
@@ -119,7 +121,10 @@ const MuseDiagnosticsSchema = z.object({
     unknown_payload_kinds: z.number().int().nonnegative().optional(),
     gaps: z.number().int().nonnegative().optional(),
     omitted_live_only: z.number().int().nonnegative().optional(),
+    omitted_records: z.number().int().nonnegative().optional(),
     duplicate_records: z.number().int().nonnegative().optional(),
+    retained_frames: z.number().int().nonnegative().optional(),
+    retained_frame_children: z.number().int().nonnegative().optional(),
 }).passthrough();
 const MuseTrajectorySchema = z.object({
     export_schema_version: z.number().int().nonnegative(),
@@ -134,24 +139,53 @@ const MuseTrajectorySchema = z.object({
 function isRecordEvent(event) {
     return event.kind === 'record';
 }
+const MuseRetainedFrameSchema = z.object({
+    retained_frame: z.string().min(1),
+    frame_schema_version: z.number().int().nonnegative().optional(),
+    outer_log_ordinal: z.number().int().nonnegative().optional(),
+    transaction_id: z.string().optional(),
+    content_sha256: z.string().optional(),
+    children: z.array(z.object({
+        child_index: z.number().int().nonnegative().optional(),
+        record_json: z.string().min(1),
+    }).passthrough()),
+}).passthrough();
 export class MuseSessionAdapter {
     limits;
+    maxFiles;
     provider = 'muse';
     adapterVersion = MUSE_ADAPTER_VERSION;
-    disposition = 'manual-only';
-    supportedOperations = ['inspect', 'stream'];
-    acquisitionModes = ['manual-export'];
-    constructor(limits) {
+    disposition = 'implemented';
+    supportedOperations = ['discover', 'inspect', 'stream'];
+    acquisitionModes = ['manual-export', 'jsonl'];
+    constructor(limits, maxFiles = 10_000) {
         this.limits = limits;
+        this.maxFiles = maxFiles;
     }
-    async *discover(_scope) {
-        throw new SessionContractError('UNSUPPORTED_OPERATION', 'Muse Code session auto-discover is unsupported: the native log under '
-            + '$XDG_DATA_HOME/muse/sessions uses an internal format. Run `muse export --session '
-            + '<id-or-session.jsonl>` and select that trajectory file. AIWG does not scrape home '
-            + 'directories for this provider.');
+    async *discover(scope) {
+        if (scope.allowedRoots.length === 0) {
+            throw unsupportedNativeDiscovery();
+        }
+        let count = 0;
+        for (const root of [...scope.allowedRoots].sort()) {
+            for await (const locator of museNativeSessionLogs(resolve(root))) {
+                if (++count > this.maxFiles) {
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'Muse native session discovery exceeded the authorized file limit');
+                }
+                yield { provider: 'muse', locator, locatorClass: MUSE_NATIVE_LOCATOR_CLASS };
+            }
+        }
     }
     async inspect(source) {
-        this.assertManualExport(source);
+        if (source.locatorClass === MUSE_NATIVE_LOCATOR_CLASS) {
+            const native = await this.readNative(source);
+            return {
+                sourceSchemaVersion: MUSE_NATIVE_SCHEMA_VERSION,
+                consistency: native.complete ? 'complete' : 'provisional',
+                operationalState: 'available',
+            };
+        }
+        this.assertSupportedLocator(source);
         const { trajectory } = await this.readTrajectory(source);
         for (const event of trajectory.events)
             this.parseEvent(event);
@@ -162,10 +196,38 @@ export class MuseSessionAdapter {
         };
     }
     async *stream(source, cursor) {
-        this.assertManualExport(source);
+        if (source.locatorClass === MUSE_NATIVE_LOCATOR_CLASS) {
+            const native = await this.readNative(source);
+            const start = parseEventCursor(cursor?.value);
+            let outputIndex = 0;
+            for (const record of native.records) {
+                const position = outputIndex;
+                outputIndex += 1;
+                if (position < start)
+                    continue;
+                const mapped = this.toProviderRecord(native.context, record.event.envelope, record.event, position);
+                mapped.rawReference = {
+                    locatorClass: MUSE_NATIVE_LOCATOR_CLASS,
+                    offset: record.line.byteOffset,
+                    sequence: record.line.sequence,
+                };
+                mapped.sourceCursor = String(outputIndex);
+                mapped.extensions = {
+                    ...mapped.extensions,
+                    'native.muse': compactObject({
+                        ...(mapped.extensions?.['native.muse'] ?? {}),
+                        retainedFrame: record.retainedFrame,
+                        retainedChildIndex: record.retainedChildIndex,
+                    }),
+                };
+                yield mapped;
+            }
+            return;
+        }
+        this.assertSupportedLocator(source);
         const { trajectory, bytesRead } = await this.readTrajectory(source);
         const start = parseEventCursor(cursor?.value);
-        const spawns = acceptedSpawnsById(trajectory);
+        const context = contextFromTrajectory(trajectory, bytesRead);
         let index = 0;
         for (const event of trajectory.events) {
             // Cursor positions are raw event positions so resume stays aligned
@@ -178,7 +240,7 @@ export class MuseSessionAdapter {
             // fabricate a ProviderRecord for one.
             if (!isRecordEvent(event))
                 continue;
-            yield this.toProviderRecord(trajectory, bytesRead, event.envelope, spawns, event, position);
+            yield this.toProviderRecord(context, event.envelope, event, position);
         }
     }
     async readTrajectory(source) {
@@ -203,12 +265,12 @@ export class MuseSessionAdapter {
     parseEvent(event) {
         eventKindOf(event);
     }
-    toProviderRecord(trajectory, bytesRead, envelope, spawns, event, index) {
+    toProviderRecord(context, envelope, event, index) {
         // Attribute by the event's own stream id; fall back to the document's
         // first session summary only when the stream block is absent. Live
         // evidence (Muse Code 1.3.0) shows merged events always carry the parent
         // id here, so never assume sessions[0] without reading the envelope.
-        const nativeSessionId = streamSessionIdOf(envelope) ?? trajectory.sessions[0].session_id;
+        const nativeSessionId = streamSessionIdOf(envelope) ?? context.fallbackSessionId;
         const payload = envelope.payload ?? {};
         const payloadRecord = payload;
         const eventKind = eventKindOf(event);
@@ -219,7 +281,7 @@ export class MuseSessionAdapter {
         const approvalOutcome = stringField(payloadRecord, 'outcome');
         const decisionSource = objectField(payloadRecord, 'decision_source');
         const linkage = subagentLinkageOf(payloadRecord);
-        const spawnContext = spawnContextOf(spawns, envelope.payload_type, linkage.subagentId);
+        const spawnContext = spawnContextOf(context.spawns, envelope.payload_type, linkage.subagentId);
         return {
             nativeSessionId,
             nativeEventId: `muse-seq-${envelope.sequence}`,
@@ -232,14 +294,15 @@ export class MuseSessionAdapter {
             model: undefined,
             entities: [],
             occurredAt: occurredAtOf(envelope.recorded_at) ?? undefined,
-            text: describeEvent(eventKind, envelope.sequence, {
+            text: describeEvent(context.sourceLabel, eventKind, envelope.sequence, {
                 operation, policyDecision, decision, approvalOutcome, decisionSource,
             }),
-            rawReference: { locatorClass: MUSE_LOCATOR_CLASS, sequence: index },
+            rawReference: { locatorClass: context.locatorClass, sequence: index },
             sourceCursor: String(index + 1),
-            sourceBytes: bytesRead,
+            sourceBytes: context.bytesRead,
             extensions: {
                 'native.muse': compactObject({
+                    acquisition: context.locatorClass,
                     eventKind,
                     recordType: event.kind,
                     payloadType: envelope.payload_type,
@@ -249,11 +312,11 @@ export class MuseSessionAdapter {
                     envelopeSequence: envelope.sequence,
                     envelopeId: envelope.id,
                     causationId: envelope.causation_id,
-                    exportSchemaVersion: trajectory.export_schema_version,
-                    redaction: trajectory.redaction,
-                    exporterVersion: trajectory.exporter_version?.display,
-                    sessionBuild: trajectory.session_build?.display,
-                    terminatedAbnormally: trajectory.session_terminated_abnormally,
+                    exportSchemaVersion: context.exportSchemaVersion,
+                    redaction: context.redaction,
+                    exporterVersion: context.exporterVersion,
+                    sessionBuild: context.sessionBuild,
+                    terminatedAbnormally: context.terminatedAbnormally,
                     operation,
                     policyDecision,
                     decision,
@@ -261,17 +324,246 @@ export class MuseSessionAdapter {
                     approvalOutcome,
                     ...linkage,
                     ...spawnContext,
-                    diagnostics: trajectory.diagnostics,
+                    diagnostics: context.diagnostics,
                 }),
             },
         };
     }
-    assertManualExport(source) {
-        if (source.locatorClass !== MUSE_LOCATOR_CLASS) {
-            throw new SessionContractError('UNSUPPORTED_OPERATION', `Muse Code supports only locatorClass "${MUSE_LOCATOR_CLASS}" because its native log format is internal `
-                + `(got "${source.locatorClass}"). Select an explicit \`muse export\` trajectory file.`);
+    async readNative(source) {
+        this.assertSupportedLocator(source);
+        let input;
+        try {
+            input = await readBoundedJsonLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'complete', limits: this.limits });
         }
+        catch (error) {
+            if (error instanceof SessionContractError && error.code === 'SCHEMA_DRIFT') {
+                throw new SessionContractError('MALFORMED_SOURCE', 'Muse native session log contains malformed JSONL');
+            }
+            throw error;
+        }
+        const diagnostics = {};
+        const records = [];
+        let fallbackSessionId = nativeSessionIdFromLocator(source.locator) ?? source.sourceId;
+        let complete = false;
+        for (const line of input.records) {
+            const value = line.value;
+            if (isOmissionMarker(value)) {
+                diagnostics.omitted_records = (diagnostics.omitted_records ?? 0) + 1;
+                if (asObject(value).retained_marker === 'omitted_live_only') {
+                    diagnostics.omitted_live_only = (diagnostics.omitted_live_only ?? 0) + 1;
+                }
+                continue;
+            }
+            const retained = MuseRetainedFrameSchema.safeParse(value);
+            if (retained.success) {
+                diagnostics.retained_frames = (diagnostics.retained_frames ?? 0) + 1;
+                for (const child of retained.data.children) {
+                    let decoded;
+                    try {
+                        decoded = JSON.parse(child.record_json);
+                    }
+                    catch {
+                        throw new SessionContractError('MALFORMED_SOURCE', 'Muse retained frame child record is malformed JSON');
+                    }
+                    const event = recordEventFromEnvelope(decoded);
+                    if (!event) {
+                        throw new SessionContractError('MALFORMED_SOURCE', 'Muse retained frame child record is malformed');
+                    }
+                    fallbackSessionId = streamSessionIdOf(event.envelope) ?? fallbackSessionId;
+                    complete ||= event.envelope.payload_type === 'session.end';
+                    diagnostics.retained_frame_children = (diagnostics.retained_frame_children ?? 0) + 1;
+                    records.push({
+                        event,
+                        line,
+                        retainedFrame: retained.data.retained_frame,
+                        retainedChildIndex: child.child_index,
+                    });
+                }
+                continue;
+            }
+            const event = recordEventFromEnvelope(value);
+            if (!event) {
+                throw new SessionContractError('MALFORMED_SOURCE', 'Muse native session log line is not a supported record shape');
+            }
+            fallbackSessionId = streamSessionIdOf(event.envelope) ?? fallbackSessionId;
+            complete ||= event.envelope.payload_type === 'session.end';
+            records.push({ event, line });
+        }
+        if (records.length === 0) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Muse native session log contains no record envelopes');
+        }
+        return {
+            records,
+            complete,
+            context: {
+                locatorClass: MUSE_NATIVE_LOCATOR_CLASS,
+                sourceLabel: 'muse native session log',
+                bytesRead: input.bytesRead,
+                fallbackSessionId,
+                spawns: new Map(),
+                diagnostics,
+            },
+        };
     }
+    assertSupportedLocator(source) {
+        if (source.locatorClass !== MUSE_LOCATOR_CLASS && source.locatorClass !== MUSE_NATIVE_LOCATOR_CLASS) {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', `Muse Code supports locatorClass "${MUSE_LOCATOR_CLASS}" and explicitly authorized `
+                + `"${MUSE_NATIVE_LOCATOR_CLASS}" sources (got "${source.locatorClass}").`);
+        }
+    }
+}
+function unsupportedNativeDiscovery() {
+    return new SessionContractError('UNSUPPORTED_OPERATION', 'Muse Code session auto-discover is unsupported: the native log under '
+        + '$XDG_DATA_HOME/muse/sessions uses an internal format. Run `muse export --session '
+        + '<id-or-session.jsonl>` and select that trajectory file. AIWG does not scrape home '
+        + 'directories for this provider.');
+}
+function contextFromTrajectory(trajectory, bytesRead) {
+    return {
+        locatorClass: MUSE_LOCATOR_CLASS,
+        sourceLabel: 'muse export trajectory',
+        bytesRead,
+        fallbackSessionId: trajectory.sessions[0].session_id,
+        spawns: acceptedSpawnsById(trajectory),
+        exportSchemaVersion: trajectory.export_schema_version,
+        redaction: trajectory.redaction,
+        exporterVersion: trajectory.exporter_version?.display,
+        sessionBuild: trajectory.session_build?.display,
+        terminatedAbnormally: trajectory.session_terminated_abnormally,
+        diagnostics: trajectory.diagnostics,
+    };
+}
+async function* museNativeSessionLogs(root) {
+    let years;
+    try {
+        years = await opendir(root);
+    }
+    catch {
+        return;
+    }
+    for await (const year of years) {
+        if (!year.isDirectory() || !/^\d{4}$/.test(year.name))
+            continue;
+        const yearPath = resolve(root, year.name);
+        let months;
+        try {
+            months = await opendir(yearPath);
+        }
+        catch {
+            continue;
+        }
+        for await (const month of months) {
+            if (!month.isDirectory() || !/^(0[1-9]|1[0-2])$/.test(month.name))
+                continue;
+            const monthPath = resolve(yearPath, month.name);
+            let days;
+            try {
+                days = await opendir(monthPath);
+            }
+            catch {
+                continue;
+            }
+            for await (const day of days) {
+                if (!day.isDirectory() || !/^(0[1-9]|[12]\d|3[01])$/.test(day.name))
+                    continue;
+                const dayPath = resolve(monthPath, day.name);
+                let sessions;
+                try {
+                    sessions = await opendir(dayPath);
+                }
+                catch {
+                    continue;
+                }
+                for await (const session of sessions) {
+                    if (!session.isDirectory() || !/^[A-Za-z0-9._-]+$/.test(session.name))
+                        continue;
+                    const sessionPath = resolve(dayPath, session.name);
+                    let entries;
+                    try {
+                        entries = await opendir(sessionPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    for await (const entry of entries) {
+                        if (entry.isFile() && entry.name === 'session.jsonl') {
+                            yield resolve(sessionPath, entry.name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+export async function museNativeSourceMatchesWorkspace(source, workspacePath) {
+    let input;
+    try {
+        input = await readBoundedJsonLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'complete', limits: { maxRecords: 100, maxRecordBytes: 8 * 1024 * 1024 } });
+    }
+    catch {
+        return false;
+    }
+    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;
+        }
+    }
+    return false;
+}
+function nativeEnvelopesFromLine(value) {
+    if (isOmissionMarker(value))
+        return [];
+    const event = recordEventFromEnvelope(value);
+    if (event)
+        return [event.envelope];
+    const retained = MuseRetainedFrameSchema.safeParse(value);
+    if (!retained.success)
+        return [];
+    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 [];
+        }
+    }
+    return envelopes;
+}
+function recordEventFromEnvelope(value) {
+    const envelope = MuseEnvelopeSchema.safeParse(value);
+    return envelope.success ? { kind: 'record', envelope: envelope.data } : null;
+}
+function isOmissionMarker(value) {
+    const record = asObject(value);
+    return Object.prototype.hasOwnProperty.call(record, 'omitted_record')
+        || record.retained_marker === 'omitted_live_only';
+}
+function workspaceEvidenceOf(envelope) {
+    const payload = asObject(envelope.payload);
+    const record = asObject(payload.record);
+    for (const candidate of [record.workspace_root, record.cwd]) {
+        if (typeof candidate === 'string' && candidate.length > 0)
+            return candidate;
+    }
+    return null;
+}
+function workspacePathEquals(candidate, workspacePath) {
+    return resolve(candidate) === workspacePath;
+}
+function nativeSessionIdFromLocator(locator) {
+    const parts = locator.replaceAll('\\', '/').split('/');
+    const leaf = parts.at(-1);
+    if (leaf !== 'session.jsonl')
+        return null;
+    const sessionId = parts.at(-2);
+    return sessionId && /^[A-Za-z0-9._-]+$/.test(sessionId) ? sessionId : null;
 }
 /**
  * Effective event kind per the documented jq projection:
@@ -371,6 +663,11 @@ function objectField(payload, key) {
         ? value
         : null;
 }
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
 function occurredAtOf(recordedAt) {
     if (typeof recordedAt === 'number') {
         // Epoch microseconds (Muse Code 1.4.0 export and native log).
@@ -381,8 +678,8 @@ function occurredAtOf(recordedAt) {
         return null;
     return Rfc3339Schema.safeParse(recordedAt).success ? recordedAt : null;
 }
-function describeEvent(eventKind, sequence, provenance) {
-    const parts = [`muse export trajectory event ${eventKind} (sequence ${sequence})`];
+function describeEvent(sourceLabel, eventKind, sequence, provenance) {
+    const parts = [`${sourceLabel} event ${eventKind} (sequence ${sequence})`];
     if (provenance.operation)
         parts.push(`operation=${provenance.operation}`);
     if (provenance.policyDecision)

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

@@ -5,6 +5,7 @@ import { CLAUDE_ADAPTER_VERSION, ClaudeSessionAdapter, } from './adapters/claude
 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 { BATCH_IMPORT_VERSION, coverageFromBatchRun, } from './batch-contracts.js';
 import { IncrementalSessionImporter, SessionImportFailure } from './importer.js';
@@ -211,6 +212,8 @@ function adapterFor(provider) {
         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}`);
 }
 async function sessionSource(selected, adapter) {
@@ -244,6 +247,8 @@ function adapterVersion(provider) {
         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) {
@@ -262,6 +267,8 @@ function providerProfile(provider, locatorClass) {
     }
     if (provider === 'factory')
         return 'documented-project-jsonl';
+    if (provider === 'muse')
+        return 'muse-native-session-log-v1';
     return 'manual-interchange';
 }
 function importErrorCode(error) {

package/dist/src/sessions/workspace-discovery.js

@@ -7,6 +7,7 @@ import { ClaudeSessionAdapter } from './adapters/claude.js';
 import { CodexSessionAdapter } from './adapters/codex.js';
 import { CursorSessionAdapter } from './adapters/cursor.js';
 import { FactorySessionAdapter } from './adapters/factory.js';
+import { MuseSessionAdapter, museNativeSourceMatchesWorkspace } from './adapters/muse.js';
 import { OmpSessionAdapter, readOmpSessionHeader } from './adapters/omp.js';
 import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 import { PiSessionAdapter } from './adapters/pi.js';
@@ -17,7 +18,7 @@ import { fingerprintSourceFile } from './readers.js';
 export const DISCOVERY_MANIFEST_VERSION = '1.0.0';
 const MANUAL_EXPORT_PROVIDERS = new Set([
     'copilot', 'hermes', 'opencode', 'openclaw', 'openhuman', 'grokbot', 'grok-build',
-    'warp', 'devin-desktop', 'muse', 'generic',
+    'warp', 'devin-desktop', 'generic',
 ]);
 export async function discoverWorkspaceHistories(options) {
     const workspacePath = await canonicalPath(options.workspace);
@@ -32,6 +33,8 @@ export async function discoverWorkspaceHistories(options) {
         { provider: 'omp', adapter: new OmpSessionAdapter(), roots: options.ompRoot
                 ? [resolve(options.ompRoot)] : options.providerHome
                 ? [resolveOmpPaths({ home: resolve(options.providerHome), cwd: workspacePath }).sessionsDir] : [] },
+        { provider: 'muse', adapter: new MuseSessionAdapter(), roots: options.museRoot
+                ? [resolve(options.museRoot)] : [] },
         {
             provider: 'claude',
             adapter: new ClaudeSessionAdapter(),
@@ -79,7 +82,8 @@ export async function discoverWorkspaceHistories(options) {
                 availableRoots.push(await canonicalPath(root));
         }
         if (availableRoots.length === 0) {
-            const codexNeedsAuthorization = (entry.provider === 'codex' || entry.provider === 'omp' || entry.provider === 'deepseek-harness')
+            const codexNeedsAuthorization = (entry.provider === 'codex' || entry.provider === 'omp'
+                || entry.provider === 'deepseek-harness' || entry.provider === 'muse')
                 && entry.roots.length === 0;
             reports.set(entry.provider, providerReport(entry.provider, codexNeedsAuthorization ? 'export-required' : 'unavailable', codexNeedsAuthorization ? 'manual-export' : 'discoverable', [], codexNeedsAuthorization
                 ? 'SHARED_ROOT_AUTHORIZATION_REQUIRED'
@@ -98,6 +102,13 @@ export async function discoverWorkspaceHistories(options) {
             if (entry.provider === 'codex'
                 && !await codexSourceMatchesWorkspace(locator, workspacePath))
                 continue;
+            if (entry.provider === 'muse'
+                && !await museNativeSourceMatchesWorkspace({
+                    ...descriptor,
+                    sourceId: 'discovery',
+                    authorizedScope: scope,
+                }, workspacePath))
+                continue;
             const ompHeader = entry.provider === 'omp' ? await readOmpSessionHeader({ ...descriptor, sourceId: 'discovery', authorizedScope: scope }) : undefined;
             if (ompHeader && resolve(ompHeader.cwd) !== workspacePath)
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.9.21",
+  "version": "2026.10.0",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",