monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/monovector/index.d.ts

@@ -1,54 +0,0 @@
-/**
- * MonoVector Integration Module for Monomind CLI (lean)
- *
- * After the SONA / native / WASM teardown this module provides:
- * - Initialization state: createInitState()
- * - Keyword-based task routing: createKeywordRouter()
- * - Route recommendation→outcome records: recordRoute(), joinOutcome(), accuracy
- * - AST diff classification: DiffClassifier
- *
- * @module @monomind/cli/monovector
- */
-export { createInitState, type InitState, type InitStatus } from './init-state.js';
-export { recordRoute, joinOutcome, joinLatestUnresolved, readOutcomes, computeRoutingAccuracy, computeAdherence, type RouteOutcomeRecord, type RoutingAccuracy, } from './route-outcomes.js';
-export { DiffClassifier, createDiffClassifier, analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, clearDiffCache, clearAllDiffCaches, type DiffClassification, type DiffHunk, type DiffChange, type FileDiff, type DiffAnalysis, type DiffClassifierConfig, type DiffFile, type RiskLevel, type FileRisk, type OverallRisk, type DiffAnalysisResult, } from './diff-classifier.js';
-/** A single alternative route suggestion. */
-export interface RouteAlternative {
-    route: string;
-    score?: number;
-}
-/** Statistics surfaced by the keyword router (stub fields for CLI display). */
-export interface KeywordRouterStats {
-    updateCount: number;
-    qTableSize: number;
-    stepCount: number;
-    epsilon: number;
-    avgTDError: number;
-    useNative: number;
-    [key: string]: unknown;
-}
-export interface KeywordRouter {
-    route: (task: string, useExploration?: boolean) => Promise<RouteDecision>;
-    initialize: () => Promise<void>;
-    getStats: () => KeywordRouterStats;
-    /** Record feedback; returns the TD-error (0 in the lean keyword stub). */
-    update: (task: string, agentId: string, reward: number, nextTask?: string) => number;
-    reset: () => void;
-    export: () => unknown;
-    import: (data: unknown) => void;
-}
-export interface RouteDecision {
-    agentType: string;
-    confidence: number;
-    reasoning?: string;
-    route: string;
-    qValues?: number[];
-    explored?: boolean;
-    alternatives?: RouteAlternative[];
-}
-export interface KeywordRouterConfig {
-    learningRate?: number;
-    discountFactor?: number;
-}
-export declare function createKeywordRouter(_config?: KeywordRouterConfig): KeywordRouter;
-//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/monovector/index.js

@@ -1,55 +0,0 @@
-/**
- * MonoVector Integration Module for Monomind CLI (lean)
- *
- * After the SONA / native / WASM teardown this module provides:
- * - Initialization state: createInitState()
- * - Keyword-based task routing: createKeywordRouter()
- * - Route recommendation→outcome records: recordRoute(), joinOutcome(), accuracy
- * - AST diff classification: DiffClassifier
- *
- * @module @monomind/cli/monovector
- */
-export { createInitState } from './init-state.js';
-export { recordRoute, joinOutcome, joinLatestUnresolved, readOutcomes, computeRoutingAccuracy, computeAdherence, } from './route-outcomes.js';
-export { DiffClassifier, createDiffClassifier, analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, clearDiffCache, clearAllDiffCaches, } from './diff-classifier.js';
-export function createKeywordRouter(_config) {
-    const agentTypes = ['coder', 'tester', 'reviewer', 'architect', 'researcher', 'optimizer', 'debugger', 'documenter'];
-    return {
-        async route(task) {
-            const lower = task.toLowerCase();
-            let agentType = 'coder';
-            if (lower.includes('test'))
-                agentType = 'tester';
-            else if (lower.includes('review') || lower.includes('security'))
-                agentType = 'reviewer';
-            else if (lower.includes('design') || lower.includes('architect'))
-                agentType = 'architect';
-            else if (lower.includes('research') || lower.includes('analyz'))
-                agentType = 'researcher';
-            else if (lower.includes('optim') || lower.includes('perform'))
-                agentType = 'optimizer';
-            else if (lower.includes('debug') || lower.includes('fix') || lower.includes('bug'))
-                agentType = 'debugger';
-            else if (lower.includes('doc'))
-                agentType = 'documenter';
-            return {
-                agentType,
-                confidence: 0.75,
-                reasoning: 'keyword-based routing',
-                route: agentType,
-                qValues: [],
-                explored: false,
-                alternatives: agentTypes.filter(a => a !== agentType).slice(0, 3).map(a => ({ route: a, score: 0 })),
-            };
-        },
-        async initialize() { },
-        getStats() {
-            return { updateCount: 0, qTableSize: 0, stepCount: 0, epsilon: 0, avgTDError: 0, useNative: 0 };
-        },
-        update() { return 0; },
-        reset() { },
-        export() { return {}; },
-        import() { },
-    };
-}
-//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/monovector/init-state.d.ts

