@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.51

package/dist/mind/pending.js

@@ -33,24 +33,56 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INNER_DIALOG_PENDING = void 0;
 exports.getPendingDir = getPendingDir;
+exports.getDeferredReturnDir = getDeferredReturnDir;
+exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
+exports.hasPendingMessages = hasPendingMessages;
+exports.enqueueDeferredReturn = enqueueDeferredReturn;
+exports.drainDeferredReturns = drainDeferredReturns;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 function getPendingDir(agentName, friendId, channel, key) {
-    return path.join(os.homedir(), ".agentstate", agentName, "pending", friendId, channel, key);
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending", friendId, channel, key);
 }
-function drainPending(pendingDir) {
+function getDeferredReturnDir(agentName, friendId) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending-returns", friendId);
+}
+/** 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 hasPendingMessages(pendingDir) {
     if (!fs.existsSync(pendingDir))
-        return [];
+        return false;
+    try {
+        return fs.readdirSync(pendingDir).some((entry) => entry.endsWith(".json") || entry.endsWith(".json.processing"));
+    }
+    catch {
+        return false;
+    }
+}
+function writeQueueFile(queueDir, message) {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(queueDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(message, null, 2));
+    return filePath;
+}
+function drainQueue(queueDir) {
+    if (!fs.existsSync(queueDir))
+        return { messages: [], recovered: 0 };
     let entries;
     try {
-        entries = fs.readdirSync(pendingDir);
+        entries = fs.readdirSync(queueDir);
     }
     catch {
-        return [];
+        return { messages: [], recovered: 0 };
     }
     // Collect both .json (new) and .processing (crash recovery)
     const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
@@ -62,9 +94,9 @@ function drainPending(pendingDir) {
     ].sort((a, b) => a.file.localeCompare(b.file));
     const messages = [];
     for (const { file, needsRename } of allFiles) {
-        const srcPath = path.join(pendingDir, file);
+        const srcPath = path.join(queueDir, file);
         const processingPath = needsRename
-            ? path.join(pendingDir, file + ".processing")
+            ? path.join(queueDir, file + ".processing")
             : srcPath;
         try {
             if (needsRename) {
@@ -83,11 +115,42 @@ function drainPending(pendingDir) {
             catch { /* ignore */ }
         }
     }
+    return {
+        messages,
+        recovered: processingFiles.length,
+    };
+}
+function enqueueDeferredReturn(agentName, friendId, message) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const filePath = writeQueueFile(queueDir, message);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_return_enqueued",
+        component: "mind",
+        message: "deferred return queued for later friend delivery",
+        meta: { friendId, queueDir },
+    });
+    return filePath;
+}
+function drainDeferredReturns(agentName, friendId) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const { messages } = drainQueue(queueDir);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_returns_drained",
+        component: "mind",
+        message: "deferred friend returns drained",
+        meta: { friendId, queueDir, count: messages.length },
+    });
+    return messages;
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    const { messages, recovered } = drainQueue(pendingDir);
     (0, runtime_1.emitNervesEvent)({
         event: "mind.pending_drained",
         component: "mind",
         message: "pending queue drained",
-        meta: { pendingDir, count: messages.length, recovered: processingFiles.length },
+        meta: { pendingDir, count: messages.length, recovered },
     });
     return messages;
 }

package/dist/mind/phrases.js

@@ -16,6 +16,7 @@ function getPhrases() {
         message: "loading phrase pools",
         meta: {},
     });
+    (0, identity_1.resetAgentConfigCache)();
     const phrases = (0, identity_1.loadAgentConfig)().phrases;
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",

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,13 +50,17 @@ 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 os = __importStar(require("os"));
+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");
 const first_impressions_1 = require("./first-impressions");
 const tasks_1 = require("../repertoire/tasks");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
 // Lazy-loaded psyche text cache
 let _psycheCache = null;
