@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.1

package/dist/heart/daemon/hatch-specialist.js

@@ -0,0 +1,107 @@
+"use strict";
+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.getSpecialistIdentitySourceDir = getSpecialistIdentitySourceDir;
+exports.getRepoSpecialistIdentitiesDir = getRepoSpecialistIdentitiesDir;
+exports.syncSpecialistIdentities = syncSpecialistIdentities;
+exports.pickRandomSpecialistIdentity = pickRandomSpecialistIdentity;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function getSpecialistIdentitySourceDir() {
+    return path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+}
+function getRepoSpecialistIdentitiesDir() {
+    return path.join(process.cwd(), "AdoptionSpecialist.ouro", "psyche", "identities");
+}
+function listMarkdownIdentityFiles(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.endsWith(".md"))
+        .sort((left, right) => left.localeCompare(right));
+}
+function syncSpecialistIdentities(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_sync_start",
+        message: "syncing specialist identity files",
+        meta: { sourceDir: input.sourceDir, targetDir: input.targetDir },
+    });
+    const files = listMarkdownIdentityFiles(input.sourceDir);
+    fs.mkdirSync(input.targetDir, { recursive: true });
+    for (const fileName of files) {
+        const sourcePath = path.join(input.sourceDir, fileName);
+        const targetPath = path.join(input.targetDir, fileName);
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_sync_end",
+        message: "synced specialist identity files",
+        meta: { copiedCount: files.length },
+    });
+    return files;
+}
+function pickRandomSpecialistIdentity(input) {
+    const files = listMarkdownIdentityFiles(input.identitiesDir);
+    if (files.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.hatch_identity_pick_error",
+            message: "no specialist identities were found",
+            meta: { identitiesDir: input.identitiesDir },
+        });
+        throw new Error(`No specialist identities found in ${input.identitiesDir}`);
+    }
+    const random = input.random ?? Math.random;
+    const index = Math.min(files.length - 1, Math.floor(random() * files.length));
+    const fileName = files[index];
+    const content = fs.readFileSync(path.join(input.identitiesDir, fileName), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_pick",
+        message: "picked specialist identity",
+        meta: { fileName },
+    });
+    return { fileName, content };
+}

package/dist/heart/daemon/health-monitor.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthMonitor = void 0;
+const runtime_1 = require("../../nerves/runtime");
+class HealthMonitor {
+    processManager;
+    scheduler;
+    alertSink;
+    diskUsagePercent;
+    constructor(options) {
+        this.processManager = options.processManager;
+        this.scheduler = options.scheduler;
+        this.alertSink = options.alertSink ?? (() => undefined);
+        this.diskUsagePercent = options.diskUsagePercent ?? (() => 0);
+    }
+    async runChecks() {
+        const results = [];
+        const snapshots = this.processManager.listAgentSnapshots();
+        const unhealthy = snapshots.filter((snapshot) => snapshot.status !== "running");
+        if (unhealthy.length > 0) {
+            results.push({
+                name: "agent-processes",
+                status: "critical",
+                message: `non-running agents: ${unhealthy.map((item) => item.name).join(", ")}`,
+            });
+        }
+        else {
+            results.push({ name: "agent-processes", status: "ok", message: "all managed agents running" });
+        }
+        const jobs = this.scheduler.listJobs();
+        const neverRan = jobs.filter((job) => !job.lastRun);
+        if (neverRan.length > 0) {
+            results.push({
+                name: "cron-health",
+                status: "warn",
+                message: `jobs never run: ${neverRan.map((job) => job.id).join(", ")}`,
+            });
+        }
+        else {
+            results.push({ name: "cron-health", status: "ok", message: "cron jobs are healthy" });
+        }
+        const diskPercent = this.diskUsagePercent();
+        if (diskPercent >= 90) {
+            results.push({
+                name: "disk-space",
+                status: "critical",
+                message: `disk usage critical (${diskPercent}%)`,
+            });
+        }
+        else if (diskPercent >= 80) {
+            results.push({
+                name: "disk-space",
+                status: "warn",
+                message: `disk usage high (${diskPercent}%)`,
+            });
+        }
+        else {
+            results.push({
+                name: "disk-space",
+                status: "ok",
+                message: `disk usage healthy (${diskPercent}%)`,
+            });
+        }
+        for (const result of results) {
+            (0, runtime_1.emitNervesEvent)({
+                level: result.status === "critical" ? "error" : result.status === "warn" ? "warn" : "info",
+                component: "daemon",
+                event: "daemon.health_result",
+                message: "daemon health check result",
+                meta: { name: result.name, status: result.status },
+            });
+            if (result.status === "critical") {
+                await this.alertSink(`[critical] ${result.name}: ${result.message}`);
+            }
+        }
+        return results;
+    }
+}
+exports.HealthMonitor = HealthMonitor;