@@ -1,35 +0,0 @@
-/**
- * Reusable init-state tracker with a counter-with-max pattern.
- *
- * - Allows transient failures (returns NOT_READY) without permanently disabling
- * - Permanently disables after maxAttempts consecutive failures
- * - Thread-safe for single-threaded JS (no concurrent writes)
- *
- * Usage:
- *   const state = createInitState({ maxAttempts: 3 });
- *   if (state.canTry()) {
- *     try { ... state.markReady(); }
- *     catch { state.markFailed(); }
- *   }
- */
-export type InitStatus = 'pending' | 'ready' | 'failed';
-export interface InitState {
-    /** True if another init attempt should be made */
-    canTry(): boolean;
-    /** Mark initialization as permanently successful */
-    markReady(): void;
-    /** Mark this attempt as failed; permanently fails after maxAttempts */
-    markFailed(): void;
-    /** Immediately mark as permanently failed without consuming retry budget */
-    markPermanentlyFailed(): void;
-    /** True if init succeeded */
-    isReady(): boolean;
-    /** True if permanently failed (exhausted retries) */
-    isFailed(): boolean;
-    /** Number of failed attempts so far */
-    attempts(): number;
-}
-export declare function createInitState(opts?: {
-    maxAttempts?: number;
-}): InitState;
-//# sourceMappingURL=init-state.d.ts.map

package/packages/@monomind/cli/dist/src/monovector/init-state.js

@@ -1,36 +0,0 @@
-/**
- * Reusable init-state tracker with a counter-with-max pattern.
- *
- * - Allows transient failures (returns NOT_READY) without permanently disabling
- * - Permanently disables after maxAttempts consecutive failures
- * - Thread-safe for single-threaded JS (no concurrent writes)
- *
- * Usage:
- *   const state = createInitState({ maxAttempts: 3 });
- *   if (state.canTry()) {
- *     try { ... state.markReady(); }
- *     catch { state.markFailed(); }
- *   }
- */
-export function createInitState(opts = {}) {
-    const max = opts.maxAttempts ?? 3;
-    let status = 'pending';
-    let count = 0;
-    return {
-        canTry() { return status === 'pending' && count < max; },
-        markReady() { status = 'ready'; },
-        markFailed() {
-            count++;
-            if (count >= max)
-                status = 'failed';
-        },
-        markPermanentlyFailed() {
-            count = max;
-            status = 'failed';
-        },
-        isReady() { return status === 'ready'; },
-        isFailed() { return status === 'failed'; },
-        attempts() { return count; },
-    };
-}
-//# sourceMappingURL=init-state.js.map

package/packages/@monomind/cli/dist/src/monovector/route-outcomes.d.ts