+let _senseStatusLinesCache = null;
 function loadPsycheFile(name) {
     try {
         const psycheDir = path.join((0, identity_1.getAgentRoot)(), "psyche");
@@ -74,82 +84,28 @@ function loadPsyche() {
 }
 function resetPsycheCache() {
     _psycheCache = null;
+    _senseStatusLinesCache = null;
 }
 const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
-function resolveFriendName(friendId, friendsDir, agentName) {
-    if (friendId === "self")
-        return agentName;
-    try {
-        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
-        const record = JSON.parse(raw);
-        return record.name ?? friendId;
-    }
-    catch {
-        return friendId;
-    }
-}
 function buildSessionSummary(options) {
     const { sessionsDir, friendsDir, agentName, currentFriendId, currentChannel, currentKey, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, } = options;
-    if (!fs.existsSync(sessionsDir))
-        return "";
     const now = Date.now();
-    const entries = [];
-    let friendDirs;
-    try {
-        friendDirs = fs.readdirSync(sessionsDir);
-    }
-    catch {
-        return "";
-    }
-    for (const friendId of friendDirs) {
-        const friendPath = path.join(sessionsDir, friendId);
-        let channels;
-        try {
-            channels = fs.readdirSync(friendPath);
-        }
-        catch {
-            continue;
-        }
-        for (const channel of channels) {
-            const channelPath = path.join(friendPath, channel);
-            let keys;
-            try {
-                keys = fs.readdirSync(channelPath);
-            }
-            catch {
-                continue;
-            }
-            for (const keyFile of keys) {
-                if (!keyFile.endsWith(".json"))
-                    continue;
-                const key = keyFile.replace(/\.json$/, "");
-                // Exclude current session
-                if (friendId === currentFriendId && channel === currentChannel && key === currentKey) {
-                    continue;
-                }
-                const filePath = path.join(channelPath, keyFile);
-                let mtimeMs;
-                try {
-                    mtimeMs = fs.statSync(filePath).mtimeMs;
-                }
-                catch {
-                    continue;
-                }
-                if (now - mtimeMs > activeThresholdMs)
-                    continue;
-                const displayName = resolveFriendName(friendId, friendsDir, agentName);
-                entries.push({ friendId, displayName, channel, key, lastActivityMs: mtimeMs });
-            }
-        }
-    }
+    const query = {
+        sessionsDir,
+        friendsDir,
+        agentName,
+        activeThresholdMs,
+        currentSession: currentFriendId && currentChannel && currentKey
+            ? { friendId: currentFriendId, channel: currentChannel, key: currentKey }
+            : null,
+    };
+    const entries = (0, session_activity_1.listSessionActivity)(query);
     if (entries.length === 0)
         return "";
-    // Sort by most recent first
-    entries.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
     const lines = ["## active sessions"];
     for (const entry of entries) {
         const ago = formatTimeAgo(now - entry.lastActivityMs);
-        lines.push(`- ${entry.displayName}/${entry.channel}/${entry.key} (last: ${ago})`);
+        lines.push(`- ${entry.friendName}/${entry.channel}/${entry.key} (last: ${ago})`);
     }
     return lines.join("\n");
 }
@@ -187,22 +143,166 @@ 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");
+        const raw = fs.readFileSync(metaPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        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)();
+    const currentVersion = (0, bundle_manifest_1.getPackageVersion)();
     lines.push(`## runtime`);
     lines.push(`agent: ${agentName}`);
+    lines.push(`runtime version: ${currentVersion}`);
+    const bundleMeta = readBundleMeta();
+    if (bundleMeta?.previousRuntimeVersion && bundleMeta.previousRuntimeVersion !== currentVersion) {
+        lines.push(`previously: ${bundleMeta.previousRuntimeVersion}`);
+    }
+    lines.push(`changelog available at: ${(0, bundle_manifest_1.getChangelogPath)()}`);
     lines.push(`cwd: ${process.cwd()}`);
     lines.push(`channel: ${channel}`);
-    lines.push(`i can read and modify my own source code.`);
+    lines.push(`current sense: ${channel}`);
+    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.");
+    }
     else {
         lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");
     }
+    lines.push("");
+    lines.push(...senseRuntimeGuidance(channel));
     return lines.join("\n");
 }
