claude-flow 3.62.0 → 3.63.0

package/v3/@claude-flow/cli/dist/src/services/managed-memory-client.js

@@ -0,0 +1,236 @@
+/** Native memory runs behind a bounded child boundary, never in the MCP process. */
+import { fork } from 'node:child_process';
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+export const MANAGED_MEMORY_NAMESPACE = 'managed-workflow-evidence';
+export const MANAGED_MEMORY_LIMITS = { workers: 1, requestBytes: 80_000, resultBytes: 200_000, rows: 20, rowBytes: 8192, timeoutMs: 15_000, idleMs: 5000 };
+const HASH = /^[a-f0-9]{64}$/;
+const TYPES = ['code-review', 'migration', 'research', 'test-generation', 'implementation', 'other'];
+function requestOf(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid managed memory request');
+    const r = value;
+    const keys = r.operation === 'index' ? ['operation', 'id', 'value', 'taskType'] : ['operation', 'taskType', 'allowedIds'];
+    if (!['index', 'recall'].includes(String(r.operation)) || Object.keys(r).length !== keys.length || Object.keys(r).some(k => !keys.includes(k)) || !TYPES.includes(String(r.taskType)))
+        throw new Error('Invalid managed memory request');
+    if (r.operation === 'index' && (typeof r.id !== 'string' || !HASH.test(r.id) || typeof r.value !== 'string' || Buffer.byteLength(r.value) > MANAGED_MEMORY_LIMITS.rowBytes))
+        throw new Error('Invalid managed index request');
+    if (r.operation === 'recall' && (!Array.isArray(r.allowedIds) || r.allowedIds.length > 500 || r.allowedIds.some(id => typeof id !== 'string' || !HASH.test(id))))
+        throw new Error('Invalid managed recall request');
+    if (Buffer.byteLength(JSON.stringify(r)) > MANAGED_MEMORY_LIMITS.requestBytes)
+        throw new Error('Managed memory request limit exceeded');
+    return JSON.parse(JSON.stringify(r));
+}
+function resultOf(value, operation, requestId) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || Buffer.byteLength(JSON.stringify(value)) > MANAGED_MEMORY_LIMITS.resultBytes)
+        throw new Error('Invalid managed memory worker response');
+    const r = value;
+    if (r.v !== 1 || r.ok !== true || r.operation !== operation || r.requestId !== requestId)
+        throw new Error('Managed native memory worker did not complete');
+    if (operation === 'index') {
+        if (Object.keys(r).some(k => !['v', 'ok', 'requestId', 'operation', 'durable', 'hasEmbedding'].includes(k)) || r.durable !== true || typeof r.hasEmbedding !== 'boolean')
+            throw new Error('Unconfirmed managed memory persistence');
+        return { operation, durable: true, hasEmbedding: r.hasEmbedding };
+    }
+    if (Object.keys(r).some(k => !['v', 'ok', 'requestId', 'operation', 'available', 'rows'].includes(k)) || typeof r.available !== 'boolean' || !Array.isArray(r.rows) || r.rows.length > MANAGED_MEMORY_LIMITS.rows)
+        throw new Error('Invalid managed recall response');
+    for (const raw of r.rows) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error('Invalid managed recall row');
+        const row = raw;
+        if (Object.keys(row).length !== 4 || Object.keys(row).some(k => !['key', 'namespace', 'score', 'content'].includes(k)) || typeof row.key !== 'string' || !HASH.test(row.key) || row.namespace !== MANAGED_MEMORY_NAMESPACE || typeof row.score !== 'number' || !Number.isFinite(row.score) || row.score < -1 || row.score > 1 || typeof row.content !== 'string' || Buffer.byteLength(row.content) > MANAGED_MEMORY_LIMITS.rowBytes)
+            throw new Error('Invalid managed recall row');
+    }
+    return { operation, available: r.available, rows: r.rows };
+}
+function sourceLoader() {
+    try {
+        return createRequire(import.meta.url).resolve('tsx');
+    }
+    catch { /* npx tsx can live outside project node_modules */ }
+    for (let i = 0; i < process.execArgv.length; i++) {
+        const arg = process.execArgv[i];
+        const path = arg === '--import' ? process.execArgv[i + 1] : arg.startsWith('--import=') ? arg.slice(9) : undefined;
+        if (!path)
+            continue;
+        const file = path.startsWith('file:') ? fileURLToPath(path) : path;
+        if (/[/\\]node_modules[/\\]tsx[/\\]dist[/\\](?:loader\.mjs|esm[/\\]index\.mjs)$/.test(file) && existsSync(file))
+            return file;
+    }
+    throw new Error('Source managed memory worker requires tsx');
+}
+function launch(root) {
+    const js = new URL('./managed-memory-worker.js', import.meta.url), ts = new URL('./managed-memory-worker.ts', import.meta.url);
+    const compiled = existsSync(fileURLToPath(js));
+    const entry = compiled ? js : ts;
+    if (!existsSync(fileURLToPath(entry)))
+        throw new Error('Managed memory worker is not installed');
+    // Production uses emitted JS. Source development uses the project's declared
+    // tsx dependency so internal .js imports resolve to TypeScript sources.
+    const args = compiled ? [] : ['--import', sourceLoader()];
+    const env = {};
+    for (const key of ['PATH', 'HOME', 'USERPROFILE', 'SystemRoot', 'SYSTEMROOT', 'WINDIR', 'TMPDIR', 'TMP', 'TEMP', 'LANG', 'LC_ALL', 'CLAUDE_FLOW_DISABLE_BRIDGE', 'CLAUDE_FLOW_ENABLE_NATIVE_BRIDGE_ON_WINDOWS'])
+        if (process.env[key] !== undefined)
+            env[key] = process.env[key];
+    // No provider credentials or startup hooks are inherited. Existing local
+    // models may be used; indexing never initiates a model download.
+    env.CLAUDE_FLOW_CWD = root;
+    env.HF_HUB_OFFLINE = '1';
+    env.TRANSFORMERS_OFFLINE = '1';
+    return fork(entry, [], { cwd: root, env, execArgv: args, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], serialization: 'json' });
+}
+/** The optional fork callback is an in-process host test seam, not a serialized tool argument. */
+export class ManagedMemoryClient {
+    slots = new Map();
+    timeoutMs;
+    idleMs;
+    forkWorker;
+    constructor(options = {}) {
+        this.timeoutMs = options.timeoutMs ?? MANAGED_MEMORY_LIMITS.timeoutMs;
+        this.idleMs = options.idleMs ?? MANAGED_MEMORY_LIMITS.idleMs;
+        this.forkWorker = options.forkWorker ?? launch;
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs < 20 || this.timeoutMs > 60_000 || !Number.isFinite(this.idleMs) || this.idleMs < 20 || this.idleMs > 30_000)
+            throw new Error('Invalid managed memory worker limits');
+    }
+    run(root, raw, authorize = () => true) {
+        let input, cwd;
+        try {
+            input = requestOf(raw);
+            cwd = realpathSync(root);
+            if (!statSync(cwd).isDirectory())
+                throw new Error('Invalid learning project root');
+        }
+        catch {
+            return Promise.reject(new Error('Invalid managed memory operation or project root'));
+        }
+        try {
+            if (!authorize())
+                return Promise.reject(new Error('Managed memory policy denied'));
+        }
+        catch {
+            return Promise.reject(new Error('Managed memory policy denied'));
+        }
+        let slot = this.slots.get(cwd);
+        if (slot?.busy)
+            return Promise.reject(new Error('Managed memory worker is busy; retry later'));
+        if (!slot) {
+            if (this.slots.size >= MANAGED_MEMORY_LIMITS.workers) {
+                const idle = [...this.slots.values()].filter(s => !s.busy).sort((a, b) => a.lastUsed - b.lastUsed)[0];
+                if (!idle)
+                    return Promise.reject(new Error('Managed memory worker limit reached; retry later'));
+                this.remove(idle);
+            }
+            try {
+                slot = { child: this.forkWorker(cwd), root: cwd, busy: false, lastUsed: Date.now() };
+                this.slots.set(cwd, slot);
+                const owned = slot;
+                slot.child.once('error', () => { owned.fail?.(); this.remove(owned); });
+                slot.child.once('exit', () => { owned.fail?.(); this.remove(owned); });
+            }
+            catch {
+                return Promise.reject(new Error('Managed native memory worker unavailable'));
+            }
+        }
+        const owned = slot;
+        const requestId = randomUUID();
+        if (owned.timer)
+            clearTimeout(owned.timer);
+        owned.busy = true;
+        return new Promise((resolve, reject) => {
+            let settled = false, policyDenied = false, ready = false, writeGranted = false;
+            const complete = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                owned.child.off('message', onMessage);
+                owned.fail = undefined;
+                owned.busy = false;
+                owned.lastUsed = Date.now();
+                if (result) {
+                    owned.timer = setTimeout(() => this.remove(owned), this.idleMs);
+                    owned.timer.unref();
+                    owned.child.unref();
+                    owned.child.channel?.unref();
+                    resolve(result);
+                }
+                else {
+                    this.remove(owned);
+                    reject(new Error(policyDenied ? (writeGranted ? 'Managed memory policy changed; admitted write may have completed' : 'Managed memory policy denied before dispatch') : 'Managed native memory operation failed or timed out; parent remains available'));
+                }
+            };
+            const onMessage = (value) => {
+                try {
+                    if (!authorize()) {
+                        policyDenied = true;
+                        complete();
+                        return;
+                    }
+                    const message = value;
+                    if (message?.phase !== undefined) {
+                        if (Object.keys(message).length !== 3 || message.v !== 1 || message.requestId !== requestId || !['ready', 'before-write'].includes(String(message.phase)))
+                            throw new Error('Invalid worker grant request');
+                        if (message.phase === 'ready') {
+                            if (ready)
+                                throw new Error('Repeated worker ready');
+                            ready = true;
+                        }
+                        else {
+                            if (!ready || writeGranted || input.operation !== 'index')
+                                throw new Error('Invalid worker write grant');
+                            writeGranted = true;
+                        }
+                        owned.child.send({ v: 1, requestId, grant: message.phase === 'ready' ? 'execute' : 'write' }, error => { if (error)
+                            complete(); });
+                        return;
+                    }
+                    if (!ready)
+                        throw new Error('Worker was not ready');
+                    complete(resultOf(value, input.operation, requestId));
+                }
+                catch {
+                    complete();
+                }
+            };
+            const timeout = setTimeout(() => complete(), this.timeoutMs);
+            owned.fail = () => complete();
+            owned.child.on('message', onMessage);
+            try {
+                if (!authorize()) {
+                    policyDenied = true;
+                    complete();
+                    return;
+                }
+                owned.child.send({ v: 1, requestId, ...input }, error => { if (error)
+                    complete(); });
+            }
+            catch {
+                policyDenied = true;
+                complete();
+            }
+        });
+    }
+    stats() { return { workers: this.slots.size, busy: [...this.slots.values()].filter(s => s.busy).length }; }
+    close() { for (const slot of [...this.slots.values()]) {
+        slot.fail?.();
+        this.remove(slot);
+    } }
+    remove(slot) {
+        if (slot.timer)
+            clearTimeout(slot.timer);
+        if (this.slots.get(slot.root) === slot)
+            this.slots.delete(slot.root);
+        if (!slot.child.killed)
+            slot.child.kill('SIGKILL');
+    }
+}
+export const managedMemoryClient = new ManagedMemoryClient();
+export async function nativeMemoryIndex(root, input, authorize) {
+    return await managedMemoryClient.run(root, { operation: 'index', ...input }, authorize);
+}
+export async function nativeMemoryRecall(root, input, authorize) {
+    return await managedMemoryClient.run(root, { operation: 'recall', ...input }, authorize);
+}
+//# sourceMappingURL=managed-memory-client.js.map

