@ouro.bot/cli 0.1.0-alpha.43 → 0.1.0-alpha.431

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

@@ -0,0 +1,604 @@
+"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.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 logs_prune_1 = require("./logs-prune");
+const daemon_health_1 = require("./daemon-health");
+const log_tailer_1 = require("./log-tailer");
+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 provider_models_1 = require("../provider-models");
+const cli_parse_1 = require("./cli-parse");
+const provider_discovery_1 = require("./provider-discovery");
+const provider_credentials_1 = require("../provider-credentials");
+// ── 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) {
+    process.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+}
+/* v8 ignore start -- thin terminal adapter around process stdout @preserve */
+function defaultWriteRaw(text) {
+    process.stdout.write(text);
+}
+/* v8 ignore stop */
+/**
+ * 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 defaultReadHealthUpdatedAt(healthPath) {
+    try {
+        return fs.statSync(healthPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultReadRecentDaemonLogLines(lines = 10) {
+    const files = (0, log_tailer_1.discoverLogFiles)({});
+    const recentLines = [];
+    for (const file of files) {
+        recentLines.push(...(0, log_tailer_1.readLastLines)(file, lines, fs.readFileSync));
+    }
+    return recentLines.slice(-lines).map((line) => (0, log_tailer_1.formatLogLine)(line));
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+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();
+    }
+}
+async function defaultPromptSecret(question) {
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+        throw new Error("vault unlock secret entry requires an interactive terminal so the secret can be hidden. Re-run this command in a terminal and enter the human-chosen secret when prompted.");
+    }
+    const readline = await Promise.resolve().then(() => __importStar(require("readline")));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    const mutableRl = rl;
+    const originalWriteToOutput = mutableRl._writeToOutput;
+    let muted = false;
+    if (originalWriteToOutput) {
+        mutableRl._writeToOutput = (stringToWrite) => {
+            if (!muted) {
+                originalWriteToOutput.call(rl, stringToWrite);
+            }
+        };
+    }
+    try {
+        const response = await new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                process.stdout.write("\n");
+                resolve(answer);
+            });
+            muted = true;
+        });
+        return response.trim();
+    }
+    finally {
+        if (originalWriteToOutput) {
+            mutableRl._writeToOutput = originalWriteToOutput;
+        }
+        rl.close();
+    }
+}
+function defaultListDiscoveredAgents() {
+    return (0, agent_discovery_1.listEnabledBundleAgents)({
+        bundlesRoot: (0, identity_1.getAgentBundlesRoot)(),
+        readdirSync: fs.readdirSync,
+        readFileSync: fs.readFileSync,
+    });
+}
+// ── 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 { 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 = {};
+    let selectedCredentialPayload = {};
+    const tempDir = path.join(os.tmpdir(), `ouro-hatch-${crypto.randomUUID()}`);
+    try {
+        const discovered = [];
+        const existingBundles = (0, specialist_orchestrator_1.listExistingBundles)((0, identity_1.getAgentBundlesRoot)());
+        const existingBundleCount = existingBundles.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 = provider_models_1.DEFAULT_PROVIDER_MODELS;
+        const { pingProvider } = await Promise.resolve().then(() => __importStar(require("../provider-ping")));
+        const installedAgentCreds = await (0, provider_discovery_1.discoverInstalledAgentCredentials)(existingBundles);
+        for (const cred of installedAgentCreds) {
+            discovered.push({
+                ...cred,
+                providerConfig: { model: defaultModels[cred.provider], ...cred.providerConfig },
+            });
+        }
+        // Scan environment variables for API keys using the shared helper
+        const envCreds = (0, provider_discovery_1.scanEnvVarCredentials)(process.env);
+        const envDiscovered = [];
+        for (const cred of envCreds) {
+            // Enrich with default model and first matching env var name (for display)
+            const desc = identity_1.PROVIDER_CREDENTIALS[cred.provider];
+            const firstEnvVar = Object.entries(desc.envVars).find(([envVar]) => process.env[envVar])?.[0] ?? "";
+            const provCfg = { model: defaultModels[cred.provider], ...cred.providerConfig };
+            if (cred.provider === "azure" && cred.credentials.deployment)
+                provCfg.deployment = cred.credentials.deployment;
+            const enriched = { ...cred, providerConfig: provCfg };
+            envDiscovered.push({ ...enriched, envVar: firstEnvVar });
+            discovered.push(enriched);
+        }
+        let welcomed = false;
+        while (true) {
+            if (!welcomed) {
+                process.stdout.write(`\n\ud83d\udc0d welcome to ouroboros! ${hatchVerb}\n`);
+                welcomed = true;
+            }
+            if (discovered.length > 0) {
+                process.stdout.write("i found existing API credentials:\n\n");
+                const credentialOptions = discovered;
+                for (let i = 0; i < credentialOptions.length; i++) {
+                    const model = credentialOptions[i].providerConfig.model || credentialOptions[i].providerConfig.deployment || "";
+                    const modelLabel = model ? `, ${model}` : "";
+                    const envMatch = envDiscovered.find((e) => e.provider === credentialOptions[i].provider && credentialOptions[i].agentName === "env");
+                    const sourceLabel = (0, provider_discovery_1.describeDiscoveredCredentialSource)(credentialOptions[i], envMatch?.envVar);
+                    process.stdout.write(`  ${i + 1}. ${credentialOptions[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, or 'q' to cancel: ");
+                if (["q", "quit", "cancel"].includes(choice.toLowerCase())) {
+                    coldRl.close();
+                    return null;
+                }
+                const idx = parseInt(choice, 10) - 1;
+                if (idx >= 0 && idx < credentialOptions.length) {
+                    providerRaw = credentialOptions[idx].provider;
+                    credentials = credentialOptions[idx].credentials;
+                    providerConfig = credentialOptions[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("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 }, {});
+            }
+            selectedCredentialPayload = { ...providerConfig, ...credentials };
+            const pingResult = await pingProvider(providerRaw, selectedCredentialPayload);
+            if (pingResult.ok) {
+                break;
+            }
+            process.stdout.write(`credentials didn't work (${pingResult.message}). `);
+            if (discovered.length > 0) {
+                process.stdout.write("choose another saved credential or enter 'new'.\n\n");
+            }
+            else {
+                process.stdout.write("let's try again.\n\n");
+            }
+        }
+        coldRl.close();
+        process.stdout.write("\n");
+        const split = (0, provider_credentials_1.splitProviderCredentialFields)(providerRaw, selectedCredentialPayload);
+        (0, provider_credentials_1.cacheProviderCredentialRecords)("SerpentGuide", [
+            (0, provider_credentials_1.createProviderCredentialRecord)({
+                provider: providerRaw,
+                credentials: split.credentials,
+                config: split.config,
+                provenance: { source: "manual" },
+            }),
+        ]);
+        // Phase 2: configure runtime for serpent guide
+        const bundleSourceDir = path.resolve(__dirname, "..", "..", "..", "SerpentGuide.ouro");
+        const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+        // Suppress non-critical log noise during hatch.
+        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,
+        });
+        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: selectedCredentialPayload,
+            provider: providerRaw,
+            bundlesRoot,
+            animationWriter: (text) => process.stdout.write(text),
+            promptSecret: defaultPromptSecret,
+        });
+        // 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,
+        writeRaw: defaultWriteRaw,
+        isTTY: process.stdout.isTTY === true,
+        checkSocketAlive: socket_client_1.checkDaemonSocketAlive,
+        cleanupStaleSocket: defaultCleanupStaleSocket,
+        fallbackPendingMessage: defaultFallbackPendingMessage,
+        healthFilePath: (0, daemon_health_1.getDefaultHealthPath)(),
+        readHealthState: daemon_health_1.readHealth,
+        readHealthUpdatedAt: defaultReadHealthUpdatedAt,
+        readRecentDaemonLogLines: defaultReadRecentDaemonLogLines,
+        sleep: defaultSleep,
+        now: () => Date.now(),
+        startupPollIntervalMs: 250,
+        startupStabilityWindowMs: 1_500,
+        startupTimeoutMs: 10_000,
+        startupRetryLimit: 1,
+        listDiscoveredAgents: defaultListDiscoveredAgents,
+        runHatchFlow: hatch_flow_1.runHatchFlow,
+        promptInput: defaultPromptInput,
+        promptSecret: defaultPromptSecret,
+        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, {});
+            // Self-prune: every successful version activation cleans up old
+            // versions outside the retention window. Without this, every CLI
+            // version ever installed accumulates indefinitely under
+            // ~/.ouro-cli/versions/ — the user observed installs going back to
+            // alpha.85 from March 20 (~100MB of dead node_modules trees).
+            // pruneOldVersions keeps the 5 most recent + the active + the
+            // previous version, so rollback stays one command away.
+            (0, ouro_version_manager_1.pruneOldVersions)(undefined, {});
+        },
+        /* 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: "latest",
+            });
+        },
+        installCliVersion: async (version) => { (0, ouro_version_manager_1.installVersion)(version, {}); },
+        activateCliVersion: (version) => {
+            (0, ouro_version_manager_1.activateVersion)(version, {});
+            // Same self-prune as ensureCurrentVersionInstalled — fires from the
+            // checkForCliUpdate path 1 (in-process update detected → activate
+            // → re-exec). Without this, the path 1 code path never triggers
+            // a prune.
+            (0, ouro_version_manager_1.pruneOldVersions)(undefined, {});
+        },
+        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,
+        pruneDaemonLogs: logs_prune_1.pruneDaemonLogs,
+        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 (agentName) => {
+            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,
+            }));
+        },
+    };
+}