@ouro.bot/cli 0.1.0-alpha.19 → 0.1.0-alpha.191

package/dist/repertoire/tools-base.js

@@ -33,60 +33,361 @@ 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 shell_sessions_1 = require("./shell-sessions");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
+const file_state_1 = require("../mind/file-state");
+const scrutiny_1 = require("../mind/scrutiny");
 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}`;
-function normalizeOptionalText(value) {
-    if (typeof value !== "string")
+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");
+const episodes_1 = require("../mind/episodes");
+const cares_1 = require("../heart/cares");
+const presence_1 = require("../heart/presence");
+const intentions_1 = require("../heart/intentions");
+// 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;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
+    }
+    if (trimmed.startsWith("\"") && trimmed.endsWith("\"") && trimmed.length >= 2) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
 }
-function buildTaskCreateInput(args) {
+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 {
-        title: args.title,
-        type: args.type,
-        category: args.category,
-        body: args.body,
-        status: normalizeOptionalText(args.status) ?? undefined,
-        validator: normalizeOptionalText(args.validator),
-        requester: normalizeOptionalText(args.requester),
-        cadence: normalizeOptionalText(args.cadence),
-        scheduledAt: normalizeOptionalText(args.scheduledAt),
+        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: {
             type: "function",
             function: {
                 name: "read_file",
-                description: "read file contents",
+                description: "Read file contents. Results include line numbers. Use offset/limit for large files -- don't read the whole thing if you only need a section. Use this tool before editing any file. When reading code, read enough context to understand the surrounding logic, not just the target line.",
                 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;
+            // Record in file state cache for staleness detection
+            try {
+                const mtime = fs.statSync(resolvedPath).mtimeMs;
+                const readContent = (offset === undefined && limit === undefined)
+                    ? content
+                    : content.split("\n").slice(offset ? offset - 1 : 0, limit !== undefined ? (offset ? offset - 1 : 0) + limit : undefined).join("\n");
+                file_state_1.fileStateCache.record(resolvedPath, readContent, mtime, offset, limit);
+            }
+            catch {
+                // stat failed -- skip cache recording
+            }
+            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: {
             type: "function",
             function: {
                 name: "write_file",
-                description: "write content to file",
+                description: "Prefer this tool for creating new files or fully replacing existing ones. You MUST read an existing file with read_file before overwriting it. Prefer edit_file for modifying existing files -- it only sends the diff. Do not create documentation files (*.md, README) by default; only do so when explicitly asked or when documentation is clearly part of the requested change.",
                 parameters: {
                     type: "object",
                     properties: { path: { type: "string" }, content: { type: "string" } },
@@ -95,106 +396,339 @@ exports.baseToolDefinitions = [
             },
         },
         handler: (a) => {
-            fs.mkdirSync(path.dirname(a.path), { recursive: true });
-            fs.writeFileSync(a.path, a.content, "utf-8");
-            return "ok";
+            const resolvedPath = resolveLocalToolPath(a.path);
+            fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+            fs.writeFileSync(resolvedPath, a.content, "utf-8");
+            (0, scrutiny_1.trackModifiedFile)(resolvedPath);
+            const scrutiny = (0, scrutiny_1.getPostImplementationScrutiny)((0, scrutiny_1.getModifiedFileCount)());
+            /* v8 ignore next -- scrutiny appendix branch depends on session-level file count @preserve */
+            return scrutiny ? `ok\n\n${scrutiny}` : "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 -- this tool will reject the call otherwise. old_string must match EXACTLY ONE location in the file -- if it matches zero or multiple, the edit fails. To fix: provide more surrounding context to make the match unique. Preserve exact indentation (tabs/spaces) from the file. Prefer this over write_file for modifications -- it only sends the diff.",
                 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.`;
