@ouro.bot/cli 0.1.0-alpha.552 → 0.1.0-alpha.554

package/dist/heart/daemon/agent-config-check.js

@@ -41,13 +41,15 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const provider_models_1 = require("../provider-models");
-const machine_identity_1 = require("../machine-identity");
-const provider_state_1 = require("../provider-state");
 const provider_credentials_1 = require("../provider-credentials");
+const provider_readiness_cache_1 = require("../provider-readiness-cache");
 const vault_unlock_1 = require("../../repertoire/vault-unlock");
 const readiness_repair_1 = require("./readiness-repair");
 const provider_ping_progress_1 = require("./provider-ping-progress");
-const drift_detection_1 = require("./drift-detection");
+const LANES = [
+    { lane: "outward", facing: "humanFacing" },
+    { lane: "inner", facing: "agentFacing" },
+];
 function isAgentProvider(value) {
     return Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
 }
@@ -57,6 +59,9 @@ function agentRootFor(agentName, bundlesRoot) {
 function configPathFor(agentName, bundlesRoot) {
     return path.join(agentRootFor(agentName, bundlesRoot), "agent.json");
 }
+function laneForFacing(facing) {
+    return facing === "humanFacing" ? "outward" : "inner";
+}
 function resolveFacingProvider(parsed, facing, agentName, agentJsonPath) {
     const raw = parsed[facing];
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -90,9 +95,13 @@ function resolveFacingProvider(parsed, facing, agentName, agentJsonPath) {
             },
         };
     }
-    return { ok: true, selected: { facing, provider } };
+    const rawModel = raw.model;
+    const model = typeof rawModel === "string" && rawModel.trim().length > 0
+        ? rawModel.trim()
+        : (0, provider_models_1.getDefaultModelForProvider)(provider);
+    return { ok: true, selected: { facing, lane: laneForFacing(facing), provider, model } };
 }
