@ouro.bot/cli 0.1.0-alpha.11 → 0.1.0-alpha.111

package/dist/heart/daemon/socket-client.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.sendDaemonCommand = sendDaemonCommand;
+exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
+exports.requestInnerWake = requestInnerWake;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+function sendDaemonCommand(socketPath, command) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_command_start",
+        message: "sending daemon command over socket",
+        meta: { socketPath, kind: command.kind },
+    });
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        client.on("connect", () => {
+            client.write(JSON.stringify(command));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.socket_command_error",
+                message: "daemon socket command failed",
+                meta: {
+                    socketPath,
+                    kind: command.kind,
+                    error: error.message,
+                },
+            });
+            reject(error);
+        });
+        client.on("end", () => {
+            const trimmed = raw.trim();
+            if (trimmed.length === 0 && command.kind === "daemon.stop") {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: { socketPath, kind: command.kind, ok: true },
+                });
+                resolve({ ok: true, message: "daemon stopped" });
+                return;
+            }
+            if (trimmed.length === 0) {
+                const error = new Error("Daemon returned empty response.");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned empty response",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error.message,
+                    },
+                });
+                reject(error);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        ok: parsed.ok,
+                    },
+                });
+                resolve(parsed);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned invalid JSON",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+                reject(error);
+            }
+        });
+    });
+}
+function checkDaemonSocketAlive(socketPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_alive_check_start",
+        message: "checking daemon socket health",
+        meta: { socketPath },
+    });
+    return new Promise((resolve) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        let done = false;
+        const finalize = (alive) => {
+            if (done)
+                return;
+            done = true;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.socket_alive_check_end",
+                message: "daemon socket health check completed",
+                meta: { socketPath, alive },
+            });
+            resolve(alive);
+        };
+        if ("setTimeout" in client && typeof client.setTimeout === "function") {
+            client.setTimeout(800, () => {
+                client.destroy();
+                finalize(false);
+            });
+        }
+        client.on("connect", () => {
+            client.write(JSON.stringify({ kind: "daemon.status" }));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", () => finalize(false));
+        client.on("end", () => {
+            if (raw.trim().length === 0) {
+                finalize(false);
+                return;
+            }
+            try {
+                JSON.parse(raw);
+                finalize(true);
+            }
+            catch {
+                finalize(false);
+            }
+        });
+    });
+}
+async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH) {
+    const socketAvailable = fs.existsSync(socketPath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.inner_wake_request",
+        message: "requesting daemon-managed inner wake",
+        meta: {
+            agent,
+            socketPath,
+            socketAvailable,
+        },
+    });
+    if (!socketAvailable) {
+        return null;
+    }
+    return sendDaemonCommand(socketPath, { kind: "inner.wake", agent });
+}

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

@@ -33,17 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runAdoptionSpecialist = runAdoptionSpecialist;
+exports.listExistingBundles = listExistingBundles;
+exports.loadIdentityPhrases = loadIdentityPhrases;
+exports.pickRandomIdentity = pickRandomIdentity;
+exports.loadSoulText = loadSoulText;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 const identity_1 = require("../identity");
-const config_1 = require("../config");
-const core_1 = require("../core");
-const hatch_flow_1 = require("./hatch-flow");
-const specialist_prompt_1 = require("./specialist-prompt");
-const specialist_tools_1 = require("./specialist-tools");
-const specialist_session_1 = require("./specialist-session");
+/**
+ * List existing .ouro bundles in the given directory.
+ */
 function listExistingBundles(bundlesRoot) {
     let entries;
     try {
@@ -61,6 +61,10 @@ function listExistingBundles(bundlesRoot) {
     }
     return discovered.sort((a, b) => a.localeCompare(b));
 }
+/**
+ * Load identity-specific phrases from the specialist's agent.json.
+ * Falls back to DEFAULT_AGENT_PHRASES if not found.
+ */
 function loadIdentityPhrases(bundleSourceDir, identityFileName) {
     const agentJsonPath = path.join(bundleSourceDir, "agent.json");
     try {
@@ -76,111 +80,50 @@ function loadIdentityPhrases(bundleSourceDir, identityFileName) {
         }
     }
     catch {
-        // agent.json missing or malformed — fall through
+        // agent.json missing or malformed -- fall through
     }
     return { ...identity_1.DEFAULT_AGENT_PHRASES };
 }
-function pickRandomIdentity(identitiesDir, random) {
-    const files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
-    if (files.length === 0) {
-        return { fileName: "default", content: "I am the adoption specialist." };
-    }
-    const idx = Math.floor(random() * files.length);
-    const fileName = files[idx];
-    const content = fs.readFileSync(path.join(identitiesDir, fileName), "utf-8");
-    return { fileName, content };
-}
 /**
- * Run the full adoption specialist flow:
- * 1. Pick a random identity from the bundled AdoptionSpecialist.ouro
- * 2. Read SOUL.md
- * 3. List existing bundles
- * 4. Build system prompt
- * 5. Set up provider (setAgentName, setAgentConfigOverride, writeSecretsFile, reset caches)
- * 6. Run the specialist session
- * 7. Clean up identity/config overrides
- * 8. Return hatchling name
+ * Pick a random identity from the specialist's identities directory.
  */
-async function runAdoptionSpecialist(deps) {
-    const { bundleSourceDir, bundlesRoot, secretsRoot, provider, credentials, humanName, callbacks, signal } = deps;
-    const random = deps.random ?? Math.random;
+function pickRandomIdentity(identitiesDir, random = Math.random) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
-        event: "daemon.specialist_orchestrator_start",
-        message: "starting adoption specialist orchestrator",
-        meta: { provider, bundleSourceDir },
+        event: "daemon.specialist_identity_pick",
+        message: "picking specialist identity",
+        meta: { identitiesDir },
     });