@@ -1,56 +0,0 @@
-export interface RouteOutcomeRecord {
-    routeId: string;
-    ts: number;
-    task: string;
-    recommendedAgent: string;
-    routingMethod: string;
-    confidence: number;
-    learningMode: 'native' | 'js';
-    agentActuallyUsed?: string;
-    measuredSuccess?: boolean;
-    quality?: number;
-}
-/** Append a route recommendation (pre-outcome). Opportunistically trims the
- *  file to MAX_ROUTE_RECORDS lines to prevent unbounded growth. */
-export declare function recordRoute(baseDir: string, rec: RouteOutcomeRecord): Promise<void>;
-/** Join outcome data onto the most recent matching route record by routeId. */
-export declare function joinOutcome(baseDir: string, routeId: string, outcome: {
-    agentActuallyUsed?: string;
-    measuredSuccess?: boolean;
-    quality?: number;
-}): Promise<void>;
-/**
- * Join an outcome to the most recent route record that has no measured outcome yet.
- * Used when the caller does not thread an explicit routeId — auto-correlates the
- * latest recommendation to the next task completion. Returns the joined routeId or null.
- */
-export declare function joinLatestUnresolved(baseDir: string, outcome: {
-    agentActuallyUsed?: string;
-    measuredSuccess?: boolean;
-    quality?: number;
-}, maxAgeMs?: number): Promise<string | null>;
-/** Read all outcome records (for metrics). */
-export declare function readOutcomes(baseDir: string): Promise<RouteOutcomeRecord[]>;
-export interface RoutingAccuracy {
-    window: number;
-    totalWithOutcome: number;
-    accuracy: number | null;
-    byMode: {
-        native: number | null;
-        js: number | null;
-    };
-    recentVsPrior: number | null;
-}
-/**
- * Compute routing accuracy over the most recent N records that have a joined outcome.
- * accuracy = fraction of records whose joined outcome reports measuredSuccess === true.
- * (agentActuallyUsed is recorded per row but not required to match the recommendation;
- * the success label already reflects whether the chosen routing worked out.)
- */
-export declare function computeRoutingAccuracy(baseDir: string, window?: number): Promise<RoutingAccuracy>;
-/** Fraction of joined routes where the agent actually used matched the recommendation. */
-export declare function computeAdherence(baseDir: string, window?: number): Promise<{
-    adherence: number | null;
-    sample: number;
-}>;
-//# sourceMappingURL=route-outcomes.d.ts.map

package/packages/@monomind/cli/dist/src/monovector/route-outcomes.js

