@aiwg/cli 2026.10.1 → 2026.10.3

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

@@ -1,49 +1,448 @@
 /**
- * Grok Bot session adapter — manual-export only until product evidence exists
- * for a native session filesystem or API locator.
+ * Grok Bot session adapter — manual-export interchange plus an evidence-gated
+ * native locator for the Grok Bot desktop app's local transcript cache.
  *
- * Auto-discover is unsupported and must never scrape invented ~/.grokbot,
- * Cursor session paths, or other unverified roots.
+ * Native discovery (#2970) is Linux-only and requires an explicitly
+ * authorized `sand-client-persistence` root (`--grokbot-root`); there is no
+ * default path and nothing is guessed for macOS/Windows, where the layout is
+ * unverified. The store is one JSON document per key, named `<base32
+ * key>.blob` (RFC 4648 section 6, lowercase, unpadded). Discovery decodes
+ * ONLY filenames to classify them; it never opens a file whose decoded key
+ * is outside the allowlist below, and it never recurses or follows symlinks.
  *
- * Authorized imports reuse the AIWG generic session interchange format so
- * operators can supply an explicit export without inventing a Grok schema.
+ * Allowlisted keys (see grokbot-locator.ts):
+ *   - `...transcript.replicas.<conversation-uuid>` — one conversation; the
+ *     only key class ever selected as an importable source.
+ *   - `...roster.last-roster` — account conversation index; never opened by
+ *     this adapter (no session content), kept out of discover() results.
+ * Every other key (composer-drafts, send-journal, experiments, ui-layout,
+ * sand-secrets, box-secrets, cookies, local/session storage, etc.) is never
+ * decoded content, never opened, and `~/.grokbot` (daemon credentials) is
+ * never referenced.
+ *
+ * Grok Bot conversations carry no workspace/cwd field — there is no native
+ * evidence linking a conversation to a project directory. Following the
+ * established precedent for other account-scoped, non-workspace-scoped
+ * native locators (`pi`, `deepseek-harness`: no per-source workspace
+ * filtering in workspace-discovery.ts), every authorized conversation under
+ * `--grokbot-root` surfaces to whichever workspace runs discovery; this
+ * adapter never guesses a workspace link and `inspect()` never sets
+ * `declaredWorkspaceId` for native sources.
+ *
+ * The replica is a bounded client-side cache (~200 entries) that can evict
+ * its oldest entries as new ones arrive, so a re-read is not append-only —
+ * the file may shrink, and Grok Bot may rewrite it via a rename-swap that
+ * changes its inode. This adapter declares `sourceContinuity: 'snapshot'`
+ * (contracts.ts), which tells the shared importer to skip its generic
+ * size-shrink / file-identity / prefix-rewrite checks (those assume
+ * append-only growth) for this source. Idempotent, non-duplicating re-import
+ * across the sliding window then relies on two things instead: (1)
+ * `workspace-discovery.ts` assigns a conversation-id–derived,
+ * content-independent `sourceId` for native sources (mirroring the existing
+ * OMP convention), so the importer's checkpoint continuity survives content
+ * changes; (2) `stream()` resumes from the native, monotonic `seq` carried
+ * by each entry (not a position/byte offset, which the sliding window would
+ * invalidate) and tags every record's `sourceCursor` as `native:<seq>` — an
+ * opaque provider-native resume token the importer stores verbatim
+ * (`positionKind: 'provider-native'`), never reinterpreted as a byte offset.
+ * Combined with the catalog's identity-keyed `INSERT OR IGNORE`, re-importing
+ * after the window has slid can only add genuinely new entries, never
+ * duplicate ones.
  *
  * @see docs/providers/grokbot-sessions.md
- * @issue #215
+ * @issue #215, #2970
  */
-import { SessionContractError, } from '../contracts.js';
+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 { GenericSessionInterchangeAdapter, } from './generic.js';
+import { classifyGrokbotBlobName, grokbotConversationIdFromLocator, } from './grokbot-locator.js';
 export const GROKBOT_ADAPTER_VERSION = '1.0.0';
 export const GROKBOT_EXPORT_SCHEMA_VERSION = '1.0.0';
