@ouro.bot/cli 0.1.0-alpha.697 → 0.1.0-alpha.698

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.698",
+      "changes": [
+        "Open the daemon socket before provider credential warm-up and preload only configured lane providers so slow vault reads cannot make ouro up falsely report a dead daemon.",
+        "Require explicitly selected provider credential refreshes to load every requested provider before replacing cached provider state.",
+        "Return structured RSVP smoke guidance when the latest snapshot is missing or invalid, with hermetic CLI coverage that cannot send live BlueBubbles messages from tests.",
+        "Keep native RSVP update notifications on the legacy message skeleton while replacing only the obsolete script-vs-Slugger footer copy."
+      ]
+    },
     {
       "version": "0.1.0-alpha.697",
       "changes": [

package/dist/heart/agent-entry.js

@@ -119,6 +119,35 @@ if (!ipcState.installed) {
     message: "starting private-runtime process entrypoint",
     meta: { entry: "private-runtime", agentName },
 });
+async function selectedProviderTargets(agentName) {
+    try {
+        const [{ readAgentConfigForAgent }, { getAgentBundlesRoot }] = await Promise.all([
+            Promise.resolve().then(() => __importStar(require("./auth/auth-flow"))),
+            Promise.resolve().then(() => __importStar(require("./identity"))),
+        ]);
+        const { config } = readAgentConfigForAgent(agentName, getAgentBundlesRoot());
+        return [...new Set([config.humanFacing.provider, config.agentFacing.provider])];
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.provider_refresh_skipped",
+            message: "skipping private-runtime provider credential refresh because agent config could not be read",
+            meta: {
+                entry: "private-runtime",
+                agentName,
+                error: error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error agent-config failures @preserve */ String(error),
+            },
+        });
+        return [];
+    }
+}
+function providerPoolMissingTargets(providerPool, providers) {
+    if (!providerPool.ok)
+        return true;
+    return providers.some((provider) => !providerPool.pool.providers[provider]);
+}
 // Dynamic import: agent-entry is process-start wiring that starts a sense process.
 // Using dynamic import avoids a static heart/ -> senses/ dependency.
 Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).then(async ({ readMachineRuntimeCredentialConfig, readRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, refreshRuntimeCredentialConfig, applyRuntimeCredentialBootstrapMessage, waitForRuntimeCredentialBootstrap, }) => {
@@ -135,8 +164,9 @@ Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).the
         void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
     }
     const providerPool = readProviderCredentialPool(agentName);
