@ouro.bot/cli 0.1.0-alpha.32 → 0.1.0-alpha.320

package/dist/heart/turn-context.js

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * TurnContext: a single pre-read snapshot of all state sources needed
+ * by the inbound-turn pipeline and prompt assembly.
+ *
+ * Before this module existed, pipeline.ts read ~10 state sources inline
+ * and prompt.ts did several ad-hoc filesystem reads. This centralizes
+ * all reads into one place so the rest of the turn is pure derivation.
+ */
+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.buildTurnContext = buildTurnContext;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const manager_1 = require("./bridges/manager");
+const identity_1 = require("./identity");
+const tasks_1 = require("../repertoire/tasks");
+const coding_1 = require("../repertoire/coding");
+const session_activity_1 = require("./session-activity");
+const thoughts_1 = require("./daemon/thoughts");
+const pending_1 = require("../mind/pending");
+const obligations_1 = require("../arc/obligations");
+const target_resolution_1 = require("./target-resolution");
+const episodes_1 = require("../arc/episodes");
+const cares_1 = require("../arc/cares");
+const config_1 = require("./config");
+const daemon_health_1 = require("./daemon/daemon-health");
+const prompt_1 = require("../mind/prompt");
+// ── Helpers ─────────────────────────────────────────────────────────
+const DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+function isLiveCodingSessionStatus(status) {
+    return status === "spawning"
+        || status === "running"
+        || status === "waiting_input"
+        || status === "stalled";
+}
+function emptyTaskBoard() {
+    return {
+        compact: "",
+        full: "",
+        byStatus: {
+            drafting: [],
+            processing: [],
+            validating: [],
+            collaborating: [],
+            paused: [],
+            blocked: [],
+            done: [],
+            cancelled: [],
+        },
+        issues: [],
+        actionRequired: [],
+        unresolvedDependencies: [],
+        activeSessions: [],
+        activeBridges: [],
+    };
+}
+function readInnerWorkState() {
+    const defaultJob = {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+        const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+        const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+        const dialogStatus = (0, thoughts_1.deriveInnerDialogStatus)(pendingMessages, turns, runtimeState);
+        const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+        const storeObligationPending = (0, obligations_1.readPendingObligations)(agentRoot).length > 0;
+        return {
+            status: dialogStatus.processing === "started" ? "running" : "idle",
+            hasPending: dialogStatus.queue !== "clear",
+            origin: dialogStatus.origin,
+            contentSnippet: dialogStatus.contentSnippet,
+            obligationPending: dialogStatus.obligationPending || storeObligationPending,
+            job,
+        };
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        return {
+            status: "idle",
+            hasPending: false,
+            job: defaultJob,
+            /* v8 ignore stop */
+        };
+    }
+}
+function checkDaemonRunning() {
+    try {
+        return fs.existsSync(DAEMON_SOCKET_PATH);
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        return false;
+        /* v8 ignore stop */
+    }
+}
+function hasTextField(record, key) {
+    return typeof record?.[key] === "string" && record[key].trim().length > 0;
+}
+function readSenseStatusLines() {
+    const config = (0, identity_1.loadAgentConfig)();
+    const senses = config.senses ?? {
+        cli: { enabled: true },
+        teams: { enabled: false },
+        bluebubbles: { enabled: false },
+    };
+    let payload = {};
+    try {
+        const raw = fs.readFileSync((0, identity_1.getAgentSecretsPath)(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            payload = parsed;
+        }
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        payload = {};
+        /* v8 ignore stop */
+    }
+    const teams = payload.teams;
+    const bluebubbles = payload.bluebubbles;
+    const configured = {
+        cli: true,
+        teams: hasTextField(teams, "clientId") && hasTextField(teams, "clientSecret") && hasTextField(teams, "tenantId"),
+        bluebubbles: hasTextField(bluebubbles, "serverUrl") && hasTextField(bluebubbles, "password"),
+    };
+    const rows = [
+        { label: "CLI", status: "interactive" },
+        {
+            label: "Teams",
+            status: !senses.teams.enabled ? "disabled" : configured.teams ? "ready" : "needs_config",
+        },
+        {
+            label: "BlueBubbles",
+            status: !senses.bluebubbles.enabled ? "disabled" : configured.bluebubbles ? "ready" : "needs_config",
+        },
+    ];
+    return rows.map((row) => `- ${row.label}: ${row.status}`);
+}
+function readBundleMetaFile() {
+    try {
+        const metaPath = path.join((0, identity_1.getAgentRoot)(), "bundle-meta.json");
+        const raw = fs.readFileSync(metaPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        return null;
+        /* v8 ignore stop */
+    }
+}
+// ── Builder ─────────────────────────────────────────────────────────
+async function buildTurnContext(input) {
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const agentName = (0, identity_1.getAgentName)();
+    // Sync config
+    let syncConfig = { enabled: false, remote: "origin" };
+    try {
+        syncConfig = (0, config_1.getSyncConfig)();
+    }
+    catch { /* v8 ignore next -- defensive @preserve */ /* config not available */ }
+    // Bridges
+    const activeBridges = (0, manager_1.createBridgeManager)().findBridgesForSession({
+        friendId: input.currentSession.friendId,
+        channel: input.currentSession.channel,
+        key: input.currentSession.key,
+    });
+    // Session activity
+    let sessionActivity = [];
+    try {
+        sessionActivity = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: `${agentRoot}/state/sessions`,
+            friendsDir: `${agentRoot}/friends`,
+            agentName,
+            currentSession: {
+                friendId: input.currentSession.friendId,
+                channel: input.currentSession.channel,
+                key: input.currentSession.key,
+            },
+        });
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        sessionActivity = [];
+        /* v8 ignore stop */
+    }
+    // Target candidates
+    let targetCandidates = [];
+    try {
+        if (input.channel !== "inner") {
+            targetCandidates = await (0, target_resolution_1.listTargetSessionCandidates)({
+                sessionsDir: `${agentRoot}/state/sessions`,
+                friendsDir: `${agentRoot}/friends`,
+                agentName,
+                currentSession: {
+                    friendId: input.currentSession.friendId,
+                    channel: input.currentSession.channel,
+                    key: input.currentSession.key,
+                },
+                friendStore: input.friendStore,
+            });
+        }
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        targetCandidates = [];
+        /* v8 ignore stop */
+    }
+    // Pending obligations
+    let pendingObligations = [];
+    try {
+        pendingObligations = (0, obligations_1.readPendingObligations)(agentRoot);
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        pendingObligations = [];
+        /* v8 ignore stop */
+    }
+    // Coding sessions
+    let codingSessions = [];
+    let otherCodingSessions = [];
+    try {
+        const liveCodingSessions = (0, coding_1.getCodingSessionManager)()
+            .listSessions()
+            .filter((session) => isLiveCodingSessionStatus(session.status) && Boolean(session.originSession));
+        codingSessions = liveCodingSessions.filter((session) => session.originSession?.friendId === input.currentSession.friendId
+            && session.originSession.channel === input.currentSession.channel
+            && session.originSession.key === input.currentSession.key);
+        otherCodingSessions = liveCodingSessions.filter((session) => !(session.originSession?.friendId === input.currentSession.friendId
+            && session.originSession.channel === input.currentSession.channel
+            && session.originSession.key === input.currentSession.key));
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        codingSessions = [];
+        otherCodingSessions = [];
+        /* v8 ignore stop */
+    }
+    // Inner work state
+    const innerWorkState = readInnerWorkState();
+    // Task board
+    let taskBoard;
+    try {
+        taskBoard = (0, tasks_1.getTaskModule)().getBoard();
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        taskBoard = emptyTaskBoard();
+        /* v8 ignore stop */
+    }
+    // Return obligations
+    let returnObligations = [];
+    try {
+        returnObligations = (0, obligations_1.listActiveReturnObligations)(agentName);
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        returnObligations = [];
+        /* v8 ignore stop */
+    }
+    // Recent episodes
+    const recentEpisodes = (0, episodes_1.readRecentEpisodes)(agentRoot, { limit: 20 });
+    // Active cares
+    const activeCares = (0, cares_1.readActiveCares)(agentRoot);
+    // ── Prompt-assembly pre-reads ──────────────────────────────────────
+    const daemonRunning = checkDaemonRunning();
+    let senseStatusLines = [];
+    try {
+        senseStatusLines = readSenseStatusLines();
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        senseStatusLines = [];
+        /* v8 ignore stop */
+    }
+    const bundleMeta = readBundleMetaFile();
+    let daemonHealth = null;
+    try {
+        daemonHealth = (0, daemon_health_1.readHealth)((0, daemon_health_1.getDefaultHealthPath)());
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        daemonHealth = null;
+        /* v8 ignore stop */
+    }
+    let journalFiles = [];
+    try {
+        const journalDir = path.join(agentRoot, "journal");
+        journalFiles = (0, prompt_1.readJournalFiles)(journalDir);
+    }
+    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        journalFiles = [];
+        /* v8 ignore stop */
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.turn_context_built",
+        message: "turn context snapshot assembled",
+        meta: {
+            channel: input.channel,
+            obligationCount: pendingObligations.length,
+            bridgeCount: activeBridges.length,
+            codingSessionCount: codingSessions.length,
+            episodeCount: recentEpisodes.length,
+        },
+    });
+    return {
+        activeBridges,
+        sessionActivity,
+        targetCandidates,
+        pendingObligations,
+        codingSessions,
+        otherCodingSessions,
+        innerWorkState,
+        taskBoard,
+        returnObligations,
+        recentEpisodes,
+        activeCares,
+        syncConfig,
+        syncFailure: undefined, // Set by pipeline after preTurnPull
+        daemonRunning,
+        senseStatusLines,
+        bundleMeta,
+        daemonHealth,
+        journalFiles,
+    };
+}