+export const GROKBOT_NATIVE_SCHEMA_VERSION = '1.0.0';
+export const GROKBOT_NATIVE_SCHEMA_MAJOR = 1;
 export const GROKBOT_LOCATOR_CLASS = 'manual-export';
+export const GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS = 'grokbot-native-transcript-replica';
+const GrokbotEntryBaseSchema = z.object({
+    kind: z.string().min(1),
+    id: z.string().min(1),
+    timestampMs: z.number().int().nonnegative(),
+    requestId: z.string().optional(),
+    seq: z.number().int().nonnegative(),
+}).passthrough();
+const SendMessageEntrySchema = GrokbotEntryBaseSchema.extend({
+    kind: z.literal('send-message'),
+    respondedValue: z.unknown().optional(),
+    secretProvided: z.boolean().optional(),
+    message: z.discriminatedUnion('type', [
+        z.object({ type: z.literal('text'), content: z.string() }).passthrough(),
+        z.object({
+            type: z.literal('widget'),
+            widget: z.object({ prompt: z.string() }).passthrough(),
+        }).passthrough(),
+        z.object({
+            type: z.literal('email-draft'),
+            draft: z.object({ subject: z.string().optional(), body: z.string() }).passthrough(),
+        }).passthrough(),
+        z.object({
+            type: z.literal('slack-draft'),
+            draft: z.object({ target: z.string().optional(), body: z.string() }).passthrough(),
+        }).passthrough(),
+        z.object({
+            type: z.literal('attachment'),
+            url: z.string(),
+            file_name: z.string(),
+        }).passthrough(),
+        z.object({
+            type: z.literal('user-form'),
+            formRequest: z.object({ title: z.string() }).passthrough(),
+        }).passthrough(),
+        z.object({
+            type: z.literal('secret-request'),
+            secretRequest: z.object({ label: z.string() }).passthrough(),
+        }).passthrough(),
+    ]),
+});
+const MessageEntrySchema = GrokbotEntryBaseSchema.extend({
+    kind: z.literal('message'),
+    role: z.enum(['user', 'assistant']),
+    content: z.string(),
+    fromAgent: z.object({ id: z.string().optional(), name: z.string().optional() })
+        .passthrough().optional(),
+});
+const UserAttachmentEntrySchema = GrokbotEntryBaseSchema.extend({
+    kind: z.literal('user-attachment'),
+    file_name: z.string(),
+    file_path: z.string().optional(),
+    width: z.number().optional(),
+    height: z.number().optional(),
+    byteSize: z.number().optional(),
+});
+const EventEntrySchema = GrokbotEntryBaseSchema.extend({
+    kind: z.literal('event'),
+    event: z.record(z.string(), z.unknown()),
+});
+const NoticeEntrySchema = GrokbotEntryBaseSchema.extend({
+    kind: z.literal('notice'),
+    text: z.string(),
+});
+const GrokbotReplicaValueSchema = z.object({
+    entries: z.array(GrokbotEntryBaseSchema),
+    epochHint: z.string().optional(),
+    acceptedSequenceHint: z.number().int().nonnegative().optional(),
+    persistedAt: z.number().int().nonnegative().optional(),
+    precedingTimestampMs: z.number().int().nonnegative().optional(),
+}).passthrough();
+const GrokbotReplicaDocumentSchema = z.object({
+    schemaVersion: z.number().int().nonnegative(),
+    value: GrokbotReplicaValueSchema,
+}).passthrough();
 export class GrokbotSessionAdapter {
+    limits;
+    maxFiles;
     provider = 'grokbot';
     adapterVersion = GROKBOT_ADAPTER_VERSION;
-    disposition = 'manual-only';
-    supportedOperations = ['inspect', 'stream'];
-    acquisitionModes = ['manual-export'];
+    disposition = 'implemented';
+    supportedOperations = ['discover', 'inspect', 'stream'];
+    acquisitionModes = ['manual-export', 'jsonl'];
+    /**
+     * The replica is rewritten wholesale (sliding window, possible
+     * rename-swap), not appended to. See the class-level doc comment.
+     */
+    sourceContinuity = 'snapshot';
     interchange;
-    constructor(limits) {
+    constructor(limits, maxFiles = 10_000) {
+        this.limits = limits;
+        this.maxFiles = maxFiles;
         this.interchange = new GenericSessionInterchangeAdapter(limits);
     }
-    async *discover(_scope) {
-        throw new SessionContractError('UNSUPPORTED_OPERATION', 'Grok Bot session auto-discover is unsupported until a verified native locator exists; '
-            + 'select an authorized manual export explicitly. AIWG does not scrape ~/.grokbot, '
-            + '~/grokbot-skills, or Cursor session paths.');
+    async *discover(scope) {
+        if (scope.allowedRoots.length === 0) {
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'Grok Bot native discovery requires an explicitly authorized sand-client-persistence root; '
+                + 'pass --grokbot-root. There is no default root and nothing is guessed for macOS or Windows.');
+        }
+        let count = 0;
+        for (const root of [...scope.allowedRoots].sort()) {
+            let directory;
+            try {
+                directory = await opendir(resolve(root));
+            }
+            catch {
+                continue;
+            }
+            for await (const dirent of directory) {
+                // Never recurse, never follow symlinks: only plain files directly
+                // under the authorized root are even filename-classified.
+                if (!dirent.isFile())
+                    continue;
+                const classification = classifyGrokbotBlobName(dirent.name);
+                if (classification?.kind !== 'transcript-replica')
+                    continue;
+                if (++count > this.maxFiles) {
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'Grok Bot native discovery exceeded the authorized file limit');
+                }
+                yield {
+                    provider: 'grokbot',
+                    locator: resolve(root, dirent.name),
+                    locatorClass: GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS,
+                };
+            }
+        }
     }
     async inspect(source) {
-        this.assertManualExport(source);
-        return this.interchange.inspect(source);
+        if (source.locatorClass === GROKBOT_LOCATOR_CLASS) {
+            return this.interchange.inspect(source);
+        }
+        this.assertNativeReplica(source);
+        const native = await this.readReplica(source);
+        return {
+            sourceSchemaVersion: GROKBOT_NATIVE_SCHEMA_VERSION,
+            consistency: native.truncated ? 'provisional' : 'complete',
+            operationalState: 'available',
+            // No native evidence links a conversation to a workspace/cwd; never
+            // fabricate one.
+        };
     }
     async *stream(source, cursor) {
-        this.assertManualExport(source);
-        yield* this.interchange.stream(source, cursor);
+        if (source.locatorClass === GROKBOT_LOCATOR_CLASS) {
+            yield* this.interchange.stream(source, cursor);
+            return;
+        }
+        this.assertNativeReplica(source);
+        const native = await this.readReplica(source);
+        const conversationId = grokbotConversationIdFromLocator(source.locator);
+        if (!conversationId) {
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'Grok Bot native locator does not decode to an authorized transcript-replica key');
+        }
+        const lastSeq = parseNativeCursor(cursor?.value);
+        const seen = new Set();
+        for (const entry of native.entries) {
+            if (seen.has(entry.seq)) {
+                throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Grok Bot transcript replica contains a duplicate entry sequence');
+            }
+            seen.add(entry.seq);
+            if (entry.seq <= lastSeq)
+                continue;
+            const mapped = mapGrokbotEntry(entry);
+            if (!mapped)
+                continue; // Unrecognized entry kind: skipped, never fabricated.
+            yield {
+                nativeSessionId: conversationId,
+                nativeEventId: mapped.nativeEventId,
+                sequence: mapped.sequence,
+                kind: mapped.kind,
+                role: mapped.role,
+                participant: mapped.participant,
+                text: mapped.text,
+                occurredAt: mapped.occurredAt,
+                // Opaque provider-native resume token: the importer stores this
+                // verbatim (positionKind: 'provider-native') and never reinterprets
+                // it as a byte offset. It encodes the last imported native `seq`,
+                // which is monotonic and stable across the bounded cache evicting
+                // old entries. See the class-level doc comment for the full
+                // rationale.
+                sourceCursor: `native:${entry.seq}`,
+                rawReference: { locatorClass: GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS, sequence: entry.seq },
+                extensions: mapped.extensions,
+            };
+        }
+    }
+    assertNativeReplica(source) {
+        if (source.locatorClass !== GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS) {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', `Grok Bot supports only locatorClass "${GROKBOT_LOCATOR_CLASS}" or `
+                + `"${GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS}" (got "${source.locatorClass}"). `
+                + 'Do not reuse Cursor or other provider locators.');
+        }
+        // Enforce the filename allowlist before any read, not only in discover():
+        // a caller can hand inspect()/stream() any path with the native class.
+        if (!grokbotConversationIdFromLocator(source.locator)) {
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'Grok Bot native locator does not decode to an authorized transcript-replica key');
+        }
     }
