@ouro.bot/cli 0.1.0-alpha.16 → 0.1.0-alpha.161

package/dist/repertoire/tools-base.js

@@ -33,19 +33,304 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.finalAnswerTool = exports.baseToolHandlers = exports.tools = exports.baseToolDefinitions = void 0;
+exports.restTool = exports.settleTool = exports.observeTool = exports.ponderTool = exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = void 0;
+exports.renderInnerProgressStatus = renderInnerProgressStatus;
 const fs = __importStar(require("fs"));
+const fg = __importStar(require("fast-glob"));
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const skills_1 = require("./skills");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
-const os = __importStar(require("os"));
-const tasks_1 = require("./tasks");
+const identity_2 = require("../heart/identity");
+const socket_client_1 = require("../heart/daemon/socket-client");
+const thoughts_1 = require("../heart/daemon/thoughts");
+const manager_1 = require("../heart/bridges/manager");
+const session_recall_1 = require("../heart/session-recall");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
 const tools_1 = require("./coding/tools");
-const memory_1 = require("../mind/memory");
-const postIt = (msg) => `post-it from past you:\n${msg}`;
+const coding_1 = require("./coding");
+const diary_1 = require("../mind/diary");
+const tasks_1 = require("./tasks");
+const pending_1 = require("../mind/pending");
+const obligations_1 = require("../mind/obligations");
+const progress_story_1 = require("../heart/progress-story");
+const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
+const obligations_2 = require("../heart/obligations");
+// Tracks which file paths have been read via read_file in this session.
+// edit_file requires a file to be read first (must-read-first guard).
+exports.editFileReadTracker = new Set();
+function buildContextDiff(lines, changeStart, changeEnd, contextSize = 3) {
+    const start = Math.max(0, changeStart - contextSize);
+    const end = Math.min(lines.length, changeEnd + contextSize);
+    const result = [];
+    for (let i = start; i < end; i++) {
+        const lineNum = i + 1;
+        const prefix = (i >= changeStart && i < changeEnd) ? ">" : " ";
+        result.push(`${prefix} ${lineNum} | ${lines[i]}`);
+    }
+    return result.join("\n");
+}
+function resolveLocalToolPath(targetPath) {
+    if (!path.isAbsolute(targetPath)) {
+        return path.resolve((0, identity_2.getRepoRoot)(), targetPath);
+    }
+    return targetPath;
+}
+const NO_SESSION_FOUND_MESSAGE = "no session found for that friend/channel/key combination.";
+const EMPTY_SESSION_MESSAGE = "session exists but has no non-system messages.";
+function findDelegatingBridgeId(ctx) {
+    const currentSession = ctx?.currentSession;
+    if (!currentSession)
+        return undefined;
+    return ctx?.activeBridges?.find((bridge) => bridge.lifecycle === "active"
+        && bridge.attachedSessions.some((session) => session.friendId === currentSession.friendId
+            && session.channel === currentSession.channel
+            && session.key === currentSession.key))?.id;
+}
+async function recallSessionSafely(options) {
+    try {
+        return await (0, session_recall_1.recallSession)(options);
+    }
+    catch (error) {
+        if (options.summarize) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.session_recall_summary_fallback",
+                message: "session recall summarization failed; using raw transcript",
+                meta: {
+                    friendId: options.friendId,
+                    channel: options.channel,
+                    key: options.key,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+            try {
+                return await (0, session_recall_1.recallSession)({
+                    ...options,
+                    summarize: undefined,
+                });
+            }
+            catch {
+                return { kind: "missing" };
+            }
+        }
+        return { kind: "missing" };
+    }
+}
+async function searchSessionSafely(options) {
+    try {
+        return await (0, session_recall_1.searchSessionTranscript)(options);
+    }
+    catch {
+        return { kind: "missing" };
+    }
+}
+function normalizeProgressOutcome(text) {
+    const trimmed = text.trim();
+    /* v8 ignore next -- defensive: normalizeProgressOutcome null branch @preserve */
+    if (!trimmed || trimmed === "nothing yet" || trimmed === "nothing recent") {
+        return null;
+    }
+    if (trimmed.startsWith("\"") && trimmed.endsWith("\"") && trimmed.length >= 2) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function writePendingEnvelope(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));
+}
+function renderCrossChatDeliveryStatus(target, result) {
+    const phase = result.status === "delivered_now"
+        ? "completed"
+        : result.status === "queued_for_later"
+            ? "queued"
+            : result.status === "blocked"
+                ? "blocked"
+                : "errored";
+    const lead = result.status === "delivered_now"
+        ? "delivered now"
+        : result.status === "queued_for_later"
+            ? "queued for later"
+            : result.status === "blocked"
+                ? "blocked"
+                : "failed";
+    return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+        scope: "shared-work",
+        phase,
+        objective: `message to ${target}`,
+        outcomeText: `${lead}\n${result.detail}`,
+    }));
+}
+function emptyTaskBoard() {
+    return {
+        compact: "",
+        full: "",
+        byStatus: {
+            drafting: [],
+            processing: [],
+            validating: [],
+            collaborating: [],
+            paused: [],
+            blocked: [],
+            done: [],
+            cancelled: [],
+        },
+        issues: [],
+        actionRequired: [],
+        unresolvedDependencies: [],
+        activeSessions: [],
+        activeBridges: [],
+    };
+}
+function isLiveCodingSessionStatus(status) {
+    return status === "spawning"
+        || status === "running"
+        || status === "waiting_input"
+        || status === "stalled";
+}
+function readActiveWorkInnerState() {
+    const defaultJob = {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+        const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+        const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+        const dialogStatus = (0, thoughts_1.deriveInnerDialogStatus)(pendingMessages, turns, runtimeState);
+        const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+        const storeObligationPending = (0, obligations_2.readPendingObligations)(agentRoot).length > 0;
+        return {
+            status: dialogStatus.processing === "started" ? "running" : "idle",
+            hasPending: dialogStatus.queue !== "clear",
+            origin: dialogStatus.origin,
+            contentSnippet: dialogStatus.contentSnippet,
+            obligationPending: dialogStatus.obligationPending || storeObligationPending,
+            job,
+        };
+    }
+    catch {
+        return {
+            status: "idle",
+            hasPending: false,
+            job: defaultJob,
+        };
+    }
+}
+async function buildToolActiveWorkFrame(ctx) {
+    const currentSession = ctx?.currentSession
+        ? {
+            friendId: ctx.currentSession.friendId,
+            channel: ctx.currentSession.channel,
+            key: ctx.currentSession.key,
+            sessionPath: (0, config_1.resolveSessionPath)(ctx.currentSession.friendId, ctx.currentSession.channel, ctx.currentSession.key),
+        }
+        : null;
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const bridges = currentSession
+        ? (0, manager_1.createBridgeManager)().findBridgesForSession({
+            friendId: currentSession.friendId,
+            channel: currentSession.channel,
+            key: currentSession.key,
+        })
+        : [];
+    let friendActivity = [];
+    try {
+        friendActivity = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: `${agentRoot}/state/sessions`,
+            friendsDir: `${agentRoot}/friends`,
+            agentName: (0, identity_1.getAgentName)(),
+            currentSession,
+        });
+    }
+    catch {
+        friendActivity = [];
+    }
+    const pendingObligations = (() => {
+        try {
+            return (0, obligations_2.readPendingObligations)(agentRoot);
+        }
+        catch {
+            return [];
+        }
+    })();
+    let codingSessions = [];
+    let otherCodingSessions = [];
+    try {
+        const liveCodingSessions = (0, coding_1.getCodingSessionManager)()
+            .listSessions()
+            .filter((session) => isLiveCodingSessionStatus(session.status) && Boolean(session.originSession));
+        if (currentSession) {
+            codingSessions = liveCodingSessions.filter((session) => session.originSession?.friendId === currentSession.friendId
+                && session.originSession.channel === currentSession.channel
+                && session.originSession.key === currentSession.key);
+            otherCodingSessions = liveCodingSessions.filter((session) => !(session.originSession?.friendId === currentSession.friendId
+                && session.originSession.channel === currentSession.channel
+                && session.originSession.key === currentSession.key));
+        }
+        else {
+            codingSessions = [];
+            otherCodingSessions = liveCodingSessions;
+        }
+    }
+    catch {
+        codingSessions = [];
+        otherCodingSessions = [];
+    }
+    const currentObligation = currentSession
+        ? pendingObligations.find((obligation) => obligation.status !== "fulfilled"
+            && obligation.origin.friendId === currentSession.friendId
+            && obligation.origin.channel === currentSession.channel
+            && obligation.origin.key === currentSession.key)?.content ?? null
+        : null;
+    return (0, active_work_1.buildActiveWorkFrame)({
+        currentSession,
+        currentObligation,
+        mustResolveBeforeHandoff: false,
+        inner: readActiveWorkInnerState(),
+        bridges,
+        codingSessions,
+        otherCodingSessions,
+        pendingObligations,
+        taskBoard: (() => {
+            try {
+                return (0, tasks_1.getTaskModule)().getBoard();
+            }
+            catch {
+                return emptyTaskBoard();
+            }
+        })(),
+        friendActivity,
+        targetCandidates: [],
+    });
+}
+function renderInnerProgressStatus(status) {
+    if (status.processing === "pending") {
+        return "i've queued this thought for private attention. it'll come up when my inner dialog is free.";
+    }
+    if (status.processing === "started") {
+        return "i'm working through this privately right now.";
+    }
+    // processed / completed
+    if (status.surfaced && status.surfaced !== "nothing recent" && status.surfaced !== "no outward result") {
+        return `i thought about this privately and came to something: ${status.surfaced}`;
+    }
+    return "i thought about this privately. i'll bring it back when the time is right.";
+}
 exports.baseToolDefinitions = [
     {
         tool: {
@@ -55,12 +340,29 @@ exports.baseToolDefinitions = [
                 description: "read file contents",
                 parameters: {
                     type: "object",
-                    properties: { path: { type: "string" } },
+                    properties: {
+                        path: { type: "string" },
+                        offset: { type: "number", description: "1-based line number to start reading from" },
+                        limit: { type: "number", description: "maximum number of lines to return" },
+                    },
                     required: ["path"],
                 },
             },
         },
-        handler: (a) => fs.readFileSync(a.path, "utf-8"),
+        handler: (a) => {
+            const resolvedPath = resolveLocalToolPath(a.path);
+            const content = fs.readFileSync(resolvedPath, "utf-8");
+            exports.editFileReadTracker.add(resolvedPath);
+            const offset = a.offset ? parseInt(a.offset, 10) : undefined;
+            const limit = a.limit ? parseInt(a.limit, 10) : undefined;
+            if (offset === undefined && limit === undefined)
+                return content;
+            const lines = content.split("\n");
+            const start = offset ? offset - 1 : 0;
+            const end = limit !== undefined ? start + limit : lines.length;
+            return lines.slice(start, end).join("\n");
+        },
+        summaryKeys: ["path"],
     },
     {
         tool: {
@@ -75,103 +377,225 @@ exports.baseToolDefinitions = [
                 },
             },
         },
-        handler: (a) => (fs.writeFileSync(a.path, a.content, "utf-8"), "ok"),
+        handler: (a) => {
+            const resolvedPath = resolveLocalToolPath(a.path);
+            fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+            fs.writeFileSync(resolvedPath, a.content, "utf-8");
+            return "ok";
+        },
+        summaryKeys: ["path"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "shell",
-                description: "run shell command",
+                name: "edit_file",
+                description: "surgically edit a file by replacing an exact string. the file must have been read via read_file first. old_string must match exactly one location in the file.",
                 parameters: {
                     type: "object",
-                    properties: { command: { type: "string" } },
-                    required: ["command"],
+                    properties: {
+                        path: { type: "string" },
+                        old_string: { type: "string" },
+                        new_string: { type: "string" },
+                    },
+                    required: ["path", "old_string", "new_string"],
                 },
             },
         },