package/dist/heart/turn-coordinator.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTurnCoordinator = createTurnCoordinator;
+exports.withSharedTurnLock = withSharedTurnLock;
+exports.tryBeginSharedTurn = tryBeginSharedTurn;
+exports.endSharedTurn = endSharedTurn;
+exports.isSharedTurnActive = isSharedTurnActive;
+exports.enqueueSharedFollowUp = enqueueSharedFollowUp;
+exports.drainSharedFollowUps = drainSharedFollowUps;
 const runtime_1 = require("../nerves/runtime");
+function scopedKey(scope, key) {
+    return `${scope}:${key}`;
+}
 function createTurnCoordinator() {
     const turnLocks = new Map();
     const activeTurns = new Set();
@@ -60,3 +69,22 @@ function createTurnCoordinator() {
         },
     };
 }
+const _sharedTurnCoordinator = createTurnCoordinator();
+function withSharedTurnLock(scope, key, fn) {
+    return _sharedTurnCoordinator.withTurnLock(scopedKey(scope, key), fn);
+}
+function tryBeginSharedTurn(scope, key) {
+    return _sharedTurnCoordinator.tryBeginTurn(scopedKey(scope, key));
+}
+function endSharedTurn(scope, key) {
+    _sharedTurnCoordinator.endTurn(scopedKey(scope, key));
+}
+function isSharedTurnActive(scope, key) {
+    return _sharedTurnCoordinator.isTurnActive(scopedKey(scope, key));
+}
+function enqueueSharedFollowUp(scope, key, followUp) {
+    _sharedTurnCoordinator.enqueueFollowUp(scopedKey(scope, key), followUp);
+}
+function drainSharedFollowUps(scope, key) {
+    return _sharedTurnCoordinator.drainFollowUps(scopedKey(scope, key));
+}