-function readAgentConfigForProviderState(agentName, bundlesRoot) {
+function readAgentConfigForProviderCheck(agentName, bundlesRoot) {
     const agentJsonPath = configPathFor(agentName, bundlesRoot);
     let raw;
     try {
@@ -127,83 +136,25 @@ function readAgentConfigForProviderState(agentName, bundlesRoot) {
     }
     return { ok: true, disabled: false, agentJsonPath, parsed };
 }
-function readFacingForBootstrap(parsed, facing, agentName, agentJsonPath) {
-    const providerResult = resolveFacingProvider(parsed, facing, agentName, agentJsonPath);
-    if (!providerResult.ok) {
-        return {
-            ok: false,
-            result: {
-                ok: false,
-                error: providerResult.result.error,
-                fix: `Run 'ouro use --agent ${agentName} --lane ${facing === "humanFacing" ? "outward" : "inner"} --provider <provider> --model <model>' to configure this machine's provider binding.`,
-            },
-        };
-    }
-    const raw = parsed[facing];
-    const model = typeof raw.model === "string" && raw.model.trim().length > 0
-        ? raw.model.trim()
-        : (0, provider_models_1.getDefaultModelForProvider)(providerResult.selected.provider);
-    return { ok: true, provider: providerResult.selected.provider, model };
-}
-function bootstrapMissingProviderState(input) {
-    const outward = readFacingForBootstrap(input.parsed, "humanFacing", input.agentName, input.agentJsonPath);
-    if (!outward.ok)
-        return { ok: false, error: outward.result.error, fix: outward.result.fix };
-    const inner = readFacingForBootstrap(input.parsed, "agentFacing", input.agentName, input.agentJsonPath);
-    if (!inner.ok)
-        return { ok: false, error: inner.result.error, fix: inner.result.fix };
-    const now = new Date();
-    const homeDir = (0, provider_credentials_1.providerCredentialMachineHomeDir)(input.homeDir);
-    const machine = (0, machine_identity_1.loadOrCreateMachineIdentity)({ homeDir, now: () => now });
-    const state = (0, provider_state_1.bootstrapProviderStateFromAgentConfig)({
-        machineId: machine.machineId,
-        now,
-        agentConfig: {
-            humanFacing: { provider: outward.provider, model: outward.model },
-            agentFacing: { provider: inner.provider, model: inner.model },
-        },
-    });
-    const agentRoot = agentRootFor(input.agentName, input.bundlesRoot);
-    (0, provider_state_1.writeProviderState)(agentRoot, state);
-    (0, runtime_1.emitNervesEvent)({
-        component: "daemon",
-        event: "daemon.provider_state_bootstrapped",
-        message: "bootstrapped local provider state from agent config",
-        meta: { agent: input.agentName, agentRoot },
-    });
-    return { ok: true, agentRoot, state };
-}
-function readOrBootstrapProviderStateForCheck(agentName, bundlesRoot, deps = {}) {
-    const configResult = readAgentConfigForProviderState(agentName, bundlesRoot);
+function readProviderSelectionForCheck(agentName, bundlesRoot) {
+    const configResult = readAgentConfigForProviderCheck(agentName, bundlesRoot);
     if (!configResult.ok)
         return { ok: false, result: configResult.result };
     if (configResult.disabled)
         return { ok: true, disabled: true };
-    const agentRoot = agentRootFor(agentName, bundlesRoot);
-    const stateResult = (0, provider_state_1.readProviderState)(agentRoot);
-    if (stateResult.ok) {
-        return { ok: true, disabled: false, agentRoot, state: stateResult.state };
-    }
-    if (stateResult.reason === "invalid") {
-        return {
-            ok: false,
-            result: {
-                ok: false,
-                error: `provider state for ${agentName} is invalid at ${stateResult.statePath}: ${stateResult.error}`,
-                fix: `Run 'ouro use --agent ${agentName} --lane outward --provider <provider> --model <model> --force' to rewrite this machine's provider binding.`,
-            },
-        };
+    const bindings = {};
+    for (const { lane, facing } of LANES) {
+        const selected = resolveFacingProvider(configResult.parsed, facing, agentName, configResult.agentJsonPath);
+        if (!selected.ok)
+            return { ok: false, result: selected.result };
+        bindings[lane] = selected.selected;
     }
-    const bootstrap = bootstrapMissingProviderState({
-        agentName,
-        bundlesRoot,
-        parsed: configResult.parsed,
-        agentJsonPath: configResult.agentJsonPath,
-        homeDir: deps.homeDir,
-    });
-    if (!bootstrap.ok)
-        return { ok: false, result: bootstrap };
-    return { ok: true, disabled: false, agentRoot: bootstrap.agentRoot, state: bootstrap.state };
+    return {
+        ok: true,
+        disabled: false,
+        agentRoot: agentRootFor(agentName, bundlesRoot),
+        bindings,
+    };
 }
 function providerCredentialConfig(record) {
     return {
@@ -216,21 +167,6 @@ function pingAttemptCount(result) {
         return result.attempts.length;
     return undefined;
 }
-function writeLaneReadiness(input) {
-    const binding = input.state.lanes[input.lane];
-    const checkedAt = new Date().toISOString();
-    input.state.updatedAt = checkedAt;
-    input.state.readiness[input.lane] = {
-        status: input.status,
-        provider: binding.provider,
-        model: binding.model,
-        checkedAt,
-        credentialRevision: input.credentialRevision,
-        ...(input.error ? { error: input.error } : {}),
-        ...(input.attempts !== undefined ? { attempts: input.attempts } : {}),
-    };
-    (0, provider_state_1.writeProviderState)(input.agentRoot, input.state);
-}
 function missingCredentialResult(agentName, lane, provider, model, credentialPath) {
     return {
         ok: false,
@@ -325,14 +261,14 @@ function laneAudienceLabel(lane) {
 function bindingLabel(binding) {
     return `${binding.provider} / ${binding.model}`;
 }
-function selectedProviderPlan(agentName, state) {
+function selectedProviderPlan(agentName, bindings) {
     return [
-        `${agentName}: checking the providers this agent uses right now`,
-        ...["outward", "inner"].map((lane) => `- ${laneAudienceLabel(lane)}: ${bindingLabel(state.lanes[lane])}`),
+        `${agentName}: checking the providers in agent.json`,
+        ...LANES.map(({ lane }) => `- ${laneAudienceLabel(lane)}: ${bindingLabel(bindings[lane])}`),
     ].join("\n");
 }
-function selectedProvidersForState(state) {
-    return [...new Set(["outward", "inner"].map((lane) => state.lanes[lane].provider))];
+function selectedProvidersForBindings(bindings) {
+    return [...new Set(LANES.map(({ lane }) => bindings[lane].provider))];
 }
 function mapVaultRefreshProgress(agentName, onProgress) {
     return (message) => {
@@ -359,80 +295,52 @@ function providerPingSubject(agentName, lanes) {
  * checkAgentConfigWithProviderHealth(), which reads the agent vault and pings.
  */
 function checkAgentConfig(agentName, bundlesRoot) {
-    const configResult = readAgentConfigForProviderState(agentName, bundlesRoot);
-    if (!configResult.ok)
-        return configResult.result;
-    if (configResult.disabled)
+    const selectionResult = readProviderSelectionForCheck(agentName, bundlesRoot);
+    if (!selectionResult.ok)
+        return selectionResult.result;
+    if (selectionResult.disabled)
         return { ok: true };
-    const outward = readFacingForBootstrap(configResult.parsed, "humanFacing", agentName, configResult.agentJsonPath);
-    if (!outward.ok)
-        return outward.result;
-    const inner = readFacingForBootstrap(configResult.parsed, "agentFacing", agentName, configResult.agentJsonPath);
-    if (!inner.ok)
-        return inner.result;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.agent_config_valid",
         message: "agent config validation passed",
         meta: {
             agent: agentName,
-            providers: [...new Set([outward.provider, inner.provider])],
+            providers: selectedProvidersForBindings(selectionResult.bindings),
             liveProviderCheck: false,
         },
     });
     return { ok: true };
 }
 async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps = {}) {
-    const stateResult = readOrBootstrapProviderStateForCheck(agentName, bundlesRoot, deps);
-    if (!stateResult.ok)
-        return stateResult.result;
-    if (stateResult.disabled)
+    const selectionResult = readProviderSelectionForCheck(agentName, bundlesRoot);
+    if (!selectionResult.ok)
+        return selectionResult.result;
+    if (selectionResult.disabled)
         return { ok: true };
-    // Layer 4 drift detection. Runs once per call after state setup so that
-    // drift findings ride along regardless of ping outcome — consumers
-    // (Layer 4 rollup, Layer 3 RepairGuide) want to see drift even when a
-    // live-check is failing for unrelated reasons. Drift detection is pure
-    // and never throws on a malformed agent.json: any read error here would
-    // indicate the bundle disappeared between state setup and now (a
-    // race), which we surface as `[]` rather than a hard failure.
-    let driftFindings = [];
-    try {
-        const inputs = (0, drift_detection_1.loadDriftInputsForAgent)(bundlesRoot, agentName);
-        driftFindings = (0, drift_detection_1.detectProviderBindingDrift)({
-            agentName,
-            agentJson: inputs.agentJson,
-            providerState: inputs.providerState,
-        });
-    }
-    catch {
-        /* v8 ignore next 1 -- defensive race-window guard: agent.json went away after state setup. Tested via Unit 5 integration when at all. @preserve */
-        driftFindings = [];
-    }
-    deps.onProgress?.(selectedProviderPlan(agentName, stateResult.state));
+    deps.onProgress?.(selectedProviderPlan(agentName, selectionResult.bindings));
     const ping = deps.pingProvider ?? (await Promise.resolve().then(() => __importStar(require("../provider-ping")))).pingProvider;
-    const shouldRecordReadiness = deps.recordReadiness ?? true;
-    const providers = selectedProvidersForState(stateResult.state);
+    const providers = selectedProvidersForBindings(selectionResult.bindings);
     const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, {
         ...(deps.onProgress ? { onProgress: mapVaultRefreshProgress(agentName, deps.onProgress) } : {}),
         providers,
         preserveCachedOnFailure: true,
     });
     const pingGroups = new Map();
-    const lanes = ["outward", "inner"];
-    for (const lane of lanes) {
-        const binding = stateResult.state.lanes[lane];
+    for (const { lane } of LANES) {
+        const binding = selectionResult.bindings[lane];
         if (!poolResult.ok) {
             if (poolResult.reason === "missing") {
-                return { ...missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath), driftFindings };
+                return missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath);
             }
-            return { ...invalidPoolResult(agentName, lane, binding.provider, binding.model, {
-                    ...poolResult,
-                    reason: poolResult.reason,
-                }), driftFindings };
+            return invalidPoolResult(agentName, lane, binding.provider, binding.model, {
+                ...poolResult,
+                reason: poolResult.reason,
+            });
         }
         const record = credentialRecordForLane(poolResult.pool, binding.provider);
         if (!record) {
-            return { ...missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath), driftFindings };
+            return missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath);
         }
         const key = `${binding.provider}\0${binding.model}\0${record.revision}`;
         const group = pingGroups.get(key);
@@ -466,37 +374,37 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
     let firstFailure = null;
     for (const { group, result } of pingResults) {
         if (!result.ok) {
-            if (shouldRecordReadiness) {
-                for (const lane of group.lanes) {
-                    writeLaneReadiness({
-                        agentRoot: stateResult.agentRoot,
-                        state: stateResult.state,
-                        lane,
-                        status: "failed",
-                        credentialRevision: group.record.revision,
-                        error: result.message,
-                        attempts: pingAttemptCount(result),
-                    });
-                }
-            }
-            firstFailure ??= failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
-            continue;
-        }
-        if (shouldRecordReadiness) {
             for (const lane of group.lanes) {
-                writeLaneReadiness({
-                    agentRoot: stateResult.agentRoot,
-                    state: stateResult.state,
+                (0, provider_readiness_cache_1.recordProviderLaneReadiness)({
+                    agentName,
                     lane,
-                    status: "ready",
+                    provider: group.provider,
+                    model: group.model,
                     credentialRevision: group.record.revision,
+                    status: "failed",
+                    checkedAt: new Date().toISOString(),
+                    error: result.message,
                     attempts: pingAttemptCount(result),
                 });
             }
+            firstFailure ??= failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
+            continue;
+        }
+        for (const lane of group.lanes) {
+            (0, provider_readiness_cache_1.recordProviderLaneReadiness)({
+                agentName,
+                lane,
+                provider: group.provider,
+                model: group.model,
+                credentialRevision: group.record.revision,
+                status: "ready",
+                checkedAt: new Date().toISOString(),
+                attempts: pingAttemptCount(result),
+            });
         }
     }
     if (firstFailure)
-        return { ...firstFailure, driftFindings };
+        return firstFailure;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.agent_config_valid",
@@ -505,8 +413,7 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
             agent: agentName,
             providers: [...new Set([...pingGroups.values()].map((group) => group.provider))],
             liveProviderCheck: true,
-            driftCount: driftFindings.length,
         },
     });
-    return { ok: true, driftFindings };
+    return { ok: true };
 }

package/dist/heart/daemon/agentic-repair.js

@@ -68,7 +68,7 @@ function buildSystemPrompt(degraded) {
         "and the simplest fix the user can apply.",
     ].join("\n");
 }
-function buildUserMessage(degraded, logsTail, driftFindings = [], syncFindings = []) {
+function buildUserMessage(degraded, logsTail, syncFindings = []) {
     const agentDetails = degraded
         .map((d) => `Agent: ${d.agent}\n  Error: ${d.errorReason}\n  Fix hint: ${d.fixHint}`)
         .join("\n\n");
@@ -80,13 +80,6 @@ function buildUserMessage(degraded, logsTail, driftFindings = [], syncFindings =
         "Recent daemon logs:",
         logsTail,
     ];
-    // Layer 3: thread Layer 4's structured drift findings into the prompt as
-    // a JSON block. The `diagnose-bootstrap-drift` skill (loaded into the
-    // system prompt by `buildSystemPromptWithRepairGuide`) instructs the LLM
-    // how to read this shape and what `ouro use` repair to propose.
-    if (driftFindings.length > 0) {
-        sections.push("", "driftFindings (DriftFinding[]):", "```json", JSON.stringify(driftFindings, null, 2), "```");
-    }
     // Layer 3: thread Layer 2's structured sync-probe findings into the
     // prompt as a JSON block. `diagnose-broken-remote` (auth/404/network/
     // timeout-hard) and `diagnose-sync-blocked` (dirty/non-fast-forward/
@@ -158,7 +151,7 @@ async function tryAgenticDiagnosis(degraded, provider, deps) {
     const repoRoot = deps.repoRootOverride ?? (0, identity_1.getRepoRoot)();
     const repairGuide = loadRepairGuideContent(repoRoot);
     const systemPrompt = buildSystemPromptWithRepairGuide(degraded, repairGuide);
-    const userMessage = buildUserMessage(degraded, logsTail, deps.driftFindings, deps.syncFindings);
+    const userMessage = buildUserMessage(degraded, logsTail, deps.syncFindings);
     const messages = [
         { role: "system", content: systemPrompt },
         { role: "user", content: userMessage },

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

@@ -77,7 +77,10 @@ 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) {
+async function defaultStartDaemonProcess(socketPath) {
+    const launchdStarted = await startDaemonProcessViaLaunchd(socketPath);
+    if (launchdStarted)
+        return launchdStarted;
     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.
@@ -89,7 +92,7 @@ function defaultStartDaemonProcess(socketPath) {
     });
     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 });
+    return { pid: child.pid ?? null };
 }
 function defaultWriteStdout(text) {
     process.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
@@ -224,6 +227,32 @@ function currentUserUid() {
 function launchAgentDomain(userUid = currentUserUid()) {
     return `gui/${userUid}`;
 }
+function writeDaemonBootPlist(socketPath) {
+    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 = resolveDaemonBootEntryPath(homeDir);
+    /* 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 },
+        });
+    }
+    return (0, launchd_1.writeLaunchAgentPlist)(writeDeps, {
+        nodePath: process.execPath,
+        entryPath,
+        socketPath,
+        logDir: (0, identity_1.getAgentDaemonLogsDir)(),
+        envPath: process.env.PATH,
+    });
+}
 function isDaemonLaunchAgentLoaded(deps) {
     const userUid = deps?.userUid ?? currentUserUid();
     const exec = deps?.exec ?? ((cmd) => { (0, child_process_1.execSync)(cmd, { stdio: "ignore" }); });
@@ -235,6 +264,16 @@ function isDaemonLaunchAgentLoaded(deps) {
         return false;
     }
 }
+function readDaemonLaunchAgentPid() {
+    try {
+        const output = (0, child_process_1.execSync)(`launchctl print ${launchAgentDomain()}/${launchd_1.DAEMON_PLIST_LABEL}`, { encoding: "utf-8" });
+        const match = output.match(/^\s*pid = (\d+)/m);
+        return match ? Number(match[1]) : null;
+    }
+    catch {
+        return null;
+    }
+}
 async function waitForBootstrappedDaemonSocket(socketPath, deps = {}) {
     const checkSocketAlive = deps.checkSocketAlive ?? socket_client_1.checkDaemonSocketAlive;
     const now = deps.now ?? Date.now;
@@ -267,69 +306,60 @@ async function waitForBootstrappedDaemonSocket(socketPath, deps = {}) {
         meta: { socketPath },
     });
 }
-async function defaultEnsureDaemonBootPersistence(socketPath) {
+async function startDaemonProcessViaLaunchd(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 = resolveDaemonBootEntryPath(homeDir);
-    /* 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 },
-        });
+        return null;
     }
-    const logDir = (0, identity_1.getAgentDaemonLogsDir)();
-    const plistPath = (0, launchd_1.writeLaunchAgentPlist)(writeDeps, {
-        nodePath: process.execPath,
-        entryPath,
-        socketPath,
-        logDir,
-        envPath: process.env.PATH,
-    });
+    const plistPath = writeDaemonBootPlist(socketPath);
     const userUid = currentUserUid();
-    if (isDaemonLaunchAgentLoaded({ exec: (cmd) => { (0, child_process_1.execSync)(cmd, { stdio: "ignore" }); }, userUid })) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "daemon",
-            event: "daemon.launchd_bootstrap_skipped_loaded",
-            message: "daemon launch agent already loaded",
-            meta: { plistPath, label: launchd_1.DAEMON_PLIST_LABEL },
-        });
-        return;
-    }
+    const domain = launchAgentDomain(userUid);
     try {
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.launchd_bootstrap_start",
-            message: "bootstrapping daemon launch agent for current login session",
+            message: "starting daemon launch agent for current login session",
             meta: { plistPath, label: launchd_1.DAEMON_PLIST_LABEL },
         });
-        (0, child_process_1.execSync)(`launchctl bootstrap ${launchAgentDomain(userUid)} "${plistPath}"`, { stdio: "ignore" });
+        if (isDaemonLaunchAgentLoaded({ exec: (cmd) => { (0, child_process_1.execSync)(cmd, { stdio: "ignore" }); }, userUid })) {
+            (0, child_process_1.execSync)(`launchctl kickstart -k ${domain}/${launchd_1.DAEMON_PLIST_LABEL}`, { stdio: "ignore" });
+        }
+        else {
+            (0, child_process_1.execSync)(`launchctl bootstrap ${domain} "${plistPath}"`, { stdio: "ignore" });
+        }
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.launchd_bootstrap_end",
-            message: "daemon launch agent bootstrapped for current login session",
+            message: "daemon launch agent started for current login session",
             meta: { plistPath, label: launchd_1.DAEMON_PLIST_LABEL },
         });
         await waitForBootstrappedDaemonSocket(socketPath);
+        return { pid: readDaemonLaunchAgentPid() };
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "daemon",
             event: "daemon.launchd_bootstrap_error",
-            message: "failed to bootstrap daemon launch agent for current login session",
+            message: "failed to start daemon launch agent for current login session",
             meta: { plistPath, label: launchd_1.DAEMON_PLIST_LABEL, error: error instanceof Error ? error.message : String(error) },
         });
+        return null;
+    }
+}
+async function defaultEnsureDaemonBootPersistence(socketPath) {
+    if (process.platform !== "darwin") {
+        return;
+    }
+    const plistPath = writeDaemonBootPlist(socketPath);
+    const userUid = currentUserUid();
+    if (isDaemonLaunchAgentLoaded({ exec: (cmd) => { (0, child_process_1.execSync)(cmd, { stdio: "ignore" }); }, userUid })) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.launchd_bootstrap_skipped_loaded",
+            message: "daemon launch agent already loaded",
+            meta: { plistPath, label: launchd_1.DAEMON_PLIST_LABEL },
+        });
+        return;
     }
 }
 function defaultPrepareDaemonRuntimeReplacement() {