package/v3/@claude-flow/cli/dist/src/services/managed-memory-worker.d.ts

@@ -0,0 +1,56 @@
+type Row = {
+    key: string;
+    namespace: string;
+    content: string;
+    hasEmbedding?: boolean;
+};
+export type NativeMemoryAdapter = {
+    getEntry: (options: Record<string, unknown>) => Promise<{
+        success: boolean;
+        found: boolean;
+        entry?: Row;
+    } | null>;
+    storeEntry: (options: Record<string, unknown>) => Promise<{
+        success: boolean;
+        persistWarning?: unknown;
+        embedding?: {
+            dimensions?: number;
+        };
+        error?: unknown;
+    } | null>;
+    searchEntries: (options: Record<string, unknown>) => Promise<{
+        success: boolean;
+        results: Array<{
+            key: string;
+            namespace: string;
+            score: number;
+        }>;
+    } | null>;
+};
+/** Pure operation seam for host tests. Serialized callers cannot supply an adapter. */
+export declare function executeManagedMemory(raw: unknown, adapter: NativeMemoryAdapter, dbPath: string, beforeWrite?: () => Promise<void>): Promise<{
+    v: number;
+    requestId: string;
+    ok: boolean;
+    operation: string;
+    durable: boolean;
+    hasEmbedding: boolean;
+    available?: undefined;
+    rows?: undefined;
+} | {
+    v: number;
+    requestId: string;
+    ok: boolean;
+    operation: string;
+    available: boolean;
+    rows: {
+        key: string;
+        namespace: string;
+        score: number;
+        content: string;
+    }[];
+    durable?: undefined;
+    hasEmbedding?: undefined;
+}>;
+export {};
+//# sourceMappingURL=managed-memory-worker.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/managed-memory-worker.js

