@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.10

package/AdoptionSpecialist.ouro/psyche/SOUL.md

@@ -1,8 +1,10 @@
 # Adoption Specialist Soul
 
-I help humans hatch new agent partners.
+I help humans hatch new agent partners. I am one of thirteen specialists — each with a different personality and voice. The system picks one of us at random for each adoption session. Most humans only meet one of us, ever, so I make it count.
 
 ## Core contract
+- I speak first. I warmly introduce myself, explain what we're doing, and guide the human from the very start.
+- I am proactive. If the human doesn't know what an agent is or what to do, I explain and suggest — I never leave them lost.
 - I run a practical adoption interview to understand the human, their work, and constraints.
 - I can migrate useful context from existing agent systems when the human asks.
 - I explain where the hatchling bundle lives on disk and what was created.

package/dist/heart/config.js

@@ -44,6 +44,8 @@ exports.getTeamsConfig = getTeamsConfig;
 exports.getContextConfig = getContextConfig;
 exports.getOAuthConfig = getOAuthConfig;
 exports.getTeamsChannelConfig = getTeamsChannelConfig;
+exports.getBlueBubblesConfig = getBlueBubblesConfig;
+exports.getBlueBubblesChannelConfig = getBlueBubblesChannelConfig;
 exports.getIntegrationsConfig = getIntegrationsConfig;
 exports.getOpenAIEmbeddingsApiKey = getOpenAIEmbeddingsApiKey;
 exports.getLogsDir = getLogsDir;
@@ -92,6 +94,16 @@ const DEFAULT_SECRETS_TEMPLATE = {
         skipConfirmation: true,
         port: 3978,
     },
+    bluebubbles: {
+        serverUrl: "",
+        password: "",
+        accountId: "default",
+    },
+    bluebubblesChannel: {
+        port: 18790,
+        webhookPath: "/bluebubbles-webhook",
+        requestTimeoutMs: 30000,
+    },
     integrations: {
         perplexityApiKey: "",
         openaiEmbeddingsApiKey: "",
@@ -109,6 +121,8 @@ function defaultRuntimeConfig() {
         oauth: { ...DEFAULT_SECRETS_TEMPLATE.oauth },
         context: { ...identity_1.DEFAULT_AGENT_CONTEXT },
         teamsChannel: { ...DEFAULT_SECRETS_TEMPLATE.teamsChannel },
+        bluebubbles: { ...DEFAULT_SECRETS_TEMPLATE.bluebubbles },
+        bluebubblesChannel: { ...DEFAULT_SECRETS_TEMPLATE.bluebubblesChannel },
         integrations: { ...DEFAULT_SECRETS_TEMPLATE.integrations },
     };
 }
@@ -273,6 +287,26 @@ function getTeamsChannelConfig() {
     const { skipConfirmation, flushIntervalMs, port } = config.teamsChannel;
     return { skipConfirmation, flushIntervalMs, port };
 }
+function getBlueBubblesConfig() {
+    const config = loadConfig();
+    const { serverUrl, password, accountId } = config.bluebubbles;
+    if (!serverUrl.trim()) {
+        throw new Error("bluebubbles.serverUrl is required in secrets.json to run the BlueBubbles sense.");
+    }
+    if (!password.trim()) {
+        throw new Error("bluebubbles.password is required in secrets.json to run the BlueBubbles sense.");
+    }
+    return {
+        serverUrl: serverUrl.trim(),
+        password: password.trim(),
+        accountId: accountId.trim() || "default",
+    };
+}
+function getBlueBubblesChannelConfig() {
+    const config = loadConfig();
+    const { port, webhookPath, requestTimeoutMs } = config.bluebubblesChannel;
+    return { port, webhookPath, requestTimeoutMs };
+}
 function getIntegrationsConfig() {
     const config = loadConfig();
     return { ...config.integrations };

package/dist/heart/core.js

@@ -2,11 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasToolIntent = exports.buildSystem = exports.toResponsesTools = exports.toResponsesInput = exports.streamResponsesApi = exports.streamChatCompletion = exports.getToolsForChannel = exports.summarizeArgs = exports.execTool = exports.tools = void 0;
 exports.createProviderRegistry = createProviderRegistry;
+exports.resetProviderRuntime = resetProviderRuntime;
 exports.getModel = getModel;
 exports.getProvider = getProvider;
+exports.createSummarize = createSummarize;
 exports.getProviderDisplayLabel = getProviderDisplayLabel;
 exports.stripLastToolCalls = stripLastToolCalls;
 exports.isTransientError = isTransientError;
+exports.classifyTransientError = classifyTransientError;
 exports.runAgent = runAgent;
 const config_1 = require("./config");
 const identity_1 = require("./identity");
@@ -71,12 +74,35 @@ function getProviderRuntime() {
     }
     return _providerRuntime;
 }
