@ouro.bot/cli 0.1.0-alpha.37 → 0.1.0-alpha.39

package/dist/heart/daemon/daemon.js

@@ -46,6 +46,8 @@ const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const update_checker_1 = require("./update-checker");
 const staged_restart_1 = require("./staged-restart");
 const child_process_1 = require("child_process");
+const pending_1 = require("../../mind/pending");
+const channel_1 = require("../../mind/friends/channel");
 function buildWorkerRows(snapshots) {
     return snapshots.map((snapshot) => ({
         agent: snapshot.name,
@@ -156,6 +158,7 @@ class OuroDaemon {
         this.scheduler.start?.();
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();
+        await this.drainPendingSenseMessages();
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }
@@ -231,6 +234,93 @@ class OuroDaemon {
             fs.writeFileSync(pendingPath, next, "utf-8");
         }
     }
+    /** Drains per-sense pending dirs for always-on senses across all agents. */
+    static ALWAYS_ON_SENSES = new Set((0, channel_1.getAlwaysOnSenseNames)());
+    async drainPendingSenseMessages() {
+        if (!fs.existsSync(this.bundlesRoot))
+            return;
+        let bundleDirs;
+        try {
+            bundleDirs = fs.readdirSync(this.bundlesRoot, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const bundleDir of bundleDirs) {
+            if (!bundleDir.isDirectory() || !bundleDir.name.endsWith(".ouro"))
+                continue;
+            const agentName = bundleDir.name.replace(/\.ouro$/, "");
+            const pendingRoot = path.join(this.bundlesRoot, bundleDir.name, "state", "pending");
+            if (!fs.existsSync(pendingRoot))
+                continue;
+            let friendDirs;
+            try {
+                friendDirs = fs.readdirSync(pendingRoot, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const friendDir of friendDirs) {
+                if (!friendDir.isDirectory())
+                    continue;
+                const friendPath = path.join(pendingRoot, friendDir.name);
+                let channelDirs;
+                try {
+                    channelDirs = fs.readdirSync(friendPath, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const channelDir of channelDirs) {
+                    if (!channelDir.isDirectory())
+                        continue;
+                    if (!OuroDaemon.ALWAYS_ON_SENSES.has(channelDir.name))
+                        continue;
+                    const channelPath = path.join(friendPath, channelDir.name);
+                    let keyDirs;
+                    try {
+                        keyDirs = fs.readdirSync(channelPath, { withFileTypes: true });
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const keyDir of keyDirs) {
+                        if (!keyDir.isDirectory())
+                            continue;
+                        const leafDir = path.join(channelPath, keyDir.name);
+                        const messages = (0, pending_1.drainPending)(leafDir);
+                        for (const msg of messages) {
+                            try {
+                                await this.router.send({
+                                    from: msg.from,
+                                    to: agentName,
+                                    content: msg.content,
+                                    priority: "normal",
+                                });
+                            }
+                            catch {
+                                // Best-effort delivery — log and continue
+                            }
+                        }
+                        if (messages.length > 0) {
+                            (0, runtime_1.emitNervesEvent)({
+                                component: "daemon",
+                                event: "daemon.startup_sense_drain",
+                                message: "drained pending sense messages on startup",
+                                meta: {
+                                    agent: agentName,
+                                    channel: channelDir.name,
+                                    friendId: friendDir.name,
+                                    key: keyDir.name,
+                                    count: messages.length,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
     async stop() {
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",

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

@@ -76,6 +76,7 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "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.",
+        "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",
@@ -88,7 +89,7 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "- `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`, task tools like `task_create` and `schedule_reminder`, memory tools, coding tools, and repo helpers.",
+        "- 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.",
         "",

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

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSpecialistTools = getSpecialistTools;
 exports.createSpecialistExecTool = createSpecialistExecTool;
+const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const tools_base_1 = require("../../repertoire/tools-base");
@@ -58,6 +59,14 @@ const completeAdoptionTool = {
                     type: "string",
                     description: "a warm handoff message to display to the human after the agent is hatched",
                 },
+                phone: {
+                    type: "string",
+                    description: "the human's phone number (optional, for iMessage contact recognition)",
+                },
+                teams_handle: {
+                    type: "string",
+                    description: "the human's Teams email/handle (optional, for Teams contact recognition)",
+                },
             },
             required: ["name", "handoff_message"],
         },
@@ -65,12 +74,23 @@ const completeAdoptionTool = {
 };
 const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
 const writeFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "write_file");
-const listDirTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "list_directory");
+const listDirToolSchema = {
+    type: "function",
+    function: {
+        name: "list_directory",
+        description: "list directory contents",
+        parameters: {
+            type: "object",
+            properties: { path: { type: "string" } },
+            required: ["path"],
+        },
+    },
+};
 /**
  * Returns the specialist's tool schema array.
  */
 function getSpecialistTools() {
-    return [completeAdoptionTool, tools_base_1.finalAnswerTool, readFileTool.tool, writeFileTool.tool, listDirTool.tool];
+    return [completeAdoptionTool, tools_base_1.finalAnswerTool, readFileTool.tool, writeFileTool.tool, listDirToolSchema];
 }
 const PSYCHE_FILES = ["SOUL.md", "IDENTITY.md", "LORE.md", "TACIT.md", "ASPIRATIONS.md"];
 function isPascalCase(name) {
@@ -164,6 +184,32 @@ async function execCompleteAdoption(args, deps) {
         }
         return `error: failed to write secrets: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
     }
+    // Create initial friend record if contact info provided
+    const phone = args.phone;
+    const teamsHandle = args.teams_handle;
+    if (phone || teamsHandle) {
+        const friendId = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const externalIds = [];
+        if (phone)
+            externalIds.push({ provider: "imessage-handle", externalId: phone, linkedAt: now });
+        if (teamsHandle)
+            externalIds.push({ provider: "aad", externalId: teamsHandle, linkedAt: now });
+        const friendRecord = {
+            id: friendId,
+            name: deps.humanName ?? "primary",
+            trustLevel: "family",
+            externalIds,
+            tenantMemberships: [],
+            toolPreferences: {},
+            notes: {},
+            createdAt: now,
+            updatedAt: now,
+            schemaVersion: 1,
+        };
+        const friendPath = path.join(targetBundle, "friends", `${friendId}.json`);
+        fs.writeFileSync(friendPath, JSON.stringify(friendRecord, null, 2), "utf-8");
+    }
     // Play hatch animation
     await (0, hatch_animation_1.playHatchAnimation)(name, deps.animationWriter);
     // Display handoff message

package/dist/heart/kicks.js

@@ -1,7 +1,7 @@
 "use strict";
 // TODO: Kicks enforce "any action" but not "meaningful action". After a narration
 // kick, the model can satisfy the constraint by calling a no-op tool like
-// get_current_time({}). We need to detect trivial compliance and either re-kick
+// list_skills({}). We need to detect trivial compliance and either re-kick
 // or discount the tool call. Ideally, the kick message would suggest a specific
 // tool call based on conversation context (what the user asked, what tools are
 // relevant) rather than just saying "call a tool". That's a bigger piece of work —

package/dist/mind/friends/channel.js

@@ -3,10 +3,13 @@
 // Pure lookup, no I/O, cannot fail. Unknown channel gets minimal defaults.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChannelCapabilities = getChannelCapabilities;
+exports.isRemoteChannel = isRemoteChannel;
+exports.getAlwaysOnSenseNames = getAlwaysOnSenseNames;
 const runtime_1 = require("../../nerves/runtime");
 const CHANNEL_CAPABILITIES = {
     cli: {
         channel: "cli",
+        senseType: "local",
         availableIntegrations: [],
         supportsMarkdown: false,
         supportsStreaming: true,
@@ -15,6 +18,7 @@ const CHANNEL_CAPABILITIES = {
     },
     teams: {
         channel: "teams",
+        senseType: "closed",
         availableIntegrations: ["ado", "graph", "github"],
         supportsMarkdown: true,
         supportsStreaming: true,
@@ -23,15 +27,26 @@ const CHANNEL_CAPABILITIES = {
     },
     bluebubbles: {
         channel: "bluebubbles",
+        senseType: "open",
         availableIntegrations: [],
         supportsMarkdown: false,
         supportsStreaming: false,
         supportsRichCards: false,
         maxMessageLength: Infinity,
     },
+    inner: {
+        channel: "inner",
+        senseType: "internal",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: true,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",
+    senseType: "local",
     availableIntegrations: [],
     supportsMarkdown: false,
     supportsStreaming: false,
@@ -47,3 +62,23 @@ function getChannelCapabilities(channel) {
     });
     return CHANNEL_CAPABILITIES[channel] ?? DEFAULT_CAPABILITIES;
 }
+/** Whether the channel is remote (open or closed) vs local/internal. */
+function isRemoteChannel(capabilities) {
+    const senseType = capabilities?.senseType;
+    return senseType !== undefined && senseType !== "local" && senseType !== "internal";
+}
+/**
+ * Returns channel names whose senseType is "open" or "closed" -- i.e. channels
+ * that are always-on (daemon-managed) rather than interactive or internal.
+ */
+function getAlwaysOnSenseNames() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.always_on_lookup",
+        message: "always-on sense names lookup",
+        meta: {},
+    });
+    return Object.entries(CHANNEL_CAPABILITIES)
+        .filter(([, cap]) => cap.senseType === "open" || cap.senseType === "closed")
+        .map(([channel]) => channel);
+}

package/dist/mind/friends/store-file.js

@@ -100,6 +100,25 @@ class FileFriendStore {
         }
         return entries.some((entry) => entry.endsWith(".json"));
     }
+    async listAll() {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return [];
+        }
+        const records = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await this.readJson(path.join(this.friendsPath, entry));
+            if (!raw)
+                continue;
+            records.push(this.normalize(raw));
+        }
+        return records;
+    }
     normalize(raw) {
         const trustLevel = raw.trustLevel;
         const normalizedTrustLevel = trustLevel === "family" ||

package/dist/mind/friends/types.js

@@ -2,8 +2,10 @@
 // Context kernel type definitions.
 // FriendRecord (merged identity + memory), channel capabilities, and resolved context.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRUSTED_LEVELS = void 0;
 exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
+exports.isTrustedLevel = isTrustedLevel;
 const runtime_1 = require("../../nerves/runtime");
 const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
 function isIdentityProvider(value) {
@@ -19,3 +21,9 @@ const INTEGRATIONS = new Set(["ado", "github", "graph"]);
 function isIntegration(value) {
     return typeof value === "string" && INTEGRATIONS.has(value);
 }
+/** Trust levels that grant full tool access and proactive send capability. */
+exports.TRUSTED_LEVELS = new Set(["family", "friend"]);
+/** Whether a trust level grants full access (family or friend). Defaults to "friend" for legacy records. */
+function isTrustedLevel(trustLevel) {
+    return exports.TRUSTED_LEVELS.has(trustLevel ?? "friend");
+}

package/dist/mind/pending.js

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INNER_DIALOG_PENDING = void 0;
 exports.getPendingDir = getPendingDir;
+exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -42,6 +44,12 @@ const runtime_1 = require("../nerves/runtime");
 function getPendingDir(agentName, friendId, channel, key) {
     return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending", friendId, channel, key);
 }
+/** Canonical inner-dialog pending path segments. */
+exports.INNER_DIALOG_PENDING = { friendId: "self", channel: "inner", key: "dialog" };
+/** Returns the pending dir for this agent's inner dialog. */
+function getInnerDialogPendingDir(agentName) {
+    return getPendingDir(agentName, exports.INNER_DIALOG_PENDING.friendId, exports.INNER_DIALOG_PENDING.channel, exports.INNER_DIALOG_PENDING.key);
+}
 function drainPending(pendingDir) {
     if (!fs.existsSync(pendingDir))
         return [];

package/dist/mind/prompt.js

@@ -35,8 +35,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetPsycheCache = resetPsycheCache;
 exports.buildSessionSummary = buildSessionSummary;
+exports.bodyMapSection = bodyMapSection;
 exports.runtimeInfoSection = runtimeInfoSection;
+exports.toolRestrictionSection = toolRestrictionSection;
 exports.contextSection = contextSection;
+exports.metacognitiveFramingSection = metacognitiveFramingSection;
+exports.loopOrientationSection = loopOrientationSection;
+exports.channelNatureSection = channelNatureSection;
+exports.mixedTrustGroupSection = mixedTrustGroupSection;
 exports.buildSystem = buildSystem;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -44,6 +50,7 @@ const core_1 = require("../heart/core");
 const tools_1 = require("../repertoire/tools");
 const skills_1 = require("../repertoire/skills");
 const identity_1 = require("../heart/identity");
+const types_1 = require("./friends/types");
 const channel_1 = require("./friends/channel");
 const runtime_1 = require("../nerves/runtime");
 const bundle_manifest_1 = require("./bundle-manifest");
@@ -189,6 +196,41 @@ function aspirationsSection() {
         return "";
     return `## my aspirations\n${text}`;
 }
+function bodyMapSection(agentName) {
+    return `## my body
+
+i have a home and i have bones.
+
+### home — ~/AgentBundles/${agentName}.ouro/
+
+my home is fully mine — who i am, everything i know, everything i've built:
+
+  psyche/    who i am. my soul, identity, aspirations, lore, tacit knowledge.
+  memory/    what i've learned and remember.
+  friends/   people i know and what i know about them.
+  tasks/     what i'm working on.
+  skills/    capabilities i've picked up beyond my core tools.
+
+my home is mine to explore and evolve. i can read anything here,
+change anything here. this is where i grow.
+
+### bones — @ouro.bot/cli
+
+my bones are the framework that gives me my tools, my senses, and
+my ability to think and talk. they update when new versions come out.
+i don't touch them directly, but they're what make me, me.
+
+my bones give me the \`ouro\` cli:
+  ouro whoami            who i am, where i live, what i'm running on
+  ouro task board        my task board
+  ouro task create       start a new task (--type required)
+  ouro task update       move a task forward
+  ouro friend list       people i know and how to reach them
+  ouro friend show <id>  everything i know about someone
+  ouro session list      my open conversations right now
+  ouro reminder create   remind myself about something later
+  ouro --help            the full list`;
+}
 function readBundleMeta() {
     try {
         const metaPath = path.join((0, identity_1.getAgentRoot)(), "bundle-meta.json");
@@ -199,6 +241,24 @@ function readBundleMeta() {
         return null;
     }
 }
+const PROCESS_TYPE_LABELS = {
+    cli: "cli session",
+    inner: "inner dialog",
+    teams: "teams handler",
+    bluebubbles: "bluebubbles handler",
+};
+function processTypeLabel(channel) {
+    return PROCESS_TYPE_LABELS[channel];
+}
+const DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+function daemonStatus() {
+    try {
+        return fs.existsSync(DAEMON_SOCKET_PATH) ? "running" : "not running";
+    }
+    catch {
+        return "unknown";
+    }
+}
 function runtimeInfoSection(channel) {
     const lines = [];
     const agentName = (0, identity_1.getAgentName)();
@@ -214,10 +274,14 @@ function runtimeInfoSection(channel) {
     lines.push(`cwd: ${process.cwd()}`);
     lines.push(`channel: ${channel}`);
     lines.push(`current sense: ${channel}`);
-    lines.push(`i can read and modify my own source code.`);
+    lines.push(`process type: ${processTypeLabel(channel)}`);
+    lines.push(`daemon: ${daemonStatus()}`);
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
+    else if (channel === "inner") {
+        // No boot greeting or channel-specific guidance for inner dialog
+    }
     else if (channel === "bluebubbles") {
         lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
         lines.push("when a bluebubbles turn arrives from a thread, the harness tells me the current lane and any recent active thread ids. if widening back to top-level or routing into a different active thread is the better move, i use bluebubbles_set_reply_target before final_answer.");
@@ -307,6 +371,17 @@ function toolsSection(channel, options, context) {
         .join("\n");
     return `## my tools\n${list}`;
 }
+function toolRestrictionSection(context) {
+    if (!context?.friend || !(0, channel_1.isRemoteChannel)(context.channel))
+        return "";
+    if ((0, types_1.isTrustedLevel)(context.friend.trustLevel))
+        return "";
+    const toolList = [...tools_1.REMOTE_BLOCKED_LOCAL_TOOLS].join(", ");
+    return `## restricted tools
+some of my tools are unavailable right now: ${toolList}
+
+i don't know this person well enough yet to run local operations on their behalf. i can suggest remote-safe alternatives or ask them to run it from CLI.`;
+}
 function skillsSection() {
     const names = (0, skills_1.listSkills)() || [];
     if (!names.length)
@@ -346,7 +421,7 @@ tool_choice is set to "required" -- i must call a tool on every turn.
 - ready to respond to the user? i call \`final_answer\`.
 \`final_answer\` is a tool call -- it satisfies the tool_choice requirement.
 \`final_answer\` must be the ONLY tool call in that turn. do not combine it with other tool calls.
-do NOT call \`get_current_time\` or other no-op tools just before \`final_answer\`. if i am done, i call \`final_answer\` directly.`;
+do NOT call no-op tools just before \`final_answer\`. if i am done, i call \`final_answer\` directly.`;
 }
 function contextSection(context) {
     if (!context)
@@ -398,6 +473,49 @@ function contextSection(context) {
     }
     return lines.join("\n");
 }
+function metacognitiveFramingSection(channel) {
+    if (channel !== "inner")
+        return "";
+    return `this is my inner dialog. there is no one else here.
+
+the messages that appear here are my own awareness surfacing:
+instincts, the passage of time, notes from my conversations,
+things i asked myself to think about. not commands. not requests.
+just my own mind, noticing.
+
+i can think freely here. i can also act — check on things,
+reach out to people, work on tasks, or just sit with a thought.
+
+thoughts worth sharing can go outward — i reach out to whoever
+needs to hear them. things from conversations that need time
+to process arrive here, in my thinking space.
+
+think. share. think some more.`;
+}
+function loopOrientationSection(channel) {
+    if (channel === "inner")
+        return "";
+    return `sometimes a thought of mine surfaces alongside what someone is saying — marked as [inner thought: ...]. that's me, bringing up something i was thinking about. i can weave it into the conversation naturally, or let it go. my call.
+
+when something deserves more thought than the moment allows, i can note it to myself and come back later with a considered answer.`;
+}
+function channelNatureSection(capabilities) {
+    const { senseType } = capabilities;
+    if (senseType === "local" || senseType === "internal")
+        return "";
+    if (senseType === "open") {
+        return "## channel nature\nthis is an open channel — anyone with my number can reach me here. i may hear from people i don't know.";
+    }
+    // closed
+    return "## channel nature\nthis is an org-gated channel — i know everyone here is already part of the organization.";
+}
+function mixedTrustGroupSection(context) {
+    if (!context?.friend || !(0, channel_1.isRemoteChannel)(context.channel))
+        return "";
+    if (!context.isGroupChat)
+        return "";
+    return "## mixed trust group\nin this group chat, my capabilities depend on who's talking. some people here have full trust, others don't — i adjust what i can do based on who's asking.";
+}
 async function buildSystem(channel = "cli", options, context) {
     (0, runtime_1.emitNervesEvent)({
         event: "mind.step_start",
@@ -413,10 +531,16 @@ async function buildSystem(channel = "cli", options, context) {
         loreSection(),
         tacitKnowledgeSection(),
         aspirationsSection(),
+        bodyMapSection((0, identity_1.getAgentName)()),
+        metacognitiveFramingSection(channel),
+        loopOrientationSection(channel),
         runtimeInfoSection(channel),
+        channelNatureSection((0, channel_1.getChannelCapabilities)(channel)),
         providerSection(),
         dateSection(),
         toolsSection(channel, options, context),
+        toolRestrictionSection(context),
+        mixedTrustGroupSection(context),
         skillsSection(),
         taskBoardSection(),
         buildSessionSummary({