@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/desktop-automation/omniparser-runner.d.ts

@@ -0,0 +1,63 @@
+export interface OmniParserElement {
+    /** Index in the server's parsed_content_list — this is the number drawn on the annotated (SOM) image. */
+    id: number;
+    /** 'text' | 'icon' (whatever the server reports). */
+    type: string;
+    /** OCR text or icon caption (the server's `content`). */
+    content: string;
+    /** Whether OmniParser flagged the element as interactive/clickable (`interactivity`). */
+    interactable: boolean;
+    /** Bounding box [x1, y1, x2, y2]. Pixels when `normalized` is false, else 0-1 ratios. */
+    bbox: [number, number, number, number];
+    /** Box center [x, y] — pixels when `normalized` is false. Handy for a follow-up click. */
+    center: [number, number];
+    /** True when bbox/center are 0-1 ratios (image dimensions were unknown). */
+    normalized: boolean;
+}
+export interface OmniParserResult {
+    elements: OmniParserElement[];
+    /** Base64 of the Set-of-Marks (numbered) image returned by the server, or the original on failure. */
+    annotatedImageBase64: string;
+}
+export interface ParseScreenOptions {
+    /** Screenshot pixel width — when provided, normalized boxes are scaled to pixels. */
+    width?: number;
+    /** Screenshot pixel height. */
+    height?: number;
+}
+/**
+ * Runner for OmniParser (Microsoft's screen-parsing model — github.com/microsoft/OmniParser).
+ *
+ * Talks to the OmniParser v2 `omniparserserver` FastAPI service (omnitool/omniparserserver):
+ *   - POST {base}/parse/  body {"base64_image": "<b64>"}
+ *       -> {"som_image_base64": "<b64>", "parsed_content_list": [{type, content, interactivity, bbox}], "latency"}
+ *   - GET  {base}/probe/  -> health check
+ *
+ * `bbox` from the server is normalized to 0-1; we scale it to pixels when the
+ * screenshot dimensions are known so the coordinates are directly clickable.
+ *
+ * The model is GPU/Python and must be self-hosted; configure the base URL via
+ * OMNIPARSER_API_URL (default http://localhost:8000). Off-server, every call
+ * degrades gracefully to empty elements + the original screenshot.
+ */
+export declare class OmniParserRunner {
+    private baseUrl;
+    private apiKey;
+    constructor();
+    private get parseUrl();
+    private get probeUrl();
+    /**
+     * Send a base64-encoded screenshot to the OmniParser server for analysis.
+     *
+     * @param imageBase64 The raw screenshot in base64 (no data: prefix).
+     * @param opts Optional screenshot pixel dimensions used to scale normalized boxes.
+     * @returns Parsed elements and the annotated (Set-of-Marks) image.
+     */
+    parseScreen(imageBase64: string, opts?: ParseScreenOptions): Promise<OmniParserResult>;
+    /** Map OmniParser's parsed_content_list into our element shape, scaling boxes to pixels when possible. */
+    private mapElements;
+    /**
+     * Check if the OmniParser server is reachable via its /probe/ health endpoint.
+     */
+    isAvailable(): Promise<boolean>;
+}

package/dist/desktop-automation/omniparser-runner.js