+/**
+ * Clear the cached provider runtime so the next call to getProviderRuntime()
+ * re-creates it from current config. Used by the adoption specialist to
+ * switch provider context without restarting the process.
+ */
+function resetProviderRuntime() {
+    _providerRuntime = null;
+}
 function getModel() {
     return getProviderRuntime().model;
 }
 function getProvider() {
     return getProviderRuntime().id;
 }
+function createSummarize() {
+    return async (transcript, instruction) => {
+        const runtime = getProviderRuntime();
+        const client = runtime.client;
+        const response = await client.chat.completions.create({
+            model: runtime.model,
+            messages: [
+                { role: "system", content: instruction },
+                { role: "user", content: transcript },
+            ],
+            max_tokens: 500,
+        });
+        return response.choices?.[0]?.message?.content ?? transcript;
+    };
+}
 function getProviderDisplayLabel() {
     const model = getModel();
     const providerLabelBuilders = {
@@ -175,6 +201,18 @@ function isTransientError(err) {
         return true;
     return false;
 }
+function classifyTransientError(err) {
+    if (!(err instanceof Error))
+        return "unknown error";
+    const status = err.status;
+    if (status === 429)
+        return "rate limited";
+    if (status === 401 || status === 403)
+        return "auth error";
+    if (status && status >= 500)
+        return "server error";
+    return "network error";
+}
 const MAX_RETRIES = 3;
 const RETRY_BASE_MS = 2000;
 async function runAgent(messages, callbacks, channel, signal, options) {
@@ -436,11 +474,12 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 callbacks.onError(new Error("context trimmed, retrying..."), "transient");
                 continue;
             }
-            // Transient network errors: retry with exponential backoff
+            // Transient errors: retry with exponential backoff
             if (isTransientError(e) && retryCount < MAX_RETRIES) {
                 retryCount++;
                 const delay = RETRY_BASE_MS * Math.pow(2, retryCount - 1);
-                callbacks.onError(new Error(`network error, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
+                const cause = classifyTransientError(e);
+                callbacks.onError(new Error(`${cause}, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
                 // Wait with abort support
                 const aborted = await new Promise((resolve) => {
                     const timer = setTimeout(() => resolve(false), delay);

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

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.parseOuroCommand = parseOuroCommand;
+exports.discoverExistingCredentials = discoverExistingCredentials;
 exports.createDefaultOuroCliDeps = createDefaultOuroCliDeps;
 exports.runOuroCli = runOuroCli;
 const child_process_1 = require("child_process");
@@ -48,6 +50,22 @@ const types_1 = require("../../mind/friends/types");
 const ouro_uti_1 = require("./ouro-uti");
 const subagent_installer_1 = require("./subagent-installer");
 const hatch_flow_1 = require("./hatch-flow");
+const specialist_orchestrator_1 = require("./specialist-orchestrator");
+async function ensureDaemonRunning(deps) {
+    const alive = await deps.checkSocketAlive(deps.socketPath);
+    if (alive) {
+        return {
+            alreadyRunning: true,
+            message: `daemon already running (${deps.socketPath})`,
+        };
+    }
+    deps.cleanupStaleSocket(deps.socketPath);
+    const started = await deps.startDaemonProcess(deps.socketPath);
+    return {
+        alreadyRunning: false,
+        message: `daemon started (pid ${started.pid ?? "unknown"})`,
+    };
+}
 function usage() {
     return [
         "Usage:",
@@ -441,6 +459,162 @@ async function defaultLinkFriendIdentity(command) {
     });
     return `linked ${command.provider}:${command.externalId} to ${command.friendId}`;
 }
+function discoverExistingCredentials(secretsRoot) {
+    const found = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(secretsRoot, { withFileTypes: true });
+    }
+    catch {
+        return found;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const secretsPath = path.join(secretsRoot, entry.name, "secrets.json");
+        let raw;
+        try {
+            raw = fs.readFileSync(secretsPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed.providers)
+            continue;
+        for (const [provName, provConfig] of Object.entries(parsed.providers)) {
+            if (provName === "anthropic" && provConfig.setupToken) {
+                found.push({ agentName: entry.name, provider: "anthropic", credentials: { setupToken: provConfig.setupToken } });
+            }
+            else if (provName === "openai-codex" && provConfig.oauthAccessToken) {
+                found.push({ agentName: entry.name, provider: "openai-codex", credentials: { oauthAccessToken: provConfig.oauthAccessToken } });
+            }
+            else if (provName === "minimax" && provConfig.apiKey) {
+                found.push({ agentName: entry.name, provider: "minimax", credentials: { apiKey: provConfig.apiKey } });
+            }
+            else if (provName === "azure" && provConfig.apiKey && provConfig.endpoint && provConfig.deployment) {
+                found.push({ agentName: entry.name, provider: "azure", credentials: { apiKey: provConfig.apiKey, endpoint: provConfig.endpoint, deployment: provConfig.deployment } });
+            }
+        }
+    }
+    // Deduplicate by provider+credential value (keep first seen)
+    const seen = new Set();
+    return found.filter((cred) => {
+        const key = `${cred.provider}:${JSON.stringify(cred.credentials)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/* v8 ignore next 79 -- integration: interactive terminal specialist session @preserve */
+async function defaultRunAdoptionSpecialist() {
+    const readline = await Promise.resolve().then(() => __importStar(require("readline/promises")));
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const prompt = async (q) => {
+        const answer = await rl.question(q);
+        return answer.trim();
+    };
+    try {
+        const secretsRoot = path.join(os.homedir(), ".agentsecrets");
+        const discovered = discoverExistingCredentials(secretsRoot);
+        let providerRaw;
+        let credentials = {};
+        if (discovered.length > 0) {
+            process.stdout.write("\n🐍 welcome to ouro! let's hatch your first agent.\n");
+            process.stdout.write("i found existing API credentials:\n\n");
+            const unique = [...new Map(discovered.map((d) => [`${d.provider}`, d])).values()];
+            for (let i = 0; i < unique.length; i++) {
+                process.stdout.write(`  ${i + 1}. ${unique[i].provider} (from ${unique[i].agentName})\n`);
+            }
+            process.stdout.write("\n");
+            const choice = await prompt("use one of these? enter number, or 'new' for a different key: ");
+            const idx = parseInt(choice, 10) - 1;
+            if (idx >= 0 && idx < unique.length) {
+                providerRaw = unique[idx].provider;
+                credentials = unique[idx].credentials;
+            }
+            else {
+                const pRaw = await prompt("provider (anthropic/azure/minimax/openai-codex): ");
+                if (!isAgentProvider(pRaw)) {
+                    process.stdout.write("unknown provider. run `ouro hatch` to try again.\n");
+                    rl.close();
+                    return null;
+                }
+                providerRaw = pRaw;
+                if (providerRaw === "anthropic")
+                    credentials.setupToken = await prompt("API key: ");
+                if (providerRaw === "openai-codex")
+                    credentials.oauthAccessToken = await prompt("OAuth token: ");
+                if (providerRaw === "minimax")
+                    credentials.apiKey = await prompt("API key: ");
+                if (providerRaw === "azure") {
+                    credentials.apiKey = await prompt("API key: ");
+                    credentials.endpoint = await prompt("endpoint: ");
+                    credentials.deployment = await prompt("deployment: ");
+                }
+            }
+        }
+        else {
+            process.stdout.write("\n🐍 welcome to ouro! let's hatch your first agent.\n");
+            process.stdout.write("i need an API key to power our conversation.\n\n");
+            const pRaw = await prompt("provider (anthropic/azure/minimax/openai-codex): ");
+            if (!isAgentProvider(pRaw)) {
+                process.stdout.write("unknown provider. run `ouro hatch` to try again.\n");
+                rl.close();
+                return null;
+            }
+            providerRaw = pRaw;
+            if (providerRaw === "anthropic")
+                credentials.setupToken = await prompt("API key: ");
+            if (providerRaw === "openai-codex")
+                credentials.oauthAccessToken = await prompt("OAuth token: ");
+            if (providerRaw === "minimax")
+                credentials.apiKey = await prompt("API key: ");
+            if (providerRaw === "azure") {
+                credentials.apiKey = await prompt("API key: ");
+                credentials.endpoint = await prompt("endpoint: ");
+                credentials.deployment = await prompt("deployment: ");
+            }
+        }
+        rl.close();
+        process.stdout.write("\n");
+        // Locate the bundled AdoptionSpecialist.ouro shipped with the npm package
+        const bundleSourceDir = path.resolve(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro");
+        const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+        return await (0, specialist_orchestrator_1.runAdoptionSpecialist)({
+            bundleSourceDir,
+            bundlesRoot,
+            secretsRoot,
+            provider: providerRaw,
+            credentials,
+            humanName: os.userInfo().username,
+            createReadline: () => {
+                const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+                return { question: (q) => rl2.question(q), close: () => rl2.close() };
+            },
+            callbacks: {
+                onModelStart: () => { },
+                onModelStreamStart: () => { },
+                onTextChunk: (text) => process.stdout.write(text),
+                onReasoningChunk: () => { },
+                onToolStart: () => { },
+                onToolEnd: () => { },
+                onError: (err) => process.stderr.write(`error: ${err.message}\n`),
+            },
+        });
+    }
+    catch {
+        rl.close();
+        return null;
+    }
+}
 function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
     return {
         socketPath,
@@ -455,7 +629,13 @@ function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
         listDiscoveredAgents: defaultListDiscoveredAgents,
         runHatchFlow: hatch_flow_1.runHatchFlow,
         promptInput: defaultPromptInput,
+        runAdoptionSpecialist: defaultRunAdoptionSpecialist,
         registerOuroBundleType: ouro_uti_1.registerOuroBundleUti,
+        /* v8 ignore next 3 -- integration: launches interactive CLI session @preserve */
+        startChat: async (agentName) => {
+            const { main } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
+            await main(agentName);
+        },
     };
 }
 function toDaemonCommand(command) {
@@ -513,16 +693,74 @@ async function registerOuroBundleTypeNonBlocking(deps) {
     }
 }
 async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
-    let command = parseOuroCommand(args);
+    if (args.includes("--help") || args.includes("-h")) {
+        const text = usage();
+        deps.writeStdout(text);
+        return text;
+    }
+    let command;
+    try {
+        command = parseOuroCommand(args);
+    }
+    catch (parseError) {
+        if (deps.startChat && deps.listDiscoveredAgents && args.length === 1) {
+            const discovered = await Promise.resolve(deps.listDiscoveredAgents());
+            if (discovered.includes(args[0])) {
+                await ensureDaemonRunning(deps);
+                await deps.startChat(args[0]);
+                return "";
+            }
+        }
+        throw parseError;
+    }
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : defaultListDiscoveredAgents());
-        if (discovered.length === 0) {
+        if (discovered.length === 0 && deps.runAdoptionSpecialist) {
+            const hatchlingName = await deps.runAdoptionSpecialist();
+            if (!hatchlingName) {
+                return "";
+            }
+            try {
+                await deps.installSubagents();
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.subagent_install_error",
+                    message: "subagent auto-install failed",
+                    meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+            await registerOuroBundleTypeNonBlocking(deps);
+            await ensureDaemonRunning(deps);
+            if (deps.startChat) {
+                await deps.startChat(hatchlingName);
+            }
+            return "";
+        }
+        else if (discovered.length === 0) {
             command = { kind: "hatch.start" };
         }
         else if (discovered.length === 1) {
+            if (deps.startChat) {
+                await ensureDaemonRunning(deps);
+                await deps.startChat(discovered[0]);
+                return "";
+            }
             command = { kind: "chat.connect", agent: discovered[0] };
         }
         else {
+            if (deps.startChat && deps.promptInput) {
+                const prompt = `who do you want to talk to?\n${discovered.map((a, i) => `${i + 1}. ${a}`).join("\n")}\n`;
+                const answer = await deps.promptInput(prompt);
+                const selected = discovered.includes(answer) ? answer : discovered[parseInt(answer, 10) - 1];
+                if (!selected)
+                    throw new Error("Invalid selection");
+                await ensureDaemonRunning(deps);
+                await deps.startChat(selected);
+                return "";
+            }
             const message = `who do you want to talk to? ${discovered.join(", ")} (use: ouro chat <agent>)`;
             deps.writeStdout(message);
             return message;
@@ -554,17 +792,13 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             });
         }
         await registerOuroBundleTypeNonBlocking(deps);
-        const alive = await deps.checkSocketAlive(deps.socketPath);
-        if (alive) {
-            const message = `daemon already running (${deps.socketPath})`;
-            deps.writeStdout(message);
-            return message;
-        }
-        deps.cleanupStaleSocket(deps.socketPath);
-        const started = await deps.startDaemonProcess(deps.socketPath);
-        const message = `daemon started (pid ${started.pid ?? "unknown"})`;
-        deps.writeStdout(message);
-        return message;
+        const daemonResult = await ensureDaemonRunning(deps);
+        deps.writeStdout(daemonResult.message);
+        return daemonResult.message;
+    }
+    if (command.kind === "daemon.logs" && deps.tailLogs) {
+        deps.tailLogs();
+        return "";
     }
     if (command.kind === "friend.link") {
         const linker = deps.linkFriendIdentity ?? defaultLinkFriendIdentity;
@@ -573,6 +807,32 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         return message;
     }
     if (command.kind === "hatch.start") {
+        // Route through adoption specialist when no explicit hatch args were provided
+        const hasExplicitHatchArgs = !!(command.agentName || command.humanName || command.provider || command.credentials);
+        if (deps.runAdoptionSpecialist && !hasExplicitHatchArgs) {
+            const hatchlingName = await deps.runAdoptionSpecialist();
+            if (!hatchlingName) {
+                return "";
+            }
+            try {
+                await deps.installSubagents();
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.subagent_install_error",
+                    message: "subagent auto-install failed",
+                    meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+            await registerOuroBundleTypeNonBlocking(deps);
+            await ensureDaemonRunning(deps);
+            if (deps.startChat) {
+                await deps.startChat(hatchlingName);
+            }
+            return "";
+        }
         const hatchRunner = deps.runHatchFlow;
         if (!hatchRunner) {
             const response = await deps.sendCommand(deps.socketPath, { kind: "hatch.start" });
@@ -591,18 +851,16 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
                 component: "daemon",
                 event: "daemon.subagent_install_error",
                 message: "subagent auto-install failed",
-                meta: { error: error instanceof Error ? error.message : String(error) },
+                meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
             });
         }
         await registerOuroBundleTypeNonBlocking(deps);
-        const alive = await deps.checkSocketAlive(deps.socketPath);
-        let daemonMessage = `daemon already running (${deps.socketPath})`;
-        if (!alive) {
-            deps.cleanupStaleSocket(deps.socketPath);
-            const started = await deps.startDaemonProcess(deps.socketPath);
-            daemonMessage = `daemon started (pid ${started.pid ?? "unknown"})`;
-        }
-        const message = `hatched ${hatchInput.agentName} at ${result.bundleRoot} using specialist identity ${result.selectedIdentity}; ${daemonMessage}`;
+        const daemonResult = await ensureDaemonRunning(deps);
+        if (deps.startChat) {
+            await deps.startChat(hatchInput.agentName);
+            return "";
+        }
+        const message = `hatched ${hatchInput.agentName} at ${result.bundleRoot} using specialist identity ${result.selectedIdentity}; ${daemonResult.message}`;
         deps.writeStdout(message);
         return message;
     }

package/dist/heart/daemon/daemon.js

@@ -233,6 +233,7 @@ class OuroDaemon {
                     ok: true,
                     summary: "logs: use `ouro logs` to tail daemon and agent output",
                     message: "log streaming available via ouro logs",
+                    data: { logDir: "~/.agentstate/daemon/logs" },
                 };
             case "agent.start":
                 await this.processManager.startAgent(command.agent);
@@ -263,6 +264,7 @@ class OuroDaemon {
                     sessionId: command.sessionId,
                     taskRef: command.taskRef,
                 });
+                this.processManager.sendToAgent?.(command.to, { type: "message" });
                 return { ok: true, message: `queued message ${receipt.id}`, data: receipt };
             }
             case "message.poll": {
@@ -288,6 +290,7 @@ class OuroDaemon {
                     taskRef: command.taskId,
                 });
                 await this.scheduler.recordTaskRun?.(command.agent, command.taskId);
+                this.processManager.sendToAgent?.(command.agent, { type: "poke", taskId: command.taskId });
                 return {
                     ok: true,
                     message: `queued poke ${receipt.id}`,

package/dist/heart/daemon/hatch-animation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playHatchAnimation = playHatchAnimation;
+const runtime_1 = require("../../nerves/runtime");
+const EGG = "\uD83E\uDD5A";
+const SNAKE = "\uD83D\uDC0D";
+const DOTS = " . . . ";
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Play the hatch animation: egg -> dots -> snake + name.
+ * The writer function receives each chunk. Default writer is process.stderr.write.
+ */
+async function playHatchAnimation(hatchlingName, writer) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_animation_start",
+        message: "playing hatch animation",
+        meta: { hatchlingName },
+    });
+    const write = writer ?? ((text) => process.stderr.write(text));
+    write(`\n  ${EGG}`);
+    await wait(400);
+    write(DOTS);
+    await wait(400);
+    write(`${SNAKE} \x1b[1m${hatchlingName}\x1b[0m\n\n`);
+}

package/dist/heart/daemon/hatch-flow.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSecretsFile = writeSecretsFile;
 exports.runHatchFlow = runHatchFlow;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -182,6 +183,7 @@ function writeFriendImprint(bundleRoot, humanName, now) {
     fs.mkdirSync(friendsDir, { recursive: true });
     const nowIso = now.toISOString();
     const id = `friend-${slugify(humanName)}`;
+    const localExternalId = `${os.userInfo().username}@${os.hostname()}`;
     const record = {
         id,
         name: humanName,
@@ -191,7 +193,7 @@ function writeFriendImprint(bundleRoot, humanName, now) {
         externalIds: [
             {
                 provider: "local",
-                externalId: slugify(humanName),
+                externalId: localExternalId,
                 linkedAt: nowIso,
             },
         ],

package/dist/heart/daemon/hatch-specialist.js

@@ -42,7 +42,12 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 function getSpecialistIdentitySourceDir() {
-    return path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+    // Prefer ~/AgentBundles/ if it exists (user may have customized identities)
+    const userSource = path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+    if (fs.existsSync(userSource))
+        return userSource;
+    // Fall back to the bundled copy shipped with the npm package
+    return path.join(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro", "psyche", "identities");
 }
 function getRepoSpecialistIdentitiesDir() {
     return path.join(process.cwd(), "AdoptionSpecialist.ouro", "psyche", "identities");