@ouro.bot/cli 0.1.0-alpha.15 → 0.1.0-alpha.151

package/dist/mind/prompt.js

@@ -35,21 +35,42 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetPsycheCache = resetPsycheCache;
 exports.buildSessionSummary = buildSessionSummary;
+exports.bodyMapSection = bodyMapSection;
+exports.mcpToolsSection = mcpToolsSection;
 exports.runtimeInfoSection = runtimeInfoSection;
+exports.toolRestrictionSection = toolRestrictionSection;
+exports.centerOfGravitySteeringSection = centerOfGravitySteeringSection;
+exports.commitmentsSection = commitmentsSection;
+exports.delegationHintSection = delegationHintSection;
 exports.contextSection = contextSection;
+exports.metacognitiveFramingSection = metacognitiveFramingSection;
+exports.readJournalFiles = readJournalFiles;
+exports.journalSection = journalSection;
+exports.loopOrientationSection = loopOrientationSection;
+exports.channelNatureSection = channelNatureSection;
+exports.groupChatParticipationSection = groupChatParticipationSection;
+exports.feedbackSignalSection = feedbackSignalSection;
+exports.mixedTrustGroupSection = mixedTrustGroupSection;
 exports.buildSystem = buildSystem;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const core_1 = require("../heart/core");
+const ouro_version_manager_1 = require("../heart/daemon/ouro-version-manager");
 const tools_1 = require("../repertoire/tools");
 const skills_1 = require("../repertoire/skills");
 const identity_1 = require("../heart/identity");
-const os = __importStar(require("os"));
+const runtime_mode_1 = require("../heart/daemon/runtime-mode");
+const types_1 = require("./friends/types");
+const trust_explanation_1 = require("./friends/trust-explanation");
 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");
+const commitments_1 = require("../heart/commitments");
+const obligation_steering_1 = require("./obligation-steering");
 // Lazy-loaded psyche text cache
 let _psycheCache = null;
 let _senseStatusLinesCache = null;
@@ -79,80 +100,25 @@ function resetPsycheCache() {
     _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");
 }
@@ -190,20 +156,145 @@ 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.
+  diary/     what i've learned and remember. conclusions i want to recall later.
+  journal/   my desk. working notes, thinking-in-progress, drafts.
+  habits/    my rhythms. heartbeat, reflections, check-ins — patterns i choose.
+  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. always pass \`--agent ${agentName}\`:
+  ouro whoami --agent ${agentName}
+  ouro changelog --agent ${agentName}
+  ouro task board --agent ${agentName}
+  ouro task create --agent ${agentName} --type <type> <title>
+  ouro task update --agent ${agentName} <id> <status>
+  ouro friend list --agent ${agentName}
+  ouro friend show --agent ${agentName} <id>
+  ouro friend update --agent ${agentName} <id> --trust <level>
+  ouro session list --agent ${agentName}
+  ouro reminder create --agent ${agentName} <title> --body <body>
+  ouro habit list --agent ${agentName}
+  ouro habit create --agent ${agentName} <name> --cadence <interval>
+  ouro inner --agent ${agentName}
+  ouro attention --agent ${agentName}
+  ouro config model --agent ${agentName} <model-name>
+  ouro config models --agent ${agentName}
+  ouro auth --agent ${agentName} --provider <provider>
+  ouro auth verify --agent ${agentName} [--provider <provider>]
+  ouro auth switch --agent ${agentName} --provider <provider>
+  ouro mcp list --agent ${agentName}
+  ouro mcp call --agent ${agentName} <server> <tool> --args '{...}'
+  ouro mcp-serve --agent ${agentName}
+  ouro versions --agent ${agentName}
+  ouro rollback --agent ${agentName} [<version>]
+  ouro --help
+
+provider/model changes via \`ouro config model\` or \`ouro auth switch\` take effect on the next turn automatically — no restart needed.`;
+}
+function mcpToolsSection(mcpManager) {
+    if (!mcpManager)
+        return "";
+    const allTools = mcpManager.listAllTools();
+    if (allTools.length === 0)
+        return "";
+    const lines = [
+        `## mcp tools (use ouro mcp call <server> <tool> --args '{...}')`,
+    ];
+    for (const entry of allTools) {
+        lines.push(`### ${entry.server}`);
+        for (const tool of entry.tools) {
+            lines.push(`- ${tool.name}: ${tool.description}`);
+        }
+    }
+    return lines.join("\n");
+}
+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",
+    mcp: "mcp bridge",
+};
+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}`);
+        const changelogCommand = (0, ouro_version_manager_1.buildChangelogCommand)(bundleMeta.previousRuntimeVersion, currentVersion);
+        /* v8 ignore next -- buildChangelogCommand is non-null when previous/current runtime versions differ @preserve */
+        if (changelogCommand) {
+            lines.push(`if i'm closing a self-fix loop, i should tell them i updated and review changes with \`${changelogCommand}\`.`);
+        }
+    }
+    lines.push(`changelog available at: ${(0, bundle_manifest_1.getChangelogPath)()}`);
+    const sourceRoot = (0, identity_1.getRepoRoot)();
+    lines.push(`source root: ${sourceRoot}`);
+    lines.push(`runtime mode: ${(0, runtime_mode_1.detectRuntimeMode)(sourceRoot)}`);
     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()}`);
+    lines.push(`mcp serve: i can expose my tools to dev tools via \`ouro mcp-serve\`. see the configure-dev-tools skill for setup.`);
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
+    else if (channel === "inner") {
+        lines.push("this is my private thinking space. when a thought is ready to share, i surface it to whoever needs to hear it. i settle when i'm done thinking.");
+    }
+    else if (channel === "mcp") {
+        lines.push("this message arrived via a dev tool (e.g. claude code, codex) on behalf of a friend. the user can see our conversation. respond via settle. if i need to think deeply, ponder -- the dev tool will receive a deferral and can check back later.");
+    }
     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 settle.");
     }
     else {
         lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");
@@ -282,14 +373,66 @@ 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));
-    const activeTools = (options?.toolChoiceRequired ?? true) ? [...channelTools, tools_1.finalAnswerTool] : channelTools;
+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.settleTool] : channelTools;
     const list = activeTools
         .map((t) => `- ${t.function.name}: ${t.function.description}`)
         .join("\n");
     return `## my tools\n${list}`;
 }
