@phuetz/code-buddy 1.1.0 → 1.3.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.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;
@@ -216,7 +227,7 @@ export class FleetColabStore {
         const task = file.tasks.find((t) => t.id === taskId);
         if (!task)
             throw new Error(`Unknown fleet task '${taskId}'`);
-        task.goalTurnsUsed = (task.goalTurnsUsed ?? 0) + 1;
+        task.goalTurnsUsed = normalizeGoalTurnsUsed(task.goalTurnsUsed) + 1;
         task.goalLastReason = reason;
         this.writeTasks(file);
         return { ...task };
@@ -235,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,
@@ -249,7 +261,7 @@ export class FleetColabStore {
             ...(input.verifyCommand ? { verifyCommand: input.verifyCommand } : {}),
             ...(input.dependsOn && input.dependsOn.length > 0 ? { dependsOn: [...new Set(input.dependsOn)] } : {}),
             ...(input.goalMode ? { goalMode: true } : {}),
-            ...(input.goalMaxTurns && input.goalMaxTurns > 0 ? { goalMaxTurns: Math.trunc(input.goalMaxTurns) } : {}),
+            ...(goalMaxTurns !== undefined ? { goalMaxTurns } : {}),
             createdBy: input.createdBy ?? this.agentId,
             createdAt: this.isoNow(),
         };

package/dist/fleet/peer-session-bridge.js

@@ -32,9 +32,10 @@
 import { beginFleetWork } from './fleet-load.js';
 import { registerPeerMethod, unregisterPeerMethod } from '../server/websocket/peer-rpc.js';
 import { broadcastChatSessionEnd, broadcastChatSessionGoal, broadcastChatSessionStart, broadcastChatSessionTurn, } from '../server/websocket/fleet-bridge.js';
+import { resolveGoalJudgeClientFailOpen } from '../goals/goal-judge-client.js';
 import { judgeGoal } from '../goals/goal-judge.js';
 import { resolveGoalsConfig } from '../goals/goal-manager.js';
-import { applyJudgeOutcome, createGoalState, formatGoalStatusLine, normalizeGoalState, renderSubgoalsBlock, } from '../goals/goal-state.js';
+import { applyJudgeOutcome, createGoalState, formatGoalStatusLine, getGoalJudgeCriteria, normalizeGoalState, renderSubgoalsBlock, } from '../goals/goal-state.js';
 import { logger } from '../utils/logger.js';
 import { getPeerSessionStore, } from './peer-session-store.js';
 import { DEFAULT_DISPATCH_POLICY_PREVIEW_TOOLS, FLEET_DISPATCH_PROFILES, buildDispatchSystemPrompt, buildHermesToolsetDescriptor, getDispatchToolPolicy, isFleetDispatchProfile, mergeDispatchSystemPrompt, normalizeDispatchProfile, } from './dispatch-profile.js';
@@ -107,6 +108,14 @@ function newSessionId() {
     const rand = Math.floor(Math.random() * 1e9).toString(36);
     return `sess_${ts}_${rand}`;
 }
+function resolvePeerGoalMaxTurns(raw) {
+    if (raw === undefined)
+        return resolveGoalsConfig().maxTurns;
+    if (typeof raw !== 'number' || !Number.isSafeInteger(raw) || raw <= 0) {
+        throw new Error('peer.chat-session.goal: maxTurns must be a positive integer');
+    }
+    return raw;
+}
 /**
  * Opportunistic GC — drop sessions whose `lastUsedAt` is older than
  * the configured idle window. Called at the top of each `start` and
@@ -162,16 +171,38 @@ async function evaluateSessionGoalAfterTurn(session, assistantText) {
     const goal = session.goal;
     if (!goal || goal.status !== 'active')
         return null;
-    if (!assistantText.trim())
-        return null; // empty turn: don't burn budget
+    if (!assistantText.trim()) {
+        goal.status = 'paused';
+        goal.pausedReason = 'empty response (nothing to evaluate)';
+        const report = {
+            status: 'paused',
+            verdict: 'skipped',
+            reason: goal.pausedReason,
+            turnsUsed: goal.turnsUsed,
+            maxTurns: goal.maxTurns,
+            message: '⏸ Goal paused — the peer produced no judgeable response.',
+        };
+        broadcastChatSessionGoal({
+            sessionId: session.sessionId,
+            status: report.status,
+            verdict: report.verdict,
+            turnsUsed: report.turnsUsed,
+            maxTurns: report.maxTurns,
+        });
+        return report;
+    }
     let report;
     try {
         const config = resolveGoalsConfig();
-        const outcome = await judgeGoal(cachedGetter?.() ?? null, {
+        const baseClient = cachedGetter?.() ?? null;
+        const judgeClient = await resolveGoalJudgeClientFailOpen(baseClient, config.judgeModel);
+        const criteria = getGoalJudgeCriteria(goal);
+        const outcome = await judgeGoal(judgeClient, {
             goal: goal.goal,
             lastResponse: assistantText,
-            ...(goal.subgoals.length ? { subgoals: goal.subgoals } : {}),
+            ...(criteria.length ? { subgoals: criteria } : {}),
             ...(config.judgeModel ? { model: config.judgeModel } : {}),
+            maxTokens: config.judgeMaxTokens,
             timeoutMs: config.judgeTimeoutMs,
         });
         const decision = applyJudgeOutcome(goal, outcome);
@@ -602,6 +633,7 @@ export async function wirePeerSessionBridge(getClient) {
                 turnsUsed: session.goal.turnsUsed,
                 maxTurns: session.goal.maxTurns,
                 subgoals: [...session.goal.subgoals],
+                ...(session.goal.goalPlan ? { goalPlan: session.goal.goalPlan } : {}),
                 ...(session.goal.lastVerdict ? { lastVerdict: session.goal.lastVerdict } : {}),
                 ...(session.goal.lastReason ? { lastReason: session.goal.lastReason } : {}),
                 ...(session.goal.pausedReason ? { pausedReason: session.goal.pausedReason } : {}),
@@ -618,9 +650,7 @@ export async function wirePeerSessionBridge(getClient) {
                     throw new Error('GOAL_ACTIVE: a goal is already active on this session. ' +
                         'Use action "status"/"pause"/"clear" mid-run; clear it before setting a new goal.');
                 }
-                const maxTurns = typeof params.maxTurns === 'number' && params.maxTurns > 0
-                    ? Math.trunc(params.maxTurns)
-                    : resolveGoalsConfig().maxTurns;
+                const maxTurns = resolvePeerGoalMaxTurns(params.maxTurns);
                 session.goal = createGoalState(text, maxTurns);
                 await persist();
                 emitGoal('active');
@@ -629,8 +659,9 @@ export async function wirePeerSessionBridge(getClient) {
             case 'status':
                 return { ...goalView(), traceId: ctx.traceId };
             case 'pause': {
-                if (!session.goal)
+                if (!session.goal || !['active', 'paused'].includes(session.goal.status)) {
                     return { ...goalView(), traceId: ctx.traceId };
+                }
                 session.goal.status = 'paused';
                 session.goal.pausedReason = 'user-paused';
                 await persist();
@@ -638,10 +669,14 @@ export async function wirePeerSessionBridge(getClient) {
                 return { ...goalView(), traceId: ctx.traceId };
             }
             case 'resume': {
-                if (!session.goal)
+                if (!session.goal || session.goal.status !== 'paused') {
                     return { ...goalView(), traceId: ctx.traceId };
+                }
                 session.goal.status = 'active';
                 delete session.goal.pausedReason;
+                delete session.goal.lastVerdict;
+                delete session.goal.lastReason;
+                session.goal.consecutiveParseFailures = 0;
                 session.goal.turnsUsed = 0; // Hermes resume semantics: budget reset
                 await persist();
                 emitGoal('active');
@@ -674,11 +709,14 @@ export async function wirePeerSessionBridge(getClient) {
                     traceId: ctx.traceId,
                 };
             case 'subgoal-remove': {
-                const index = typeof params.index === 'number' ? Math.trunc(params.index) : NaN;
+                const index = typeof params.index === 'number' ? params.index : NaN;
                 if (!session.goal || !['active', 'paused'].includes(session.goal.status)) {
                     throw new Error('NO_ACTIVE_GOAL: set a goal before removing subgoals');
                 }
-                if (!Number.isInteger(index) || index < 1 || index > session.goal.subgoals.length) {
+                if (!Number.isSafeInteger(index) || index < 1) {
+                    throw new Error('peer.chat-session.goal: subgoal index must be a positive integer');
+                }
+                if (index > session.goal.subgoals.length) {
                     throw new Error(`peer.chat-session.goal: subgoal index out of range (1..${session.goal.subgoals.length})`);
                 }
                 const [removed] = session.goal.subgoals.splice(index - 1, 1);

package/dist/fleet/peer-tool-bridge.js

@@ -34,6 +34,7 @@ import { PolicyEngine } from '../security/policy-engine.js';
 import { ConfirmationService } from '../utils/confirmation-service.js';
 import { auditLogger } from '../security/audit-logger.js';
 import { assertPeerToolInvokeAllowed } from './permissions.js';
+import { getGlobalEventBus } from '../events/event-bus.js';
 // ──────────────────────────────────────────────────────────────────
 // Allowlist & gates
 // ──────────────────────────────────────────────────────────────────
@@ -397,6 +398,19 @@ async function runInvocation(params, ctx, stream) {
     }
 }
 function logAudit(input) {
+    try {
+        getGlobalEventBus().emit('fleet:activity', {
+            activityType: 'fleet.tool.invoke',
+            title: 'Peer Tool Invoked',
+            description: input.error
+                ? `Peer ${input.ctx.connectionId} failed to invoke ${input.tool}: ${input.error}`
+                : `Peer ${input.ctx.connectionId} invoked ${input.tool}`,
+            metadata: { peerId: input.ctx.connectionId, tool: input.tool, ok: input.ok, error: input.error }
+        });
+    }
+    catch (err) {
+        // ignore
+    }
     auditLogger.log({
         action: 'tool_execution',
         decision: input.ok ? 'allow' : 'block',