-    assertManualExport(source) {
-        if (source.locatorClass !== GROKBOT_LOCATOR_CLASS) {
-            throw new SessionContractError('UNSUPPORTED_OPERATION', `Grok Bot supports only locatorClass "${GROKBOT_LOCATOR_CLASS}" until native session evidence exists `
-                + `(got "${source.locatorClass}"). Do not reuse Cursor session locators.`);
+    async readReplica(source) {
+        const { value } = await readBoundedJson({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, this.limits);
+        const parsed = GrokbotReplicaDocumentSchema.safeParse(value);
+        if (!parsed.success) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Grok Bot transcript replica is malformed');
         }
+        assertSupportedSchemaMajor(`${parsed.data.schemaVersion}.0.0`, GROKBOT_NATIVE_SCHEMA_MAJOR);
+        const { entries, precedingTimestampMs } = parsed.data.value;
+        // The resume cursor is the last yielded seq, so stream in seq order even
+        // if the cache stores entries out of order.
+        entries.sort((left, right) => left.seq - right.seq);
+        // A window that no longer starts at seq 1 has evicted history, whether or
+        // not the optional precedingTimestampMs hint is present.
+        const truncated = entries.length > 0
+            && (entries[0].seq > 1 || (precedingTimestampMs ?? 0) > 0);
+        return { entries, truncated };
+    }
+}
+function parseNativeCursor(value) {
+    if (!value)
+        return 0;
+    const raw = value.startsWith('native:') ? value.slice('native:'.length) : value;
+    if (!/^\d+$/.test(raw))
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Grok Bot native cursor');
+    return Number(raw);
+}
+function mapGrokbotEntry(entry) {
+    const occurredAt = new Date(entry.timestampMs).toISOString();
+    switch (entry.kind) {
+        case 'send-message':
+            return mapSendMessage(entry, occurredAt);
+        case 'message':
+            return mapMessage(entry, occurredAt);
+        case 'user-attachment':
+            return mapUserAttachment(entry, occurredAt);
+        case 'event':
+            return mapEvent(entry, occurredAt);
+        case 'notice':
+            return mapNotice(entry, occurredAt);
+        default:
+            // Unrecognized entry kind: safely skipped, never fabricated into a record.
+            return null;
+    }
+}
+function mapSendMessage(raw, occurredAt) {
+    const parsed = SendMessageEntrySchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'Grok Bot send-message entry is malformed');
+    }
+    const entry = parsed.data;
+    const { message } = entry;
+    let text;
+    switch (message.type) {
+        case 'text':
+            text = message.content;
+            break;
+        case 'widget':
+            text = `[widget] ${message.widget.prompt} -> ${stringOrEmpty(entry.respondedValue)}`;
+            break;
+        case 'email-draft':
+            text = `[email-draft] ${message.draft.subject ?? ''}\n${message.draft.body}`;
+            break;
+        case 'slack-draft':
+            text = `[slack-draft] ${message.draft.target ?? ''}\n${message.draft.body}`;
+            break;
+        case 'attachment':
+            text = `[attachment] ${message.file_name} (${message.url})`;
+            break;
+        case 'user-form':
+            text = `[user-form] ${message.formRequest.title}`;
+            break;
+        case 'secret-request':
+            text = `[secret-request] ${message.secretRequest.label} (value not exported)`;
+            break;
+        default:
+            text = '';
     }