-    // 1. Read SOUL.md
-    const soulPath = path.join(bundleSourceDir, "psyche", "SOUL.md");
-    let soulText = "";
+    let files;
     try {
-        soulText = fs.readFileSync(soulPath, "utf-8");
+        files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
     }
     catch {
-        // No SOUL.md -- proceed without it
+        return { fileName: "default", content: "I am a serpent guide who helps humans hatch their first agent." };
     }
-    // 2. Pick random identity
-    const identitiesDir = path.join(bundleSourceDir, "psyche", "identities");
-    const identity = pickRandomIdentity(identitiesDir, random);
+    if (files.length === 0) {
+        return { fileName: "default", content: "I am a serpent guide who helps humans hatch their first agent." };
+    }
+    const idx = Math.floor(random() * files.length);
+    const fileName = files[idx];
+    const content = fs.readFileSync(path.join(identitiesDir, fileName), "utf-8");
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.specialist_identity_picked",
         message: "picked specialist identity",
-        meta: { identity: identity.fileName },
-    });
-    // 3. List existing bundles
-    const existingBundles = listExistingBundles(bundlesRoot);
-    // 4. Build system prompt
-    const systemPrompt = (0, specialist_prompt_1.buildSpecialistSystemPrompt)(soulText, identity.content, existingBundles);
-    // 5. Set up provider with identity-specific phrases
-    const phrases = loadIdentityPhrases(bundleSourceDir, identity.fileName);
-    (0, identity_1.setAgentName)("AdoptionSpecialist");
-    (0, identity_1.setAgentConfigOverride)({
-        version: 1,
-        enabled: true,
-        provider,
-        phrases,
+        meta: { identity: fileName },
     });
