aiden-runtime 3.16.0

package/dist/integrations/computerUse/apiRegistry.js

@@ -0,0 +1,113 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRegistry = void 0;
+class APIRegistry {
+    constructor() {
+        this.registry = new Map();
+    }
+    // ── Registration ─────────────────────────────────────────────
+    register(serviceName, handler) {
+        this.registry.set(serviceName.toLowerCase(), handler);
+    }
+    hasAPI(service) {
+        return this.registry.has(service.toLowerCase());
+    }
+    // ── Execute ──────────────────────────────────────────────────
+    /**
+     * Execute a service call.
+     *
+     * Resolution order:
+     *   1. Registered API handler → fast, structured, no UI
+     *   2. BrowserVault UI fallback → slow, visual, always works
+     *
+     * Returns `{ result, usedAPI: true }` when a handler succeeded,
+     * or `{ result: { status: 'ui_fallback', ... }, usedAPI: false }` for fallback.
+     */
+    async execute(service, params) {
+        const handler = this.registry.get(service.toLowerCase());
+        if (handler) {
+            try {
+                const result = await handler(params);
+                return { result, usedAPI: true };
+            }
+            catch (err) {
+                console.warn(`[APIRegistry] ${service} API handler failed — falling back to UI: ${err?.message}`);
+            }
+        }
+        // UI fallback — open BrowserVault on the service's web app
+        const { browserVault } = await Promise.resolve().then(() => __importStar(require('../../security/browserVault')));
+        const SERVICE_URLS = {
+            gmail: 'https://mail.google.com',
+            notion: 'https://notion.so',
+            github: 'https://github.com',
+            slack: 'https://app.slack.com',
+            sheets: 'https://docs.google.com/spreadsheets',
+            linear: 'https://linear.app',
+            jira: 'https://id.atlassian.com',
+            figma: 'https://www.figma.com',
+            trello: 'https://trello.com',
+            asana: 'https://app.asana.com',
+        };
+        const url = SERVICE_URLS[service.toLowerCase()];
+        if (!url)
+            throw new Error(`[APIRegistry] No API handler and no UI fallback for service: ${service}`);
+        const taskId = `api-fallback-${Date.now()}`;
+        const vault = await browserVault.createBrowserVault(taskId);
+        const liveViewUrl = browserVault.getLiveViewUrl(taskId);
+        console.log(`[APIRegistry] 🌐 UI fallback → ${url}  (vault: ${vault.containerName})`);
+        return {
+            result: {
+                status: 'ui_fallback',
+                url,
+                vaultId: vault.taskId,
+                liveViewUrl,
+            },
+            usedAPI: false,
+        };
+    }
+    // ── Introspection ─────────────────────────────────────────────
+    listServices() {
+        return Array.from(this.registry.keys());
+    }
+}
+exports.apiRegistry = new APIRegistry();
+// ── Built-in registrations ────────────────────────────────────
+// Extend via config/api-keys.json or register() calls at startup.
+// Example: apiRegistry.register('github', githubHandler)

package/dist/integrations/computerUse/screenAgent.js