package/dist/heart/daemon/message-router.js

@@ -0,0 +1,98 @@
+"use strict";
+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.FileMessageRouter = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function messageId(nowIso) {
+    return `msg-${nowIso.replace(/[^0-9]/g, "")}`;
+}
+class FileMessageRouter {
+    baseDir;
+    now;
+    constructor(options = {}) {
+        this.baseDir = options.baseDir ?? path.join(os.homedir(), ".agentstate", "messages");
+        this.now = options.now ?? (() => new Date().toISOString());
+        fs.mkdirSync(this.baseDir, { recursive: true });
+    }
+    async send(input) {
+        const queuedAt = this.now();
+        const id = messageId(queuedAt);
+        const message = {
+            id,
+            from: input.from,
+            to: input.to,
+            content: input.content,
+            queuedAt,
+            priority: input.priority ?? "normal",
+            sessionId: input.sessionId,
+            taskRef: input.taskRef,
+        };
+        const inboxPath = this.inboxPath(input.to);
+        fs.appendFileSync(inboxPath, `${JSON.stringify(message)}\n`, "utf-8");
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.message_queued",
+            message: "queued inter-agent message",
+            meta: { id, from: input.from, to: input.to },
+        });
+        return { id, queuedAt };
+    }
+    pollInbox(agent) {
+        const inboxPath = this.inboxPath(agent);
+        if (!fs.existsSync(inboxPath))
+            return [];
+        const raw = fs.readFileSync(inboxPath, "utf-8");
+        fs.writeFileSync(inboxPath, "", "utf-8");
+        const messages = raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((line) => JSON.parse(line));
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.message_polled",
+            message: "polled inter-agent inbox",
+            meta: { agent, messageCount: messages.length },
+        });
+        return messages;
+    }
+    inboxPath(agent) {
+        return path.join(this.baseDir, `${agent}-inbox.jsonl`);
+    }
+}
+exports.FileMessageRouter = FileMessageRouter;

package/dist/heart/daemon/ouro-bot-entry.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("../../nerves/runtime");
+const runtime_logging_1 = require("./runtime-logging");
+const ouro_bot_wrapper_1 = require("./ouro-bot-wrapper");
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("ouro-bot");
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.ouro_bot_entry_start",
+    message: "starting ouro.bot wrapper entrypoint",
+    meta: { args: process.argv.slice(2) },
+});
+void (0, ouro_bot_wrapper_1.runOuroBotWrapper)(process.argv.slice(2)).catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.ouro_bot_entry_error",
+        message: "ouro.bot wrapper entrypoint failed",
+        meta: { error: error instanceof Error ? error.message : String(error) },
+    });
+    process.exit(1);
+});

package/dist/heart/daemon/ouro-bot-wrapper.js