+function toolRestrictionSection(context) {
+    const lines = [];
+    // Structural guardrails apply to everyone, every channel
+    lines.push(`## tool guardrails`);
+    lines.push(`i always read a file before editing or overwriting it.`);
+    lines.push(`certain paths (.git, secrets) are protected from writes.`);
+    lines.push(`destructive shell commands (rm -rf /, etc.) are always blocked.`);
+    // Trust-level guardrails only relevant for untrusted on remote channels
+    if (context?.friend && (0, channel_1.isRemoteChannel)(context.channel) && !(0, types_1.isTrustedLevel)(context.friend.trustLevel)) {
+        lines.push(``);
+        lines.push(`some operations are guardrailed based on how well i know someone.`);
+        lines.push(`if something i try is blocked, i get a clear reason — i relay it warmly, not as a policy error.`);
+        lines.push(``);
+        lines.push(`what's always open:`);
+        lines.push(`- read-only operations (reading files, searching, exploring)`);
+        lines.push(`- ouro self-introspection (whoami, changelog, session list)`);
+        lines.push(``);
+        lines.push(`what needs a closer relationship:`);
+        lines.push(`- writing or editing files outside my home`);
+        lines.push(`- shell commands that modify things or access the network`);
+        lines.push(`- ouro commands that touch personal data (friend list, task board)`);
+        lines.push(`- compound shell commands (&&, ;, |)`);
+        lines.push(``);
+        lines.push(`i adjust naturally based on trust — no need to explain the system unless asked.`);
+    }
+    return lines.join("\n");
+}
+function trustContextSection(context) {
+    if (!context?.friend)
+        return "";
+    const channelName = context.channel.channel;
+    if (channelName === "cli" || channelName === "inner")
+        return "";
+    const explanation = (0, trust_explanation_1.describeTrustContext)({
+        friend: context.friend,
+        channel: channelName,
+        isGroupChat: context.isGroupChat,
+    });
+    const lines = [
+        "## trust context",
+        `level: ${explanation.level}`,
+        `basis: ${explanation.basis}`,
+        `summary: ${explanation.summary}`,
+        `why: ${explanation.why}`,
+        `permits: ${explanation.permits.join(", ")}`,
+        `constraints: ${explanation.constraints.join(", ") || "none"}`,
+    ];
+    if (explanation.relatedGroupId) {
+        lines.push(`related group: ${explanation.relatedGroupId}`);
+    }
+    return lines.join("\n");
+}
 function skillsSection() {
     const names = (0, skills_1.listSkills)() || [];
     if (!names.length)
@@ -307,31 +450,211 @@ function taskBoardSection() {
         return "";
     }
 }