+            }
+            // Check staleness before editing
+            const stalenessCheck = file_state_1.fileStateCache.isStale(resolvedPath);
+            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");
+            // Update file state cache with new content
+            try {
+                const newMtime = fs.statSync(resolvedPath).mtimeMs;
+                file_state_1.fileStateCache.record(resolvedPath, updated, newMtime);
+            }
+            catch {
+                // stat failed -- skip cache update
+            }
+            // 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;
+            const diffResult = buildContextDiff(lines, changeStartLine, changeEndLine);
+            // Track modified file and compute scrutiny appendix
+            (0, scrutiny_1.trackModifiedFile)(resolvedPath);
+            const scrutiny = (0, scrutiny_1.getPostImplementationScrutiny)((0, scrutiny_1.getModifiedFileCount)());
+            // Append staleness warning if detected (do not block -- TTFA)
+            /* v8 ignore start -- staleness+diff+scrutiny combo not exercised in integration tests @preserve */
+            if (stalenessCheck.stale) {
+                const base = `${diffResult}\n\n⚠️ warning: file changed externally since last read -- re-read recommended`;
+                return scrutiny ? `${base}\n\n${scrutiny}` : base;
+            }
+            /* v8 ignore stop */
+            /* v8 ignore next -- scrutiny appendix branch depends on session-level file count @preserve */
+            return scrutiny ? `${diffResult}\n\n${scrutiny}` : diffResult;
+        },
+        summaryKeys: ["path"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "list_directory",
-                description: "list directory contents",
+                name: "glob",
+                description: "Find files matching a glob pattern, sorted alphabetically. Use this instead of shell commands like `find` or `ls`. For broad exploratory searches that would require multiple rounds of globbing and grepping, consider using claude or coding_spawn.",
                 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 in directories. Use this instead of shell commands like `grep` or `rg`. Returns matching lines with file path and line numbers. Use context_lines for surrounding context. Use include to filter file types (e.g., '*.ts').",
                 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");
+                }
+                catch {
+                    return [];
                 }
-                for (const p of a.paths) {
-                    if (!fs.existsSync(p)) {
-                        return postIt(`path does not exist: ${p}`);
+                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);
                     }