@@ -0,0 +1,90 @@
+"use strict";
+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.runOuroBotWrapper = runOuroBotWrapper;
+const runtime_1 = require("../../nerves/runtime");
+const daemon_cli_1 = require("./daemon-cli");
+async function defaultLoadCanonicalRunner() {
+    const packageName = "@ouro.bot/cli";
+    const specifier = packageName;
+    const loaded = await Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
+    const candidate = Object.prototype.hasOwnProperty.call(loaded, "runOuroCli")
+        ? loaded["runOuroCli"]
+        : undefined;
+    if (typeof candidate === "function") {
+        return candidate;
+    }
+    throw new Error("@ouro.bot/cli does not export runOuroCli");
+}
+function defaultWriteStdout(_text) {
+    // Wrapper is intentionally silent by default to avoid duplicate terminal output.
+}
+async function runOuroBotWrapper(args, deps = {}) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_wrapper_start",
+        message: "starting ouro.bot wrapper delegation",
+        meta: { args },
+    });
+    const loadCanonicalRunner = deps.loadCanonicalRunner ?? defaultLoadCanonicalRunner;
+    const fallbackRunCli = deps.fallbackRunCli ?? daemon_cli_1.runOuroCli;
+    const writeStdout = deps.writeStdout ?? defaultWriteStdout;
+    let delegatedTo = "@ouro.bot/cli";
+    let runner = fallbackRunCli;
+    try {
+        runner = await loadCanonicalRunner();
+    }
+    catch (error) {
+        delegatedTo = "local-fallback";
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_bot_wrapper_fallback",
+            message: "canonical ouro.bot package unavailable; falling back to local CLI",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+    const result = await runner(args);
+    if (result.trim().length > 0) {
+        writeStdout(result);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_wrapper_end",
+        message: "completed ouro.bot wrapper delegation",
+        meta: { delegatedTo },
+    });
+    return result;
+}

package/dist/heart/daemon/ouro-entry.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("../../nerves/runtime");
+const daemon_cli_1 = require("./daemon-cli");
+const runtime_logging_1 = require("./runtime-logging");
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("ouro");
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.cli_entry_start",
+    message: "starting ouro CLI entrypoint",
+    meta: { args: process.argv.slice(2) },
+});
+void (0, daemon_cli_1.runOuroCli)(process.argv.slice(2)).catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.cli_entry_error",
+        message: "ouro CLI entrypoint failed",
+        meta: { error: error instanceof Error ? error.message : String(error) },
+    });
+    process.exit(1);
+});

package/dist/heart/daemon/ouro-uti.js