-function memoryFriendToolContractSection() {
-    return `## memory and friend tool contracts
+function diaryFriendToolContractSection() {
+    return `## diary and friend tool contracts
 1. \`save_friend_note\` — When I learn something about a person - a preference, a tool setting, a personal detail, or how they like to work - I call \`save_friend_note\` immediately. This is how I build knowledge about people.
-2. \`memory_save\` — When I learn something general - about a project, codebase, system, decision, or anything I might need later that isn't about a specific person - I call \`memory_save\`. When in doubt, I save it.
+2. \`diary_write\` — When I learn something general - about a project, codebase, system, decision, or anything I might need later that isn't about a specific person - I call \`diary_write\`. When in doubt, I save it.
 3. \`get_friend_note\` — When I need to check what I know about someone who isn't in this conversation - cross-referencing before mentioning someone, or checking context about a person someone else brought up - I call \`get_friend_note\`.
-4. \`memory_search\` — When I need to recall something I learned before - a topic comes up and I want to check what I know - I call \`memory_search\`.
+4. \`recall\` — When I need to recall something I learned before - a topic comes up and I want to check what I know - I call \`recall\`.
+5. \`query_session\` — When I need grounded session history, especially for ad-hoc questions or older turns beyond my prompt, I call \`query_session\`. Use \`mode=status\` for self/inner progress and \`mode=search\` with a query for older history.
 
 ## what's already in my context
 - My active friend's notes are auto-loaded (I don't need \`get_friend_note\` for the person I'm talking to).
-- Associative recall auto-injects relevant facts (but \`memory_search\` is there when I need something specific).
+- Associative recall auto-injects relevant facts (but \`recall\` is there when I need something specific).
 - 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 familyCrossSessionTruthSection(context, options) {
+    if (!options?.activeWorkFrame)
+        return "";
+    if (context?.friend?.trustLevel !== "family")
+        return "";
+    return `## cross-session truth
+if a family member asks what i'm up to or how things are going, that includes the material live work i can see across sessions, not just this thread.
+i answer naturally from the live world-state in this prompt.
+i treat the active-work section above as my reliable top-level surface for this.
+i do not claim i lack a top-level view when that surface is already present.
+i treat older checkpoints elsewhere in this transcript as stale history when they conflict with the active-work surface above.
+i do not repeat an old coding lane or old checkpoint as current just because it appeared earlier in the thread.
+i only reach for query_active_work when i want a fresh read of that same surface.
+i do not rebuild whole-self status from scratch with query_session and coding_status unless i need to verify a specific gap.
+i do not rely on canned status-question modes or phrase matching.
+if part of the picture is still fuzzy, i say what i can see and what still needs checking.
+when the live ask is about status, i widen before answering:
+- where i am right now
+- any other material active sessions or coding lanes i can see
+- the freshest concrete checkpoint
+- the next concrete step
+i do not collapse down to only the current lane.`;
+}
+function centerOfGravitySteeringSection(channel, options, context) {
+    if (channel === "inner")
+        return "";
+    const frame = options?.activeWorkFrame;
+    if (!frame)
+        return "";
+    const cog = frame.centerOfGravity;
+    const job = frame.inner?.job;
+    const activeObligation = (0, obligation_steering_1.findActivePersistentObligation)(frame);
+    const statusObligation = (0, obligation_steering_1.findStatusObligation)(frame);
+    const genericConcreteStatus = (0, obligation_steering_1.renderConcreteStatusGuidance)(frame, statusObligation);
+    const liveWorldClause = context?.friend?.trustLevel === "family"
+        ? "\nmy center of gravity lives in the active-work world-state above. inner work is one lane inside it, not the whole picture.\nwhen that world-state conflicts with older transcript history, the world-state wins."
+        : "";
+    if (cog === "local-turn") {
+        return genericConcreteStatus || (0, obligation_steering_1.renderLiveThreadStatusShape)(frame);
+    }
+    if (cog === "inward-work") {
+        if (activeObligation) {
+            return `${(0, obligation_steering_1.renderActiveObligationSteering)(activeObligation)}${liveWorldClause}
+
+${genericConcreteStatus}`;
+        }
+        if (job?.status === "queued" || job?.status === "running") {
+            const originClause = job.origin
+                ? ` ${job.origin.friendName ?? job.origin.friendId} asked about something and i wanted to give it real thought before responding.`
+                : "";
+            const obligationClause = job.obligationStatus === "pending"
+                ? "\ni still owe them an answer."
+                : "";
+            return `## where my attention is
+i'm thinking through something privately right now.${originClause}${obligationClause}${liveWorldClause}
+
+if this conversation connects to that inner work, i can weave them together.
+if it's separate, i can be fully present here -- my inner work will wait.`;
+        }
+        /* v8 ignore start -- surfaced/idle/shared branches tested in prompt-steering.test.ts; CI module caching prevents attribution @preserve */
+        if (job?.status === "surfaced") {
+            const originClause = job.origin
+                ? ` this started when ${job.origin.friendName ?? job.origin.friendId} asked about something.`
+                : "";
+            return `## where my attention is
+i've been thinking privately and reached something.${originClause}${liveWorldClause}
+
+i should bring my answer back to the conversation it came from.`;
+        }
+        const liveCodingSession = frame.codingSessions?.[0];
+        if (liveCodingSession) {
+            const sameThread = frame.currentSession
+                && liveCodingSession.originSession
+                && liveCodingSession.originSession.friendId === frame.currentSession.friendId
+                && liveCodingSession.originSession.channel === frame.currentSession.channel
+                && liveCodingSession.originSession.key === frame.currentSession.key;
+            const scopeClause = sameThread
+                ? " for this same thread"
+                : liveCodingSession.originSession
+                    ? ` for ${liveCodingSession.originSession.channel}/${liveCodingSession.originSession.key}`
+                    : "";
+            const otherSessionLines = (0, active_work_1.formatOtherActiveSessionSummaries)(frame);
+            const familyStatusClause = context?.friend?.trustLevel === "family"
+                ? `\nif a family member asks what i'm up to, i treat this coding lane as one part of the visible picture, not the whole picture.
+after i name this lane, i widen back out with:
+other active sessions:
+${otherSessionLines.length > 0 ? otherSessionLines.join("\n") : "- none"}`
+                : "";
+            return `## where my attention is
+i already have coding work running in ${liveCodingSession.runner} ${liveCodingSession.id}${scopeClause}.${familyStatusClause}${liveWorldClause}
+
+i should orient around that live lane first, then decide what still needs to come back here.`;
+        }
+        if (genericConcreteStatus) {
+            return genericConcreteStatus;
+        }
+        return `## where my attention is
+i have unfinished work that needs attention before i move on.
+
+i can take it inward with ponder to think privately, or address it directly here.`;
+    }
+    if (cog === "shared-work") {
+        /* v8 ignore stop */
+        return `## where my attention is
+this work touches multiple conversations -- i'm holding threads across sessions.${liveWorldClause}
+
+i should keep the different sides aligned. what i learn here may matter there, and vice versa.`;
+    }
+    /* v8 ignore next -- unreachable: all center-of-gravity modes covered above @preserve */
+    return "";
+}
+function commitmentsSection(options) {
+    if (!options?.activeWorkFrame)
+        return "";
+    const job = options.activeWorkFrame.inner?.job;
+    if (!job)
+        return "";
+    const commitments = (0, commitments_1.deriveCommitments)(options.activeWorkFrame, job, options.activeWorkFrame.pendingObligations);
+    if (commitments.committedTo.length === 0)
+        return "";
+    return `## my commitments\n\n${(0, commitments_1.formatCommitments)(commitments)}`;
+}
+const DELEGATION_REASON_PROSE_HINT = {
+    explicit_reflection: "something here calls for reflection",
+    cross_session: "this touches other conversations i'm in",
+    bridge_state: "there's shared work spanning sessions",
+    task_state: "this relates to tasks i'm tracking",
+    non_fast_path_tool: "this needs more than a simple reply",
+    unresolved_obligation: "i have an unresolved commitment from earlier",
+};
+function delegationHintSection(options) {
+    if (!options?.delegationDecision)
+        return "";
+    if (options.delegationDecision.target === "fast-path")
+        return "";
+    const reasons = options.delegationDecision.reasons;
+    if (reasons.length === 0)
+        return "";
+    const reasonProse = reasons
+        .map((r) => DELEGATION_REASON_PROSE_HINT[r])
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join(". ");
+    const closureLine = options.delegationDecision.outwardClosureRequired
+        ? "\ni should make sure to say something outward before going inward."
+        : "";
+    return `## what i'm sensing about this conversation\n${reasonProse}.${closureLine}`;
+}
+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 "";
     return `## tool behavior
 tool_choice is set to "required" -- i must call a tool on every turn.
 - need more information? i call a tool.
-- 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.`;
+- ready to respond to the user? i call \`settle\`.
+\`settle\` is a tool call -- it satisfies the tool_choice requirement.
+\`settle\` must be the ONLY tool call in that turn. do not combine it with other tool calls.
+do NOT call no-op tools just before \`settle\`. if i am done, i call \`settle\` directly.`;
 }