@@ -0,0 +1,203 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screenAgent = void 0;
+// integrations/computerUse/screenAgent.ts
+// Low-level computer control: screenshot, mouse, keyboard.
+// Every action is gated by CommandGate (confidence < 0.65)
+// and verified by TruthChecker after execution.
+const screenshot_desktop_1 = __importDefault(require("screenshot-desktop"));
+const commandGate_1 = require("../../coordination/commandGate");
+const truthCheck_1 = require("../../core/truthCheck");
+const faultEngine_1 = require("../../core/faultEngine");
+// ── Lazy nut-js loader ────────────────────────────────────────
+// @nut-tree-fork/nut-js requires native build tools. We load it
+// lazily so the API server can start even when the native module
+// is not installed / built.
+let _nutjs = null;
+async function getNut() {
+    if (!_nutjs) {
+        try {
+            _nutjs = await Promise.resolve().then(() => __importStar(require('@nut-tree-fork/nut-js')));
+        }
+        catch (err) {
+            throw new Error(`@nut-tree-fork/nut-js is not installed or failed to build. ` +
+                `Run: npm install @nut-tree-fork/nut-js --build-from-source\n` +
+                `Original error: ${err?.message ?? err}`);
+        }
+    }
+    return _nutjs;
+}
+// ── ScreenAgent ───────────────────────────────────────────────
+class ScreenAgent {
+    constructor() {
+        this.actionLog = [];
+    }
+    // ── Approval ─────────────────────────────────────────────────
+    /**
+     * Request CommandGate approval before executing a sensitive action.
+     * Always triggered for actions with confidence < 0.65 and for the
+     * first action of a new session.
+     */
+    async requestApproval(action) {
+        return commandGate_1.commandGate.requestApproval(`Computer control: ${action.type} — ${action.description ?? 'no description'}`, `Action ID: ${action.id}, Confidence: ${action.confidence}`);
+    }
+    // ── Screenshot ───────────────────────────────────────────────
+    /**
+     * Capture the current screen and return a base64-encoded PNG string.
+     */
+    async takeScreenshot() {
+        const img = await (0, screenshot_desktop_1.default)({ format: 'png' });
+        return img.toString('base64');
+    }
+    // ── Execute ──────────────────────────────────────────────────
+    /**
+     * Execute a single ComputerUseAction.
+     * - Appends to actionLog unconditionally
+     * - Confidence < 0.65 → requests CommandGate approval first
+     * - After execution, does a lightweight postcondition check:
+     *   takes a new screenshot and verifies the screen changed
+     *   (non-blocking best-effort; never blocks success on indeterminate result)
+     */
+    async execute(action) {
+        this.actionLog.push(action);
+        // Confidence gate
+        if (action.confidence < 0.65) {
+            const approved = await this.requestApproval(action);
+            if (!approved)
+                return { success: false, error: 'Rejected by CommandGate' };
+        }
+        try {
+            const { mouse, keyboard, Button, Key } = await getNut();
+            switch (action.type) {
+                case 'click': {
+                    const a = action;
+                    await mouse.move([{ x: a.x, y: a.y }]);
+                    await mouse.click(a.button === 'right' ? Button.RIGHT : Button.LEFT);
+                    break;
+                }
+                case 'type': {
+                    const a = action;
+                    await keyboard.type(a.text);
+                    break;
+                }
+                case 'scroll': {
+                    const a = action;
+                    if (a.deltaY && a.deltaY > 0)
+                        await mouse.scrollDown(Math.abs(a.deltaY));
+                    if (a.deltaY && a.deltaY < 0)
+                        await mouse.scrollUp(Math.abs(a.deltaY));
+                    break;
+                }
+                case 'keypress': {
+                    const a = action;
+                    const mapped = a.keys
+                        .map((k) => Key[k])
+                        .filter((v) => v !== undefined);
+                    if (mapped.length === 1)
+                        await keyboard.pressKey(mapped[0]);
+                    else if (mapped.length > 1)
+                        await keyboard.pressKey(...mapped);
+                    break;
+                }
+                case 'screenshot':
+                    await this.takeScreenshot();
+                    break;
+                // api_call is handled upstream by APIRegistry — not executed here
+                default:
+                    break;
+            }
+            // Lightweight postcondition: verify via TruthChecker that the action type
+            // is considered complete.  We build a minimal single-node TaskGraph to
+            // re-use the existing TruthChecker.verify() logic.
+            const verified = await this.verifyAction(action);
+            if (!verified) {
+                const fault = faultEngine_1.faultEngine.classify(`Action ${action.type} produced no visible change`, {
+                    actionType: action.type,
+                    workspacePath: process.cwd(),
+                });
+                return { success: false, error: fault.manualFix };
+            }
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: err?.message ?? String(err) };
+        }
+    }
+    // ── Verify ───────────────────────────────────────────────────
+    /**
+     * Best-effort postcondition check for computer-use actions.
+     * TruthChecker.verify() is graph-oriented; for computer actions we
+     * use the 'notify' fallback (fire-and-forget → always passes) so we
+     * don't block on unverifiable state, while still running the
+     * TruthChecker code path for auditability.
+     */
+    async verifyAction(action) {
+        try {
+            // Build a minimal synthetic TaskGraph node for the action
+            const fakeGraph = {
+                nodes: new Map([
+                    [
+                        action.id,
+                        {
+                            id: action.id,
+                            description: action.description ?? action.type,
+                            status: 'done',
+                            action: { type: 'notify' }, // maps to pass-through postcondition
+                            result: { status: 'completed' },
+                        },
+                    ],
+                ]),
+            };
+            const result = truthCheck_1.truthChecker.verify(fakeGraph, process.cwd());
+            return result.passed;
+        }
+        catch {
+            // Non-fatal — don't block execution on verify failure
+            return true;
+        }
+    }
+    // ── Log ──────────────────────────────────────────────────────
+    getLog() { return this.actionLog; }
+    clearLog() { this.actionLog = []; }
+}
+exports.screenAgent = new ScreenAgent();