+    return {
+        nativeEventId: entry.id,
+        sequence: entry.seq,
+        kind: `grokbot.send-message.${message.type}`,
+        role: 'assistant',
+        text,
+        occurredAt,
+        extensions: {
+            nativeKind: 'send-message',
+            messageType: message.type,
+            secretProvided: entry.secretProvided,
+            provenance: { acquisition: GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS },
+        },
+    };
+}
+function mapMessage(raw, occurredAt) {
+    const parsed = MessageEntrySchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'Grok Bot message entry is malformed');
+    }
+    const entry = parsed.data;
+    return {
+        nativeEventId: entry.id,
+        sequence: entry.seq,
+        kind: 'grokbot.message',
+        role: entry.role,
+        participant: entry.fromAgent?.name ?? entry.fromAgent?.id,
+        text: entry.content,
+        occurredAt,
+        extensions: {
+            nativeKind: 'message',
+            fromAgent: entry.fromAgent,
+            provenance: { acquisition: GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS },
+        },
+    };
+}
+function mapUserAttachment(raw, occurredAt) {
+    const parsed = UserAttachmentEntrySchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'Grok Bot user-attachment entry is malformed');
+    }
+    const entry = parsed.data;
+    return {
+        nativeEventId: entry.id,
+        sequence: entry.seq,
+        kind: 'grokbot.user-attachment',
+        role: 'user',
+        text: `[user-attachment] ${entry.file_name} `
+            + `(${entry.width ?? '?'}x${entry.height ?? '?'}, ${entry.byteSize ?? '?'} bytes)`,
+        occurredAt,
+        extensions: {
+            nativeKind: 'user-attachment',
+            fileName: entry.file_name,
+            filePath: entry.file_path,
+            width: entry.width,
+            height: entry.height,
+            byteSize: entry.byteSize,
+            provenance: { acquisition: GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS },
+        },
+    };
+}
+function mapEvent(raw, occurredAt) {
+    const parsed = EventEntrySchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'Grok Bot event entry is malformed');
+    }
+    const entry = parsed.data;
+    const label = stringOrEmpty(entry.event.kind) || stringOrEmpty(entry.event.type) || 'event';
+    return {
+        nativeEventId: entry.id,
+        sequence: entry.seq,
+        kind: 'grokbot.event',
+        role: 'system',
+        text: `[event] ${label}`,
+        occurredAt,
+        extensions: {
+            nativeKind: 'event',
+            event: entry.event,
+            provenance: { acquisition: GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS },
+        },
+    };
+}
+function mapNotice(raw, occurredAt) {
+    const parsed = NoticeEntrySchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'Grok Bot notice entry is malformed');
+    }
+    const entry = parsed.data;
+    return {
+        nativeEventId: entry.id,
+        sequence: entry.seq,
+        kind: 'grokbot.notice',
+        role: 'system',
+        text: entry.text,
+        occurredAt,
+        extensions: {
+            nativeKind: 'notice',
+            provenance: { acquisition: GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS },
+        },
+    };
+}
+function stringOrEmpty(value) {
+    return typeof value === 'string' ? value : '';
 }
 //# sourceMappingURL=grokbot.js.map