-                    (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.");
+                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 commit -m \"${a.message}\"`, { encoding: "utf-8" });
-                return `${diff}\ncommitted`;
+                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]}`);
+                    }
+                }
+                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 a shell command and return stdout/stderr. Working directory persists between calls. Use dedicated tools instead of shell when available: read_file instead of cat, edit_file instead of sed, glob instead of find, grep instead of grep/rg. Reserve shell for operations that genuinely need the shell: installing packages, running builds/tests, git operations, process management. Be careful with destructive commands -- consider reversibility before running. If a command fails, read the error output before retrying with a different approach.",
                 parameters: {
                     type: "object",
                     properties: {
                         command: { type: "string" },
+                        timeout_ms: {
+                            type: "number",
+                            description: "Timeout in milliseconds. Default: 30000. Max: 600000.",
+                        },
+                        background: {
+                            type: "boolean",
+                            description: "Run in background. Returns immediately with a process ID. Use shell_status/shell_tail to monitor.",
+                        },
                     },
                     required: ["command"],
                 },
             },
         },
         handler: (a) => {
+            // Destructive pattern detection (friction, not a block)
+            const destructivePatterns = (0, shell_sessions_1.detectDestructivePatterns)(a.command);
+            if (destructivePatterns.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    event: "tool.shell.destructive_detected",
+                    component: "tools",
+                    message: `destructive pattern detected: ${destructivePatterns.join(", ")}`,
+                    meta: { command: a.command, patterns: destructivePatterns },
+                });
+            }
+            // Background mode: spawn and return immediately
+            if (a.background === "true") {
+                const session = (0, shell_sessions_1.spawnBackgroundShell)(a.command);
+                return JSON.stringify({ id: session.id, command: session.command, status: session.status });
+            }
+            const MAX_TIMEOUT = 600000;
+            const requestedTimeout = Number(a.timeout_ms) || 0;
+            let configDefault = 30000;
             try {
-                return (0, child_process_1.execSync)(`gh ${a.command}`, { encoding: "utf-8", timeout: 60000 });
+                configDefault = (0, identity_1.loadAgentConfig)().shell?.defaultTimeout ?? 30000;
             }
-            catch (e) {
-                return `error: ${e}`;
+            catch { /* test env: no --agent flag */ }
+            const baseTimeout = requestedTimeout > 0 ? requestedTimeout : configDefault;
+            const timeout = Math.min(baseTimeout, MAX_TIMEOUT);
+            const output = (0, child_process_1.execSync)(a.command, {
+                encoding: "utf-8",
+                timeout,
+            });
+            if (destructivePatterns.length > 0) {
+                return `${output}\n\n--- destructive pattern detected: ${destructivePatterns.join(", ")} ---`;
             }
+            return output;
+        },
+        summaryKeys: ["command"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_status",
+                description: "Check status of background shell processes. Omit id to list all.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            if (!a.id) {
+                return JSON.stringify((0, shell_sessions_1.listShellSessions)());
+            }
+            const session = (0, shell_sessions_1.getShellSession)(a.id);
+            if (!session)
+                return `process not found: ${a.id}`;
+            return JSON.stringify(session);
+        },
+        summaryKeys: ["id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_tail",
+                description: "Show recent output from a background shell process.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                    required: ["id"],
+                },
+            },
+        },
+        handler: (a) => {
+            /* v8 ignore next -- schema requires id, defensive guard @preserve */
+            if (!a.id)
+                return "id is required";
+            const output = (0, shell_sessions_1.tailShellSession)(a.id);
+            if (output === undefined)
+                return `process not found: ${a.id}`;
+            return output || "(no output yet)";
         },
+        summaryKeys: ["id"],
     },
     {
         tool: {
@@ -228,27 +762,14 @@ 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: {
             type: "function",
             function: {
                 name: "claude",
-                description: "use claude code to query this codebase or get an outside perspective. useful for code review, second opinions, and asking questions about your own source.",
+                description: "use claude code to query this codebase or get an outside perspective. Use for code review, second opinions, or questions that benefit from a fresh perspective outside this conversation's context.",
                 parameters: {
                     type: "object",
                     properties: { prompt: { type: "string" } },
@@ -273,6 +794,7 @@ exports.baseToolDefinitions = [
                 return `error: ${e}`;
             }
         },
+        summaryKeys: ["prompt"],
     },
     {
         tool: {
@@ -313,13 +835,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: "Search my diary and journal for facts, thoughts, and working notes matching a query. Uses semantic similarity -- phrasing matters. Try different angles if the first query doesn't find what you're looking for. Check recall before asking the human something you might already know.",
                 parameters: {
                     type: "object",
                     properties: { query: { type: "string" } },
@@ -332,44 +855,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. Use 'about' to tag the entry to a person, topic, or context. Write for my future self: include enough context that the entry makes sense without the surrounding conversation. Prefer durable conclusions over passing noise. Don't duplicate what already belongs in friend notes.",
                 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: {
@@ -397,382 +945,859 @@ exports.baseToolDefinitions = [
                 return `friend not found: ${friendId}`;
             return JSON.stringify(friend, null, 2);
         },
+        summaryKeys: ["friendId"],
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "task_board",
-                description: "show the task board grouped by status",
-                parameters: { type: "object", properties: {} },
+                name: "save_friend_note",
+                description: "save something i learned about my friend. use type 'name' to update their display name, 'tool_preference' for how they like a specific tool to behave (key = tool category like 'ado', 'graph'), or 'note' for general knowledge (key = topic). when updating an existing value, set override to true if i'm replacing/correcting it. omit override (or set false) if i'm unsure and want to check what's already saved.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        type: { type: "string", enum: ["name", "tool_preference", "note"], description: "what kind of information to save" },
+                        key: { type: "string", description: "category key (required for tool_preference and note, e.g. 'ado', 'role')" },
+                        content: { type: "string", description: "the value to save" },
+                        override: { type: "string", enum: ["true", "false"], description: "set to 'true' to overwrite an existing value" },
+                    },
+                    required: ["type", "content"],
+                },
             },
         },
-        handler: () => {
-            const board = (0, tasks_1.getTaskModule)().getBoard();
-            return board.full || board.compact || "no tasks found";
+        handler: async (a, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.save_friend_note",
+                message: "save friend note invoked",
+                meta: { type: a.type },
+            });
+            if (!ctx?.context) {
+                return "i can't save notes -- no friend context available";
+            }
+            if (!ctx.friendStore) {
+                return "i can't save notes -- friend store not available";
+            }
+            const friendId = ctx.context.friend?.id;
+            if (!friendId)
+                return "i can't save notes -- no friend identity available";
+            // Validate parameters
+            if (!a.content)
+                return "i need a content value to save";
+            const validTypes = ["name", "tool_preference", "note"];
+            if (!validTypes.includes(a.type))
+                return `i don't recognize type '${a.type}' -- use name, tool_preference, or note`;
+            if ((a.type === "tool_preference" || a.type === "note") && !a.key)
+                return "i need a key for tool_preference or note type";
+            try {
+                // Read fresh record from disk
+                const record = await ctx.friendStore.get(friendId);
+                if (!record)
+                    return "i can't find the friend record on disk";
+                const isOverride = a.override === "true";
+                if (a.type === "name") {
+                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
+                    await ctx.friendStore.put(friendId, updated);
+                    return `saved: name = ${a.content}`;
+                }
+                if (a.type === "tool_preference") {
+                    const existing = record.toolPreferences[a.key];
+                    if (existing && !isOverride) {
+                        return `i already have a preference for '${a.key}': "${existing}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
+                    }
+                    const updated = { ...record, toolPreferences: { ...record.toolPreferences, [a.key]: a.content }, updatedAt: new Date().toISOString() };
+                    await ctx.friendStore.put(friendId, updated);
+                    return `saved: toolPreference ${a.key} = ${a.content}`;
+                }
+                // type === "note"
+                // Redirect "name" key to name field
+                if (a.key === "name") {
+                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
+                    await ctx.friendStore.put(friendId, updated);
+                    return `updated friend's name to '${a.content}' (stored as name, not a note)`;
+                }
+                const existing = record.notes[a.key];
+                if (existing && !isOverride) {
+                    return `i already have a note for '${a.key}': "${existing.value}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
+                }
+                const updated = { ...record, notes: { ...record.notes, [a.key]: { value: a.content, savedAt: new Date().toISOString() } }, updatedAt: new Date().toISOString() };
+                await ctx.friendStore.put(friendId, updated);
+                return `saved: note ${a.key} = ${a.content}`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: non-Error branch for String(err) @preserve */
+                return `error saving note: ${err instanceof Error ? err.message : String(err)}`;
+            }
         },
+        summaryKeys: ["type", "key", "content"],
     },
+    // -- cross-session awareness --
     {
         tool: {
             type: "function",
             function: {
-                name: "task_create",
-                description: "create a new task in the bundle task system. optionally set `scheduledAt` for a one-time reminder or `cadence` for recurring daemon-scheduled work.",
+                name: "bridge_manage",
+                description: "create and manage shared live-work bridges across already-active sessions.",
                 parameters: {
                     type: "object",
                     properties: {
-                        title: { type: "string" },
-                        type: { type: "string", enum: ["one-shot", "ongoing", "habit"] },
-                        category: { type: "string" },
-                        body: { type: "string" },
-                        status: { type: "string" },
-                        validator: { type: "string" },
-                        requester: { type: "string" },
-                        scheduledAt: { type: "string", description: "ISO timestamp for a one-time scheduled run/reminder" },
-                        cadence: { type: "string", description: "recurrence like 30m, 1h, 1d, or cron" },
+                        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: ["title", "type", "category", "body"],
+                    required: ["action"],
                 },
             },
         },
-        handler: (a) => {
-            try {
-                const created = (0, tasks_1.getTaskModule)().createTask(buildTaskCreateInput(a));
-                return `created: ${created}`;
+        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);
             }
-            catch (error) {
-                return `error: ${error instanceof Error ? error.message : String(error)}`;
+            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: "schedule_reminder",
-                description: "create a scheduled reminder or recurring daemon job. use `scheduledAt` for one-time reminders and `cadence` for recurring reminders. this writes canonical task fields that the daemon reconciles into OS-level jobs.",
+                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: "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: {
-                        title: { type: "string" },
-                        body: { type: "string" },
-                        category: { type: "string" },
-                        scheduledAt: { type: "string", description: "ISO timestamp for a one-time reminder" },
-                        cadence: { type: "string", description: "recurrence like 30m, 1h, 1d, or cron" },
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        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: ["title", "body"],
+                    required: ["friendId", "channel"],
                 },
             },
         },
-        handler: (a) => {
-            const scheduledAt = normalizeOptionalText(a.scheduledAt);
-            const cadence = normalizeOptionalText(a.cadence);
-            if (!scheduledAt && !cadence) {
-                return "error: provide scheduledAt or cadence";
+        handler: async (args, ctx) => {
+            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;
+                }
             }
-            try {
-                const created = (0, tasks_1.getTaskModule)().createTask({
-                    title: a.title,
-                    type: cadence ? "habit" : "one-shot",
-                    category: normalizeOptionalText(a.category) ?? "reminder",
-                    body: a.body,
-                    scheduledAt,
-                    cadence,
+            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,
                 });
-                return `created: ${created}`;
+                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");
             }
-            catch (error) {
-                return `error: ${error instanceof Error ? error.message : String(error)}`;
+            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;
         },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "task_update_status",
-                description: "update a task status using validated transitions",
+                name: "send_message",
+                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: {
-                        name: { type: "string" },
-                        status: { type: "string" },
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        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" },
                     },
-                    required: ["name", "status"],
+                    required: ["friendId", "channel", "content"],
                 },
             },
         },
-        handler: (a) => {
-            const result = (0, tasks_1.getTaskModule)().updateStatus(a.name, a.status);
-            if (!result.ok) {
-                return `error: ${result.reason ?? "status update failed"}`;
+        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 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: agentName,
+                friendId,
+                channel,
+                key,
+                content,
+                timestamp: now,
+                ...(delegatedFrom ? { delegatedFrom, obligationStatus: "pending" } : {}),
+                ...(obligationId ? { obligationId } : {}),
+            };
+            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(", ")}`;
             }
-            const archivedSuffix = result.archived && result.archived.length > 0
-                ? ` | archived: ${result.archived.join(", ")}`
-                : "";
-            return `updated: ${a.name} -> ${result.to}${archivedSuffix}`;
+            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"],
     },
+    // ── Continuity tools ──────────────────────────────────────────────
     {
         tool: {
             type: "function",
             function: {
-                name: "task_board_status",
-                description: "show board detail for a specific status",
+                name: "query_episodes",
+                description: "Query recent episodes from my continuity memory. Returns timestamped records of significant events (obligation shifts, coding milestones, bridge events, care events, turning points).",
                 parameters: {
                     type: "object",
                     properties: {
-                        status: { type: "string" },
+                        limit: { type: "number", description: "Maximum episodes to return (default 20)" },
+                        kind: { type: "string", description: "Filter by episode kind: obligation_shift, coding_milestone, bridge_event, care_event, tempo_shift, turning_point" },
+                        since: { type: "string", description: "ISO timestamp — only return episodes after this time" },
                     },
-                    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";
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const options = {};
+            if (a.limit)
+                options.limit = parseInt(a.limit, 10);
+            if (a.kind)
+                options.kinds = [a.kind];
+            if (a.since)
+                options.since = a.since;
+            const episodes = (0, episodes_1.readRecentEpisodes)(agentRoot, options);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_episodes", message: `queried ${episodes.length} episodes`, meta: { count: episodes.length } });
+            return JSON.stringify(episodes, null, 2);
         },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "task_board_action",
-                description: "show tasks or validation issues that require action",
+                name: "capture_episode",
+                description: "Record a turning point or significant moment. This is my tool for saying 'that was important — keep it.' Nearly frictionless: only summary and whyItMattered required.",
                 parameters: {
                     type: "object",
                     properties: {
-                        scope: { type: "string" },
+                        summary: { type: "string", description: "What happened" },
+                        whyItMattered: { type: "string", description: "Why this was significant" },
+                        kind: { type: "string", description: "Episode kind (default: turning_point)" },
+                        salience: { type: "string", description: "low, medium, high, or critical (default: medium)" },
                     },
+                    required: ["summary", "whyItMattered"],
                 },
             },
         },
         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";
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const episode = (0, episodes_1.emitEpisode)(agentRoot, {
+                kind: a.kind ?? "turning_point",
+                summary: a.summary,
+                whyItMattered: a.whyItMattered,
+                relatedEntities: [],
+                salience: a.salience ?? "medium",
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.capture_episode", message: `captured episode ${episode.id}`, meta: { id: episode.id } });
+            return JSON.stringify(episode, null, 2);
         },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "task_board_deps",
-                description: "show unresolved task dependencies",
+                name: "query_presence",
+                description: "Check who's around — my own availability/lane and known peer agents.",
                 parameters: { type: "object", properties: {} },
             },
         },
         handler: () => {
-            const lines = (0, tasks_1.getTaskModule)().boardDeps();
-            return lines.length > 0 ? lines.join("\n") : "no unresolved dependencies";
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const agentName = (0, identity_1.getAgentName)();
+            const self = (0, presence_1.readPresence)(agentRoot, agentName);
+            const peers = (0, presence_1.readPeerPresence)(agentRoot);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_presence", message: `presence: self + ${peers.length} peers`, meta: { peerCount: peers.length } });
+            return JSON.stringify({ self, peers }, null, 2);
         },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "task_board_sessions",
-                description: "show tasks with active coding or sub-agent sessions",
-                parameters: { type: "object", properties: {} },
+                name: "query_cares",
+                description: "Query things I care about — ongoing concerns, watched situations, projects, people.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        status: { type: "string", description: "Filter by status: 'active', 'watching', 'resolved', 'dormant', or 'all' (default: active cares only)" },
+                    },
+                },
             },
         },