@@ -0,0 +1,115 @@
+import { logger } from '../utils/logger.js';
+/**
+ * Runner for OmniParser (Microsoft's screen-parsing model — github.com/microsoft/OmniParser).
+ *
+ * Talks to the OmniParser v2 `omniparserserver` FastAPI service (omnitool/omniparserserver):
+ *   - POST {base}/parse/  body {"base64_image": "<b64>"}
+ *       -> {"som_image_base64": "<b64>", "parsed_content_list": [{type, content, interactivity, bbox}], "latency"}
+ *   - GET  {base}/probe/  -> health check
+ *
+ * `bbox` from the server is normalized to 0-1; we scale it to pixels when the
+ * screenshot dimensions are known so the coordinates are directly clickable.
+ *
+ * The model is GPU/Python and must be self-hosted; configure the base URL via
+ * OMNIPARSER_API_URL (default http://localhost:8000). Off-server, every call
+ * degrades gracefully to empty elements + the original screenshot.
+ */
+export class OmniParserRunner {
+    baseUrl;
+    apiKey;
+    constructor() {
+        // OMNIPARSER_API_URL is the server base (scheme://host:port); endpoints are derived.
+        const raw = process.env.OMNIPARSER_API_URL || 'http://localhost:8000';
+        this.baseUrl = raw.replace(/\/+$/, '');
+        this.apiKey = process.env.OMNIPARSER_API_KEY;
+    }
+    get parseUrl() {
+        return `${this.baseUrl}/parse/`;
+    }
+    get probeUrl() {
+        return `${this.baseUrl}/probe/`;
+    }
+    /**
+     * Send a base64-encoded screenshot to the OmniParser server for analysis.
+     *
+     * @param imageBase64 The raw screenshot in base64 (no data: prefix).
+     * @param opts Optional screenshot pixel dimensions used to scale normalized boxes.
+     * @returns Parsed elements and the annotated (Set-of-Marks) image.
+     */
+    async parseScreen(imageBase64, opts = {}) {
+        try {
+            logger.debug('Sending screenshot to OmniParser API', { url: this.parseUrl });
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (this.apiKey) {
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(this.parseUrl, {
+                method: 'POST',
+                headers,
+                // OmniParser v2 ParseRequest expects the field `base64_image`.
+                body: JSON.stringify({ base64_image: imageBase64 }),
+            });
+            if (!response.ok) {
+                throw new Error(`OmniParser API returned status: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            const elements = this.mapElements(data.parsed_content_list ?? [], opts);
+            return {
+                elements,
+                annotatedImageBase64: data.som_image_base64 || imageBase64,
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.error('OmniParser API call failed', { error: msg, url: this.parseUrl });
+            // Graceful fallback if the server is down/misconfigured: original image, no elements.
+            return {
+                elements: [],
+                annotatedImageBase64: imageBase64,
+            };
+        }
+    }
+    /** Map OmniParser's parsed_content_list into our element shape, scaling boxes to pixels when possible. */
+    mapElements(raw, opts) {
+        const { width, height } = opts;
+        const scalable = typeof width === 'number' && width > 0 && typeof height === 'number' && height > 0;
+        return raw.map((item, index) => {
+            const b = Array.isArray(item.bbox) && item.bbox.length === 4 ? item.bbox : [0, 0, 0, 0];
+            let [x1, y1, x2, y2] = [Number(b[0]) || 0, Number(b[1]) || 0, Number(b[2]) || 0, Number(b[3]) || 0];
+            if (scalable) {
+                x1 = Math.round(x1 * width);
+                y1 = Math.round(y1 * height);
+                x2 = Math.round(x2 * width);
+                y2 = Math.round(y2 * height);
+            }
+            return {
+                id: index,
+                type: item.type ?? 'unknown',
+                content: item.content ?? '',
+                interactable: item.interactivity ?? false,
+                bbox: [x1, y1, x2, y2],
+                center: [Math.round((x1 + x2) / 2), Math.round((y1 + y2) / 2)],
+                normalized: !scalable,
+            };
+        });
+    }
+    /**
+     * Check if the OmniParser server is reachable via its /probe/ health endpoint.
+     */
+    async isAvailable() {
+        try {
+            const headers = {};
+            if (this.apiKey) {
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(this.probeUrl, { method: 'GET', headers });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=omniparser-runner.js.map

package/dist/desktop-automation/smart-snapshot.d.ts

@@ -132,6 +132,8 @@ export declare class SmartSnapshotManager extends EventEmitter {
     private snapshotCache;
     private static readonly MAX_CACHE_SIZE;
     private nextRef;
+    /** Cached python interpreter that has the Atspi GI binding (`''` = none found, `null` = not yet probed). */
+    private atspiPython;
     constructor(config?: Partial<SmartSnapshotConfig>);
     private runPowerShellEncoded;
     /**
@@ -206,6 +208,15 @@ export declare class SmartSnapshotManager extends EventEmitter {
      * Detect elements on WSL2 via PowerShell UIAutomation (same script as detectWindowsElements)
      */
     private detectWSLElements;
+    /**
+     * Resolve a python3 interpreter that actually has the Atspi GObject-Introspection
+     * binding. `python3` on PATH is frequently a conda/pyenv interpreter that lacks the
+     * system `gi`/Atspi typelib (PyGObject is installed against the system python), so a
+     * bare `python3 -c "import gi"` silently fails and the snapshot falls back to mock
+     * elements. We probe a small candidate list once and cache the winner.
+     * Returns '' when no interpreter has the binding.
+     */
+    private resolveAtspiPython;
     /**
      * Detect elements on native Linux via AT-SPI
      */

package/dist/desktop-automation/smart-snapshot.js

@@ -43,6 +43,8 @@ export class SmartSnapshotManager extends EventEmitter {
     snapshotCache = new Map();
     static MAX_CACHE_SIZE = 20;
     nextRef = 1;
+    /** Cached python interpreter that has the Atspi GI binding (`''` = none found, `null` = not yet probed). */
+    atspiPython = null;
     constructor(config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
@@ -678,17 +680,76 @@ if ($focused) {
         }
         return elements;
     }
+    /**
+     * Resolve a python3 interpreter that actually has the Atspi GObject-Introspection
+     * binding. `python3` on PATH is frequently a conda/pyenv interpreter that lacks the
+     * system `gi`/Atspi typelib (PyGObject is installed against the system python), so a
+     * bare `python3 -c "import gi"` silently fails and the snapshot falls back to mock
+     * elements. We probe a small candidate list once and cache the winner.
+     * Returns '' when no interpreter has the binding.
+     */
+    resolveAtspiPython() {
+        if (this.atspiPython !== null) {
+            return this.atspiPython;
+        }
+        const candidates = [
+            process.env.CODEBUDDY_ATSPI_PYTHON,
+            'python3',
+            '/usr/bin/python3',
+            'python',
+        ].filter((c) => typeof c === 'string' && c.length > 0);
+        // Probe the *exact* requirement — a python can have `gi` yet lack the Atspi typelib.
+        const probe = `import gi; gi.require_version('Atspi','2.0'); from gi.repository import Atspi; print('OK')`;
+        let transientFailure = false;
+        for (const candidate of candidates) {
+            try {
+                const out = execSync(`${candidate} -c "${probe}" 2>/dev/null`, {
+                    encoding: 'utf-8',
+                    timeout: 5000,
+                }).trim();
+                if (out.includes('OK')) {
+                    this.atspiPython = candidate;
+                    return candidate;
+                }
+            }
+            catch (err) {
+                // Distinguish a transient timeout/kill (machine under load) from a genuine
+                // missing interpreter/binding. A timeout must NOT poison the cache, or a
+                // single slow probe would silently downgrade every later snapshot to mock
+                // until the process restarts.
+                const e = err;
+                if (e?.signal === 'SIGTERM' || e?.code === 'ETIMEDOUT')
+                    transientFailure = true;
+            }
+        }
+        if (transientFailure) {
+            // Leave the cache unset (null) so the next snapshot re-probes once load clears.
+            return '';
+        }
+        // Every candidate cleanly failed (absent/binding missing) — cache to avoid
+        // re-probing 3 interpreters on every snapshot.
+        this.atspiPython = '';
+        return '';
+    }
     /**
      * Detect elements on native Linux via AT-SPI
      */
     async detectLinuxATSPIElements(_options) {
         const elements = [];
+        const python = this.resolveAtspiPython();
+        if (!python) {
+            logger.warn('AT-SPI element enumeration unavailable: no python3 interpreter with the gi/Atspi binding found. ' +
+                'Install python3-gi + gir1.2-atspi-2.0, or set CODEBUDDY_ATSPI_PYTHON to a python that has them. ' +
+                'Falling back to mock UI elements (NOT a real snapshot).');
+            elements.push(...this.getMockElements());
+            return elements;
+        }
         try {
             // Use AT-SPI via python-atspi or accerciser
             // This requires libatspi and python3-atspi2 to be installed
             const script = `
 import gi
-gi.require_version('Atspi', '2.0')
+gi.require_version("Atspi", "2.0")
 from gi.repository import Atspi
 import json
 
@@ -733,9 +794,14 @@ for i in range(desktop.get_child_count()):
 
 print(json.dumps(all_elements[:100]))
       `;
-            // Try to run the Python script
+            // Try to run the Python script. Pass it base64-encoded and decode inside the
+            // interpreter — embedding a multi-line script (which itself contains quotes)
+            // directly in a `-c '...'` shell argument breaks quoting and silently yields a
+            // NameError, masking real AT-SPI output behind the mock fallback.
             try {
-                const { stdout } = await execAsync(`python3 -c '${script}' 2>/dev/null`, {
+                const encoded = Buffer.from(script, 'utf-8').toString('base64');
+                const runner = `import base64; exec(base64.b64decode("${encoded}").decode("utf-8"))`;
+                const { stdout } = await execAsync(`${python} -c '${runner}' 2>/dev/null`, {
                     timeout: 10000,
                 });
                 const parsed = JSON.parse(stdout);
@@ -758,12 +824,13 @@ print(json.dumps(all_elements[:100]))
                 }
             }
             catch (_err) {
-                // Intentionally ignored: AT-SPI parsing may fail, fallback to mock elements
+                // AT-SPI query/parse failed even though a gi-capable python was found.
+                logger.warn('AT-SPI enumeration failed at query time; falling back to mock UI elements (NOT a real snapshot)', { error: _err });
                 elements.push(...this.getMockElements());
             }
         }
         catch (error) {
-            logger.debug('Linux accessibility detection failed', { error });
+            logger.warn('Linux accessibility detection failed; falling back to mock UI elements (NOT a real snapshot)', { error });
             elements.push(...this.getMockElements());
         }
         return elements;

package/dist/doctor/index.js

@@ -1,7 +1,8 @@
 import { execSync } from 'child_process';
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, statfsSync, unlinkSync, writeFileSync, } from 'fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync, } from 'fs';
 import { join } from 'path';
 import { logger } from '../utils/logger.js';
+import { getFreeSpaceInfo } from '../utils/disk-guard.js';
 function commandExists(cmd) {
     try {
         const lookupCommand = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
@@ -17,10 +18,34 @@ function getCommandAvailability(cmd) {
 }
 function checkNodeVersion() {
     const major = parseInt(process.version.slice(1), 10);
-    if (major >= 18) {
-        return { name: 'Node.js version', status: 'ok', message: `${process.version} (>= 18 required)` };
+    if (major < 18) {
+        return { name: 'Node.js version', status: 'error', message: `${process.version} — Node.js >= 18 is required` };
+    }
+    if (major < 22) {
+        return {
+            name: 'Node.js version',
+            status: 'warn',
+            message: `${process.version} — OK for the CLI (>= 18), but the Cowork desktop app needs >= 22`,
+        };
+    }
+    return { name: 'Node.js version', status: 'ok', message: `${process.version} (CLI >= 18 and Cowork >= 22 OK)` };
+}
+// The SQLite layer (memory/sessions/cache/analytics) is a native module. On a
+// platform without a matching prebuilt binary, `npm install` may have failed to
+// build it — surface that here clearly instead of crashing a DB feature later.
+async function checkNativeSqlite() {
+    try {
+        await import('better-sqlite3');
+        return { name: 'SQLite (better-sqlite3)', status: 'ok', message: 'native module available' };
+    }
+    catch {
+        return {
+            name: 'SQLite (better-sqlite3)',
+            status: 'warn',
+            message: 'native module not built — DB-backed features (memory/sessions/cache) are unavailable. ' +
+                'Install build tools and reinstall (Linux: `build-essential python3`; macOS: `xcode-select --install`).',
+        };
     }
-    return { name: 'Node.js version', status: 'error', message: `${process.version} — Node.js >= 18 is required` };
 }
 function checkDependencies() {
     const checks = [];
@@ -170,33 +195,24 @@ function checkTtsProviders() {
         { cmd: 'espeak', label: 'espeak' },
     ];
     const found = providers.filter(p => commandExists(p.cmd));
-    try {
-        // Check if kokoro-js is installed in workspace node_modules
-        import.meta.resolve?.('kokoro-js');
-        found.push({ cmd: 'kokoro', label: 'kokoro (npm)' });
-    }
-    catch {
-        // ignore
-    }
     return [{
             name: 'TTS providers',
             status: found.length > 0 ? 'ok' : 'warn',
-            message: found.length > 0 ? `available: ${found.map(p => p.label).join(', ')}` : 'none found (install edge-tts, espeak or use kokoro via npm)',
+            message: found.length > 0 ? `available: ${found.map(p => p.label).join(', ')}` : 'none found (install edge-tts, espeak)',
         }];
 }
 function checkDiskSpace(cwd) {
-    try {
-        const stats = statfsSync(cwd);
-        const freeBytes = stats.bfree * stats.bsize;
-        const freeGB = freeBytes / (1024 ** 3);
-        if (freeGB < 1) {
-            return { name: 'Disk space', status: 'warn', message: `${freeGB.toFixed(2)} GB free (< 1 GB)` };
-        }
-        return { name: 'Disk space', status: 'ok', message: `${freeGB.toFixed(1)} GB free` };
-    }
-    catch {
+    // Single source of truth (disk-guard). Uses bavail — free space actually
+    // available to a non-root process — rather than bfree.
+    const info = getFreeSpaceInfo(cwd);
+    if (info === null) {
         return { name: 'Disk space', status: 'warn', message: 'unable to check' };
     }
+    const freeGB = info.freeBytes / (1024 ** 3);
+    if (freeGB < 1) {
+        return { name: 'Disk space', status: 'warn', message: `${freeGB.toFixed(2)} GB free (< 1 GB)` };
+    }
+    return { name: 'Disk space', status: 'ok', message: `${freeGB.toFixed(1)} GB free` };
 }
 function checkGit(cwd) {
     if (!commandExists('git')) {
@@ -385,6 +401,7 @@ export async function runDoctorChecks(cwd) {
     const dir = cwd ?? process.cwd();
     return [
         checkNodeVersion(),
+        await checkNativeSqlite(),
         ...checkDependencies(),
         ...checkApiKeys(),
         await checkChatGptOAuth(),

package/dist/events/types.d.ts

@@ -629,6 +629,16 @@ export interface CostEvents extends Record<string, BaseEvent> {
     'cost:limit_reached': CostLimitReachedEvent;
     'cost:warning': CostWarningEvent;
 }
+export interface FleetActivityEvent extends BaseEvent {
+    type: 'fleet:activity';
+    activityType: string;
+    title: string;
+    description: string;
+    metadata?: Record<string, unknown>;
+}
+export interface FleetEvents extends Record<string, BaseEvent> {
+    'fleet:activity': FleetActivityEvent;
+}
 /**
  * Complete map of all application events.
  * This is the master type for the unified event system.
@@ -723,6 +733,7 @@ export interface AllEvents extends Record<string, BaseEvent> {
     'sandbox:created': SandboxCreatedEvent;
     'sandbox:destroyed': SandboxDestroyedEvent;
     'sandbox:execution': SandboxExecutionEvent;
+    'fleet:activity': FleetActivityEvent;
     'cost:updated': CostUpdatedEvent;
     'cost:limit_reached': CostLimitReachedEvent;
     'cost:warning': CostWarningEvent;

package/dist/fleet/colab-store.d.ts

@@ -48,6 +48,20 @@ export interface ColabTask {
     verifyCommand?: string;
     /** Ids of tasks that must be `completed` before this one is claimable (DAG). */
     dependsOn?: string[];
+    /**
+     * Goal-mode (Hermes kanban goal-mode parity): the worker loops on this task
+     * — after each attempt an LLM judge checks the title/description (+
+     * `acceptanceCriteria` as strict criteria); "continue" re-opens the task
+     * with a continuation nudge until `goalMaxTurns` is spent, then it is
+     * BLOCKED for human review instead of spinning.
+     */
+    goalMode?: boolean;
+    /** Per-task turn budget for goal-mode (default 5). */
+    goalMaxTurns?: number;
+    /** Goal-mode turns consumed so far (persisted — survives daemon restarts). */
+    goalTurnsUsed?: number;
+    /** Last judge reason (shown in the next continuation nudge). */
+    goalLastReason?: string;
     createdBy?: string;
     createdAt?: string;
 }
@@ -104,6 +118,8 @@ export interface AddTaskInput {
     acceptanceCriteria?: string[];
     verifyCommand?: string;
     dependsOn?: string[];
+    goalMode?: boolean;
+    goalMaxTurns?: number;
     createdBy?: string;
     id?: string;
 }
@@ -164,6 +180,11 @@ export declare class FleetColabStore {
     };
     /** Block a task with a reason (needs human/unblocking). */
     blockTask(taskId: string, reason: string): ColabTask;
+    /**
+     * Record a consumed goal-mode turn (persisted, so the budget survives daemon
+     * restarts) and remember the judge's reason for the next continuation nudge.
+     */
+    recordGoalTurn(taskId: string, reason: string): ColabTask;
     /** Release a claimed task back to the open pool. */
     releaseTask(taskId: string): ColabTask;
     addTask(input: AddTaskInput): ColabTask;

package/dist/fleet/colab-store.js

@@ -41,6 +41,17 @@ export function defaultFleetAgentId(cwd = process.cwd()) {
     const repo = path.basename(path.resolve(cwd)) || 'repo';
     return `${host}/${repo}`;
 }
+function resolveGoalMaxTurns(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== 'number' || !Number.isSafeInteger(raw) || raw <= 0) {
+        throw new Error('goalMaxTurns must be a positive integer');
+    }
+    return raw;
+}
+function normalizeGoalTurnsUsed(raw) {
+    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0 ? raw : 0;
+}
 export class FleetColabStore {
     dir;
     agentId;
@@ -207,6 +218,20 @@ export class FleetColabStore {
         this.writeTasks(file);
         return { ...task };
     }
+    /**
+     * Record a consumed goal-mode turn (persisted, so the budget survives daemon
+     * restarts) and remember the judge's reason for the next continuation nudge.
+     */
+    recordGoalTurn(taskId, reason) {
+        const file = this.readTasks();
+        const task = file.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error(`Unknown fleet task '${taskId}'`);
+        task.goalTurnsUsed = normalizeGoalTurnsUsed(task.goalTurnsUsed) + 1;
+        task.goalLastReason = reason;
+        this.writeTasks(file);
+        return { ...task };
+    }
     /** Release a claimed task back to the open pool. */
     releaseTask(taskId) {
         const file = this.readTasks();
@@ -221,6 +246,7 @@ export class FleetColabStore {
     }
     addTask(input) {
         const file = this.readTasks();
+        const goalMaxTurns = resolveGoalMaxTurns(input.goalMaxTurns);
         const task = {
             id: input.id ?? this.generateId('task'),
             title: input.title,
@@ -234,6 +260,8 @@ export class FleetColabStore {
             ...(input.acceptanceCriteria ? { acceptanceCriteria: input.acceptanceCriteria } : {}),
             ...(input.verifyCommand ? { verifyCommand: input.verifyCommand } : {}),
             ...(input.dependsOn && input.dependsOn.length > 0 ? { dependsOn: [...new Set(input.dependsOn)] } : {}),
+            ...(input.goalMode ? { goalMode: true } : {}),
+            ...(goalMaxTurns !== undefined ? { goalMaxTurns } : {}),
             createdBy: input.createdBy ?? this.agentId,
             createdAt: this.isoNow(),
         };

package/dist/fleet/peer-session-bridge.d.ts

@@ -42,7 +42,7 @@ export type PeerChatClientGetter = () => CodeBuddyClient | null;
  * getter; un-wire first if you need to swap).
  */
 export declare function wirePeerSessionBridge(getClient: PeerChatClientGetter): Promise<void>;
-/** Detach all three methods. Idempotent. Does NOT clear in-memory sessions. */
+/** Detach all registered methods. Idempotent. Does NOT clear in-memory sessions. */
 export declare function unwirePeerSessionBridge(): void;
 /** Whether the bridge is currently registered on the peer-rpc registry. */
 export declare function isPeerSessionBridgeWired(): boolean;