@ouro.bot/cli 0.1.0-alpha.24 → 0.1.0-alpha.241

package/dist/heart/daemon/cli-defaults.js

@@ -0,0 +1,557 @@
+"use strict";
+/**
+ * CLI default dependency wiring.
+ *
+ * Creates the production OuroCliDeps with real filesystem, socket, and
+ * process bindings. Tests inject mocks for all of these.
+ */
+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.defaultStartDaemonProcess = defaultStartDaemonProcess;
+exports.readFirstBundleMetaVersion = readFirstBundleMetaVersion;
+exports.defaultListDiscoveredAgents = defaultListDiscoveredAgents;
+exports.discoverExistingCredentials = discoverExistingCredentials;
+exports.defaultRunSerpentGuide = defaultRunSerpentGuide;
+exports.createDefaultOuroCliDeps = createDefaultOuroCliDeps;
+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 ouro_path_installer_1 = require("../versioning/ouro-path-installer");
+const ouro_uti_1 = require("../versioning/ouro-uti");
+const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
+const skill_management_installer_1 = require("./skill-management-installer");
+const hatch_flow_1 = require("../hatch/hatch-flow");
+const specialist_orchestrator_1 = require("../hatch/specialist-orchestrator");
+const specialist_prompt_1 = require("../hatch/specialist-prompt");
+const specialist_tools_1 = require("../hatch/specialist-tools");
+const runtime_mode_1 = require("./runtime-mode");
+const agent_discovery_1 = require("./agent-discovery");
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const ouro_bot_global_installer_1 = require("../versioning/ouro-bot-global-installer");
+const launchd_1 = require("./launchd");
+const socket_client_1 = require("./socket-client");
+const session_activity_1 = require("../session-activity");
+const auth_flow_1 = require("../auth/auth-flow");
+const cli_parse_1 = require("./cli-parse");
+// ── Default implementations ──
+function defaultStartDaemonProcess(socketPath) {
+    const entry = path.join((0, identity_1.getRepoRoot)(), "dist", "heart", "daemon", "daemon-entry.js");
+    // Redirect stdio to /dev/null via file descriptors — using 'ignore' causes EPIPE
+    // when the daemon's logging system writes to stderr after the parent exits.
+    const outFd = fs.openSync(os.devNull, "w");
+    const errFd = fs.openSync(os.devNull, "w");
+    const child = (0, child_process_1.spawn)("node", [entry, "--socket", socketPath], {
+        detached: true,
+        stdio: ["ignore", outFd, errFd],
+    });
+    child.unref();
+    // Don't close fds — the child process needs them. They'll be cleaned up when the parent exits.
+    return Promise.resolve({ pid: child.pid ?? null });
+}
+function defaultWriteStdout(text) {
+    // eslint-disable-next-line no-console -- terminal UX: CLI command output
+    console.log(text);
+}
+/**
+ * Read the runtimeVersion from the first .ouro bundle's bundle-meta.json.
+ * Returns undefined if none found or unreadable.
+ */
+function readFirstBundleMetaVersion(bundlesRoot) {
+    try {
+        if (!fs.existsSync(bundlesRoot))
+            return undefined;
+        const entries = fs.readdirSync(bundlesRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            /* v8 ignore next -- skip non-.ouro dirs: tested via version-detect tests @preserve */
+            if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+                continue;
+            const metaPath = path.join(bundlesRoot, entry.name, "bundle-meta.json");
+            if (!fs.existsSync(metaPath))
+                continue;
+            const raw = fs.readFileSync(metaPath, "utf-8");
+            const meta = JSON.parse(raw);
+            if (meta.runtimeVersion)
+                return meta.runtimeVersion;
+        }
+    }
+    catch {
+        // Best effort — return undefined on any error
+    }
+    return undefined;
+}
+function defaultCleanupStaleSocket(socketPath) {
+    if (fs.existsSync(socketPath)) {
+        fs.unlinkSync(socketPath);
+    }
+}
+function defaultFallbackPendingMessage(command) {
+    const inboxDir = path.join((0, identity_1.getAgentBundlesRoot)(), `${command.to}.ouro`, "inbox");
+    const pendingPath = path.join(inboxDir, "pending.jsonl");
+    const queuedAt = new Date().toISOString();
+    const payload = {
+        from: command.from,
+        to: command.to,
+        content: command.content,
+        priority: command.priority ?? "normal",
+        sessionId: command.sessionId,
+        taskRef: command.taskRef,
+        queuedAt,
+    };
+    fs.mkdirSync(inboxDir, { recursive: true });
+    fs.appendFileSync(pendingPath, `${JSON.stringify(payload)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "daemon",
+        event: "daemon.message_fallback_queued",
+        message: "queued message to pending fallback file",
+        meta: {
+            to: command.to,
+            path: pendingPath,
+            sessionId: command.sessionId ?? null,
+            taskRef: command.taskRef ?? null,
+        },
+    });
+    return pendingPath;
+}
+function defaultEnsureDaemonBootPersistence(socketPath) {
+    if (process.platform !== "darwin") {
+        return;
+    }
+    const homeDir = os.homedir();
+    const writeDeps = {
+        writeFile: (filePath, content) => fs.writeFileSync(filePath, content, "utf-8"),
+        mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
+        homeDir,
+    };
+    const entryPath = path.join((0, identity_1.getRepoRoot)(), "dist", "heart", "daemon", "daemon-entry.js");
+    /* v8 ignore next -- covered via mock in daemon-cli-defaults.test.ts; v8 on CI attributes the real fs.existsSync branch to the non-mock load @preserve */
+    if (!fs.existsSync(entryPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.entry_path_missing",
+            message: "entryPath does not exist on disk — plist may point to a stale location. Run 'ouro daemon install' from the correct location.",
+            meta: { entryPath },
+        });
+    }
+    const logDir = (0, identity_1.getAgentDaemonLogsDir)();
+    // Write plist only — do NOT launchctl bootstrap.
+    // The daemon is already running (started by ouro up). Bootstrapping would
+    // start a SECOND daemon via launchd's RunAtLoad, causing a race where
+    // killOrphanProcesses kills the first daemon and both end up dead.
+    // The plist on disk is sufficient: launchd picks it up on login.
+    (0, launchd_1.writeLaunchAgentPlist)(writeDeps, {
+        nodePath: process.execPath,
+        entryPath,
+        socketPath,
+        logDir,
+        envPath: process.env.PATH,
+    });
+}
+async function defaultPromptInput(question) {
+    const readline = await Promise.resolve().then(() => __importStar(require("readline/promises")));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const response = await rl.question(question);
+        return response.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+function defaultListDiscoveredAgents() {
+    return (0, agent_discovery_1.listEnabledBundleAgents)({
+        bundlesRoot: (0, identity_1.getAgentBundlesRoot)(),
+        readdirSync: fs.readdirSync,
+        readFileSync: fs.readFileSync,
+    });
+}
+// ── Credential discovery ──
+function discoverExistingCredentials(secretsRoot) {
+    const found = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(secretsRoot, { withFileTypes: true });
+    }
+    catch {
+        return found;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const secretsPath = path.join(secretsRoot, entry.name, "secrets.json");
+        let raw;
+        try {
+            raw = fs.readFileSync(secretsPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed.providers)
+            continue;
+        for (const [provName, provConfig] of Object.entries(parsed.providers)) {
+            const desc = identity_1.PROVIDER_CREDENTIALS[provName];
+            /* v8 ignore next -- guard: unknown provider names in stored secrets @preserve */
+            if (!desc)
+                continue;
+            const hasRequired = desc.required.every((key) => !!provConfig[key]);
+            if (hasRequired) {
+                const credentials = {};
+                for (const key of Object.keys(provConfig))
+                    credentials[key] = provConfig[key];
+                found.push({ agentName: entry.name, provider: provName, credentials, providerConfig: { ...provConfig } });
+            }
+        }
+    }
+    // Deduplicate by provider+credential value (keep first seen)
+    const seen = new Set();
+    return found.filter((cred) => {
+        const key = `${cred.provider}:${JSON.stringify(cred.credentials)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+// ── Serpent guide (interactive hatch) ──
+/* v8 ignore start -- integration: interactive terminal specialist session @preserve */
+async function defaultRunSerpentGuide() {
+    const { runCliSession } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
+    const { patchRuntimeConfig } = await Promise.resolve().then(() => __importStar(require("../config")));
+    const { setAgentName, setAgentConfigOverride } = await Promise.resolve().then(() => __importStar(require("../identity")));
+    const readlinePromises = await Promise.resolve().then(() => __importStar(require("readline/promises")));
+    const crypto = await Promise.resolve().then(() => __importStar(require("crypto")));
+    // Phase 1: cold CLI — collect provider/credentials with a simple readline
+    const coldRl = readlinePromises.createInterface({ input: process.stdin, output: process.stdout });
+    const coldPrompt = async (q) => {
+        const answer = await coldRl.question(q);
+        return answer.trim();
+    };
+    let providerRaw;
+    let credentials = {};
+    let providerConfig = {};
+    const tempDir = path.join(os.tmpdir(), `ouro-hatch-${crypto.randomUUID()}`);
+    try {
+        const secretsRoot = path.join(os.homedir(), ".agentsecrets");
+        const discovered = discoverExistingCredentials(secretsRoot);
+        const existingBundleCount = (0, specialist_orchestrator_1.listExistingBundles)((0, identity_1.getAgentBundlesRoot)()).length;
+        const hatchVerb = existingBundleCount > 0 ? "let's hatch a new agent." : "let's hatch your first agent.";
+        // Default models per provider (used when entering new credentials)
+        const defaultModels = {
+            anthropic: "claude-opus-4-6",
+            minimax: "MiniMax-M2.7",
+            "openai-codex": "gpt-5.4",
+            "github-copilot": "claude-sonnet-4.6",
+            azure: "",
+        };
+        // Scan environment variables for API keys using the canonical descriptor
+        const envDiscovered = [];
+        for (const [provider, desc] of Object.entries(identity_1.PROVIDER_CREDENTIALS)) {
+            const envCred = {};
+            let firstEnvVar;
+            for (const [envVar, credKey] of Object.entries(desc.envVars)) {
+                const value = process.env[envVar];
+                if (value) {
+                    ;
+                    envCred[credKey] = value;
+                    if (!firstEnvVar)
+                        firstEnvVar = envVar;
+                }
+            }
+            // Only register if at least one required field was found
+            const hasRequired = desc.required.some((key) => !!envCred[key]);
+            if (hasRequired && firstEnvVar) {
+                const provCfg = { model: defaultModels[provider] };
+                if (provider === "azure" && envCred.deployment)
+                    provCfg.deployment = envCred.deployment;
+                envDiscovered.push({ provider, agentName: "env", credentials: envCred, providerConfig: provCfg, envVar: firstEnvVar });
+                discovered.push({ provider, agentName: "env", credentials: envCred, providerConfig: provCfg });
+            }
+        }
+        if (discovered.length > 0) {
+            process.stdout.write(`\n\ud83d\udc0d welcome to ouroboros! ${hatchVerb}\n`);
+            process.stdout.write("i found existing API credentials:\n\n");
+            const unique = [...new Map(discovered.map((d) => [`${d.provider}`, d])).values()];
+            for (let i = 0; i < unique.length; i++) {
+                const model = unique[i].providerConfig.model || unique[i].providerConfig.deployment || "";
+                const modelLabel = model ? `, ${model}` : "";
+                const envMatch = envDiscovered.find((e) => e.provider === unique[i].provider && unique[i].agentName === "env");
+                const sourceLabel = envMatch ? `from env: $${envMatch.envVar}` : `from ${unique[i].agentName}`;
+                process.stdout.write(`  ${i + 1}. ${unique[i].provider}${modelLabel} (${sourceLabel})\n`);
+            }
+            process.stdout.write("\n");
+            const choice = await coldPrompt("use one of these? enter number, or 'new' for a different key: ");
+            const idx = parseInt(choice, 10) - 1;
+            if (idx >= 0 && idx < unique.length) {
+                providerRaw = unique[idx].provider;
+                credentials = unique[idx].credentials;
+                providerConfig = unique[idx].providerConfig;
+            }
+            else {
+                const pRaw = await coldPrompt("provider (anthropic/azure/minimax/openai-codex/github-copilot): ");
+                if (!(0, cli_parse_1.isAgentProvider)(pRaw)) {
+                    process.stdout.write("unknown provider. run `ouro hatch` to try again.\n");
+                    coldRl.close();
+                    return null;
+                }
+                providerRaw = pRaw;
+                providerConfig = { model: defaultModels[providerRaw] };
+                credentials = await (0, auth_flow_1.collectRuntimeAuthCredentials)({ agentName: "SerpentGuide", provider: providerRaw, promptInput: coldPrompt }, {});
+            }
+        }
+        else {
+            process.stdout.write(`\n\ud83d\udc0d welcome to ouroboros! ${hatchVerb}\n`);
+            process.stdout.write("i need an API key to power our conversation.\n\n");
+            const pRaw = await coldPrompt("provider (anthropic/azure/minimax/openai-codex/github-copilot): ");
+            if (!(0, cli_parse_1.isAgentProvider)(pRaw)) {
+                process.stdout.write("unknown provider. run `ouro hatch` to try again.\n");
+                coldRl.close();
+                return null;
+            }
+            providerRaw = pRaw;
+            providerConfig = { model: defaultModels[providerRaw] };
+            credentials = await (0, auth_flow_1.collectRuntimeAuthCredentials)({ agentName: "SerpentGuide", provider: providerRaw, promptInput: coldPrompt }, {});
+        }
+        coldRl.close();
+        process.stdout.write("\n");
+        // Phase 2: configure runtime for serpent guide
+        const bundleSourceDir = path.resolve(__dirname, "..", "..", "..", "SerpentGuide.ouro");
+        const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+        const secretsRoot2 = path.join(os.homedir(), ".agentsecrets");
+        // Suppress non-critical log noise during hatch (no secrets.json, etc.)
+        const { setRuntimeLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves/runtime")));
+        const { createLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves")));
+        setRuntimeLogger(createLogger({ level: "error" }));
+        // Configure runtime: set agent identity + config override so runAgent
+        // doesn't try to read from ~/AgentBundles/SerpentGuide.ouro/
+        setAgentName("SerpentGuide");
+        // Build specialist system prompt
+        const soulText = (0, specialist_orchestrator_1.loadSoulText)(bundleSourceDir);
+        const identitiesDir = path.join(bundleSourceDir, "psyche", "identities");
+        const identity = (0, specialist_orchestrator_1.pickRandomIdentity)(identitiesDir);
+        // Load identity-specific spinner phrases (falls back to DEFAULT_AGENT_PHRASES)
+        const { loadIdentityPhrases } = await Promise.resolve().then(() => __importStar(require("../hatch/specialist-orchestrator")));
+        const phrases = loadIdentityPhrases(bundleSourceDir, identity.fileName);
+        const resolvedModel = providerConfig.model || providerConfig.deployment || "";
+        setAgentConfigOverride({
+            version: 2,
+            enabled: true,
+            provider: providerRaw,
+            humanFacing: { provider: providerRaw, model: resolvedModel },
+            agentFacing: { provider: providerRaw, model: resolvedModel },
+            phrases,
+        });
+        patchRuntimeConfig({
+            providers: {
+                [providerRaw]: { ...providerConfig, ...credentials },
+            },
+        });
+        // Ping-verify credentials before entering the serpent guide session
+        const { pingProvider } = await Promise.resolve().then(() => __importStar(require("../provider-ping")));
+        const pingResult = await pingProvider(providerRaw, { ...providerConfig, ...credentials });
+        if (!pingResult.ok) {
+            process.stdout.write(`credentials didn't work (${pingResult.message}). run 'ouro hatch' to try again.\n`);
+            return null;
+        }
+        const existingBundles = (0, specialist_orchestrator_1.listExistingBundles)(bundlesRoot);
+        const systemPrompt = (0, specialist_prompt_1.buildSpecialistSystemPrompt)(soulText, identity.content, existingBundles, {
+            tempDir,
+            provider: providerRaw,
+            model: providerConfig.model ?? "",
+        });
+        // Build specialist tools
+        const specialistTools = (0, specialist_tools_1.getSpecialistTools)();
+        const specialistExecTool = (0, specialist_tools_1.createSpecialistExecTool)({
+            tempDir,
+            credentials,
+            provider: providerRaw,
+            bundlesRoot,
+            secretsRoot: secretsRoot2,
+            animationWriter: (text) => process.stdout.write(text),
+        });
+        // Run the serpent guide session via runCliSession
+        const result = await runCliSession({
+            agentName: "SerpentGuide",
+            tools: specialistTools,
+            execTool: specialistExecTool,
+            exitOnToolCall: "complete_adoption",
+            autoFirstTurn: true,
+            banner: false,
+            disableCommands: true,
+            skipSystemPromptRefresh: true,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: "hi" },
+            ],
+        });
+        if (result.exitReason === "tool_exit" && result.toolResult) {
+            const parsed = typeof result.toolResult === "string" ? JSON.parse(result.toolResult) : result.toolResult;
+            if (parsed.success && parsed.agentName) {
+                return parsed.agentName;
+            }
+        }
+        return null;
+    }
+    catch (err) {
+        process.stderr.write(`\nouro hatch error: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+        coldRl.close();
+        return null;
+    }
+    finally {
+        // Clear specialist config/identity so the hatched agent gets its own
+        setAgentConfigOverride(null);
+        const { resetProviderRuntime } = await Promise.resolve().then(() => __importStar(require("../core")));
+        resetProviderRuntime();
+        const { resetConfigCache } = await Promise.resolve().then(() => __importStar(require("../config")));
+        resetConfigCache();
+        // Restore default logging
+        const { setRuntimeLogger: restoreLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves/runtime")));
+        restoreLogger(null);
+        // Clean up temp dir if it still exists
+        try {
+            if (fs.existsSync(tempDir)) {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Best effort cleanup
+        }
+    }
+}
+/* v8 ignore stop */
+// ── Factory ──
+function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_PATH) {
+    return {
+        socketPath,
+        sendCommand: socket_client_1.sendDaemonCommand,
+        startDaemonProcess: defaultStartDaemonProcess,
+        writeStdout: defaultWriteStdout,
+        checkSocketAlive: socket_client_1.checkDaemonSocketAlive,
+        cleanupStaleSocket: defaultCleanupStaleSocket,
+        fallbackPendingMessage: defaultFallbackPendingMessage,
+        listDiscoveredAgents: defaultListDiscoveredAgents,
+        runHatchFlow: hatch_flow_1.runHatchFlow,
+        promptInput: defaultPromptInput,
+        runSerpentGuide: defaultRunSerpentGuide,
+        runAuthFlow: auth_flow_1.runRuntimeAuthFlow,
+        registerOuroBundleType: ouro_uti_1.registerOuroBundleUti,
+        installOuroCommand: ouro_path_installer_1.installOuroCommand,
+        /* v8 ignore start -- self-healing: ensures active symlink matches running runtime version @preserve */
+        ensureCurrentVersionInstalled: () => {
+            const linkedVersion = (0, ouro_version_manager_1.getCurrentVersion)({});
+            const version = (0, bundle_manifest_1.getPackageVersion)();
+            if (linkedVersion === version)
+                return;
+            (0, ouro_version_manager_1.ensureLayout)({});
+            const cliHome = (0, ouro_version_manager_1.getOuroCliHome)();
+            const versionEntry = path.join(cliHome, "versions", version, "node_modules", "@ouro.bot", "cli", "dist", "heart", "daemon", "ouro-entry.js");
+            if (!fs.existsSync(versionEntry)) {
+                (0, ouro_version_manager_1.installVersion)(version, {});
+            }
+            (0, ouro_version_manager_1.activateVersion)(version, {});
+        },
+        /* v8 ignore stop */
+        /* v8 ignore start -- CLI version management defaults: integration code @preserve */
+        checkForCliUpdate: async () => {
+            const { checkForUpdate } = await Promise.resolve().then(() => __importStar(require("../versioning/update-checker")));
+            return checkForUpdate((0, bundle_manifest_1.getPackageVersion)(), {
+                fetchRegistryJson: async () => {
+                    const res = await fetch("https://registry.npmjs.org/@ouro.bot/cli");
+                    return res.json();
+                },
+                distTag: "alpha",
+            });
+        },
+        installCliVersion: async (version) => { (0, ouro_version_manager_1.installVersion)(version, {}); },
+        activateCliVersion: (version) => { (0, ouro_version_manager_1.activateVersion)(version, {}); },
+        getCurrentCliVersion: () => (0, ouro_version_manager_1.getCurrentVersion)({}),
+        getPreviousCliVersion: () => (0, ouro_version_manager_1.getPreviousVersion)({}),
+        listCliVersions: () => (0, ouro_version_manager_1.listInstalledVersions)({}),
+        reExecFromNewVersion: (reArgs) => {
+            const entry = path.join((0, ouro_version_manager_1.getOuroCliHome)(), "CurrentVersion", "node_modules", "@ouro.bot", "cli", "dist", "heart", "daemon", "ouro-entry.js");
+            require("child_process").execFileSync("node", [entry, ...reArgs], { stdio: "inherit" });
+            process.exit(0);
+        },
+        /* v8 ignore stop */
+        syncGlobalOuroBotWrapper: ouro_bot_global_installer_1.syncGlobalOuroBotWrapper,
+        ensureSkillManagement: skill_management_installer_1.ensureSkillManagement,
+        ensureDaemonBootPersistence: defaultEnsureDaemonBootPersistence,
+        /* v8 ignore start -- dev-mode defaults: tests inject mocks for mode detection and binary resolution @preserve */
+        detectMode: () => (0, runtime_mode_1.detectRuntimeMode)((0, identity_1.getRepoRoot)()),
+        getInstalledBinaryPath: () => {
+            const cliHome = (0, ouro_version_manager_1.getOuroCliHome)();
+            const binaryPath = path.join(cliHome, "bin", "ouro");
+            return fs.existsSync(binaryPath) ? binaryPath : null;
+        },
+        execInstalledBinary: (binaryPath, binArgs) => {
+            const { execFileSync } = require("child_process");
+            execFileSync(binaryPath, binArgs, { stdio: "inherit" });
+            process.exit(0);
+        },
+        /* v8 ignore stop */
+        /* v8 ignore next 3 -- integration: launches interactive CLI session @preserve */
+        startChat: async (agentName) => {
+            const { main } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
+            await main(agentName);
+        },
+        scanSessions: async () => {
+            const agentName = (0, identity_1.getAgentName)();
+            const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+            return (0, session_activity_1.listSessionActivity)({
+                sessionsDir: path.join(agentRoot, "state", "sessions"),
+                friendsDir: path.join(agentRoot, "friends"),
+                agentName,
+            }).map((entry) => ({
+                friendId: entry.friendId,
+                friendName: entry.friendName,
+                channel: entry.channel,
+                lastActivity: entry.lastActivityAt,
+            }));
+        },
+    };
+}