-    if (!providerPool.ok || Object.keys(providerPool.pool.providers).length === 0) {
-        await refreshProviderCredentialPool(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    const providerTargets = await selectedProviderTargets(agentName);
+    if (providerTargets.length > 0 && providerPoolMissingTargets(providerPool, providerTargets)) {
+        await refreshProviderCredentialPool(agentName, { preserveCachedOnFailure: true, providers: providerTargets }).catch(() => undefined);
     }
     /* v8 ignore next 7 -- process-start best-effort machine credential refresh runs in a child entrypoint and is covered operationally by daemon startup tests @preserve */
     if (!readMachineRuntimeCredentialConfig(agentName).ok) {

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

@@ -68,6 +68,7 @@ const context_loss_sentinel_1 = require("../context-loss-sentinel");
 const provider_credentials_1 = require("../provider-credentials");
 const runtime_credentials_1 = require("../runtime-credentials");
 const machine_identity_1 = require("../machine-identity");
+const auth_flow_1 = require("../auth/auth-flow");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -483,16 +484,116 @@ function writeStopCommandHealthState() {
         // Health writes are best-effort during shutdown.
     }
 }
+function providerPreloadTargets(agent) {
+    try {
+        const { config } = (0, auth_flow_1.readAgentConfigForAgent)(agent, (0, identity_1.getAgentBundlesRoot)());
+        return [...new Set([config.humanFacing.provider, config.agentFacing.provider])];
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.provider_preload_skipped",
+            message: "skipping provider credential preload because agent config could not be read",
+            meta: {
+                agent,
+                error: error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error config-read failures @preserve */ String(error),
+            },
+        });
+        return [];
+    }
+}
+function providerPreloadMissingTargets(result, providers) {
+    return providers.filter((provider) => !result.pool.providers[provider]);
+}
 async function preloadProviderCredentialPools() {
-    await Promise.all(managedAgents.map((agent) => (0, provider_credentials_1.refreshProviderCredentialPool)(agent, { preserveCachedOnFailure: true })));
+    await Promise.all(managedAgents.map(async (agent) => {
+        const providers = providerPreloadTargets(agent);
+        if (providers.length === 0)
+            return;
+        const result = await (0, provider_credentials_1.refreshProviderCredentialPool)(agent, { preserveCachedOnFailure: true, providers, skipCache: true });
+        if (result.ok) {
+            const missingProviders = providerPreloadMissingTargets(result, providers);
+            if (missingProviders.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.provider_preload_unavailable",
+                    message: "provider credential preload returned an incomplete selected provider cache",
+                    meta: {
+                        agent,
+                        reason: "missing",
+                        error: `missing selected providers: ${missingProviders.join(", ")}`,
+                    },
+                });
+                return;
+            }
+            const records = Object.values(result.pool.providers).filter((record) => !!record);
+            (0, provider_credentials_1.cacheProviderCredentialRecords)(agent, records, new Date(result.pool.updatedAt));
+            return;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.provider_preload_unavailable",
+            message: "provider credential preload could not refresh selected provider cache",
+            meta: {
+                agent,
+                reason: result.reason,
+                error: result.error,
+            },
+        });
+    }));
+}
+function startProviderCredentialPoolPreload() {
+    return preloadProviderCredentialPools().catch((error) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.provider_preload_error",
+            message: "provider credential preload failed after daemon startup",
+            meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error provider preload failures @preserve */ String(error) },
+        });
+    });
+}
+function scheduleStartupSentinelAfterProviderPreload(agent, preload) {
+    void preload.then(async () => {
+        const result = await refreshDaemonSentinel(agent, "daemon_startup");
+        if (result.status === "critical") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.startup_sentinel_error",
+                message: "startup Sentinel refresh reported critical after provider preload",
+                meta: {
+                    agent,
+                    error: result.message,
+                },
+            });
+        }
+        /* v8 ignore start -- refreshDaemonSentinel handles ordinary Sentinel failures; this is a promise-chain guard. @preserve */
+    }).catch((error) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.startup_sentinel_error",
+            message: "startup Sentinel refresh failed after provider preload",
+            meta: {
+                agent,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+    });
+    /* v8 ignore stop */
 }
 /* v8 ignore start -- habit wiring: lambdas delegate to processManager/fs; tested via HabitScheduler unit tests @preserve */