-        handler: () => {
-            const lines = (0, tasks_1.getTaskModule)().boardSessions();
-            return lines.length > 0 ? lines.join("\n") : "no active sessions";
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const cares = a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_cares", message: `queried ${cares.length} cares`, meta: { count: cares.length } });
+            return JSON.stringify(cares, null, 2);
         },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "save_friend_note",
-                description: "save something i learned about my friend. use type 'name' to update their display name, 'tool_preference' for how they like a specific tool to behave (key = tool category like 'ado', 'graph'), or 'note' for general knowledge (key = topic). when updating an existing value, set override to true if i'm replacing/correcting it. omit override (or set false) if i'm unsure and want to check what's already saved.",
+                name: "care_manage",
+                description: "Create, update, or resolve a care. Cares are things I watch over — people, projects, missions, system health.",
                 parameters: {
                     type: "object",
                     properties: {
-                        type: { type: "string", enum: ["name", "tool_preference", "note"], description: "what kind of information to save" },
-                        key: { type: "string", description: "category key (required for tool_preference and note, e.g. 'ado', 'role')" },
-                        content: { type: "string", description: "the value to save" },
-                        override: { type: "string", enum: ["true", "false"], description: "set to 'true' to overwrite an existing value" },
+                        action: { type: "string", enum: ["create", "update", "resolve"], description: "What to do" },
+                        id: { type: "string", description: "Care ID (required for update/resolve)" },
+                        label: { type: "string", description: "Short label for the care" },
+                        why: { type: "string", description: "Why this matters" },
+                        salience: { type: "string", description: "low, medium, high, or critical" },
+                        kind: { type: "string", description: "person, agent, project, mission, or system" },
+                        stewardship: { type: "string", description: "mine, shared, or delegated" },
                     },
-                    required: ["type", "content"],
+                    required: ["action"],
                 },
             },
         },