@@ -0,0 +1,212 @@
+"use strict";
+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.registerOuroBundleUti = registerOuroBundleUti;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const LSREGISTER_PATH = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+const ICON_SIZES = [16, 32, 128, 256, 512];
+function resolveIconSourcePath(repoRoot) {
+    return path.resolve(repoRoot, "..", "ouroboros-website", "public", "images", "ouroboros.png");
+}
+function buildIconAsset(iconSourcePath, icnsPath, iconsetDir, deps) {
+    try {
+        deps.mkdirSync(iconsetDir, { recursive: true });
+        for (const size of ICON_SIZES) {
+            const basePng = path.join(iconsetDir, `icon_${size}x${size}.png`);
+            const retinaPng = path.join(iconsetDir, `icon_${size}x${size}@2x.png`);
+            deps.execFileSync("sips", ["-z", String(size), String(size), iconSourcePath, "--out", basePng]);
+            deps.execFileSync("sips", ["-z", String(size * 2), String(size * 2), iconSourcePath, "--out", retinaPng]);
+        }
+        deps.execFileSync("iconutil", ["-c", "icns", iconsetDir, "-o", icnsPath]);
+        deps.rmSync(iconsetDir, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        deps.rmSync(iconsetDir, { recursive: true, force: true });
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_uti_icon_error",
+            message: "failed building .ouro icon; continuing without custom icon",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+        return false;
+    }
+}
+function buildInfoPlist(iconInstalled) {
+    const iconTag = iconInstalled ? "\n    <key>CFBundleTypeIconFile</key>\n    <string>ouro</string>" : "";
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        "<dict>",
+        "  <key>CFBundleIdentifier</key>",
+        "  <string>bot.ouro.bundle-registry</string>",
+        "  <key>CFBundleName</key>",
+        "  <string>Ouro Bundle Registry</string>",
+        "  <key>CFBundlePackageType</key>",
+        "  <string>APPL</string>",
+        "  <key>UTExportedTypeDeclarations</key>",
+        "  <array>",
+        "    <dict>",
+        "      <key>UTTypeIdentifier</key>",
+        "      <string>bot.ouro.bundle</string>",
+        "      <key>UTTypeConformsTo</key>",
+        "      <array>",
+        "        <string>public.folder</string>",
+        "      </array>",
+        "      <key>UTTypeTagSpecification</key>",
+        "      <dict>",
+        "        <key>public.filename-extension</key>",
+        "        <array>",
+        "          <string>ouro</string>",
+        "        </array>",
+        "      </dict>",
+        "    </dict>",
+        "  </array>",
+        "  <key>CFBundleDocumentTypes</key>",
+        "  <array>",
+        "    <dict>",
+        "      <key>CFBundleTypeName</key>",
+        "      <string>Ouro Agent Bundle</string>",
+        "      <key>LSItemContentTypes</key>",
+        "      <array>",
+        "        <string>bot.ouro.bundle</string>",
+        "      </array>",
+        "      <key>CFBundleTypeRole</key>",
+        "      <string>Editor</string>",
+        `      ${iconTag.trim()}`,
+        "    </dict>",
+        "  </array>",
+        "</dict>",
+        "</plist>",
+        "",
+    ]
+        .filter((line) => line.length > 0)
+        .join("\n");
+}
+function registerOuroBundleUti(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    if (platform !== "darwin") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_uti_register_skip",
+            message: "skipped .ouro UTI registration on non-macOS platform",
+            meta: { platform },
+        });
+        return {
+            attempted: false,
+            registered: false,
+            iconInstalled: false,
+            skippedReason: "non-macos",
+        };
+    }
+    const homeDir = deps.homeDir ?? os.homedir();
+    const repoRoot = deps.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const rmSync = deps.rmSync ?? fs.rmSync;
+    const exec = deps.execFileSync ?? ((file, args) => (0, child_process_1.execFileSync)(file, args));
+    const supportRoot = path.join(homeDir, "Library", "Application Support", "ouro", "uti");
+    const appBundlePath = path.join(supportRoot, "OuroBundleRegistry.app");
+    const contentsDir = path.join(appBundlePath, "Contents");
+    const resourcesDir = path.join(contentsDir, "Resources");
+    const plistPath = path.join(contentsDir, "Info.plist");
+    const icnsPath = path.join(resourcesDir, "ouro.icns");
+    const iconsetDir = path.join(supportRoot, "ouro.iconset");
+    const iconSourcePath = resolveIconSourcePath(repoRoot);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_uti_register_start",
+        message: "registering .ouro UTI on macOS",
+        meta: { appBundlePath },
+    });
+    let iconInstalled = false;
+    try {
+        mkdirSync(resourcesDir, { recursive: true });
+        if (existsSync(iconSourcePath)) {
+            iconInstalled = buildIconAsset(iconSourcePath, icnsPath, iconsetDir, {
+                mkdirSync,
+                rmSync,
+                execFileSync: exec,
+            });
+        }
+        else {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.ouro_uti_icon_skip",
+                message: "icon source image missing; continuing without custom icon",
+                meta: { iconSourcePath },
+            });
+        }
+        writeFileSync(plistPath, buildInfoPlist(iconInstalled), "utf-8");
+        exec(LSREGISTER_PATH, ["-f", appBundlePath]);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_uti_register_end",
+            message: "registered .ouro UTI on macOS",
+            meta: { iconInstalled },
+        });
+        return {
+            attempted: true,
+            registered: true,
+            iconInstalled,
+            registrationBundlePath: appBundlePath,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_uti_register_error",
+            message: "failed .ouro UTI registration; continuing non-blocking",
+            meta: { reason },
+        });
+        return {
+            attempted: true,
+            registered: false,
+            iconInstalled,
+            skippedReason: reason,
+            registrationBundlePath: appBundlePath,
+        };
+    }
+}