@ouro.bot/cli 0.1.0-alpha.422 → 0.1.0-alpha.425

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

@@ -71,6 +71,7 @@ const auth_flow_1 = require("../auth/auth-flow");
 const provider_credentials_1 = require("../provider-credentials");
 const runtime_credentials_1 = require("../runtime-credentials");
 const provider_binding_resolver_1 = require("../provider-binding-resolver");
+const provider_visibility_1 = require("../provider-visibility");
 const provider_state_1 = require("../provider-state");
 const machine_identity_1 = require("../machine-identity");
 const provider_models_1 = require("../provider-models");
@@ -157,6 +158,132 @@ async function listCliAgents(deps) {
     }
     return [];
 }
+function runtimeContextAgentName(deps) {
+    try {
+        return deps.whoamiInfo?.().agentName.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeCliAgentNames(agentNames) {
+    return [...new Set(agentNames.map((agent) => agent.trim()).filter((agent) => agent.length > 0))];
+}
+function resolveSelectedCliAgent(answer, agentNames) {
+    const trimmed = answer.trim();
+    if (!trimmed)
+        return undefined;
+    const byName = agentNames.find((agent) => agent.toLowerCase() === trimmed.toLowerCase());
+    if (byName)
+        return byName;
+    const parsedIndex = Number.parseInt(trimmed, 10);
+    if (Number.isNaN(parsedIndex))
+        return undefined;
+    return agentNames[parsedIndex - 1];
+}
+function noAgentsFoundMessage() {
+    return "no agents found. Run `ouro` to hatch one or `ouro clone <remote>` to add an existing agent.";
+}
+function multipleAgentsFoundMessage(agentNames) {
+    return [
+        `multiple agents found: ${agentNames.join(", ")}`,
+        "Re-run with --agent <name>.",
+    ].join("\n");
+}
+function invalidAgentSelectionMessage(agentNames) {
+    return [
+        `invalid agent selection. Available agents: ${agentNames.join(", ")}`,
+        "Re-run with --agent <name>.",
+    ].join("\n");
+}
+function agentResolutionFailureMode(command) {
+    switch (command.kind) {
+        case "task.board":
+        case "task.create":
+        case "task.update":
+        case "task.show":
+        case "task.actionable":
+        case "task.deps":
+        case "task.sessions":
+        case "task.fix":
+        case "reminder.create":
+        case "friend.list":
+        case "friend.show":
+        case "friend.create":
+        case "friend.update":
+        case "habit.list":
+        case "habit.create":
+        case "thoughts":
+        case "attention.list":
+        case "attention.show":
+        case "attention.history":
+        case "inner.status":
+        case "session.list":
+            return "return-message";
+        case "provider.use":
+        case "provider.check":
+        case "provider.status":
+        case "provider.refresh":
+        case "vault.create":
+        case "vault.replace":
+        case "vault.recover":
+        case "vault.unlock":
+        case "vault.status":
+        case "vault.config.set":
+        case "vault.config.status":
+        case "connect":
+        case "auth.run":
+        case "auth.verify":
+        case "auth.switch":
+        case "config.model":
+        case "config.models":
+        case "setup":
+        case "bluebubbles.replay":
+            return "throw";
+        default:
+            return undefined;
+    }
+}
+async function resolveMissingAgentName(deps, failureMode) {
+    const runtimeAgent = runtimeContextAgentName(deps);
+    if (runtimeAgent) {
+        return { ok: true, agent: runtimeAgent };
+    }
+    const discoveredAgents = normalizeCliAgentNames(await listCliAgents(deps));
+    if (discoveredAgents.length === 0) {
+        return { ok: false, message: noAgentsFoundMessage(), failureMode };
+    }
+    if (discoveredAgents.length === 1) {
+        return { ok: true, agent: discoveredAgents[0] };
+    }
+    if (!deps.promptInput) {
+        return { ok: false, message: multipleAgentsFoundMessage(discoveredAgents), failureMode };
+    }
+    const answer = await deps.promptInput([
+        "Which agent should this use?",
+        ...discoveredAgents.map((agent, index) => `${index + 1}. ${agent}`),
+        `Choose [1-${discoveredAgents.length}] or type a name: `,
+    ].join("\n"));
+    const selectedAgent = resolveSelectedCliAgent(answer, discoveredAgents);
+    if (!selectedAgent) {
+        return { ok: false, message: invalidAgentSelectionMessage(discoveredAgents), failureMode };
+    }
+    return { ok: true, agent: selectedAgent };
+}
+async function resolveCommandAgent(command, deps) {
+    const failureMode = agentResolutionFailureMode(command);
+    if (!failureMode) {
+        return { ok: true, command: command };
+    }
+    const explicitAgent = "agent" in command && typeof command.agent === "string" ? command.agent.trim() : "";
+    if (explicitAgent) {
+        return { ok: true, command: { ...command, agent: explicitAgent } };
+    }
+    const resolvedAgent = await resolveMissingAgentName(deps, failureMode);
+    if (!resolvedAgent.ok)
+        return resolvedAgent;
+    return { ok: true, command: { ...command, agent: resolvedAgent.agent } };
+}
 function managedAgentsSignature(agentNames) {
     const unique = [...new Set(agentNames.map((agent) => agent.trim()).filter((agent) => agent.length > 0))].sort();
     return unique.length > 0 ? unique.join(",") : "(none)";
@@ -197,7 +324,7 @@ async function runCommandProgressPhase(progress, label, run, detail) {
         return result;
     }
     catch (error) {
-        progress.completePhase(label, "failed");
+        progress.failPhase(label, "failed");
         throw error;
     }
 }
@@ -1227,6 +1354,50 @@ function currentMachineId(deps) {
         now: () => providerCliNow(deps),
     }).machineId;
 }