@@ -1,189 +0,0 @@
-/**
- * Per-route outcome records — the join between a routing recommendation and
- * what actually happened. This is the foundation for routing-accuracy metrics
- * and for giving SONA a real training label.
- */
-import { promises as fs, statSync } from 'node:fs';
-import { join } from 'node:path';
-/** Refuse to read files larger than this to prevent OOM. */
-const MAX_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
-/** Cap string fields stored in each record to prevent file bloat. */
-const MAX_FIELD_LEN = 500;
-function storePath(baseDir) {
-    return join(baseDir, 'route-outcomes.jsonl');
-}
-/** Maximum number of records to keep in route-outcomes.jsonl.
- *  computeRoutingAccuracy only ever reads the last 100 records, so anything
- *  older is dead weight. Keeping 500 gives a comfortable buffer while bounding
- *  the file size and keeping joinOutcome's full-file rewrite cheap. */
-const MAX_ROUTE_RECORDS = 500;
-/** Conservative estimate of bytes per record (capped fields + JSON overhead).
- *  Used to gate whether a stat-only check can rule out a trim pass.
- *  Actual records are ~200-400 bytes; 600 gives a 2× safety margin so we
- *  never skip a needed trim, only unnecessary reads. */
-const APPROX_BYTES_PER_RECORD = 600;
-/** Append a route recommendation (pre-outcome). Opportunistically trims the
- *  file to MAX_ROUTE_RECORDS lines to prevent unbounded growth. */
-export async function recordRoute(baseDir, rec) {
-    try {
-        await fs.mkdir(baseDir, { recursive: true });
-        const path = storePath(baseDir);
-        // Cap string fields to prevent individual records from bloating the file.
-        const safeRec = {
-            ...rec,
-            routeId: rec.routeId.slice(0, MAX_FIELD_LEN),
-            task: rec.task.slice(0, MAX_FIELD_LEN),
-            recommendedAgent: rec.recommendedAgent.slice(0, MAX_FIELD_LEN),
-            routingMethod: rec.routingMethod.slice(0, 64),
-        };
-        await fs.appendFile(path, JSON.stringify(safeRec) + '\n', 'utf8');
-        // Opportunistic trim: only read the file when it is large enough to
-        // plausibly contain more than MAX_ROUTE_RECORDS lines.  The stat() call
-        // is cheap (metadata-only); skipping the full read on the common path
-        // avoids O(file-size) I/O on every routing call.
-        const fileStat = await fs.stat(path).catch(() => null);
-        if (fileStat && fileStat.size > MAX_ROUTE_RECORDS * APPROX_BYTES_PER_RECORD) {
-            const content = await fs.readFile(path, 'utf8').catch(() => '');
-            const lines = content.trim().split('\n').filter(Boolean);
-            if (lines.length > MAX_ROUTE_RECORDS) {
-                await fs.writeFile(path, lines.slice(-MAX_ROUTE_RECORDS).join('\n') + '\n', 'utf8');
-            }
-        }
-    }
-    catch {
-        // Non-fatal — telemetry must never break routing
-    }
-}
-/** Join outcome data onto the most recent matching route record by routeId. */
-export async function joinOutcome(baseDir, routeId, outcome) {
-    try {
-        const path = storePath(baseDir);
-        try {
-            if (statSync(path).size > MAX_FILE_BYTES)
-                return;
-        }
-        catch { /* file absent */ }
-        const content = await fs.readFile(path, 'utf8').catch(() => '');
-        if (!content)
-            return;
-        const lines = content.trim().split('\n');
-        // Find the last record with this routeId and merge outcome
-        for (let i = lines.length - 1; i >= 0; i--) {
-            try {
-                const rec = JSON.parse(lines[i]);
-                if (rec.routeId === routeId) {
-                    lines[i] = JSON.stringify({ ...rec, ...outcome });
-                    break;
-                }
-            }
-            catch { /* skip malformed line */ }
-        }
-        await fs.writeFile(path, lines.join('\n') + '\n', 'utf8');
-    }
-    catch {
-        // Non-fatal
-    }
-}
-/**
- * Join an outcome to the most recent route record that has no measured outcome yet.
- * Used when the caller does not thread an explicit routeId — auto-correlates the
- * latest recommendation to the next task completion. Returns the joined routeId or null.
- */
-export async function joinLatestUnresolved(baseDir, outcome, maxAgeMs = 600_000 // only correlate within 10 minutes to avoid stale joins
-) {
-    try {
-        const path = storePath(baseDir);
-        try {
-            if (statSync(path).size > MAX_FILE_BYTES)
-                return null;
-        }
-        catch { /* file absent */ }
-        const content = await fs.readFile(path, 'utf8').catch(() => '');
-        if (!content)
-            return null;
-        const lines = content.trim().split('\n');
-        const now = Date.now();
-        for (let i = lines.length - 1; i >= 0; i--) {
-            try {
-                const rec = JSON.parse(lines[i]);
-                // Skip already-joined records
-                if (typeof rec.measuredSuccess === 'boolean')
-                    continue;
-                // Skip stale records beyond the correlation window
-                if (now - rec.ts > maxAgeMs)
-                    return null;
-                lines[i] = JSON.stringify({ ...rec, ...outcome });
-                await fs.writeFile(path, lines.join('\n') + '\n', 'utf8');
-                return rec.routeId;
-            }
-            catch { /* skip malformed */ }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Read all outcome records (for metrics). */
-export async function readOutcomes(baseDir) {
-    try {
-        const p = storePath(baseDir);
-        try {
-            if (statSync(p).size > MAX_FILE_BYTES)
-                return [];
-        }
-        catch { /* file absent */ }
-        const content = await fs.readFile(p, 'utf8').catch(() => '');
-        if (!content)
-            return [];
-        return content.trim().split('\n').map(l => {
-            try {
-                return JSON.parse(l);
-            }
-            catch {
-                return null;
-            }
-        }).filter((r) => r !== null);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Compute routing accuracy over the most recent N records that have a joined outcome.
- * accuracy = fraction of records whose joined outcome reports measuredSuccess === true.
- * (agentActuallyUsed is recorded per row but not required to match the recommendation;
- * the success label already reflects whether the chosen routing worked out.)
- */
-export async function computeRoutingAccuracy(baseDir, window = 100) {
-    const all = await readOutcomes(baseDir);
-    // Only records with a measured outcome count
-    const withOutcome = all.filter(r => typeof r.measuredSuccess === 'boolean').slice(-window);
-    const n = withOutcome.length;
-    if (n === 0) {
-        return { window, totalWithOutcome: 0, accuracy: null, byMode: { native: null, js: null }, recentVsPrior: null };
-    }
-    const succ = (recs) => recs.length ? recs.filter(r => r.measuredSuccess).length / recs.length : null;
-    const native = withOutcome.filter(r => r.learningMode === 'native');
-    const js = withOutcome.filter(r => r.learningMode === 'js');
-    const mid = Math.floor(n / 2);
-    const prior = succ(withOutcome.slice(0, mid));
-    const recent = succ(withOutcome.slice(mid));
-    return {
-        window,
-        totalWithOutcome: n,
-        accuracy: succ(withOutcome),
-        byMode: { native: succ(native), js: succ(js) },
-        recentVsPrior: (recent !== null && prior !== null) ? recent - prior : null,
-    };
-}
-/** Fraction of joined routes where the agent actually used matched the recommendation. */
-export async function computeAdherence(baseDir, window = 100) {
-    const all = await readOutcomes(baseDir);
-    const joined = all.filter(r => r.agentActuallyUsed && r.recommendedAgent).slice(-window);
-    if (joined.length === 0)
-        return { adherence: null, sample: 0 };
-    const matches = joined.filter(r => r.agentActuallyUsed === r.recommendedAgent).length;
-    return { adherence: matches / joined.length, sample: joined.length };
-}
-//# sourceMappingURL=route-outcomes.js.map

package/packages/@monomind/cli/dist/src/observability/replay-reader.d.ts

@@ -1,40 +0,0 @@
-/**
- * ReplayReader
- *
- * Reads session files from .monomind/sessions/ for replay and listing.
- * Session files follow the pattern session-{id}.json. current.json is a
- * regular file (not a symlink) pointing to the active session data.
- */
-export interface SessionSummary {
-    id: string;
-    startedAt: string;
-    endedAt?: string;
-    tokenUsage?: {
-        total?: number;
-    };
-    taskCount?: number;
-    filePath: string;
-}
-export interface SessionReplay extends SessionSummary {
-    raw: Record<string, unknown>;
-}
-export declare class ReplayReader {
-    private sessionsDir;
-    constructor(cwd?: string);
-    /**
-     * Find and return the session data for a given session ID.
-     * The ID may be a bare ID (e.g. "session-1234567890") or a timestamp number.
-     * Falls back to current.json if the id matches the current session.
-     */
-    show(sessionId: string): Promise<SessionReplay | null>;
-    /**
-     * List sessions ordered by startedAt descending (most recent first).
-     * current.json is excluded — only persisted session-*.json files are listed.
-     */
-    list(limit?: number): Promise<SessionSummary[]>;
-    private parseReplay;
-    private parseSummary;
-    private buildSummary;
-    private readJson;
-}
-//# sourceMappingURL=replay-reader.d.ts.map

package/packages/@monomind/cli/dist/src/observability/replay-reader.js

@@ -1,138 +0,0 @@
-/**
- * ReplayReader
- *
- * Reads session files from .monomind/sessions/ for replay and listing.
- * Session files follow the pattern session-{id}.json. current.json is a
- * regular file (not a symlink) pointing to the active session data.
- */
-import { readdirSync, readFileSync, existsSync, statSync } from 'fs';
-import { join, sep, resolve } from 'path';
-export class ReplayReader {
-    sessionsDir;
-    constructor(cwd = process.cwd()) {
-        this.sessionsDir = join(cwd, '.monomind', 'sessions');
-    }
-    /**
-     * Find and return the session data for a given session ID.
-     * The ID may be a bare ID (e.g. "session-1234567890") or a timestamp number.
-     * Falls back to current.json if the id matches the current session.
-     */
-    async show(sessionId) {
-        if (!existsSync(this.sessionsDir)) {
-            return null;
-        }
-        // Normalize: allow bare numeric IDs or full "session-<id>" form
-        const normalized = sessionId.startsWith('session-')
-            ? sessionId
-            : `session-${sessionId}`;
-        // Guard against path traversal (e.g. sessionId = "../../../etc/passwd")
-        const filePath = join(this.sessionsDir, `${normalized}.json`);
-        if (!resolve(filePath).startsWith(resolve(this.sessionsDir) + sep))
-            return null;
-        if (existsSync(filePath)) {
-            return this.parseReplay(filePath);
-        }
-        // Fall back to current.json if the id matches
-        const currentPath = join(this.sessionsDir, 'current.json');
-        if (existsSync(currentPath)) {
-            const current = this.parseReplay(currentPath);
-            if (current && (current.id === sessionId || current.id === normalized)) {
-                return current;
-            }
-        }
-        return null;
-    }
-    /**
-     * List sessions ordered by startedAt descending (most recent first).
-     * current.json is excluded — only persisted session-*.json files are listed.
-     */
-    async list(limit = 20) {
-        if (!existsSync(this.sessionsDir)) {
-            return [];
-        }
-        let entries;
-        try {
-            entries = readdirSync(this.sessionsDir);
-        }
-        catch {
-            return [];
-        }
-        const summaries = [];
-        for (const entry of entries) {
-            if (!entry.startsWith('session-') || !entry.endsWith('.json')) {
-                continue;
-            }
-            const filePath = join(this.sessionsDir, entry);
-            const summary = this.parseSummary(filePath);
-            if (summary) {
-                summaries.push(summary);
-            }
-        }
-        // Sort by startedAt descending; push invalid dates to the end
-        summaries.sort((a, b) => {
-            const ta = new Date(a.startedAt).getTime();
-            const tb = new Date(b.startedAt).getTime();
-            if (isNaN(ta) && isNaN(tb))
-                return 0;
-            if (isNaN(ta))
-                return 1;
-            if (isNaN(tb))
-                return -1;
-            return tb - ta;
-        });
-        return summaries.slice(0, limit);
-    }
-    // ── private helpers ──────────────────────────────────────────────────────────
-    parseReplay(filePath) {
-        const raw = this.readJson(filePath);
-        if (!raw)
-            return null;
-        const summary = this.buildSummary(raw, filePath);
-        if (!summary)
-            return null;
-        return { ...summary, raw };
-    }
-    parseSummary(filePath) {
-        const raw = this.readJson(filePath);
-        if (!raw)
-            return null;
-        return this.buildSummary(raw, filePath);
-    }
-    buildSummary(raw, filePath) {
-        const id = typeof raw.id === 'string' ? raw.id : null;
-        const startedAt = typeof raw.startedAt === 'string' ? raw.startedAt : null;
-        if (!id || !startedAt)
-            return null;
-        const endedAt = typeof raw.endedAt === 'string' ? raw.endedAt : undefined;
-        // tokenUsage is not present in current session files but kept optional per interface
-        const tokenUsage = raw.tokenUsage && typeof raw.tokenUsage === 'object'
-            ? raw.tokenUsage
-            : undefined;
-        // taskCount comes from metrics.tasks
-        const metrics = raw.metrics && typeof raw.metrics === 'object'
-            ? raw.metrics
-            : undefined;
-        const taskCount = metrics && typeof metrics.tasks === 'number' ? metrics.tasks : undefined;
-        return { id, startedAt, endedAt, tokenUsage, taskCount, filePath };
-    }
-    readJson(filePath) {
-        try {
-            // Hard size cap. Without this, a single planted multi-GB session-*.json
-            // (or a runaway log) crashes the CLI with allocation failure when
-            // any code path touches `list()` or `show()`.
-            const stat = statSync(filePath);
-            if (stat.size > 25 * 1024 * 1024)
-                return null;
-            const content = readFileSync(filePath, 'utf-8');
-            const parsed = JSON.parse(content);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                return parsed;
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-}
-//# sourceMappingURL=replay-reader.js.map

package/packages/@monomind/cli/dist/src/orgrt/broker.d.ts

@@ -1,26 +0,0 @@
-export interface BrokerEntry {
-    url: string;
-    pid: number;
-    updatedAt: number;
-}
-export declare function defaultRegistryDir(): string;
-/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease.
- *  Writes via tmp+rename (same-directory rename is atomic on POSIX/NTFS) so a concurrent lookupOrg() never observes a
- *  partially-written entry — this file is rewritten every heartbeat (default 20s) while other processes may read it. */
-export declare function registerOrg(name: string, url: string, dir?: string): void;
-/** Remove this process's registration for `name` (best effort). */
-export declare function unregisterOrg(name: string, dir?: string): void;
-/** Find which process (if any) currently hosts org `name`. Null if never registered or the registration is stale (owner crashed without cleanup). */
-export declare function lookupOrg(name: string, dir?: string, staleMs?: number): BrokerEntry | null;
-/** Keeps a broker registration alive with periodic heartbeats until stop() is called. */
-export declare class BrokerLease {
-    private name;
-    private url;
-    private dir;
-    private intervalMs;
-    private timer;
-    constructor(name: string, url: string, dir?: string, intervalMs?: number);
-    start(): void;
-    stop(): void;
-}
-//# sourceMappingURL=broker.d.ts.map