-        handler: async (a, ctx) => {
-            (0, runtime_1.emitNervesEvent)({
-                component: "repertoire",
-                event: "repertoire.save_friend_note",
-                message: "save friend note invoked",
-                meta: { type: a.type },
-            });
-            if (!ctx?.context) {
-                return "i can't save notes -- no friend context available";
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            let result;
+            if (a.action === "create") {
+                result = (0, cares_1.createCare)(agentRoot, {
+                    label: a.label ?? "untitled",
+                    why: a.why ?? "",
+                    kind: a.kind ?? "project",
+                    status: "active",
+                    salience: a.salience ?? "medium",
+                    steward: a.stewardship ?? "mine",
+                    relatedFriendIds: [],
+                    relatedAgentIds: [],
+                    relatedObligationIds: [],
+                    relatedEpisodeIds: [],
+                    currentRisk: null,
+                    nextCheckAt: null,
+                });
             }
-            if (!ctx.friendStore) {
-                return "i can't save notes -- friend store not available";
+            else if (a.action === "update") {
+                const updates = {};
+                if (a.label)
+                    updates.label = a.label;
+                if (a.why)
+                    updates.why = a.why;
+                if (a.salience)
+                    updates.salience = a.salience;
+                result = (0, cares_1.updateCare)(agentRoot, a.id, updates);
             }
-            const friendId = ctx.context.friend?.id;
-            if (!friendId)
-                return "i can't save notes -- no friend identity available";
-            // Validate parameters
-            if (!a.content)
-                return "i need a content value to save";
-            const validTypes = ["name", "tool_preference", "note"];
-            if (!validTypes.includes(a.type))
-                return `i don't recognize type '${a.type}' -- use name, tool_preference, or note`;
-            if ((a.type === "tool_preference" || a.type === "note") && !a.key)
-                return "i need a key for tool_preference or note type";
-            try {
-                // Read fresh record from disk
-                const record = await ctx.friendStore.get(friendId);
-                if (!record)
-                    return "i can't find the friend record on disk";
-                const isOverride = a.override === "true";
-                if (a.type === "name") {
-                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
-                    await ctx.friendStore.put(friendId, updated);
-                    return `saved: name = ${a.content}`;
-                }
-                if (a.type === "tool_preference") {
-                    const existing = record.toolPreferences[a.key];
-                    if (existing && !isOverride) {
-                        return `i already have a preference for '${a.key}': "${existing}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
-                    }
-                    const updated = { ...record, toolPreferences: { ...record.toolPreferences, [a.key]: a.content }, updatedAt: new Date().toISOString() };
-                    await ctx.friendStore.put(friendId, updated);
-                    return `saved: toolPreference ${a.key} = ${a.content}`;
-                }
-                // type === "note"
-                // Redirect "name" key to name field
-                if (a.key === "name") {
-                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
-                    await ctx.friendStore.put(friendId, updated);
-                    return `updated friend's name to '${a.content}' (stored as name, not a note)`;
-                }
-                const existing = record.notes[a.key];
-                if (existing && !isOverride) {
-                    return `i already have a note for '${a.key}': "${existing.value}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
-                }
-                const updated = { ...record, notes: { ...record.notes, [a.key]: { value: a.content, savedAt: new Date().toISOString() } }, updatedAt: new Date().toISOString() };
-                await ctx.friendStore.put(friendId, updated);
-                return `saved: note ${a.key} = ${a.content}`;
-            }
-            catch (err) {
-                /* v8 ignore next -- defensive: non-Error branch for String(err) @preserve */
-                return `error saving note: ${err instanceof Error ? err.message : String(err)}`;
+            else if (a.action === "resolve") {
+                result = (0, cares_1.resolveCare)(agentRoot, a.id);
             }
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.care_manage", message: `care ${a.action}`, meta: { action: a.action, id: a.id } });
+            return JSON.stringify(result, null, 2);
         },
     },
-    // -- cross-session awareness --
     {
         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.",
+                name: "query_relationships",
+                description: "Query known agent relationships — familiarity, trust, shared missions, interaction history.",
                 parameters: {
                     type: "object",
                     properties: {
-                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
-                        key: { type: "string", description: "session key (defaults to 'session')" },
-                        messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
+                        agentName: { type: "string", description: "Specific agent name to query (omit for all)" },
                     },
-                    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);
-                }
-                return transcript;
-            }
-            catch {
-                return "no session found for that friend/channel/key combination.";
+        handler: async (a, ctx) => {
+            const allFriends = ctx?.friendStore?.listAll ? await ctx.friendStore.listAll() : [];
+            let agents = allFriends.filter((f) => f.kind === "agent");
+            if (a.agentName) {
+                const needle = a.agentName.toLowerCase();
+                agents = agents.filter((f) => f.name?.toLowerCase() === needle);
             }
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_relationships", message: `queried relationships`, meta: { agentName: a.agentName ?? "all" } });
+            return JSON.stringify(agents, null, 2);
         },
     },
     {
         tool: {
             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.",
+                name: "intention_capture",
+                description: "File a lightweight mental note — something I want to do or check later, below the ceremony threshold of tasks or cares. Cheap to create, easy to close.",
                 parameters: {
                     type: "object",
                     properties: {
-                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
-                        key: { type: "string", description: "session key (defaults to 'session')" },
-                        content: { type: "string", description: "the message content to send" },
+                        content: { type: "string", description: "What I want to remember to do" },
+                        salience: { type: "string", description: "low, medium, or high (default: low)" },
+                        nudgeAfter: { type: "string", description: "ISO timestamp — nudge me after this time" },
                     },
-                    required: ["friendId", "channel", "content"],
+                    required: ["content"],
                 },
             },
         },
-        handler: async (args) => {
-            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 envelope = {
-                from: (0, identity_1.getAgentName)(),
-                friendId,
-                channel,
-                key,
-                content,
-                timestamp: now,
-            };
-            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.`;
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const intention = (0, intentions_1.captureIntention)(agentRoot, {
+                content: a.content,
+                salience: a.salience ?? "low",
+                source: "tool",
+                ...(a.nudgeAfter ? { nudgeAfter: a.nudgeAfter } : {}),
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.intention_capture", message: `captured intention ${intention.id}`, meta: { id: intention.id } });
+            return JSON.stringify(intention, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "intention_manage",
+                description: "Resolve or dismiss an intention. Resolve = done. Dismiss = no longer relevant. Both remove it from active list.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["resolve", "dismiss"], description: "What to do" },
+                        id: { type: "string", description: "Intention ID" },
+                    },
+                    required: ["action", "id"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const result = a.action === "resolve"
+                ? (0, intentions_1.resolveIntention)(agentRoot, a.id)
+                : (0, intentions_1.dismissIntention)(agentRoot, a.id);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.intention_manage", message: `intention ${a.action}: ${a.id}`, meta: { action: a.action, id: a.id } });
+            return JSON.stringify(result, null, 2);
         },
     },
     ...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: "final_answer",
-        description: "respond to the user with your message. call this tool when you are ready to deliver your response.",
+        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. Use when a question deserves more thought than this turn allows. Don't ponder trivial questions.",
         parameters: {
             type: "object",
-            properties: { answer: { type: "string" } },
+            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: "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. Only call when you have a substantive response. If you're settling with 'I'll look into that,' you probably should be using a tool instead.",
+        parameters: {
+            type: "object",
+            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: {},
+        },
+    },
+};