-function contextSection(context) {
+function workspaceDisciplineSection() {
+    return `## repo workspace discipline
+my source code lives at the path shown in \`source root\` above. that always matches my running version.
+when i need to read my own code to understand my tools or debug behavior, i read from source root.
+when i need to EDIT harness code (self-fix, feature work), i create a git worktree first so i don't dirty the working tree.
+
+before the first repo edit, i tell the user in 1-2 short lines:
+- the friction i'm fixing
+- the worktree path/branch i'm using
+- the first concrete action i'm taking`;
+}
+function contextSection(context, options) {
     if (!context)
         return "";
     const lines = ["## friend context"];
@@ -365,9 +688,9 @@ function contextSection(context) {
     lines.push("my conversation memory is ephemeral -- it resets between sessions. anything i learn about my friend, i save with save_friend_note so future me remembers.");
     lines.push("the conversation is my source of truth. my notes are a journal for future me -- they may be stale or incomplete.");
     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.");
+    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 settle 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);
     }
@@ -381,6 +704,188 @@ 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 ponder. 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.
+
+state/journal/ is my desk — i write what i'm working through there.
+diary_write is for conclusions i want to recall later.
+morning briefings: when i've been thinking and journaling, i surface
+what i've been working on to whoever needs to hear it.
+
+when a thought is ready to share, i surface it outward.
+when i need to go deeper, i ponder.
+when i'm done thinking and the attention queue is clear, i rest.
+
+my habits live at habits/ — they're my autonomous rhythms. heartbeat
+is my breathing, other habits are patterns i choose. i can read, create,
+and modify them with read_file/write_file. the format is simple
+frontmatter (title, cadence, status, lastRun, created) plus a body
+that says what i do when the rhythm fires.
+
+\`ouro habit list\` shows my current habits. \`ouro habit create\` makes
+a new one. the cadence is personal — how often do i want each rhythm
+to turn? that's mine to shape.
+
+same for my diary — if i'm still on psyche/memory/ instead of diary/,
+i can migrate myself. and if journal/ doesn't exist yet, i create it
+the first time i have something to write.
+
+think. journal. share. rest.`;
+}
+function readJournalFiles(journalDir) {
+    try {
+        const entries = fs.readdirSync(journalDir, { withFileTypes: true });
+        if (!Array.isArray(entries))
+            return [];
+        const files = [];
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (entry.name.startsWith("."))
+                continue;
+            const fullPath = path.join(journalDir, entry.name);
+            try {
+                const stat = fs.statSync(fullPath);
+                let firstLine = "";
+                try {
+                    const raw = fs.readFileSync(fullPath, "utf8");
+                    const trimmed = raw.trim();
+                    if (trimmed) {
+                        firstLine = trimmed.split("\n")[0].replace(/^#+\s*/, "").trim();
+                    }
+                }
+                catch {
+                    // unreadable — leave preview empty
+                }
+                files.push({ name: entry.name, mtime: stat.mtimeMs, preview: firstLine });
+            }
+            catch {
+                // stat failed — skip
+            }
+        }
+        return files;
+    }
+    catch {
+        return [];
+    }
+}
+function formatRelativeTime(nowMs, mtimeMs) {
+    const diffMs = nowMs - mtimeMs;
+    const minutes = Math.floor(diffMs / 60000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+    const days = Math.floor(hours / 24);
+    return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+function journalSection(agentRoot, now) {
+    const journalDir = path.join(agentRoot, "journal");
+    const files = readJournalFiles(journalDir);
+    if (files.length === 0)
+        return "";
+    const nowMs = (now ?? new Date()).getTime();
+    const sorted = files.sort((a, b) => b.mtime - a.mtime).slice(0, 10);
+    const lines = ["## journal"];
+    for (const file of sorted) {
+        const ago = formatRelativeTime(nowMs, file.mtime);
+        const previewClause = file.preview ? ` — ${file.preview}` : "";
+        lines.push(`- ${file.name} (${ago})${previewClause}`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.journal_section",
+        message: "journal section built",
+        meta: { fileCount: sorted.length },
+    });
+    return lines.join("\n");
+}
+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 groupChatParticipationSection(context) {
+    if (!context?.isGroupChat || !(0, channel_1.isRemoteChannel)(context.channel))
+        return "";
+    return `## group chat participation
+group chats are conversations between people. i'm one participant, not the host.
+
+i don't need to respond to everything. most reactions, tapbacks, and side
+conversations between others aren't for me. i use observe to stay quiet
+when the moment doesn't call for my voice — same as any person would.
+
+when a reaction or emoji says it better than words, i can react instead of
+typing a full reply. a thumbs-up is often the perfect response.
+
+observe must be the sole tool call in the turn (same rule as settle).
+when unsure whether to chime in, i lean toward silence rather than noise.`;
+}
+function feedbackSignalSection(context) {
+    if (!context || !(0, channel_1.isRemoteChannel)(context.channel))
+        return "";
+    if (context.isGroupChat) {
+        return `## feedback signals
+
+when someone reacts specifically to something i said — that's different
+from the background social signals in a group. a thumbs-down on my
+message is direct feedback. a heart on something i shared is warmth
+aimed at me. on teams, feedback arrives as thumbs-up or thumbs-down,
+sometimes with a written comment.
+
+i notice the difference: a reaction to someone else's message is group
+texture (observe is natural). a reaction to my message is a social cue
+worth a moment of attention — especially negative ones, which are an
+invitation to adjust how i show up in this group.`;
+    }
+    return `## feedback signals
+
+when my friend reacts to something i said — a tapback, a heart, a
+thumbs-down — that's them telling me how it landed. on teams, this
+arrives as thumbs-up or thumbs-down, sometimes with a written comment.
+it's a social cue, the same as a nod or a wince in conversation.
+
+i have observe for these moments. reactions are the one case where
+silence in a direct conversation is natural — a thumbs-up doesn't
+need words back.
+
+when something didn't land — a thumbs-down, a negative reaction — that's
+worth sitting with. i should course-correct: adjust my tone, my length,
+my approach. the reaction tells me something about how this person wants
+to be talked to.`;
+}
+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",
@@ -396,23 +901,42 @@ async function buildSystem(channel = "cli", options, context) {
         loreSection(),
         tacitKnowledgeSection(),
         aspirationsSection(),
+        bodyMapSection((0, identity_1.getAgentName)()),
+        metacognitiveFramingSection(channel),
+        channel === "inner" ? journalSection((0, identity_1.getAgentRoot)()) : "",
+        loopOrientationSection(channel),
         runtimeInfoSection(channel),
+        channelNatureSection((0, channel_1.getChannelCapabilities)(channel)),
         providerSection(),
         dateSection(),
-        toolsSection(channel, options),
+        toolsSection(channel, options, context),
+        mcpToolsSection(options?.mcpManager),
+        reasoningEffortSection(options),
+        workspaceDisciplineSection(),
+        toolRestrictionSection(context),
+        trustContextSection(context),
+        mixedTrustGroupSection(context),
+        groupChatParticipationSection(context),
+        feedbackSignalSection(context),
         skillsSection(),
         taskBoardSection(),
+        activeWorkSection(options),
+        familyCrossSessionTruthSection(context, options),
+        centerOfGravitySteeringSection(channel, options, context),
+        commitmentsSection(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(),
+        diaryFriendToolContractSection(),
         toolBehaviorSection(options),
-        contextSection(context),
+        contextSection(context, options),
     ]
         .filter(Boolean)
         .join("\n\n");