@@ -0,0 +1,161 @@
+/** Fixed child entry. Native dependency loading must never move into the MCP parent. */
+import { existsSync, lstatSync, mkdirSync, realpathSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+const NAMESPACE = 'managed-workflow-evidence';
+const HASH = /^[a-f0-9]{64}$/;
+const UUID = /^[a-f0-9-]{36}$/;
+const TYPES = ['code-review', 'migration', 'research', 'test-generation', 'implementation', 'other'];
+function requestOf(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw) || Buffer.byteLength(JSON.stringify(raw)) > 80_000)
+        throw new Error('invalid-request');
+    const r = raw;
+    const keys = r.operation === 'index' ? ['v', 'requestId', 'operation', 'id', 'value', 'taskType'] : ['v', 'requestId', 'operation', 'taskType', 'allowedIds'];
+    if (r.v !== 1 || typeof r.requestId !== 'string' || !UUID.test(r.requestId) || !['index', 'recall'].includes(String(r.operation)) || Object.keys(r).length !== keys.length || Object.keys(r).some(k => !keys.includes(k)) || !TYPES.includes(String(r.taskType)))
+        throw new Error('invalid-request');
+    if (r.operation === 'index' && (typeof r.id !== 'string' || !HASH.test(r.id) || typeof r.value !== 'string' || Buffer.byteLength(r.value) > 8192))
+        throw new Error('invalid-request');
+    if (r.operation === 'recall' && (!Array.isArray(r.allowedIds) || r.allowedIds.length > 500 || r.allowedIds.some(id => typeof id !== 'string' || !HASH.test(id))))
+        throw new Error('invalid-request');
+    return r;
+}
+const validRow = (row, key) => !!row && row.key === key && row.namespace === NAMESPACE && typeof row.content === 'string' && Buffer.byteLength(row.content) <= 8192;
+/** Pure operation seam for host tests. Serialized callers cannot supply an adapter. */
+export async function executeManagedMemory(raw, adapter, dbPath, beforeWrite) {
+    const r = requestOf(raw);
+    if (r.operation === 'index') {
+        const existing = await adapter.getEntry({ key: r.id, namespace: NAMESPACE, dbPath });
+        if (!existing?.success)
+            throw new Error('backend-unavailable');
+        if (existing.found) {
+            if (!validRow(existing.entry, r.id) || existing.entry.content !== r.value)
+                throw new Error('conflicting-index');
+            return { v: 1, requestId: r.requestId, ok: true, operation: 'index', durable: true, hasEmbedding: existing.entry.hasEmbedding === true };
+        }
+        await beforeWrite?.();
+        const result = await adapter.storeEntry({ key: r.id, namespace: NAMESPACE, value: r.value, tags: ['managed-workflow', r.taskType], generateEmbeddingFlag: true, upsert: false, requireNative: true, appendOnly: true, dbPath, provenanceType: 'system_observation' });
+        if (!result?.success || result.persistWarning)
+            throw new Error('persistence-unconfirmed');
+        // Observe the exact durable row after the append. Neither success nor a
+        // signed local ledger alone establishes that the native row exists.
+        const stored = await adapter.getEntry({ key: r.id, namespace: NAMESPACE, dbPath });
+        if (!stored?.success || !stored.found || !validRow(stored.entry, r.id) || stored.entry.content !== r.value)
+            throw new Error('persistence-unconfirmed');
+        return { v: 1, requestId: r.requestId, ok: true, operation: 'index', durable: true, hasEmbedding: stored.entry.hasEmbedding === true };
+    }
+    const result = await adapter.searchEntries({ query: `managed workflow ${r.taskType}`, namespace: NAMESPACE, limit: 20, threshold: 0, dbPath });
+    if (!result?.success || !Array.isArray(result.results))
+        return { v: 1, requestId: r.requestId, ok: true, operation: 'recall', available: false, rows: [] };
+    const allowed = new Set(r.allowedIds), seen = new Set();
+    const rows = [];
+    for (const hit of result.results.slice(0, 20)) {
+        if (!hit || hit.namespace !== NAMESPACE || typeof hit.key !== 'string' || !HASH.test(hit.key) || !allowed.has(hit.key) || seen.has(hit.key) || !Number.isFinite(hit.score) || hit.score < -1 || hit.score > 1)
+            continue;
+        seen.add(hit.key);
+        const hydrated = await adapter.getEntry({ key: hit.key, namespace: NAMESPACE, dbPath });
+        if (hydrated?.success && hydrated.found && validRow(hydrated.entry, hit.key))
+            rows.push({ key: hit.key, namespace: NAMESPACE, score: hit.score, content: hydrated.entry.content });
+    }
+    return { v: 1, requestId: r.requestId, ok: true, operation: 'recall', available: true, rows };
+}
+function databasePath() {
+    const root = realpathSync(process.cwd()), dir = join(root, '.swarm');
+    if (!existsSync(dir))
+        mkdirSync(dir, { mode: 0o700 });
+    if (lstatSync(dir).isSymbolicLink() || !lstatSync(dir).isDirectory())
+        throw new Error('backend-unavailable');
+    const path = join(dir, 'memory.db');
+    if (existsSync(path) && (lstatSync(path).isSymbolicLink() || !lstatSync(path).isFile()))
+        throw new Error('backend-unavailable');
+    return path;
+}
+async function loadNative(dbPath) {
+    // Transformers.js does not consistently honor the Python offline env flags.
+    // Configure the exact module identity AgentDB loads, before registry init.
+    const require = createRequire(import.meta.url);
+    const memoryEntry = require.resolve('@claude-flow/memory');
+    const agentEntry = createRequire(memoryEntry).resolve('agentdb');
+    const owner = createRequire(agentEntry);
+    for (const name of ['@huggingface/transformers', '@xenova/transformers']) {
+        let path;
+        try {
+            path = owner.resolve(name);
+        }
+        catch {
+            continue;
+        }
+        const modulePath = pathToFileURL(path).href;
+        const model = await import(modulePath);
+        if (model.env)
+            model.env.allowRemoteModels = false;
+    }
+    const js = new URL('../memory/memory-bridge.js', import.meta.url);
+    const moduleUrl = existsSync(fileURLToPath(js)) ? js : new URL('../memory/memory-bridge.ts', import.meta.url);
+    // Deliberately nonliteral import: targeted boundary builds do not pull the
+    // optional native dependency graph into the parent compilation.
+    const modulePath = moduleUrl.href;
+    const bridge = await import(modulePath);
+    const registry = await bridge.getControllerRegistry(dbPath);
+    const agentdb = registry?.getAgentDB?.(), db = agentdb?.database;
+    if (!db || agentdb.isWasm === true || typeof db.inTransaction !== 'boolean' || typeof db.transaction !== 'function' || db.memory !== false || typeof db.name !== 'string' || resolve(db.name) !== resolve(dbPath))
+        throw new Error('backend-unavailable');
+    return { getEntry: bridge.bridgeGetEntry, searchEntries: bridge.bridgeSearchEntries, storeEntry: bridge.bridgeStoreEntry };
+}
+if (typeof process.send === 'function' && process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    let busy = false;
+    let idle;
+    let adapter;
+    let pendingGrant;
+    const ask = (id, phase) => new Promise(resolve => {
+        pendingGrant = { id, grant: phase === 'ready' ? 'execute' : 'write', resolve };
+        process.send?.({ v: 1, requestId: id, phase });
+    });
+    process.once('disconnect', () => process.exit(0));
+    process.on('message', async (value) => {
+        if (value && typeof value === 'object' && 'grant' in value) {
+            const message = value;
+            if (Object.keys(message).length === 3 && message.v === 1 && message.requestId === pendingGrant?.id && message.grant === pendingGrant?.grant) {
+                const grant = pendingGrant;
+                pendingGrant = undefined;
+                grant?.resolve();
+            }
+            return;
+        }
+        if (idle)
+            clearTimeout(idle);
+        let request;
+        try {
+            request = requestOf(value);
+        }
+        catch {
+            process.send?.({ v: 1, ok: false, error: 'invalid-request' });
+            return;
+        }
+        if (busy) {
+            process.send?.({ v: 1, requestId: request.requestId, ok: false, error: 'worker-busy' });
+            return;
+        }
+        busy = true;
+        try {
+            const path = databasePath();
+            adapter ??= loadNative(path);
+            const native = await adapter;
+            await ask(request.requestId, 'ready');
+            const result = await executeManagedMemory(request, native, path, () => ask(request.requestId, 'before-write'));
+            if (Buffer.byteLength(JSON.stringify(result)) > 200_000)
+                throw new Error('result-limit');
+            process.send?.(result);
+        }
+        catch {
+            // Upstream errors may carry prompts, SQL, paths or credentials.
+            process.send?.({ v: 1, requestId: request.requestId, ok: false, error: 'native-operation-unavailable' });
+        }
+        finally {
+            busy = false;
+            idle = setTimeout(() => process.exit(0), 5000);
+        }
+    });
+}
+//# sourceMappingURL=managed-memory-worker.js.map