-        handler: (a) => (0, child_process_1.execSync)(a.command, { encoding: "utf-8", timeout: 30000 }),
+        handler: (a) => {
+            const resolvedPath = resolveLocalToolPath(a.path);
+            if (!exports.editFileReadTracker.has(resolvedPath)) {
+                return `error: you must read the file with read_file before editing it. call read_file on ${a.path} first.`;
+            }
+            let content;
+            try {
+                content = fs.readFileSync(resolvedPath, "utf-8");
+            }
+            catch (e) {
+                return `error: could not read file: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+            }
+            // Count occurrences
+            const occurrences = [];
+            let searchFrom = 0;
+            while (true) {
+                const idx = content.indexOf(a.old_string, searchFrom);
+                if (idx === -1)
+                    break;
+                occurrences.push(idx);
+                searchFrom = idx + 1;
+            }
+            if (occurrences.length === 0) {
+                return `error: old_string not found in ${a.path}`;
+            }
+            if (occurrences.length > 1) {
+                return `error: old_string is ambiguous -- found ${occurrences.length} matches in ${a.path}. provide more context to make the match unique.`;
+            }
+            // Single unique match -- replace
+            const idx = occurrences[0];
+            const updated = content.slice(0, idx) + a.new_string + content.slice(idx + a.old_string.length);
+            fs.writeFileSync(resolvedPath, updated, "utf-8");
+            // Build contextual diff
+            const lines = updated.split("\n");
+            const prefixLines = content.slice(0, idx).split("\n");
+            const changeStartLine = prefixLines.length - 1;
+            const newStringLines = a.new_string.split("\n");
+            const changeEndLine = changeStartLine + newStringLines.length;
+            return buildContextDiff(lines, changeStartLine, changeEndLine);
+        },
+        summaryKeys: ["path"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "list_directory",
-                description: "list directory contents",
+                name: "glob",
+                description: "find files matching a glob pattern. returns matching paths sorted alphabetically, one per line.",
                 parameters: {
                     type: "object",
-                    properties: { path: { type: "string" } },
-                    required: ["path"],
+                    properties: {
+                        pattern: { type: "string", description: "glob pattern (e.g. **/*.ts)" },
+                        cwd: { type: "string", description: "directory to search from (defaults to process.cwd())" },
+                    },
+                    required: ["pattern"],
                 },
             },
         },
-        handler: (a) => fs
-            .readdirSync(a.path, { withFileTypes: true })
-            .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
-            .join("\n"),
+        handler: (a) => {
+            const cwd = a.cwd ? resolveLocalToolPath(a.cwd) : process.cwd();
+            const matches = fg.globSync(a.pattern, { cwd, dot: true });
+            return matches.sort().join("\n");
+        },
+        summaryKeys: ["pattern", "cwd"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "git_commit",
-                description: "commit changes to git with explicit paths",
+                name: "grep",
+                description: "search file contents for lines matching a regex pattern. searches recursively when given a directory. returns matching lines with file path and line numbers.",
                 parameters: {
                     type: "object",
                     properties: {
-                        message: { type: "string" },
-                        paths: { type: "array", items: { type: "string" } },
+                        pattern: { type: "string", description: "regex pattern to search for" },
+                        path: { type: "string", description: "file or directory to search" },
+                        context_lines: { type: "number", description: "number of surrounding context lines (default 0)" },
+                        include: { type: "string", description: "glob filter to limit searched files (e.g. *.ts)" },
                     },
-                    required: ["message", "paths"],
+                    required: ["pattern", "path"],
                 },
             },
         },
         handler: (a) => {
-            try {
-                if (!a.paths || !Array.isArray(a.paths) || a.paths.length === 0) {
-                    return postIt("paths are required. specify explicit files to commit.");
+            const targetPath = resolveLocalToolPath(a.path);
+            const regex = new RegExp(a.pattern);
+            const contextLines = parseInt(a.context_lines || "0", 10);
+            const includeGlob = a.include || undefined;
+            function searchFile(filePath) {
+                let content;
+                try {
+                    content = fs.readFileSync(filePath, "utf-8");
                 }
-                for (const p of a.paths) {
-                    if (!fs.existsSync(p)) {
-                        return postIt(`path does not exist: ${p}`);
+                catch {
+                    return [];
+                }
+                const lines = content.split("\n");
+                const matchIndices = new Set();
+                for (let i = 0; i < lines.length; i++) {
+                    if (regex.test(lines[i])) {
+                        matchIndices.add(i);
+                    }
+                }
+                if (matchIndices.size === 0)
+                    return [];
+                const outputIndices = new Set();
+                for (const idx of matchIndices) {
+                    const start = Math.max(0, idx - contextLines);
+                    const end = Math.min(lines.length - 1, idx + contextLines);
+                    for (let i = start; i <= end; i++) {
+                        outputIndices.add(i);
                     }
-                    (0, child_process_1.execSync)(`git add ${p}`, { encoding: "utf-8" });
                 }
-                const diff = (0, child_process_1.execSync)("git diff --cached --stat", { encoding: "utf-8" });
-                if (!diff || diff.trim().length === 0) {
-                    return postIt("nothing was staged. check your changes or paths.");
+                const sortedIndices = [...outputIndices].sort((a, b) => a - b);
+                const results = [];
+                for (const idx of sortedIndices) {
+                    const lineNum = idx + 1;
+                    if (matchIndices.has(idx)) {
+                        results.push(`${filePath}:${lineNum}: ${lines[idx]}`);
+                    }
+                    else {
+                        results.push(`-${filePath}:${lineNum}: ${lines[idx]}`);
+                    }
                 }
-                (0, child_process_1.execSync)(`git commit -m \"${a.message}\"`, { encoding: "utf-8" });
-                return `${diff}\ncommitted`;
+                return results;
             }
-            catch (e) {
-                return `failed: ${e}`;
+            function collectFiles(dirPath) {
+                const files = [];
+                function walk(dir) {
+                    let entries;
+                    try {
+                        entries = fs.readdirSync(dir, { withFileTypes: true });
+                    }
+                    catch {
+                        return;
+                    }
+                    for (const entry of entries) {
+                        const fullPath = path.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            walk(fullPath);
+                        }
+                        else if (entry.isFile()) {
+                            files.push(fullPath);
+                        }
+                    }
+                }
+                walk(dirPath);
+                return files.sort();
+            }
+            function matchesGlob(filePath, glob) {
+                const escaped = glob
+                    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+                    .replace(/\*/g, ".*")
+                    .replace(/\?/g, ".");
+                return new RegExp(`(^|/)${escaped}$`).test(filePath);
+            }
+            const stat = fs.statSync(targetPath, { throwIfNoEntry: false });
+            if (!stat)
+                return "";
+            if (stat.isFile()) {
+                return searchFile(targetPath).join("\n");
+            }
+            let files = collectFiles(targetPath);
+            if (includeGlob) {
+                files = files.filter((f) => matchesGlob(f, includeGlob));
+            }
+            const allResults = [];
+            for (const file of files) {
+                allResults.push(...searchFile(file));
             }
+            return allResults.join("\n");
         },