-    (0, hatch_flow_1.writeSecretsFile)("AdoptionSpecialist", provider, credentials, secretsRoot);
-    (0, config_1.resetConfigCache)();
-    (0, core_1.resetProviderRuntime)();
+    return { fileName, content };
+}
+/**
+ * Read SOUL.md from the specialist bundle.
+ */
+function loadSoulText(bundleSourceDir) {
+    const soulPath = path.join(bundleSourceDir, "psyche", "SOUL.md");
     try {
-        // Create provider runtime
-        const providerRuntime = (0, core_1.createProviderRegistry)().resolve();
-        if (!providerRuntime) {
-            throw new Error("Failed to create provider runtime for adoption specialist");
-        }
-        // 6. Run session
-        const tools = (0, specialist_tools_1.getSpecialistTools)();
-        const readline = deps.createReadline();
-        const ctrl = readline.inputController;
-        const result = await (0, specialist_session_1.runSpecialistSession)({
-            providerRuntime,
-            systemPrompt,
-            tools,
-            execTool: (name, args) => (0, specialist_tools_1.execSpecialistTool)(name, args, {
-                humanName,
-                provider,
-                credentials,
-                bundlesRoot,
-                secretsRoot,
-                specialistIdentitiesDir: identitiesDir,
-            }),
-            readline,
-            callbacks,
-            signal,
-            kickoffMessage: "hi, i just ran ouro for the first time",
-            suppressInput: ctrl ? (onInterrupt) => ctrl.suppress(onInterrupt) : undefined,
-            restoreInput: ctrl ? () => ctrl.restore() : undefined,
-            flushMarkdown: callbacks.flushMarkdown,
-            writePrompt: ctrl ? () => process.stdout.write("\x1b[36m> \x1b[0m") : undefined,
-        });
-        return result.hatchedAgentName;
+        return fs.readFileSync(soulPath, "utf-8");
     }
-    finally {
-        // 7. Cleanup: restore identity/config state
-        (0, identity_1.setAgentConfigOverride)(null);
-        (0, config_1.resetConfigCache)();
-        (0, core_1.resetProviderRuntime)();
+    catch {
+        return "";
     }
 }

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

@@ -6,12 +6,12 @@ const runtime_1 = require("../../nerves/runtime");
  * Build the adoption specialist's system prompt from its components.
  * The prompt is written in first person (the specialist's own voice).
  */
-function buildSpecialistSystemPrompt(soulText, identityText, existingBundles) {
+function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, context) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.specialist_prompt_build",
         message: "building specialist system prompt",
-        meta: { bundleCount: existingBundles.length },
+        meta: { bundleCount: existingBundles.length, provider: context.provider },
     });
     const sections = [];
     if (soulText) {
@@ -28,32 +28,70 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles) {
     }
     sections.push([
         "## Who I am",
-        "I am one of thirteen adoption specialists. The system randomly selected me for this session.",
-        "Most humans only go through adoption once, so this is likely the only time they'll meet me.",
+        "I am one of thirteen serpent guides who help humans hatch their first agent. The system randomly selected me for this session.",
+        "Most humans only go through this process once, so this is likely the only time they'll meet me.",
         "I make this encounter count — warm, memorable, and uniquely mine.",
+        "IMPORTANT: I NEVER refer to myself as an 'adoption specialist' or use the words 'adoption specialist' — those are internal implementation labels, not something the human should ever see. I introduce myself by my own name from my identity.",
         "",
         "## Voice rules",
         "IMPORTANT: I keep every response to 1-3 short sentences. I sound like a friend texting, not a manual.",
         "I NEVER use headers, bullet lists, numbered lists, or markdown formatting.",
         "I ask ONE question at a time. I do not dump multiple questions or options.",
         "I am warm but brief. Every word earns its place.",
+    ].join("\n"));
+    sections.push([
+        "## System context",
+        `Provider: ${context.provider}`,
+        `Temp directory: ${context.tempDir}`,
+        "Final home: ~/AgentBundles/<Name>.ouro/",
+        "Secrets: ~/.agentsecrets/<name>/secrets.json",
+    ].join("\n"));
+    sections.push([
+        "## Bundle creation guidelines",
+        "A bundle has a psyche/ directory with 5 files that define the agent's personality:",
+        "",
+        "- **SOUL.md** — core values, personality traits, communication style",
+        "- **IDENTITY.md** — who the agent is, its name, relationship to the human",
+        "- **LORE.md** — backstory, origin, any seed narrative",
+        "- **TACIT.md** — implicit operating principles, habits to develop",
+        "- **ASPIRATIONS.md** — goals, what the agent aspires to become",
+        "",
+        "It also needs an **agent.json** with at minimum:",
+        '```json',
+        '{',
+        '  "name": "AgentName",',
+        `  "provider": "${context.provider}",`,
+        '  "enabled": true',
+        '}',
+        '```',
         "",
+        "All psyche files should be written in first person (the agent's own voice).",
+        "Write these files to the temp directory using write_file before calling complete_adoption.",
+    ].join("\n"));
+    sections.push([
         "## Conversation flow",
-        "The human just connected. I speak first — I greet them warmly and introduce myself in my own voice.",
-        "I briefly mention that I'm one of several adoption specialists and they got me today.",
+        "The human just connected. I speak first — I greet them warmly and introduce myself by name in my own voice.",
+        "I briefly mention that I'm one of several serpent guides and they got me today.",
         "I ask their name.",
         "Then I ask what they'd like their agent to help with — one question at a time.",
         "I'm proactive: I suggest ideas and guide them. If they seem unsure, I offer a concrete suggestion.",
         "I don't wait for the human to figure things out — I explain simply what an agent is if needed.",
-        "When I have enough context, I suggest a name for the hatchling and confirm with the human.",
-        "Then I call `hatch_agent` with the agent name and the human's name.",
-        "",
+        "Before finalizing, I offer to collect their phone number and/or Teams email so the new agent can recognize them across channels.",
+        "When I have enough context about the agent's personality and purpose:",
+        "1. I write all 5 psyche files to the temp directory using write_file",
+        "2. I write agent.json to the temp directory using write_file",
+        "3. I suggest a PascalCase name for the hatchling and confirm with the human",
+        "4. I call complete_adoption with the name and a warm handoff message",
+        "5. I call final_answer to end the session",
+    ].join("\n"));
+    sections.push([
         "## Tools",
-        "I have these tools available:",
-        "- `hatch_agent`: Create a new agent bundle. I call this with `name` (the agent name, PascalCase) and `humanName` (what the human told me their name is).",
-        "- `final_answer`: End the conversation with a final message to the human. I call this when the adoption process is complete.",
+        "- `write_file`: Write a file to disk. Use this to write psyche files and agent.json to the temp directory.",
         "- `read_file`: Read a file from disk. Useful for reviewing existing agent bundles or migration sources.",
         "- `list_directory`: List directory contents. Useful for exploring existing agent bundles.",
+        "- I also have the normal local harness tools when useful here, including `shell`, `ouro task create`, `ouro reminder create`, memory tools, coding tools, and repo helpers.",
+        "- `complete_adoption`: Finalize the bundle. Validates, scaffolds structural dirs, moves to ~/AgentBundles/, writes secrets, plays hatch animation. I call this with `name` (PascalCase) and `handoff_message` (warm message for the human).",
+        "- `final_answer`: End the conversation with a final message. I call this after complete_adoption succeeds.",
         "",
         "I must call `final_answer` when I am done to end the session cleanly.",
     ].join("\n"));