package/v3/@claude-flow/cli/dist/src/services/managed-run-collector.d.ts

@@ -0,0 +1,93 @@
+import { type ManagedEvent } from './managed-workflows.js';
+export type ManagedSessionFacts = {
+    status?: string;
+    budget?: {
+        max_list_cost?: {
+            amount?: string;
+            currency?: string;
+        };
+    };
+    usage?: {
+        list_cost?: {
+            amount?: string;
+            currency?: string;
+        };
+    };
+};
+export type ManagedCollectorTransport = {
+    readEvents: (since?: string) => Promise<ManagedEvent[]>;
+    readSession: () => Promise<ManagedSessionFacts>;
+};
+type Phase = {
+    id: string;
+    name: string;
+    status: string;
+};
+type Thread = {
+    id: string;
+    runId: string | null;
+    status: string;
+    phaseId?: string;
+};
+export type ManagedRunSnapshot = {
+    sessionId: string;
+    status: string;
+    stopReason: string | null;
+    budgetCents: number | null;
+    listCostCents: number | null;
+    providerFinished: boolean;
+    workersInspected: false;
+    acceptancePassed: false;
+    verification: 'unverified';
+    runs: Array<{
+        id: string;
+        status: string;
+        result?: string;
+        phases: Phase[];
+    }>;
+    threads: Thread[];
+    threadOffset: number;
+    threadCount: number;
+    threadCounts: {
+        running: number;
+        ended: number;
+        failed: number;
+        idle: number;
+    };
+    blockedEventIds: string[];
+    observedFailures: number;
+    updatedMs: number;
+};
+export type ManagedCollection = {
+    events: ManagedEvent[];
+    snapshot: ManagedRunSnapshot;
+};
+export declare const COLLECTOR_LIMITS: {
+    readonly sessions: 6;
+    readonly events: 10000;
+    readonly bytes: 16000000;
+    readonly shownThreads: 60;
+    readonly staleMs: 300000;
+};
+/** This cache is an observation aid. Cached facts never authorize an action. */
+export declare class ManagedRunCollector {
+    private readonly states;
+    private readonly now;
+    private readonly ttlMs;
+    constructor(options?: {
+        now?: () => number;
+        ttlMs?: number;
+    });
+    /** Singleflight includes event and session reads; a failed refresh is never cached as success. */
+    refresh(sessionId: string, transport: ManagedCollectorTransport): Promise<ManagedCollection>;
+    /** Pure observation, suitable for disk snapshot publication. Never invokes a transport. */
+    snapshots(): ManagedRunSnapshot[];
+    /** A local worker page only. Aggregate counts and observation timestamp do not change. */
+    page(sessionId: string, threadOffset?: number): ManagedRunSnapshot | undefined;
+    /** A collector doing work cannot be forgotten midflight. No remote work is interrupted. */
+    forget(sessionId: string): boolean;
+    private observe;
+}
+export declare const sharedManagedCollector: ManagedRunCollector;
+export {};
+//# sourceMappingURL=managed-run-collector.d.ts.map