-void preloadProviderCredentialPools().then(() => daemon.start()).then(async () => {
+void daemon.start().then(async () => {
+    const providerPreload = startProviderCredentialPoolPreload();
     const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
     const ouroPath = (0, os_cron_deps_1.resolveOuroBinaryPath)();
     const osCronDeps = (0, os_cron_deps_1.createRealOsCronDeps)();
     for (const agent of managedAgents) {
-        await refreshDaemonSentinel(agent, "daemon_startup");
+        scheduleStartupSentinelAfterProviderPreload(agent, providerPreload);
         const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
         const habitsDir = path.join(bundleRoot, "habits");
         const degradedComponent = `habits:${agent}`;

package/dist/heart/provider-credentials.js

@@ -241,6 +241,7 @@ function readProviderCredentialPool(agentName) {
 }
 async function refreshProviderCredentialPool(agentName, options = {}) {
     const providersToRead = selectedProviders(options.providers);
+    const requiresAllSelectedProviders = !!options.providers && options.providers.length > 0;
     try {
         const store = (0, credential_access_1.getCredentialStore)(agentName);
         options.onProgress?.(`reading vault items for ${agentName}...`);
@@ -266,6 +267,21 @@ async function refreshProviderCredentialPool(agentName, options = {}) {
                 updatedAt = record.updatedAt;
         }
         options.onProgress?.("parsing provider credentials...");
+        const missingRequestedProviders = requiresAllSelectedProviders
+            ? providersToRead.filter((provider) => !providers[provider])
+            : [];
+        if (missingRequestedProviders.length > 0) {
+            const cached = cachedPools.get(agentName);
+            const result = {
+                ok: false,
+                reason: "missing",
+                poolPath: providerCredentialsVaultPath(agentName),
+                error: `requested provider credentials missing from ${providerCredentialsVaultPath(agentName)}: ${missingRequestedProviders.join(", ")}`,
+            };
+            if (options.preserveCachedOnFailure && cached?.ok)
+                return cached;
+            return options.skipCache ? result : cacheResult(agentName, result);
+        }
         const pool = {
             schemaVersion: 1,
             updatedAt,

package/dist/rsvp/cli.js

@@ -178,8 +178,21 @@ function readBaselineSnapshot(agentRoot) {
         ? parseSnapshotFromFile(snapshotFilePath(agentRoot, snapshotId))
         : null;
 }
-function readLatestSnapshot(agentRoot) {
-    return parseSnapshotFromFile(latestSnapshotPath(agentRoot));
+function resolveLatestSnapshot(agentRoot) {
+    const filePath = latestSnapshotPath(agentRoot);
+    if (!fs.existsSync(filePath)) {
+        return { ok: false, path: filePath, message: "latest RSVP snapshot missing; run `ouro rsvp refresh --mode shadow --no-send` first" };
+    }
+    try {
+        return { ok: true, snapshot: parseSnapshotFromFile(filePath) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            path: filePath,
+            message: error instanceof Error ? error.message : /* v8 ignore next -- fs and snapshot parsing failures are Error instances. @preserve */ String(error),
+        };
+    }
 }
 function machineIdForCli() {
     return (0, machine_identity_1.loadOrCreateMachineIdentity)().machineId;
@@ -609,7 +622,19 @@ async function executeSmoke(command, deps) {
             result: configResult,
         });
     }
-    const snapshot = readLatestSnapshot(agentRoot);
+    const snapshotResult = resolveLatestSnapshot(agentRoot);
+    if (!snapshotResult.ok) {
+        return {
+            ...basePayload(command, false, "RSVP smoke requires latest RSVP snapshot before follow-up can run", {
+                allowSend: command.allowSend === true,
+                sendAllowed: false,
+                requires: "latest RSVP snapshot",
+                result: snapshotResult,
+            }),
+            ok: false,
+        };
+    }
+    const snapshot = snapshotResult.snapshot;
     const question = command.question ?? "who is pending?";
     const answer = (0, query_1.queryRsvpSnapshot)(snapshot, { query: question });
     const wantsLiveSend = command.mode === "live" && command.allowSend === true;

package/dist/rsvp/diff-renderer.js

@@ -4,6 +4,7 @@ exports.guestDisplayName = guestDisplayName;
 exports.computeRsvpDelta = computeRsvpDelta;
 exports.renderRsvpReport = renderRsvpReport;
 const runtime_1 = require("../nerves/runtime");
+const RSVP_REPORT_FOOTER = "🤖 Beep boop! Automated RSVP update from Slugger — no need to reply here!";
 function byId(left, right) {
     return left.id.localeCompare(right.id);
 }
@@ -108,7 +109,7 @@ function hasChanges(delta) {
 function renderRsvpReport(delta) {
     const lines = ["RSVP Update — Ari & Rachel", ""];
     if (delta.isFirstRun) {
-        lines.push("First native RSVP check — current summary:", "");
+        lines.push("First check — here's the current summary:", "");
     }
     else if (!hasChanges(delta)) {
         lines.push("No changes since last check.", "");
@@ -144,6 +145,7 @@ function renderRsvpReport(delta) {
         }
     }
     lines.push(summaryLine(delta.summary));
+    lines.push("", RSVP_REPORT_FOOTER);
     const report = lines.join("\n");
     (0, runtime_1.emitNervesEvent)({
         component: "rsvp",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.697",
+  "version": "0.1.0-alpha.698",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",