+function hasTextField(record, key) {
+    return typeof record?.[key] === "string" && record[key].trim().length > 0;
+}
+function localSenseStatusLines() {
+    if (_senseStatusLinesCache) {
+        return [..._senseStatusLinesCache];
+    }
+    const config = (0, identity_1.loadAgentConfig)();
+    const senses = config.senses ?? {
+        cli: { enabled: true },
+        teams: { enabled: false },
+        bluebubbles: { enabled: false },
+    };
+    let payload = {};
+    try {
+        const raw = fs.readFileSync((0, identity_1.getAgentSecretsPath)(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            payload = parsed;
+        }
+    }
+    catch {
+        payload = {};
+    }
+    const teams = payload.teams;
+    const bluebubbles = payload.bluebubbles;
+    const configured = {
+        cli: true,
+        teams: hasTextField(teams, "clientId") && hasTextField(teams, "clientSecret") && hasTextField(teams, "tenantId"),
+        bluebubbles: hasTextField(bluebubbles, "serverUrl") && hasTextField(bluebubbles, "password"),
+    };
+    const rows = [
+        { label: "CLI", status: "interactive" },
+        {
+            label: "Teams",
+            status: !senses.teams.enabled ? "disabled" : configured.teams ? "ready" : "needs_config",
+        },
+        {
+            label: "BlueBubbles",
+            status: !senses.bluebubbles.enabled ? "disabled" : configured.bluebubbles ? "ready" : "needs_config",
+        },
+    ];
+    _senseStatusLinesCache = rows.map((row) => `- ${row.label}: ${row.status}`);
+    return [..._senseStatusLinesCache];
+}
+function senseRuntimeGuidance(channel) {
+    const lines = ["available senses:"];
+    lines.push(...localSenseStatusLines());
+    lines.push("sense states:");
+    lines.push("- interactive = available when opened by the user instead of kept running by the daemon");
+    lines.push("- disabled = turned off in agent.json");
+    lines.push("- needs_config = enabled but missing required secrets.json values");
+    lines.push("- ready = enabled and configured; `ouro up` should bring it online");
+    lines.push("- running = enabled and currently active");
+    lines.push("- error = enabled but unhealthy");
+    lines.push("If asked how to enable another sense, I explain the relevant agent.json senses entry and required secrets.json fields instead of guessing.");
+    lines.push("teams setup truth: enable `senses.teams.enabled`, then provide `teams.clientId`, `teams.clientSecret`, and `teams.tenantId` in secrets.json.");
+    lines.push("bluebubbles setup truth: enable `senses.bluebubbles.enabled`, then provide `bluebubbles.serverUrl` and `bluebubbles.password` in secrets.json.");
+    if (channel === "cli") {
+        lines.push("cli is interactive: it is available when the user opens it, not something `ouro up` daemonizes.");
+    }
+    return lines;
+}
 function providerSection() {
     return `## my provider\n${(0, core_1.getProviderDisplayLabel)()}`;
 }
@@ -210,14 +310,25 @@ function dateSection() {
     const today = new Date().toISOString().slice(0, 10);
     return `current date: ${today}`;
 }
-function toolsSection(channel, options) {
-    const channelTools = (0, tools_1.getToolsForChannel)((0, channel_1.getChannelCapabilities)(channel));
+function toolsSection(channel, options, context) {
+    const channelTools = (0, tools_1.getToolsForChannel)((0, channel_1.getChannelCapabilities)(channel), undefined, context, options?.providerCapabilities);
     const activeTools = (options?.toolChoiceRequired ?? true) ? [...channelTools, tools_1.finalAnswerTool] : channelTools;
     const list = activeTools
         .map((t) => `- ${t.function.name}: ${t.function.description}`)
         .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)
@@ -248,6 +359,38 @@ function memoryFriendToolContractSection() {
 - My psyche files (SOUL, IDENTITY, TACIT, LORE, ASPIRATIONS) are always loaded - I already know who I am.
 - My task board is always loaded - I already know my work.`;
 }
+function bridgeContextSection(options) {
+    if (options?.activeWorkFrame)
+        return "";
+    const bridgeContext = options?.bridgeContext?.trim() ?? "";
+    if (!bridgeContext)
+        return "";
+    return bridgeContext.startsWith("## ") ? bridgeContext : `## active bridge work\n${bridgeContext}`;
+}
+function activeWorkSection(options) {
+    if (!options?.activeWorkFrame)
+        return "";
+    return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame);
+}
+function delegationHintSection(options) {
+    if (!options?.delegationDecision)
+        return "";
+    const lines = [
+        "## delegation hint",
+        `target: ${options.delegationDecision.target}`,
+        `reasons: ${options.delegationDecision.reasons.length > 0 ? options.delegationDecision.reasons.join(", ") : "none"}`,
+        `outward closure: ${options.delegationDecision.outwardClosureRequired ? "required" : "not required"}`,
+    ];
+    return lines.join("\n");
+}
+function reasoningEffortSection(options) {
+    if (!options?.providerCapabilities?.has("reasoning-effort"))
+        return "";
+    const levels = options.supportedReasoningEfforts ?? [];
+    const levelList = levels.length > 0 ? levels.join(", ") : "varies by model";
+    return `## reasoning effort
+i can adjust my own reasoning depth using the set_reasoning_effort tool. i use higher effort for complex analysis and lower effort for simple tasks. available levels: ${levelList}.`;
+}
 function toolBehaviorSection(options) {
     if (!(options?.toolChoiceRequired ?? true))
         return "";
@@ -257,9 +400,9 @@ 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) {
+function contextSection(context, options) {
     if (!context)
         return "";
     const lines = ["## friend context"];
@@ -295,7 +438,7 @@ function contextSection(context) {
     lines.push("when i learn something that might invalidate an existing note, i check related notes and update or override any that are stale.");
     lines.push("i save ANYTHING i learn about my friend immediately with save_friend_note -- names, preferences, what they do, what they care about. when in doubt, save it. saving comes BEFORE responding: i call save_friend_note first, then final_answer on the next turn.");
     // Onboarding instructions (only below token threshold -- drop once exceeded)
-    const impressions = (0, first_impressions_1.getFirstImpressions)(friend);
+    const impressions = (0, first_impressions_1.getFirstImpressions)(friend, options);
     if (impressions) {
         lines.push(impressions);
     }
@@ -309,6 +452,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",
@@ -316,29 +502,41 @@ async function buildSystem(channel = "cli", options, context) {
         message: "buildSystem started",
         meta: { channel, has_context: Boolean(context), tool_choice_required: Boolean(options?.toolChoiceRequired) },
     });
+    // Backfill bundle-meta.json for existing agents that don't have one
+    (0, bundle_manifest_1.backfillBundleMeta)((0, identity_1.getAgentRoot)());
     const system = [
         soulSection(),
         identitySection(),
         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),
+        toolsSection(channel, options, context),
+        reasoningEffortSection(options),
+        toolRestrictionSection(context),
+        mixedTrustGroupSection(context),
         skillsSection(),
         taskBoardSection(),
+        activeWorkSection(options),
+        delegationHintSection(options),
+        bridgeContextSection(options),
         buildSessionSummary({
-            sessionsDir: path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions"),
+            sessionsDir: path.join((0, identity_1.getAgentRoot)(), "state", "sessions"),
             friendsDir: path.join((0, identity_1.getAgentRoot)(), "friends"),
             agentName: (0, identity_1.getAgentName)(),
             currentFriendId: context?.friend?.id,
             currentChannel: channel,
-            currentKey: "session",
+            currentKey: options?.currentSessionKey ?? "session",
         }),
         memoryFriendToolContractSection(),
         toolBehaviorSection(options),
-        contextSection(context),
+        contextSection(context, options),
     ]
         .filter(Boolean)
         .join("\n\n");

package/dist/mind/token-estimate.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__internal = void 0;
 exports.estimateTokensForMessage = estimateTokensForMessage;
 exports.estimateTokensForMessages = estimateTokensForMessages;
 const runtime_1 = require("../nerves/runtime");
@@ -53,7 +52,7 @@ function countCharsInContent(content) {
             return c.text.length;
         if (typeof c.content === "string")
             return c.content.length;
-        return safeStringify(content).length;
+        return safeStringify(c).length;
     }
     return 0;
 }
@@ -70,12 +69,13 @@ function countCharsInToolCalls(toolCalls) {
         if (typeof t.type === "string")
             total += t.type.length;
         if (t.function && typeof t.function === "object") {
-            if (typeof t.function.name === "string")
-                total += t.function.name.length;
-            if (typeof t.function.arguments === "string")
-                total += t.function.arguments.length;
-            else if (t.function.arguments != null)
-                total += safeStringify(t.function.arguments).length;
+            const fn = t.function;
+            if (typeof fn.name === "string")
+                total += fn.name.length;
+            if (typeof fn.arguments === "string")
+                total += fn.arguments.length;
+            else if (fn.arguments != null)
+                total += safeStringify(fn.arguments).length;
         }
     }
     return total;
@@ -113,7 +113,3 @@ function estimateTokensForMessages(msgs) {
         total += estimateTokensForMessage(msg);
     return total;
 }
-exports.__internal = {
-    CHARS_PER_TOKEN,
-    PER_MESSAGE_OVERHEAD_TOKENS,
-};