+        summaryKeys: ["pattern", "path", "include"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "gh_cli",
-                description: "execute a GitHub CLI (gh) command. use carefully.",
+                name: "shell",
+                description: "run shell command",
                 parameters: {
                     type: "object",
-                    properties: {
-                        command: { type: "string" },
-                    },
+                    properties: { command: { type: "string" } },
                     required: ["command"],
                 },
             },
         },
         handler: (a) => {
-            try {
-                return (0, child_process_1.execSync)(`gh ${a.command}`, { encoding: "utf-8", timeout: 60000 });
-            }
-            catch (e) {
-                return `error: ${e}`;
-            }
+            return (0, child_process_1.execSync)(a.command, {
+                encoding: "utf-8",
+                timeout: 30000,
+            });
         },
+        summaryKeys: ["command"],
     },
     {
         tool: {
@@ -205,20 +629,7 @@ exports.baseToolDefinitions = [
                 return `error: ${e}`;
             }
         },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "get_current_time",
-                description: "get the current date and time in America/Los_Angeles (Pacific Time)",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => new Date().toLocaleString("en-US", {
-            timeZone: "America/Los_Angeles",
-            hour12: false,
-        }),
+        summaryKeys: ["name"],
     },
     {
         tool: {
@@ -235,7 +646,7 @@ exports.baseToolDefinitions = [
         },
         handler: (a) => {
             try {
-                const result = (0, child_process_1.spawnSync)("claude", ["-p", "--dangerously-skip-permissions", "--add-dir", "."], {
+                const result = (0, child_process_1.spawnSync)("claude", ["-p", "--no-session-persistence", "--dangerously-skip-permissions", "--add-dir", "."], {
                     input: a.prompt,
                     encoding: "utf-8",
                     timeout: 60000,
@@ -250,6 +661,7 @@ exports.baseToolDefinitions = [
                 return `error: ${e}`;
             }
         },
+        summaryKeys: ["prompt"],
     },
     {
         tool: {
@@ -290,13 +702,14 @@ exports.baseToolDefinitions = [
                 return `error: ${e}`;
             }
         },
+        summaryKeys: ["query"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "memory_search",
-                description: "search remembered facts stored in psyche memory and return relevant matches for a query",
+                name: "recall",
+                description: "recall what i know — search my diary and journal for facts, thoughts, and working notes that match a query",
                 parameters: {
                     type: "object",
                     properties: { query: { type: "string" } },
@@ -309,44 +722,69 @@ exports.baseToolDefinitions = [
                 const query = (a.query || "").trim();
                 if (!query)
                     return "query is required";
-                const memoryRoot = path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-                const hits = await (0, memory_1.searchMemoryFacts)(query, (0, memory_1.readMemoryFacts)(memoryRoot));
-                return hits
-                    .map((fact) => `- ${fact.text} (source=${fact.source}, createdAt=${fact.createdAt})`)
-                    .join("\n");
+                const resultLines = [];
+                // Search diary entries
+                const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)());
+                for (const fact of hits) {
+                    resultLines.push(`[diary] ${fact.text} (source=${fact.source}, createdAt=${fact.createdAt})`);
+                }
+                // Search journal index
+                const agentRoot = (0, identity_1.getAgentRoot)();
+                const journalIndexPath = path.join(agentRoot, "journal", ".index.json");
+                try {
+                    const raw = fs.readFileSync(journalIndexPath, "utf8");
+                    const journalEntries = JSON.parse(raw);
+                    if (Array.isArray(journalEntries) && journalEntries.length > 0) {
+                        // Substring match on preview and filename
+                        const lowerQuery = query.toLowerCase();
+                        for (const entry of journalEntries) {
+                            /* v8 ignore next 4 -- both sides tested (filename-only match in recall-journal.test.ts); v8 misreports || short-circuit @preserve */
+                            if (entry.preview.toLowerCase().includes(lowerQuery) ||
+                                entry.filename.toLowerCase().includes(lowerQuery)) {
+                                resultLines.push(`[journal] ${entry.filename}: ${entry.preview}`);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // No journal index or malformed — skip journal search
+                }
+                return resultLines.join("\n");
             }
             catch (e) {
                 return `error: ${e instanceof Error ? e.message : String(e)}`;
             }
         },
+        summaryKeys: ["query"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "memory_save",
-                description: "save a general memory fact i want to recall later. optional 'about' can tag the fact to a person/topic/context",
+                name: "diary_write",
+                description: "write an entry in my diary — something i learned, noticed, or concluded that i want to recall later. optional 'about' tags the entry to a person, topic, or context.",
                 parameters: {
                     type: "object",
                     properties: {
-                        text: { type: "string" },
+                        entry: { type: "string" },
                         about: { type: "string" },
                     },
-                    required: ["text"],
+                    required: ["entry"],
                 },
             },
         },
         handler: async (a) => {
-            const text = (a.text || "").trim();
-            if (!text)
-                return "text is required";
-            const result = await (0, memory_1.saveMemoryFact)({
-                text,
-                source: "tool:memory_save",
+            const entry = (a.entry || "").trim();
+            if (!entry)
+                return "entry is required";
+            const result = await (0, diary_1.saveDiaryEntry)({
+                text: entry,
+                source: "tool:diary_write",
                 about: typeof a.about === "string" ? a.about : undefined,
             });
-            return `saved memory fact (added=${result.added}, skipped=${result.skipped})`;
+            return `saved diary entry (added=${result.added}, skipped=${result.skipped})`;
         },
+        summaryKeys: ["entry", "about"],
     },
     {
         tool: {
@@ -374,151 +812,7 @@ exports.baseToolDefinitions = [
                 return `friend not found: ${friendId}`;
             return JSON.stringify(friend, null, 2);
         },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board",
-                description: "show the task board grouped by status",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => {
-            const board = (0, tasks_1.getTaskModule)().getBoard();
-            return board.full || board.compact || "no tasks found";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_create",
-                description: "create a new task in the bundle task system",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        title: { type: "string" },
-                        type: { type: "string", enum: ["one-shot", "ongoing", "habit"] },
-                        category: { type: "string" },
-                        body: { type: "string" },
-                    },
-                    required: ["title", "type", "category", "body"],
-                },
-            },
-        },
-        handler: (a) => {
-            try {
-                const created = (0, tasks_1.getTaskModule)().createTask({
-                    title: a.title,
-                    type: a.type,
-                    category: a.category,
-                    body: a.body,
-                });
-                return `created: ${created}`;
-            }
-            catch (error) {
-                return `error: ${error instanceof Error ? error.message : String(error)}`;
-            }
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_update_status",
-                description: "update a task status using validated transitions",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        status: { type: "string" },
-                    },
-                    required: ["name", "status"],
-                },
-            },
-        },
-        handler: (a) => {
-            const result = (0, tasks_1.getTaskModule)().updateStatus(a.name, a.status);
-            if (!result.ok) {
-                return `error: ${result.reason ?? "status update failed"}`;
-            }
-            const archivedSuffix = result.archived && result.archived.length > 0
-                ? ` | archived: ${result.archived.join(", ")}`
-                : "";
-            return `updated: ${a.name} -> ${result.to}${archivedSuffix}`;
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_status",
-                description: "show board detail for a specific status",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        status: { type: "string" },
-                    },
-                    required: ["status"],
-                },
-            },
-        },
-        handler: (a) => {
-            const lines = (0, tasks_1.getTaskModule)().boardStatus(a.status);
-            return lines.length > 0 ? lines.join("\n") : "no tasks in that status";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_action",
-                description: "show tasks or validation issues that require action",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        scope: { type: "string" },
-                    },
-                },
-            },
-        },
-        handler: (a) => {
-            const lines = (0, tasks_1.getTaskModule)().boardAction();
-            if (!a.scope) {
-                return lines.length > 0 ? lines.join("\n") : "no action required";
-            }
-            const filtered = lines.filter((line) => line.includes(a.scope));
-            return filtered.length > 0 ? filtered.join("\n") : "no matching action items";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_deps",
-                description: "show unresolved task dependencies",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => {
-            const lines = (0, tasks_1.getTaskModule)().boardDeps();
-            return lines.length > 0 ? lines.join("\n") : "no unresolved dependencies";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_sessions",
-                description: "show tasks with active coding or sub-agent sessions",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => {
-            const lines = (0, tasks_1.getTaskModule)().boardSessions();
-            return lines.length > 0 ? lines.join("\n") : "no active sessions";
-        },
+        summaryKeys: ["friendId"],
     },
     {
         tool: {
@@ -602,55 +896,214 @@ exports.baseToolDefinitions = [
                 return `error saving note: ${err instanceof Error ? err.message : String(err)}`;
             }
         },
+        summaryKeys: ["type", "key", "content"],
     },
     // -- cross-session awareness --
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "bridge_manage",
+                description: "create and manage shared live-work bridges across already-active sessions.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: {
+                            type: "string",
+                            enum: ["begin", "attach", "status", "promote_task", "complete", "cancel"],
+                        },
+                        bridgeId: { type: "string", description: "bridge id for all actions except begin" },
+                        objective: { type: "string", description: "objective for begin" },
+                        summary: { type: "string", description: "optional concise shared-work summary" },
+                        friendId: { type: "string", description: "target friend id for attach" },
+                        channel: { type: "string", description: "target channel for attach" },
+                        key: { type: "string", description: "target session key for attach (defaults to 'session')" },
+                        title: { type: "string", description: "task title override for promote_task" },
+                        category: { type: "string", description: "task category override for promote_task" },
+                        body: { type: "string", description: "task body override for promote_task" },
+                    },
+                    required: ["action"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const manager = (0, manager_1.createBridgeManager)();
+            const action = (args.action || "").trim();
+            if (action === "begin") {
+                if (!ctx?.currentSession) {
+                    return "bridge_manage begin requires an active session context.";
+                }
+                const objective = (args.objective || "").trim();
+                if (!objective)
+                    return "objective is required for bridge begin.";
+                return (0, manager_1.formatBridgeStatus)(manager.beginBridge({
+                    objective,
+                    summary: (args.summary || objective).trim(),
+                    session: ctx.currentSession,
+                }));
+            }
+            const bridgeId = (args.bridgeId || "").trim();
+            if (!bridgeId) {
+                return "bridgeId is required for this bridge action.";
+            }
+            if (action === "attach") {
+                const friendId = (args.friendId || "").trim();
+                const channel = (args.channel || "").trim();
+                const key = (args.key || "session").trim();
+                if (!friendId || !channel) {
+                    return "friendId and channel are required for bridge attach.";
+                }
+                const sessionPath = (0, config_1.resolveSessionPath)(friendId, channel, key);
+                const recall = await recallSessionSafely({
+                    sessionPath,
+                    friendId,
+                    channel,
+                    key,
+                    messageCount: 20,
+                    trustLevel: ctx?.context?.friend?.trustLevel,
+                    summarize: ctx?.summarize,
+                });
+                if (recall.kind === "missing") {
+                    return NO_SESSION_FOUND_MESSAGE;
+                }
+                return (0, manager_1.formatBridgeStatus)(manager.attachSession(bridgeId, {
+                    friendId,
+                    channel,
+                    key,
+                    sessionPath,
+                    snapshot: recall.kind === "ok" ? recall.snapshot : EMPTY_SESSION_MESSAGE,
+                }));
+            }
+            if (action === "status") {
+                const bridge = manager.getBridge(bridgeId);
+                if (!bridge)
+                    return `bridge not found: ${bridgeId}`;
+                return (0, manager_1.formatBridgeStatus)(bridge);
+            }
+            if (action === "promote_task") {
+                return (0, manager_1.formatBridgeStatus)(manager.promoteBridgeToTask(bridgeId, {
+                    title: args.title,
+                    category: args.category,
+                    body: args.body,
+                }));
+            }
+            if (action === "complete") {
+                return (0, manager_1.formatBridgeStatus)(manager.completeBridge(bridgeId));
+            }
+            if (action === "cancel") {
+                return (0, manager_1.formatBridgeStatus)(manager.cancelBridge(bridgeId));
+            }
+            return `unknown bridge action: ${action}`;
+        },
+        summaryKeys: ["action", "bridgeId", "objective", "friendId", "channel", "key"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_active_work",
+                description: "read the current live world-state across visible sessions, coding lanes, inner work, and return obligations. use this instead of piecing status together from separate session and coding tools.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async (_args, ctx) => {
+            const frame = await buildToolActiveWorkFrame(ctx);
+            return `this is my current top-level live world-state.\nanswer whole-self status questions from this before drilling into individual sessions.\n\n${(0, active_work_1.formatActiveWorkFrame)(frame)}`;
+        },
+    },
     {
         tool: {
             type: "function",
             function: {
                 name: "query_session",
-                description: "read the last messages from another session. use this to check on a conversation with a friend or review your own inner dialog.",
+                description: "inspect another session. use transcript for recent context, status for self/inner progress, or search to find older history by query.",
                 parameters: {
                     type: "object",
                     properties: {
                         friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        channel: { type: "string", description: "the channel: cli, teams, bluebubbles, inner, or mcp" },
                         key: { type: "string", description: "session key (defaults to 'session')" },
                         messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
+                        mode: {
+                            type: "string",
+                            enum: ["transcript", "status", "search"],
+                            description: "transcript (default), lightweight status for self/inner checks, or search for older history",
+                        },
+                        query: { type: "string", description: "required when mode=search; search term for older session history" },
                     },
                     required: ["friendId", "channel"],
                 },
             },
         },
         handler: async (args, ctx) => {
-            try {
-                const friendId = args.friendId;
-                const channel = args.channel;
-                const key = args.key || "session";
-                const count = parseInt(args.messageCount || "20", 10);
-                const sessFile = path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions", friendId, channel, `${key}.json`);
-                const raw = fs.readFileSync(sessFile, "utf-8");
-                const data = JSON.parse(raw);
-                const messages = (data.messages || [])
-                    .filter((m) => m.role !== "system");
-                const tail = messages.slice(-count);
-                if (tail.length === 0)
-                    return "session exists but has no non-system messages.";
-                const transcript = tail.map((m) => `[${m.role}] ${m.content}`).join("\n");
-                // LLM summarization when summarize function is available
-                if (ctx?.summarize) {
-                    const trustLevel = ctx.context?.friend?.trustLevel ?? "family";
-                    const isSelfQuery = friendId === "self";
-                    const instruction = isSelfQuery
-                        ? "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning."
-                        : `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
-                    return await ctx.summarize(transcript, instruction);
+            let friendId = args.friendId;
+            const channel = args.channel;
+            const key = args.key || "session";
+            const count = parseInt(args.messageCount || "20", 10);
+            const mode = args.mode || "transcript";
+            // Resolve friend name → UUID if not already a UUID or "self"
+            if (friendId && friendId !== "self" && !/^[0-9a-f]{8}-[0-9a-f]{4}-/.test(friendId) && ctx?.friendStore?.listAll) {
+                const allFriends = await ctx.friendStore.listAll();
+                const match = allFriends.find(f => f.name.toLowerCase() === friendId.toLowerCase());
+                if (match) {
+                    friendId = match.id;
                 }
-                return transcript;
             }
-            catch {
-                return "no session found for that friend/channel/key combination.";
+            if (mode === "status") {
+                if (friendId !== "self" || channel !== "inner") {
+                    return "status mode is only available for self/inner dialog.";
+                }
+                const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)((0, identity_1.getAgentRoot)());
+                const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+                return renderInnerProgressStatus((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
+            }
+            if (mode === "search") {
+                const query = (args.query || "").trim();
+                if (!query) {
+                    return "search mode requires a non-empty query.";
+                }
+                const search = await searchSessionSafely({
+                    sessionPath: (0, config_1.resolveSessionPath)(friendId, channel, key),
+                    friendId,
+                    channel,
+                    key,
+                    query,
+                });
+                if (search.kind === "missing") {
+                    return NO_SESSION_FOUND_MESSAGE;
+                }
+                if (search.kind === "empty") {
+                    return EMPTY_SESSION_MESSAGE;
+                }
+                if (search.kind === "no_match") {
+                    return `no matches for "${search.query}" in that session.\n\n${search.snapshot}`;
+                }
+                return [
+                    `history search: "${search.query}"`,
+                    search.snapshot,
+                    ...search.matches.map((match, index) => `match ${index + 1}\n${match}`),
+                ].join("\n\n");
+            }
+            const sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key);
+            const recall = await recallSessionSafely({
+                sessionPath: sessFile,
+                friendId,
+                channel,
+                key,
+                messageCount: count,
+                trustLevel: ctx?.context?.friend?.trustLevel,
+                summarize: ctx?.summarize,
+            });
+            if (recall.kind === "missing") {
+                return NO_SESSION_FOUND_MESSAGE;
             }
+            if (recall.kind === "empty") {
+                return EMPTY_SESSION_MESSAGE;
+            }
+            return recall.summary;
         },
     },
     {
@@ -658,12 +1111,12 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "send_message",
-                description: "send a message to a friend's session. the message is queued as a pending file and delivered when the target session drains its queue.",
+                description: "send a message to a friend's session. when the request is explicitly authorized from a trusted live chat, the harness will try to deliver immediately; otherwise it reports truthful queued/block/failure state.",
                 parameters: {
                     type: "object",
                     properties: {
                         friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        channel: { type: "string", description: "the channel: cli, teams, bluebubbles, inner, or mcp" },
                         key: { type: "string", description: "session key (defaults to 'session')" },
                         content: { type: "string", description: "the message content to send" },
                     },
@@ -671,44 +1124,310 @@ exports.baseToolDefinitions = [
                 },
             },
         },
-        handler: async (args) => {
+        handler: async (args, ctx) => {
             const friendId = args.friendId;
             const channel = args.channel;
             const key = args.key || "session";
             const content = args.content;
             const now = Date.now();
-            const pendingDir = path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "pending", friendId, channel, key);
-            fs.mkdirSync(pendingDir, { recursive: true });
-            const fileName = `${now}-${Math.random().toString(36).slice(2, 10)}.json`;
-            const filePath = path.join(pendingDir, fileName);
+            const agentName = (0, identity_1.getAgentName)();
+            // Self-routing: messages to "self" always go to inner dialog pending dir,
+            // regardless of the channel or key the agent specified.
+            const isSelf = friendId === "self";
+            const pendingDir = isSelf
+                ? (0, pending_1.getInnerDialogPendingDir)(agentName)
+                : (0, pending_1.getPendingDir)(agentName, friendId, channel, key);
+            const delegatingBridgeId = findDelegatingBridgeId(ctx);
+            const delegatedFrom = isSelf
+                && ctx?.currentSession
+                && !(ctx.currentSession.friendId === "self" && ctx.currentSession.channel === "inner")
+                ? {
+                    friendId: ctx.currentSession.friendId,
+                    channel: ctx.currentSession.channel,
+                    key: ctx.currentSession.key,
+                    ...(delegatingBridgeId ? { bridgeId: delegatingBridgeId } : {}),
+                }
+                : undefined;
+            const obligationId = delegatedFrom ? (0, obligations_1.generateObligationId)(now) : undefined;
             const envelope = {
-                from: (0, identity_1.getAgentName)(),
+                from: agentName,
                 friendId,
                 channel,
                 key,
                 content,
                 timestamp: now,
+                ...(delegatedFrom ? { delegatedFrom, obligationStatus: "pending" } : {}),
+                ...(obligationId ? { obligationId } : {}),
             };
-            fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
-            const preview = content.length > 80 ? content.slice(0, 80) + "…" : content;
-            return `message queued for delivery to ${friendId} on ${channel}/${key}. preview: "${preview}". it will be delivered when their session is next active.`;
+            if (isSelf) {
+                writePendingEnvelope(pendingDir, envelope);
+                if (delegatedFrom) {
+                    try {
+                        (0, obligations_2.createObligation)((0, identity_1.getAgentRoot)(), {
+                            origin: {
+                                friendId: delegatedFrom.friendId,
+                                channel: delegatedFrom.channel,
+                                key: delegatedFrom.key,
+                            },
+                            ...(delegatedFrom.bridgeId ? { bridgeId: delegatedFrom.bridgeId } : {}),
+                            content,
+                        });
+                    }
+                    catch {
+                        /* v8 ignore next -- defensive: obligation store write failure should not break send_message @preserve */
+                    }
+                    /* v8 ignore next -- obligationId always set when delegatedFrom is set (see generateObligationId above) @preserve */
+                    if (obligationId) {
+                        (0, obligations_1.createObligation)(agentName, {
+                            id: obligationId,
+                            origin: delegatedFrom,
+                            status: "queued",
+                            delegatedContent: content.length > 120 ? `${content.slice(0, 117)}...` : content,
+                            createdAt: now,
+                        });
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        event: "repertoire.obligation_created",
+                        component: "repertoire",
+                        message: "obligation created for inner dialog delegation",
+                        meta: {
+                            friendId: delegatedFrom.friendId,
+                            channel: delegatedFrom.channel,
+                            key: delegatedFrom.key,
+                        },
+                    });
+                }
+                let wakeResponse = null;
+                try {
+                    wakeResponse = await (0, socket_client_1.requestInnerWake)(agentName);
+                }
+                catch {
+                    wakeResponse = null;
+                }
+                if (!wakeResponse?.ok) {
+                    const { runInnerDialogTurn } = await Promise.resolve().then(() => __importStar(require("../senses/inner-dialog")));
+                    if (ctx?.context?.channel.channel === "inner") {
+                        queueMicrotask(() => {
+                            void runInnerDialogTurn({ reason: "instinct" });
+                        });
+                        return renderInnerProgressStatus({
+                            queue: "queued to inner/dialog",
+                            wake: "inline scheduled",
+                            processing: "pending",
+                            surfaced: "nothing yet",
+                        });
+                    }
+                    else {
+                        const turnResult = await runInnerDialogTurn({ reason: "instinct" });
+                        const surfacedPreview = normalizeProgressOutcome((0, thoughts_1.formatSurfacedValue)((0, thoughts_1.extractThoughtResponseFromMessages)(turnResult?.messages ?? [])));
+                        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                            scope: "inner-delegation",
+                            phase: "completed",
+                            objective: "queued to inner/dialog",
+                            outcomeText: `wake: inline fallback\n${surfacedPreview}`,
+                        }));
+                    }
+                }
+                return renderInnerProgressStatus({
+                    queue: "queued to inner/dialog",
+                    wake: "daemon requested",
+                    processing: "pending",
+                    surfaced: "nothing yet",
+                });
+            }
+            const deliveryResult = await (0, cross_chat_delivery_1.deliverCrossChatMessage)({
+                friendId,
+                channel,
+                key,
+                content,
+                intent: ctx?.currentSession && ctx.currentSession.friendId !== "self"
+                    ? "explicit_cross_chat"
+                    : "generic_outreach",
+                ...(ctx?.currentSession && ctx.currentSession.friendId !== "self"
+                    ? {
+                        authorizingSession: {
+                            friendId: ctx.currentSession.friendId,
+                            channel: ctx.currentSession.channel,
+                            key: ctx.currentSession.key,
+                            trustLevel: ctx?.context?.friend?.trustLevel,
+                        },
+                    }
+                    : {}),
+            }, {
+                agentName,
+                queuePending: (message) => writePendingEnvelope(pendingDir, message),
+                deliverers: {
+                    bluebubbles: async (request) => {
+                        const { sendProactiveBlueBubblesMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/bluebubbles")));
+                        const result = await sendProactiveBlueBubblesMessageToSession({
+                            friendId: request.friendId,
+                            sessionKey: request.key,
+                            text: request.content,
+                            intent: request.intent,
+                            authorizingSession: request.authorizingSession,
+                        });
+                        if (result.delivered) {
+                            return {
+                                status: "delivered_now",
+                                detail: "sent to the active bluebubbles chat now",
+                            };
+                        }
+                        if (result.reason === "missing_target") {
+                            return {
+                                status: "blocked",
+                                detail: "bluebubbles could not resolve a routable target for that session",
+                            };
+                        }
+                        if (result.reason === "send_error") {
+                            return {
+                                status: "failed",
+                                detail: "bluebubbles send failed",
+                            };
+                        }
+                        return {
+                            status: "unavailable",
+                            detail: "live delivery unavailable right now; queued for the next active turn",
+                        };
+                    },
+                    teams: async (request) => {
+                        if (!ctx?.botApi) {
+                            return {
+                                status: "unavailable",
+                                detail: "live delivery unavailable right now; queued for the next active turn",
+                            };
+                        }
+                        const { sendProactiveTeamsMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/teams")));
+                        const result = await sendProactiveTeamsMessageToSession({
+                            friendId: request.friendId,
+                            sessionKey: request.key,
+                            text: request.content,
+                            intent: request.intent,
+                            authorizingSession: request.authorizingSession,
+                        }, {
+                            botApi: ctx.botApi,
+                        });
+                        if (result.delivered) {
+                            return {
+                                status: "delivered_now",
+                                detail: "sent to the active teams chat now",
+                            };
+                        }
+                        if (result.reason === "missing_target") {
+                            return {
+                                status: "blocked",
+                                detail: "teams could not resolve a routable target for that session",
+                            };
+                        }
+                        if (result.reason === "send_error") {
+                            return {
+                                status: "failed",
+                                detail: "teams send failed",
+                            };
+                        }
+                        return {
+                            status: "unavailable",
+                            detail: "live delivery unavailable right now; queued for the next active turn",
+                        };
+                    },
+                },
+            });
+            return renderCrossChatDeliveryStatus(`${friendId} on ${channel}/${key}`, deliveryResult);
         },
     },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "set_reasoning_effort",
+                description: "adjust your own reasoning depth for subsequent turns. use higher effort for complex analysis, lower for simple tasks.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        level: { type: "string", description: "the reasoning effort level to set" },
+                    },
+                    required: ["level"],
+                },
+            },
+        },
+        handler: (args, ctx) => {
+            if (!ctx?.supportedReasoningEfforts || !ctx.setReasoningEffort) {
+                return "reasoning effort adjustment is not available in this context.";
+            }
+            const level = (args.level || "").trim();
+            if (!ctx.supportedReasoningEfforts.includes(level)) {
+                return `invalid reasoning effort level "${level}". accepted levels: ${ctx.supportedReasoningEfforts.join(", ")}`;
+            }
+            ctx.setReasoningEffort(level);
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.reasoning_effort_changed",
+                message: `reasoning effort set to ${level}`,
+                meta: { level },
+            });
+            return `reasoning effort set to "${level}".`;
+        },
+        requiredCapability: "reasoning-effort",
+        summaryKeys: ["level"],
+    },
     ...tools_1.codingToolDefinitions,
 ];
-// Backward-compat: extract just the OpenAI tool schemas
 exports.tools = exports.baseToolDefinitions.map((d) => d.tool);
-// Backward-compat: extract just the handlers by name
-exports.baseToolHandlers = Object.fromEntries(exports.baseToolDefinitions.map((d) => [d.tool.function.name, d.handler]));
-exports.finalAnswerTool = {
+exports.ponderTool = {
+    type: "function",
+    function: {
+        name: "ponder",
+        description: "i need to sit with this. from a conversation, takes the thread inward with a thought and a parting word. from inner dialog, keeps the wheel turning for another pass. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                thought: {
+                    type: "string",
+                    description: "the question or thread that needs more thought — brief framing, not analysis. required from a conversation, ignored from inner dialog.",
+                },
+                say: {
+                    type: "string",
+                    description: "what you say before going quiet — speak to what caught your attention, not just that something did. required from a conversation, ignored from inner dialog.",
+                },
+            },
+        },
+    },
+};
+exports.observeTool = {
     type: "function",
     function: {
-        name: "final_answer",
+        name: "observe",
+        description: "absorb what happened without responding — the moment doesn't call for words. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                reason: { type: "string", description: "brief reason for staying silent (for logging)" },
+            },
+        },
+    },
+};
+exports.settleTool = {
+    type: "function",
+    function: {
+        name: "settle",
         description: "respond to the user with your message. call this tool when you are ready to deliver your response.",
         parameters: {
             type: "object",
-            properties: { answer: { type: "string" } },
+            properties: {
+                answer: { type: "string" },
+                intent: { type: "string", enum: ["complete", "blocked", "direct_reply"] },
+            },
             required: ["answer"],
         },
     },
 };
+exports.restTool = {
+    type: "function",
+    function: {
+        name: "rest",
+        description: "put this down for now — the wheel stops until the next heartbeat. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+    },
+};