package/dist/heart/{daemon → versioning}/ouro-bot-global-installer.js

@@ -38,7 +38,7 @@ const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
-const runtime_metadata_1 = require("./runtime-metadata");
+const runtime_metadata_1 = require("../daemon/runtime-metadata");
 function normalizeOutput(output) {
     return (typeof output === "string" ? output : output.toString("utf-8")).trim();
 }

package/dist/heart/{daemon → versioning}/ouro-bot-wrapper.js

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runOuroBotWrapper = runOuroBotWrapper;
 const runtime_1 = require("../../nerves/runtime");
-const daemon_cli_1 = require("./daemon-cli");
+const daemon_cli_1 = require("../daemon/daemon-cli");
 async function defaultLoadCanonicalRunner() {
     // Use the subpath export so we get the daemon-cli module directly,
     // NOT the root entry point which has side-effects (immediately runs the CLI).

package/dist/heart/{daemon → versioning}/ouro-path-installer.js

@@ -38,10 +38,30 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
-const CLI_PACKAGE_SPECIFIER = "@ouro.bot/cli@alpha";
 const WRAPPER_SCRIPT = `#!/bin/sh
-exec npx --yes ${CLI_PACKAGE_SPECIFIER} "$@"
+# Check for dev mode — if dev-config.json exists, dispatch to the dev repo
+# Skip dev dispatch for "up" command (explicitly returns to production)
+DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
+if [ -f "$DEV_CONFIG" ] && [ "$1" != "up" ]; then
+  DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
+  DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
+  if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then
+    exec node "$DEV_ENTRY" "$@"
+  fi
+fi
+# Fall back to installed version
+ENTRY="$HOME/.ouro-cli/CurrentVersion/node_modules/@ouro.bot/cli/dist/heart/daemon/ouro-entry.js"
+if [ ! -e "$ENTRY" ]; then
+  echo "ouro not installed. Run: npx ouro.bot" >&2
+  exit 1
+fi
+exec node "$ENTRY" "$@"
 `;
+function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync) {
+    mkdirSync(path.dirname(scriptPath), { recursive: true });
+    writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+    chmodSync(scriptPath, 0o755);
+}
 function detectShellProfile(homeDir, shell) {
     if (!shell)
         return null;
@@ -67,6 +87,16 @@ function buildPathExportLine(binDir, shell) {
     }
     return `\n# Added by ouro\nexport PATH="${binDir}:$PATH"\n`;
 }