package/dist/integrations/computerUse/visionLoop.js

@@ -0,0 +1,296 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visionLoop = void 0;
+// integrations/computerUse/visionLoop.ts
+// Agentic vision-action loop: screenshot → vision LLM → action → verify → repeat.
+//
+// Model routing (DataGuard):
+//   local  → llava:13b via Ollama REST (/api/chat with images[])
+//   claude → Anthropic Messages API (ANTHROPIC_API_KEY required)
+//   auto   → DataGuard decides per screenshot: sensitive → local, otherwise cloud
+//
+// CommandGate approval before session start + low-confidence (< 0.65) escalation.
+const axios_1 = __importDefault(require("axios"));
+const screenAgent_1 = require("./screenAgent");
+const apiRegistry_1 = require("./apiRegistry");
+const commandGate_1 = require("../../coordination/commandGate");
+const memoryLayers_1 = require("../../memory/memoryLayers");
+const dataGuard_1 = require("../../security/dataGuard");
+const executor_1 = require("../../core/executor");
+const memoryStrategy_1 = require("../../core/memoryStrategy");
+// ── Constants ──────────────────────────────────────────────────
+const OLLAMA_BASE = process.env.OLLAMA_HOST ?? 'http://localhost:11434';
+const VISION_MODEL = process.env.DEVOS_VISION_MODEL ?? 'llava:13b';
+// ── Vision API helpers ────────────────────────────────────────
+/**
+ * Call llava (or any vision-capable Ollama model) with a base64 image.
+ */
+async function callOllamaVision(prompt, imageB64) {
+    const res = await axios_1.default.post(`${OLLAMA_BASE}/api/chat`, {
+        model: VISION_MODEL,
+        messages: [
+            {
+                role: 'user',
+                content: prompt,
+                images: [imageB64],
+            },
+        ],
+        stream: false,
+        options: { temperature: 0.2, num_predict: 512 },
+    }, { timeout: 90000 });
+    return res.data?.message?.content ?? '';
+}
+/**
+ * Call Claude via Anthropic Messages API with a base64 PNG image.
+ * Requires ANTHROPIC_API_KEY env var.
+ */
+async function callClaudeVision(prompt, imageB64) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+        throw new Error('[VisionLoop] ANTHROPIC_API_KEY not set — use visionModel: "local"');
+    const res = await axios_1.default.post('https://api.anthropic.com/v1/messages', {
+        model: process.env.DEVOS_CLAUDE_VISION_MODEL ?? 'claude-sonnet-4-20250514',
+        max_tokens: 512,
+        messages: [
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'image',
+                        source: { type: 'base64', media_type: 'image/png', data: imageB64 },
+                    },
+                    { type: 'text', text: prompt },
+                ],
+            },
+        ],
+    }, {
+        headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json',
+        },
+        timeout: 30000,
+    });
+    return res.data?.content?.[0]?.text ?? '';
+}
+// ── VisionLoop ────────────────────────────────────────────────
+class VisionLoop {
+    constructor() {
+        this.aborted = false;
+    }
+    // ── Run ──────────────────────────────────────────────────────
+    async run(goal, options = {}) {
+        const maxIterations = options.maxIterations ?? 20;
+        const timeoutMs = options.timeoutMs ?? 120000;
+        const actionsExecuted = [];
+        const start = Date.now();
+        this.aborted = false;
+        // Memory lookup — replay known-good action sequence if available
+        const knownActions = memoryStrategy_1.memoryStrategy.retrieveActions(goal);
+        if (knownActions) {
+            console.log(`[VisionLoop] Memory hit for goal: "${goal}" — replaying ${knownActions.length} known action(s)`);
+            executor_1.executor.startSession(goal);
+            for (const action of knownActions) {
+                if (this.aborted)
+                    break;
+                await executor_1.executor.execute(action);
+                actionsExecuted.push(action);
+            }
+            // Take a final screenshot to verify goal completion
+            const verifyScreenshot = await screenAgent_1.screenAgent.takeScreenshot();
+            const useLocalForVerify = options.visionModel === 'local'
+                ? true
+                : options.visionModel === 'claude'
+                    ? false
+                    : await dataGuard_1.dataGuard.isSensitive(verifyScreenshot.slice(0, 200));
+            const done = await this.checkGoalComplete(goal, verifyScreenshot, useLocalForVerify);
+            if (done) {
+                await memoryStrategy_1.memoryStrategy.storeSuccess(goal, actionsExecuted);
+                memoryLayers_1.memoryLayers.write(`ComputerUse success (memory replay): ${goal}`, ['computer_use', 'success']);
+                const session = executor_1.executor.endSession();
+                if (session)
+                    memoryLayers_1.memoryLayers.write(JSON.stringify(session), ['computer_use', 'session']);
+                return { success: true, iterations: 1, actionsExecuted };
+            }
+            // Memory replay didn't complete goal — fall through to full vision loop
+            executor_1.executor.endSession();
+            actionsExecuted.length = 0;
+            this.aborted = false;
+        }
+        // CommandGate approval before taking control of the computer
+        if (options.requireApproval !== false) {
+            const approved = await commandGate_1.commandGate.requestApproval(`Computer control session: ${goal}`, 'VisionLoop will take screenshots and control mouse/keyboard');
+            if (!approved) {
+                executor_1.executor.endSession();
+                await memoryStrategy_1.memoryStrategy.storeFailure(goal);
+                return {
+                    success: false,
+                    iterations: 0,
+                    actionsExecuted: [],
+                    failureReason: 'Rejected by user via CommandGate',
+                };
+            }
+        }
+        executor_1.executor.startSession(goal);
+        for (let i = 0; i < maxIterations; i++) {
+            if (this.aborted)
+                break;
+            if (Date.now() - start > timeoutMs) {
+                await memoryStrategy_1.memoryStrategy.storeFailure(goal);
+                return { success: false, iterations: i, actionsExecuted, failureReason: 'Timeout' };
+            }
+            // 1. Take screenshot
+            const screenshotB64 = await screenAgent_1.screenAgent.takeScreenshot();
+            // 2. DataGuard: choose vision model
+            let useLocal;
+            if (options.visionModel === 'local') {
+                useLocal = true;
+            }
+            else if (options.visionModel === 'claude') {
+                useLocal = false;
+            }
+            else {
+                // 'auto' — scan a prefix of the base64 for sensitive text (e.g. from OCR metadata)
+                useLocal = await dataGuard_1.dataGuard.isSensitive(screenshotB64.slice(0, 200));
+            }
+            // 3. Vision LLM → next action (null = goal complete)
+            const action = await this.callVisionLLM(goal, screenshotB64, useLocal, actionsExecuted);
+            if (!action) {
+                await memoryStrategy_1.memoryStrategy.storeSuccess(goal, actionsExecuted);
+                memoryLayers_1.memoryLayers.write(`ComputerUse success: ${goal}`, ['computer_use', 'success']);
+                const session = executor_1.executor.endSession();
+                if (session)
+                    memoryLayers_1.memoryLayers.write(JSON.stringify(session), ['computer_use', 'session']);
+                return { success: true, iterations: i + 1, actionsExecuted };
+            }
+            // 4. Low-confidence escalation
+            if (action.confidence < 0.65) {
+                const approved = await commandGate_1.commandGate.requestApproval(`Low-confidence action: ${action.type} (${Math.round(action.confidence * 100)}%)`, action.description ?? 'No description');
+                if (!approved)
+                    continue;
+            }
+            // 5. API-first routing for api_call actions
+            if (action.type === 'api_call') {
+                const apiAction = action;
+                const r = await apiRegistry_1.apiRegistry.execute(apiAction.service, {
+                    endpoint: apiAction.endpoint,
+                    method: apiAction.method,
+                    payload: apiAction.payload,
+                    headers: apiAction.headers,
+                });
+                actionsExecuted.push(action);
+                if (r.usedAPI) {
+                    await memoryStrategy_1.memoryStrategy.storeSuccess(goal, actionsExecuted);
+                    memoryLayers_1.memoryLayers.write(`ComputerUse success: ${goal}`, ['computer_use', 'success']);
+                    const session = executor_1.executor.endSession();
+                    if (session)
+                        memoryLayers_1.memoryLayers.write(JSON.stringify(session), ['computer_use', 'session']);
+                    return { success: true, iterations: i + 1, actionsExecuted };
+                }
+                continue;
+            }
+            // 6. Execute via unified Executor (handles retry, fallback, TruthCheck)
+            const result = await executor_1.executor.execute(action);
+            actionsExecuted.push(action);
+            if (result.status === 'failed' && action.fallback) {
+                // Executor already tried the fallback internally; log the outcome
+                console.warn(`[VisionLoop] Action ${action.id} and its fallback both failed`);
+            }
+            // 7. Goal-complete check on fresh screenshot
+            const newScreenshot = await screenAgent_1.screenAgent.takeScreenshot();
+            const done = await this.checkGoalComplete(goal, newScreenshot, useLocal);
+            if (done) {
+                await memoryStrategy_1.memoryStrategy.storeSuccess(goal, actionsExecuted);
+                memoryLayers_1.memoryLayers.write(`ComputerUse success: ${goal}`, ['computer_use', 'success']);
+                const session = executor_1.executor.endSession();
+                if (session)
+                    memoryLayers_1.memoryLayers.write(JSON.stringify(session), ['computer_use', 'session']);
+                return { success: true, iterations: i + 1, actionsExecuted };
+            }
+        }
+        await memoryStrategy_1.memoryStrategy.storeFailure(goal);
+        const session = executor_1.executor.endSession();
+        if (session)
+            memoryLayers_1.memoryLayers.write(JSON.stringify(session), ['computer_use', 'session']);
+        return {
+            success: false,
+            iterations: maxIterations,
+            actionsExecuted,
+            failureReason: this.aborted ? 'Aborted by user' : 'Max iterations reached',
+        };
+    }
+    // ── Vision LLM call ──────────────────────────────────────────
+    async callVisionLLM(goal, screenshotB64, useLocal, history) {
+        const historyStr = history
+            .slice(-5)
+            .map(a => `${a.type}: ${a.description ?? ''}`)
+            .join('\n');
+        const prompt = `You are controlling a computer to achieve this goal: "${goal}"
+
+Recent actions taken:
+${historyStr || 'None yet'}
+
+Look at the screenshot and decide the SINGLE next action to take.
+If the goal is already complete, respond with: { "done": true }
+
+Respond ONLY with valid JSON:
+{
+  "id": "action_<timestamp>",
+  "type": "click|type|scroll|keypress|screenshot|api_call",
+  "confidence": 0.0-1.0,
+  "description": "what this action does"
+}`;
+        try {
+            const raw = useLocal
+                ? await callOllamaVision(prompt, screenshotB64)
+                : await callClaudeVision(prompt, screenshotB64);
+            return this.parseAction(raw);
+        }
+        catch (err) {
+            console.warn(`[VisionLoop] LLM call failed (${useLocal ? 'local' : 'claude'}): ${err?.message}`);
+            return null;
+        }
+    }
+    // ── Goal-complete check ───────────────────────────────────────
+    async checkGoalComplete(goal, screenshotB64, useLocal) {
+        const prompt = `Is this goal complete based on the screenshot? Goal: "${goal}". ` +
+            `Respond ONLY with JSON: {"complete": true} or {"complete": false}`;
+        try {
+            const raw = useLocal
+                ? await callOllamaVision(prompt, screenshotB64)
+                : await callClaudeVision(prompt, screenshotB64);
+            const cleaned = raw.replace(/```json|```/g, '').trim();
+            return JSON.parse(cleaned).complete === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── Parse LLM response → action ──────────────────────────────
+    parseAction(raw) {
+        try {
+            const cleaned = raw.replace(/```json|```/g, '').trim();
+            const parsed = JSON.parse(cleaned);
+            if (parsed.done)
+                return null;
+            if (!parsed.id)
+                parsed.id = `action_${Date.now()}`;
+            if (typeof parsed.confidence !== 'number')
+                parsed.confidence = 0.7;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Abort ─────────────────────────────────────────────────────
+    abort() { this.aborted = true; }
+}
+exports.visionLoop = new VisionLoop();