+const DEFAULT_RUNTIME_APPLY_TIMEOUT_MS = 15_000;
+const DEFAULT_RUNTIME_APPLY_POLL_INTERVAL_MS = 500;
+const DEFAULT_DAEMON_STATUS_TIMEOUT_MS = 4_000;
+const DEFAULT_AGENT_RESTART_TIMEOUT_MS = 8_000;
+const CONNECT_PROVIDER_CHOICES = ["openai-codex", "anthropic", "minimax", "azure", "github-copilot"];
+function hasRuntimeConfigValue(config, key) {
+    const segments = key.split(".");
+    let cursor = config;
+    for (const segment of segments) {
+        if (!cursor || typeof cursor !== "object" || Array.isArray(cursor))
+            return false;
+        cursor = cursor[segment];
+    }
+    return typeof cursor === "string" && cursor.trim().length > 0;
+}
+function runtimeConfigReadStatus(runtime) {
+    if (runtime.reason === "missing")
+        return "missing";
+    if (/locked/i.test(runtime.error))
+        return "locked";
+    return "needs attention";
+}
+function cliNowMs(deps) {
+    return (deps.now ?? Date.now)();
+}
+function cliSleep(deps, ms) {
+    if (deps.sleep)
+        return deps.sleep(ms);
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withCliTimeout(timeoutMs, label, run) {
+    let timer;
+    try {
+        return await Promise.race([
+            run(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(label)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 async function promptRuntimeConfigValue(command, deps) {
     if (command.value !== undefined)
         return command.value;
@@ -1242,7 +1413,7 @@ async function promptRuntimeConfigValue(command, deps) {
 function runtimeScopeLabel(scope) {
     return scope === "machine" ? "this machine's vault runtime config item" : "the agent vault runtime/config item";
 }
-async function storeRuntimeConfigKey(input) {
+async function storeRuntimeConfigKeys(input) {
     const machineId = input.scope === "machine" ? currentMachineId(input.deps) : undefined;
     input.onProgress?.("checking existing runtime config");
     const current = input.scope === "machine"
@@ -1251,23 +1422,77 @@ async function storeRuntimeConfigKey(input) {
     if (!current.ok && current.reason !== "missing") {
         throw new Error(`cannot read existing runtime credentials from ${current.itemPath}: ${current.error}`);
     }
-    input.onProgress?.(`storing ${input.key} in ${current.itemPath}`);
-    const nextConfig = setRuntimeConfigValue(current.ok ? current.config : {}, input.key, input.value);
+    let nextConfig = current.ok ? current.config : {};
+    for (const entry of input.entries) {
+        input.onProgress?.(`storing ${entry.key} in ${current.itemPath}`);
+        nextConfig = setRuntimeConfigValue(nextConfig, entry.key, entry.value);
+    }
     const stored = input.scope === "machine"
         ? await (0, runtime_credentials_1.upsertMachineRuntimeCredentialConfig)(input.agent, machineId, nextConfig, providerCliNow(input.deps))
         : await (0, runtime_credentials_1.upsertRuntimeCredentialConfig)(input.agent, nextConfig, providerCliNow(input.deps));
-    input.onProgress?.(`stored ${input.key}; credential value was not printed`);
+    input.onProgress?.(`stored ${input.entries.map((entry) => entry.key).join(", ")}; credential values were not printed`);
     return { revision: stored.revision, itemPath: stored.itemPath, ...(machineId ? { machineId } : {}) };
 }
-async function reloadRunningAgentAfterCredentialChange(agent, deps) {
+async function storeRuntimeConfigKey(input) {
+    return storeRuntimeConfigKeys({
+        agent: input.agent,
+        entries: [{ key: input.key, value: input.value }],
+        scope: input.scope,
+        deps: input.deps,
+        onProgress: input.onProgress,
+    });
+}
+function readRuntimeApplyWorker(payload, agent) {
+    return payload.workers.find((worker) => worker.agent === agent) ?? null;
+}
+async function applyRuntimeChangeToRunningAgent(agent, deps, onProgress) {
     try {
+        onProgress?.("checking daemon socket");
         const alive = await deps.checkSocketAlive(deps.socketPath);
         if (!alive)
-            return "daemon is not running; next `ouro up` will load it";
-        const response = await deps.sendCommand(deps.socketPath, { kind: "agent.restart", agent });
-        if (response.ok)
-            return `restarted ${agent} so the running agent reloads credentials`;
-        return `daemon restart skipped: ${response.error ?? response.message ?? "unknown daemon error"}`;
+            return "daemon is not running; next `ouro up` will load the change";
+        onProgress?.("requesting restart from daemon");
+        const response = await withCliTimeout(DEFAULT_AGENT_RESTART_TIMEOUT_MS, "daemon restart request timed out", () => deps.sendCommand(deps.socketPath, { kind: "agent.restart", agent }));
+        if (!response.ok)
+            return `daemon restart skipped: ${response.error ?? response.message ?? "unknown daemon error"}`;
+        const deadline = cliNowMs(deps) + DEFAULT_RUNTIME_APPLY_TIMEOUT_MS;
+        onProgress?.(`waiting for ${agent} to report running state`);
+        while (cliNowMs(deps) < deadline) {
+            try {
+                const statusResponse = await withCliTimeout(DEFAULT_DAEMON_STATUS_TIMEOUT_MS, "daemon status timed out", () => deps.sendCommand(deps.socketPath, { kind: "daemon.status" }));
+                if (statusResponse.ok) {
+                    const payload = (0, cli_render_1.parseStatusPayload)(statusResponse.data);
+                    if (!payload) {
+                        onProgress?.("daemon status did not include structured worker state");
+                        return "restart requested; daemon status is unavailable, so verify with `ouro status` if needed";
+                    }
+                    const worker = readRuntimeApplyWorker(payload, agent);
+                    if (!worker) {
+                        onProgress?.(`still waiting: ${agent} is not listed by daemon`);
+                    }
+                    else if (worker.status === "running") {
+                        onProgress?.(`daemon reports ${agent}/${worker.worker} running`);
+                        return `restarted ${agent} and the daemon reports it running`;
+                    }
+                    else if (worker.status === "crashed") {
+                        return `restart requested, but ${agent}/${worker.worker} crashed before reporting running${worker.errorReason ? `: ${worker.errorReason}` : worker.fixHint ? `: ${worker.fixHint}` : ""}`;
+                    }
+                    else {
+                        onProgress?.(`still waiting: ${agent}/${worker.worker} is ${worker.status}`);
+                    }
+                }
+                else {
+                    onProgress?.(`still waiting: daemon status returned ${statusResponse.error ?? statusResponse.message ?? "unknown error"}`);
+                }
+            }
+            catch (error) {
+                onProgress?.(`still waiting: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (cliNowMs(deps) >= deadline - DEFAULT_RUNTIME_APPLY_POLL_INTERVAL_MS)
+                break;
+            await cliSleep(deps, DEFAULT_RUNTIME_APPLY_POLL_INTERVAL_MS);
+        }
+        return `restart requested, but ${agent} did not report running before timeout. The change is stored; run \`ouro status\` or \`ouro up\` if it still looks stale.`;
     }
     catch (error) {
         return `daemon restart skipped: ${error instanceof Error ? error.message : String(error)}`;
@@ -1401,23 +1626,70 @@ function enableAgentSense(agent, sense, deps) {
     };
     fs.writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
 }
-function connectMenu(agent) {
+async function buildConnectMenu(agent, deps) {
+    const providerVisibility = (0, provider_visibility_1.buildAgentProviderVisibility)({
+        agentName: agent,
+        agentRoot: providerCliAgentRoot({ agent }, deps),
+        homeDir: providerCliHomeDir(deps),
+    });
+    const providerStatus = providerVisibility.lanes.some((lane) => lane.status === "unconfigured")
+        ? "needs setup"
+        : providerVisibility.lanes.some((lane) => lane.status === "configured" && lane.credential.status !== "present")
+            ? "needs auth"
+            : providerVisibility.lanes.some((lane) => lane.status === "configured" && (lane.readiness.status === "failed" || lane.readiness.status === "stale"))
+                ? "needs attention"
+                : "ready";
+    const providerDetail = providerVisibility.lanes.map((lane) => lane.status === "configured"
+        ? `${lane.lane}: ${lane.provider} / ${lane.model}`
+        : `${lane.lane}: choose provider/model`).join(" | ");
+    const runtimeConfig = await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agent, { preserveCachedOnFailure: true });
+    const machineRuntime = await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agent, currentMachineId(deps), { preserveCachedOnFailure: true });
+    const agentConfig = (0, auth_flow_1.readAgentConfigForAgent)(agent, deps.bundlesRoot).config;
+    const teamsEnabled = agentConfig.senses?.teams?.enabled === true;
+    const blueBubblesEnabled = agentConfig.senses?.bluebubbles?.enabled === true;
+    const perplexityStatus = runtimeConfig.ok
+        ? hasRuntimeConfigValue(runtimeConfig.config, "integrations.perplexityApiKey") ? "ready" : "missing"
+        : runtimeConfigReadStatus(runtimeConfig);
+    const embeddingsStatus = runtimeConfig.ok
+        ? hasRuntimeConfigValue(runtimeConfig.config, "integrations.openaiEmbeddingsApiKey") ? "ready" : "missing"
+        : runtimeConfigReadStatus(runtimeConfig);
+    const teamsStatus = runtimeConfig.ok
+        ? hasRuntimeConfigValue(runtimeConfig.config, "teams.clientId")
+            && hasRuntimeConfigValue(runtimeConfig.config, "teams.clientSecret")
+            && hasRuntimeConfigValue(runtimeConfig.config, "teams.tenantId")
+            && teamsEnabled
+            ? "ready"
+            : "missing"
+        : runtimeConfigReadStatus(runtimeConfig);
+    const blueBubblesStatus = machineRuntime.ok
+        ? hasRuntimeConfigValue(machineRuntime.config, "bluebubbles.serverUrl")
+            && hasRuntimeConfigValue(machineRuntime.config, "bluebubbles.password")
+            && blueBubblesEnabled
+            ? "attached"
+            : "not attached"
+        : machineRuntimeReadStatus(machineRuntime);
     return [
-        `Connect ${agent}`,
-        "Pick what this agent should be able to use.",
+        `${agent} // connect bay`,
+        "Bring one capability online at a time.",
+        "",
+        `  1. [${providerStatus}] Providers`,
+        `     ${providerDetail}`,
         "",
-        "  1. Perplexity search",
-        "     Portable. Stores an API key in the agent vault.",
+        `  2. [${perplexityStatus}] Perplexity search`,
+        "     Portable. Web search via Perplexity.",
         "",
-        "  2. BlueBubbles iMessage",
-        "     This machine only. Connects a local Mac Messages bridge.",
+        `  3. [${embeddingsStatus}] Memory embeddings`,
+        "     Portable. Memory retrieval and note search.",
         "",
-        "  3. Provider auth",
-        `     Model credentials: ouro auth --agent ${agent} --provider <provider>`,
+        `  4. [${teamsStatus}] Teams`,
+        "     Portable. Microsoft Teams sense credentials.",
         "",
-        "  4. Cancel",
+        `  5. [${blueBubblesStatus}] BlueBubbles iMessage`,
+        "     This machine only. Local Mac Messages bridge.",
         "",
-        "Choose [1-4]: ",
+        "  6. Cancel",
+        "",
+        "Choose [1-6] or type a name: ",
     ].join("\n");
 }
 async function executeConnectPerplexity(agent, deps) {
@@ -1437,30 +1709,24 @@ async function executeConnectPerplexity(agent, deps) {
     let stored;
     let reload;
     try {
-        progress.startPhase("saving Perplexity search");
-        stored = await storeRuntimeConfigKey({
+        stored = await runCommandProgressPhase(progress, "saving Perplexity search", () => storeRuntimeConfigKey({
             agent,
             key: "integrations.perplexityApiKey",
             value: key,
             scope: "agent",
             deps,
             onProgress: (message) => progress.updateDetail(message),
-        });
-        progress.completePhase("saving Perplexity search", "secret stored");
-        progress.startPhase(`reloading ${agent}`);
-        reload = await reloadRunningAgentAfterCredentialChange(agent, deps);
-        progress.completePhase(`reloading ${agent}`, reload);
-        progress.end();
+        }), () => "secret stored");
+        reload = await runCommandProgressPhase(progress, `applying change to running ${agent}`, () => applyRuntimeChangeToRunningAgent(agent, deps, (message) => progress.updateDetail(message)), (result) => result);
     }
-    catch (error) {
+    finally {
         progress.end();
-        throw error;
     }
     const message = [
         `Perplexity connected for ${agent}`,
         "capability: Perplexity search",
         `stored: ${stored.itemPath}`,
-        `reload: ${reload}`,
+        `running agent: ${reload}`,
         "secret was not printed",
         "",
         "Next: ask the agent to search.",
@@ -1468,6 +1734,102 @@ async function executeConnectPerplexity(agent, deps) {
     deps.writeStdout(message);
     return message;
 }
+async function executeConnectEmbeddings(agent, deps) {
+    if (agent === "SerpentGuide") {
+        throw new Error("SerpentGuide has no persistent runtime credentials. Connect embeddings on the hatchling agent instead.");
+    }
+    const promptSecret = requirePromptSecret(deps, "OpenAI embeddings API key entry");
+    deps.writeStdout([
+        `Connect embeddings for ${agent}`,
+        "The API key stays hidden while you type.",
+        `Ouro stores it in ${agent}'s vault runtime/config item.`,
+    ].join("\n"));
+    const key = (await promptSecret("OpenAI embeddings API key: ")).trim();
+    if (!key)
+        throw new Error("OpenAI embeddings API key cannot be blank");
+    const progress = createHumanCommandProgress(deps, "connect embeddings");
+    let stored;
+    let reload;
+    try {
+        stored = await runCommandProgressPhase(progress, "saving memory embeddings", () => storeRuntimeConfigKey({
+            agent,
+            key: "integrations.openaiEmbeddingsApiKey",
+            value: key,
+            scope: "agent",
+            deps,
+            onProgress: (message) => progress.updateDetail(message),
+        }), () => "secret stored");
+        reload = await runCommandProgressPhase(progress, `applying change to running ${agent}`, () => applyRuntimeChangeToRunningAgent(agent, deps, (message) => progress.updateDetail(message)), (result) => result);
+    }
+    finally {
+        progress.end();
+    }
+    const message = [
+        `Embeddings connected for ${agent}`,
+        "capability: memory embeddings",
+        `stored: ${stored.itemPath}`,
+        `running agent: ${reload}`,
+        "secret was not printed",
+        "",
+        "Next: ask the agent to search notes or memory.",
+    ].join("\n");
+    deps.writeStdout(message);
+    return message;
+}
+async function executeConnectTeams(agent, deps) {
+    if (agent === "SerpentGuide") {
+        throw new Error("SerpentGuide has no persistent runtime credentials. Connect Teams on the hatchling agent instead.");
+    }
+    const promptInput = requirePromptInput(deps, "Teams setup");
+    const promptSecret = requirePromptSecret(deps, "Teams client secret entry");
+    deps.writeStdout([
+        `Connect Teams for ${agent}`,
+        "This connects the Teams sense.",
+        "The client secret stays hidden while you type.",
+    ].join("\n"));
+    const clientId = (await promptInput("Teams client ID: ")).trim();
+    if (!clientId)
+        throw new Error("Teams client ID cannot be blank");
+    const clientSecret = (await promptSecret("Teams client secret: ")).trim();
+    if (!clientSecret)
+        throw new Error("Teams client secret cannot be blank");
+    const tenantId = (await promptInput("Teams tenant ID: ")).trim();
+    if (!tenantId)
+        throw new Error("Teams tenant ID cannot be blank");
+    const managedIdentityClientId = (await promptInput("Teams managed identity client ID [blank to skip]: ")).trim();
+    const progress = createHumanCommandProgress(deps, "connect teams");
+    let stored;
+    try {
+        stored = await runCommandProgressPhase(progress, "saving Teams setup", () => storeRuntimeConfigKeys({
+            agent,
+            entries: [
+                { key: "teams.clientId", value: clientId },
+                { key: "teams.clientSecret", value: clientSecret },
+                { key: "teams.tenantId", value: tenantId },
+                ...(managedIdentityClientId ? [{ key: "teams.managedIdentityClientId", value: managedIdentityClientId }] : []),
+            ],
+            scope: "agent",
+            deps,
+            onProgress: (message) => progress.updateDetail(message),
+        }), () => "secret stored");
+        progress.updateDetail("enabling Teams in agent.json");
+        enableAgentSense(agent, "teams", deps);
+    }
+    finally {
+        progress.end();
+    }
+    const message = appendBundleSyncSummary([
+        `Teams connected for ${agent}`,
+        "capability: Teams sense",
+        `stored: ${stored.itemPath}`,
+        "agent.json: senses.teams.enabled = true",
+        "secret was not printed",
+        "",
+        "Next: run `ouro up` so the daemon picks up the Teams sense change.",
+    ].join("\n"), agent, deps);
+    deps.writeStdout(message);
+    return message;
+}
 async function executeConnectBlueBubbles(agent, deps) {
     if (agent === "SerpentGuide") {
         throw new Error("SerpentGuide has no persistent runtime credentials. Attach BlueBubbles on the hatchling agent instead.");
@@ -1535,39 +1897,86 @@ async function executeConnectBlueBubbles(agent, deps) {
     deps.writeStdout(message);
     return message;
 }
+async function executeConnectProviders(agent, deps) {
+    const promptInput = deps.promptInput;
+    if (!promptInput) {
+        const message = [
+            `Provider auth for ${agent}`,
+            "Run one of:",
+            ...CONNECT_PROVIDER_CHOICES.map((provider) => `  ouro auth --agent ${agent} --provider ${provider}`),
+        ].join("\n");
+        deps.writeStdout(message);
+        return message;
+    }
+    const choice = (await promptInput([
+        `Which provider should ${agent} use credentials for?`,
+        ...CONNECT_PROVIDER_CHOICES.map((provider) => `  - ${provider}`),
+        "",
+        "Provider: ",
+    ].join("\n"))).trim().toLowerCase();
+    if (!(0, cli_parse_2.isAgentProvider)(choice)) {
+        throw new Error(`Unknown provider '${choice}'. Use ${CONNECT_PROVIDER_CHOICES.join("|")}.`);
+    }
+    return executeAuthRun({ kind: "auth.run", agent, provider: choice }, deps);
+}
+function machineRuntimeReadStatus(runtime) {
+    if (runtime.reason === "missing")
+        return "not attached";
+    if (/locked/i.test(runtime.error))
+        return "locked";
+    return "needs attention";
+}
+function connectMenuTarget(answer) {
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === "1" || normalized === "providers" || normalized === "provider" || normalized === "auth")
+        return "providers";
+    if (normalized === "2" || normalized === "perplexity" || normalized === "perplexity-search" || normalized === "search")
+        return "perplexity";
+    if (normalized === "3" || normalized === "embeddings" || normalized === "embedding" || normalized === "memory" || normalized === "note-search" || normalized === "notes")
+        return "embeddings";
+    if (normalized === "4" || normalized === "teams" || normalized === "msteams" || normalized === "microsoft-teams")
+        return "teams";
+    if (normalized === "5" || normalized === "bluebubbles" || normalized === "imessage" || normalized === "messages")
+        return "bluebubbles";
+    return "cancel";
+}
 async function executeConnect(command, deps) {
+    if (command.target === "providers")
+        return executeConnectProviders(command.agent, deps);
     if (command.target === "perplexity")
         return executeConnectPerplexity(command.agent, deps);
+    if (command.target === "embeddings")
+        return executeConnectEmbeddings(command.agent, deps);
+    if (command.target === "teams")
+        return executeConnectTeams(command.agent, deps);
     if (command.target === "bluebubbles")
         return executeConnectBlueBubbles(command.agent, deps);
+    const menu = await buildConnectMenu(command.agent, deps);
     const promptInput = deps.promptInput;
     if (!promptInput) {
         const message = [
-            connectMenu(command.agent).replace(/\nChoose \[1-4\]: $/, ""),
+            menu.replace(/\nChoose \[1-6\] or type a name: $/, ""),
             "",
+            `Run: ouro connect providers --agent ${command.agent}`,
             `Run: ouro connect perplexity --agent ${command.agent}`,
-            `Or:  ouro connect bluebubbles --agent ${command.agent}`,
+            `Run: ouro connect embeddings --agent ${command.agent}`,
+            `Run: ouro connect teams --agent ${command.agent}`,
+            `Run: ouro connect bluebubbles --agent ${command.agent}`,
         ].join("\n");
         deps.writeStdout(message);
         return message;
     }
-    const answer = (await promptInput(connectMenu(command.agent))).trim().toLowerCase();
-    if (answer === "1" || answer === "perplexity" || answer === "perplexity-search") {
+    const answer = connectMenuTarget(await promptInput(menu));
+    if (answer === "providers")
+        return executeConnectProviders(command.agent, deps);
+    if (answer === "perplexity")
         return executeConnectPerplexity(command.agent, deps);
-    }
-    if (answer === "2" || answer === "bluebubbles" || answer === "imessage" || answer === "messages") {
+    if (answer === "embeddings")
+        return executeConnectEmbeddings(command.agent, deps);
+    if (answer === "teams")
+        return executeConnectTeams(command.agent, deps);
+    if (answer === "bluebubbles")
         return executeConnectBlueBubbles(command.agent, deps);
-    }
-    if (answer === "3" || answer === "provider" || answer === "providers" || answer === "auth") {
-        const message = [
-            "Provider auth is its own flow:",
-            `  ouro auth --agent ${command.agent} --provider <provider>`,
-            "",
-            "Use `ouro connect` for integrations and local senses after provider auth is ready.",
-        ].join("\n");
-        deps.writeStdout(message);
-        return message;
-    }
     const message = "connect cancelled.";
     deps.writeStdout(message);
     return message;
@@ -1896,13 +2305,9 @@ async function executeProviderRefresh(command, deps) {
         deps.writeStdout(message);
         return message;
     }
-    progress.startPhase(`reloading ${command.agent}`);
-    const reload = await reloadRunningAgentAfterCredentialChange(command.agent, deps);
-    progress.completePhase(`reloading ${command.agent}`, reload);
+    const reload = await runCommandProgressPhase(progress, `applying change to running ${command.agent}`, () => applyRuntimeChangeToRunningAgent(command.agent, deps, (message) => progress.updateDetail(message)), (result) => result);
     progress.end();
-    lines.push(reload === "daemon is not running; next `ouro up` will load it"
-        ? "daemon is not running; the next start will load the refreshed snapshot"
-        : reload);
+    lines.push(`running agent: ${reload}`);
     const message = lines.join("\n");
     deps.writeStdout(message);
     return message;
@@ -2608,9 +3013,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         deps.writeStdout(text);
         return text;
     }
-    let command;
+    let parsedCommand;
     try {
-        command = (0, cli_parse_1.parseOuroCommand)(args);
+        parsedCommand = (0, cli_parse_1.parseOuroCommand)(args);
     }
     catch (parseError) {
         if (deps.startChat && deps.listDiscoveredAgents && args.length === 1) {
@@ -2623,6 +3028,15 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         }
         throw parseError;
     }
+    const resolvedCommand = await resolveCommandAgent(parsedCommand, deps);
+    if (!resolvedCommand.ok) {
+        if (resolvedCommand.failureMode === "return-message") {
+            deps.writeStdout(resolvedCommand.message);
+            return resolvedCommand.message;
+        }
+        throw new Error(resolvedCommand.message);
+    }
+    let command = resolvedCommand.command;
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : (0, cli_defaults_1.defaultListDiscoveredAgents)());
         if (discovered.length === 0 && deps.runSerpentGuide) {
@@ -3502,7 +3916,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         command.kind === "task.show" || command.kind === "task.actionable" || command.kind === "task.deps" ||
         command.kind === "task.sessions" || command.kind === "task.fix") {
         /* v8 ignore start -- production default: requires full identity setup @preserve */
-        const taskMod = deps.taskModule ?? (0, tasks_1.getTaskModule)();
+        const taskMod = deps.taskModule ?? (0, tasks_1.createTaskModule)(path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`, "tasks"));
         /* v8 ignore stop */
         const message = executeTaskCommand(command, taskMod);
         deps.writeStdout(message);
@@ -3511,7 +3925,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     // ── reminder subcommands (local, no daemon socket needed) ──
     if (command.kind === "reminder.create") {
         /* v8 ignore start -- production default: requires full identity setup @preserve */
-        const taskMod = deps.taskModule ?? (0, tasks_1.getTaskModule)();
+        const taskMod = deps.taskModule ?? (0, tasks_1.createTaskModule)(path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`, "tasks"));
         /* v8 ignore stop */
         const message = executeReminderCommand(command, taskMod);
         deps.writeStdout(message);
@@ -3521,8 +3935,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     if (command.kind === "habit.list" || command.kind === "habit.create") {
         const { parseHabitFile, renderHabitFile } = await Promise.resolve().then(() => __importStar(require("../habits/habit-parser")));
         /* v8 ignore start -- production default: uses real bundle root @preserve */
-        const agentName = command.agent ?? (0, identity_1.getAgentName)();
-        const bundleRoot = deps.agentBundleRoot ?? path.join((0, identity_1.getAgentBundlesRoot)(), `${agentName}.ouro`);
+        const bundleRoot = deps.agentBundleRoot ?? path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`);
         /* v8 ignore stop */
         const habitsDir = path.join(bundleRoot, "habits");
         if (command.kind === "habit.list") {
@@ -3581,8 +3994,8 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             // Derive agent-scoped friends dir from --agent flag or link/unlink's agent field
             const agentName = ("agent" in command && command.agent) ? command.agent : undefined;
             const friendsDir = agentName
-                ? path.join((0, identity_1.getAgentBundlesRoot)(), `${agentName}.ouro`, "friends")
-                : path.join((0, identity_1.getAgentBundlesRoot)(), "friends");
+                ? path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${agentName}.ouro`, "friends")
+                : path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), "friends");
             store = new store_file_1.FileFriendStore(friendsDir);
         }
         /* v8 ignore stop */
@@ -3765,29 +4178,41 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             deps.writeStdout(message);
             return message;
         }
-        /* v8 ignore start -- production default: requires full identity setup @preserve */
         try {
-            const info = deps.whoamiInfo
-                ? deps.whoamiInfo()
-                : {
-                    agentName: (0, identity_1.getAgentName)(),
-                    homePath: path.join((0, identity_1.getAgentBundlesRoot)(), `${(0, identity_1.getAgentName)()}.ouro`),
-                    bonesVersion: (0, runtime_metadata_1.getRuntimeMetadata)().version,
-                };
+            if (deps.whoamiInfo) {
+                try {
+                    const info = deps.whoamiInfo();
+                    const message = [
+                        `agent: ${info.agentName}`,
+                        `home: ${info.homePath}`,
+                        `bones: ${info.bonesVersion}`,
+                    ].join("\n");
+                    deps.writeStdout(message);
+                    return message;
+                }
+                catch {
+                    // Fall through to shared agent selection when no runtime identity is available.
+                }
+            }
+            const resolvedAgent = await resolveMissingAgentName(deps, "return-message");
+            if (!resolvedAgent.ok) {
+                deps.writeStdout(resolvedAgent.message);
+                return resolvedAgent.message;
+            }
+            const agentRoot = path.join((0, identity_1.getAgentBundlesRoot)(), `${resolvedAgent.agent}.ouro`);
             const message = [
-                `agent: ${info.agentName}`,
-                `home: ${info.homePath}`,
-                `bones: ${info.bonesVersion}`,
+                `agent: ${resolvedAgent.agent}`,
+                `home: ${agentRoot}`,
+                `bones: ${(0, runtime_metadata_1.getRuntimeMetadata)().version}`,
             ].join("\n");
             deps.writeStdout(message);
             return message;
         }
         catch {
-            const message = "error: no agent context — use --agent <name> to specify";
+            const message = noAgentsFoundMessage();
             deps.writeStdout(message);
             return message;
         }
-        /* v8 ignore stop */
     }
     // ── changelog (local, no daemon socket needed) ──
     if (command.kind === "changelog") {
@@ -3831,10 +4256,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     // ── thoughts (local, no daemon socket needed) ──
     if (command.kind === "thoughts") {
         try {
-            const agentName = command.agent ?? (0, identity_1.getAgentName)();
             /* v8 ignore next -- production fallback: tests always inject bundlesRoot via createTmpBundle @preserve */
             const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-            const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
+            const agentRoot = path.join(bundlesRoot, `${command.agent}.ouro`);
             const sessionFilePath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
             if (command.json) {
                 try {
@@ -3877,10 +4301,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     /* v8 ignore start -- CLI attention handler: requires real obligation store on disk @preserve */
     if (command.kind === "attention.list" || command.kind === "attention.show" || command.kind === "attention.history") {
         try {
-            const agentName = command.agent ?? (0, identity_1.getAgentName)();
             const { listActiveReturnObligations, readReturnObligation } = await Promise.resolve().then(() => __importStar(require("../../arc/obligations")));
             if (command.kind === "attention.list") {
-                const obligations = listActiveReturnObligations(agentName);
+                const obligations = listActiveReturnObligations(command.agent);
                 if (obligations.length === 0) {
                     const message = "nothing held — attention queue is empty";
                     deps.writeStdout(message);
@@ -3892,7 +4315,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 return message;
             }
             if (command.kind === "attention.show") {
-                const obligation = readReturnObligation(agentName, command.id);
+                const obligation = readReturnObligation(command.agent, command.id);
                 if (!obligation) {
                     const message = `no obligation found with id ${command.id}`;
                     deps.writeStdout(message);
@@ -3904,7 +4327,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             }
             // attention.history: show returned obligations
             const { getReturnObligationsDir } = await Promise.resolve().then(() => __importStar(require("../../arc/obligations")));
-            const obligationsDir = getReturnObligationsDir(agentName);
+            const obligationsDir = getReturnObligationsDir(command.agent);
             let attEntries = [];
             try {
                 attEntries = fs.readdirSync(obligationsDir);
@@ -3945,8 +4368,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     /* v8 ignore start -- inner status handler: requires real agent state on disk @preserve */
     if (command.kind === "inner.status") {
         try {
-            const agentName = command.agent ?? (0, identity_1.getAgentName)();
-            const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+            const agentRoot = (0, identity_1.getAgentRoot)(command.agent);
             const { buildInnerStatusOutput } = await Promise.resolve().then(() => __importStar(require("./inner-status")));
             const { sessionPath: getSessionPath } = await Promise.resolve().then(() => __importStar(require("../config")));
             const { parseCadenceToMs: parseCadenceMs, DEFAULT_CADENCE_MS } = await Promise.resolve().then(() => __importStar(require("./cadence")));
@@ -4004,9 +4426,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             }
             catch { /* no habits — heartbeat unknown */ }
             // Attention count
-            const activeObligations = listActiveReturnObligations(agentName);
+            const activeObligations = listActiveReturnObligations(command.agent);
             const message = buildInnerStatusOutput({
-                agentName,
+                agentName: command.agent,
                 runtimeState,
                 journalFiles,
                 heartbeat,
@@ -4028,7 +4450,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         /* v8 ignore start -- production default: requires full identity setup @preserve */
         const scanner = deps.scanSessions ?? (async () => []);
         /* v8 ignore stop */
-        const sessions = await scanner();
+        const sessions = await scanner(command.agent);
         if (sessions.length === 0) {
             const message = "no active sessions";
             deps.writeStdout(message);