package/dist/src/sessions/adapters/muse-workspace-scan.js

@@ -0,0 +1,108 @@
+import { open } from 'node:fs/promises';
+import { SessionContractError } from '../contracts.js';
+import { authorizeSourceFile } from '../policy.js';
+// Discovery inspects metadata, not an entire import. Bound allocation before
+// assembling a line (readline would buffer an arbitrarily large single line).
+export const MUSE_WORKSPACE_SCAN_LIMITS = Object.freeze({
+    maxRecords: 10_000,
+    maxRecordBytes: 8 * 1024 * 1024,
+    maxTotalBytes: 32 * 1024 * 1024,
+    maxNestingDepth: 64,
+});
+export async function* museWorkspaceScanLines(authorization, limits, progress) {
+    const allowed = await authorizeSourceFile(authorization);
+    const handle = await open(allowed.canonicalPath, 'r');
+    try {
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        let position = 0;
+        let parts = [];
+        let length = 0;
+        while (position < allowed.size) {
+            const remaining = limits.maxTotalBytes - progress.bytesInspected;
+            if (remaining <= 0)
+                throw scanLimit();
+            const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, allowed.size - position, remaining), position);
+            if (bytesRead === 0) {
+                throw new SessionContractError('TRUNCATED_SOURCE', 'Muse source changed during inspection');
+            }
+            position += bytesRead;
+            let start = 0;
+            while (start < bytesRead) {
+                const newline = buffer.indexOf(10, start);
+                const end = newline >= 0 && newline < bytesRead ? newline + 1 : bytesRead;
+                const segment = buffer.subarray(start, end);
+                if (length + segment.length > limits.maxRecordBytes)
+                    throw scanLimit();
+                parts.push(Buffer.from(segment));
+                length += segment.length;
+                progress.bytesInspected += segment.length;
+                start = end;
+                if (newline >= 0 && newline < bytesRead) {
+                    const line = Buffer.concat(parts, length).toString('utf8');
+                    parts = [];
+                    length = 0;
+                    if (line.trim() !== '') {
+                        if (progress.recordsInspected >= limits.maxRecords)
+                            throw scanLimit();
+                        const value = parseMuseScanJson(line, limits.maxNestingDepth);
+                        progress.recordsInspected += 1;
+                        yield value;
+                    }
+                }
+            }
+        }
+        if (length > 0) {
+            const line = Buffer.concat(parts, length).toString('utf8');
+            if (line.trim() !== '') {
+                if (progress.recordsInspected >= limits.maxRecords)
+                    throw scanLimit();
+                let value;
+                try {
+                    value = parseMuseScanJson(line, limits.maxNestingDepth);
+                }
+                catch (error) {
+                    if (error instanceof SessionContractError && error.code === 'MALFORMED_SOURCE') {
+                        throw new SessionContractError('TRUNCATED_SOURCE', 'Muse source has an incomplete JSONL tail');
+                    }
+                    throw error;
+                }
+                progress.recordsInspected += 1;
+                yield value;
+            }
+        }
+        const after = await handle.stat();
+        if (after.size !== allowed.size || after.mtimeMs !== allowed.mtimeMs) {
+            throw new SessionContractError('TRUNCATED_SOURCE', 'Muse source changed during inspection');
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function parseMuseScanJson(line, maxDepth) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        throw new SessionContractError('MALFORMED_SOURCE', 'Muse inspection encountered malformed JSON');
+    }
+    // Check depth iteratively, including decoded retained children, before zod
+    // validation. Deep input must produce a limit diagnostic, not stack overflow.
+    const pending = [{ value, depth: 0 }];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current.depth > maxDepth)
+            throw scanLimit();
+        if (current.value !== null && typeof current.value === 'object') {
+            for (const child of Object.values(current.value)) {
+                pending.push({ value: child, depth: current.depth + 1 });
+            }
+        }
+    }
+    return value;
+}
+function scanLimit() {
+    return new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'bounded Muse workspace inspection limit exceeded');
+}
+//# sourceMappingURL=muse-workspace-scan.js.map