+function isWrapperCurrent(scriptPath, existsSync, readFileSync) {
+    if (!existsSync(scriptPath))
+        return false;
+    try {
+        return readFileSync(scriptPath, "utf-8") === WRAPPER_SCRIPT;
+    }
+    catch {
+        return false;
+    }
+}
 function installOuroCommand(deps = {}) {
     /* v8 ignore start -- dep defaults: only used in real runtime, tests always inject @preserve */
     const platform = deps.platform ?? process.platform;
@@ -87,46 +117,59 @@ function installOuroCommand(deps = {}) {
             message: "skipped ouro PATH install on Windows",
             meta: { platform },
         });
-        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows" };
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows", repairedOldLauncher: false };
+    }
+    // Ensure ~/.ouro-cli/ directory layout exists
+    if (deps.ensureCliLayout) {
+        deps.ensureCliLayout();
     }
-    const binDir = path.join(homeDir, ".local", "bin");
+    const binDir = path.join(homeDir, ".ouro-cli", "bin");
     const scriptPath = path.join(binDir, "ouro");
-    (0, runtime_1.emitNervesEvent)({
-        component: "daemon",
-        event: "daemon.ouro_path_install_start",
-        message: "installing ouro command to PATH",
-        meta: { scriptPath, binDir },
-    });
-    // If ouro already exists, check content and repair if stale
-    if (existsSync(scriptPath)) {
-        let existingContent = "";
+    const oldScriptPath = path.join(homeDir, ".local", "bin", "ouro");
+    const modernCurrent = isWrapperCurrent(scriptPath, existsSync, readFileSync);
+    const oldExists = existsSync(oldScriptPath);
+    const oldCurrent = oldExists && isWrapperCurrent(oldScriptPath, existsSync, readFileSync);
+    // ── Repair old ~/.local/bin/ouro launcher ──
+    // If the old launcher exists with stale content it can shadow the modern
+    // path and cause the wrong CLI version to run.  Overwrite it with the
+    // current wrapper so both paths resolve to ~/.ouro-cli/CurrentVersion.
+    let repairedOldLauncher = false;
+    if (oldExists && !oldCurrent) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_repair_old",
+            message: "repairing stale old launcher at ~/.local/bin/ouro",
+            meta: { oldScriptPath },
+        });
         try {
-            existingContent = readFileSync(scriptPath, "utf-8");
+            writeFileSync(oldScriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+            chmodSync(oldScriptPath, 0o755);
+            repairedOldLauncher = true;
         }
         catch {
-            // Can't read — treat as stale, will overwrite below
-        }
-        if (existingContent === WRAPPER_SCRIPT) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "daemon",
-                event: "daemon.ouro_path_install_skip",
-                message: "ouro command already installed",
-                meta: { scriptPath },
-            });
-            return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed" };
+            // Best effort — old launcher repair failure must not block modern install
         }
-        // Content is stale — repair by overwriting
+    }
+    // ── Fast-path: modern wrapper already current ──
+    if (modernCurrent) {
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
-            event: "daemon.ouro_path_install_repair",
-            message: "repairing stale ouro wrapper script",
+            event: "daemon.ouro_path_install_skip",
+            message: "ouro command already installed",
             meta: { scriptPath },
         });
+        return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed", repairedOldLauncher };
     }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_start",
+        message: existsSync(scriptPath) ? "repairing stale ouro wrapper script" : "installing ouro command to PATH",
+        meta: { scriptPath, binDir },
+    });
     try {
-        mkdirSync(binDir, { recursive: true });
-        writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
-        chmodSync(scriptPath, 0o755);
+        if (!modernCurrent) {
+            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync);
+        }
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -136,11 +179,11 @@ function installOuroCommand(deps = {}) {
             message: "failed to install ouro command",
             meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
         });
-        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error) };
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error), repairedOldLauncher };
     }
-    // Check if ~/.local/bin is already in PATH
-    let shellProfileUpdated = null;
+    // Check if ~/.ouro-cli/bin is already in PATH
     const pathReady = isBinDirInPath(binDir, envPath);
+    let shellProfileUpdated = null;
     if (!pathReady) {
         const profilePath = detectShellProfile(homeDir, shell);
         if (profilePath) {
@@ -172,7 +215,7 @@ function installOuroCommand(deps = {}) {
         component: "daemon",
         event: "daemon.ouro_path_install_end",
         message: "ouro command installed",
-        meta: { scriptPath, pathReady, shellProfileUpdated },
+        meta: { scriptPath, pathReady, shellProfileUpdated, oldScriptPath: oldExists ? oldScriptPath : null },
     });
-    return { installed: true, scriptPath, pathReady, shellProfileUpdated };
+    return { installed: true, scriptPath, pathReady, shellProfileUpdated, repairedOldLauncher };
 }