@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.100

package/dist/repertoire/tools-base.js

@@ -33,18 +33,137 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.finalAnswerTool = exports.baseToolHandlers = exports.tools = exports.baseToolDefinitions = void 0;
+exports.finalAnswerTool = exports.noResponseTool = exports.goInwardTool = exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = void 0;
+exports.renderInnerProgressStatus = renderInnerProgressStatus;
 const fs = __importStar(require("fs"));
+const fg = __importStar(require("fast-glob"));
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const skills_1 = require("./skills");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
-const tasks_1 = require("./tasks");
+const safe_workspace_1 = require("../heart/safe-workspace");
+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 tools_1 = require("./coding/tools");
 const memory_1 = require("../mind/memory");
-const postIt = (msg) => `post-it from past you:\n${msg}`;
+const pending_1 = require("../mind/pending");
+const progress_story_1 = require("../heart/progress-story");
+const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
+const obligations_1 = require("../heart/obligations");
+// Tracks which file paths have been read via read_file in this session.
+// edit_file requires a file to be read first (must-read-first guard).
+exports.editFileReadTracker = new Set();
+function buildContextDiff(lines, changeStart, changeEnd, contextSize = 3) {
+    const start = Math.max(0, changeStart - contextSize);
+    const end = Math.min(lines.length, changeEnd + contextSize);
+    const result = [];
+    for (let i = start; i < end; i++) {
+        const lineNum = i + 1;
+        const prefix = (i >= changeStart && i < changeEnd) ? ">" : " ";
+        result.push(`${prefix} ${lineNum} | ${lines[i]}`);
+    }
+    return result.join("\n");
+}
+function resolveLocalToolPath(targetPath) {
+    return (0, safe_workspace_1.resolveSafeRepoPath)({ requestedPath: targetPath }).resolvedPath;
+}
+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" };
+    }
+}
+function normalizeProgressOutcome(text) {
+    const trimmed = text.trim();
+    /* v8 ignore next -- defensive: normalizeProgressOutcome null branch @preserve */
+    if (!trimmed || trimmed === "nothing yet" || trimmed === "nothing recent") {
+        return null;
+    }
+    if (trimmed.startsWith("\"") && trimmed.endsWith("\"") && trimmed.length >= 2) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function writePendingEnvelope(queueDir, message) {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(queueDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(message, null, 2));
+}
+function renderCrossChatDeliveryStatus(target, result) {
+    const phase = result.status === "delivered_now"
+        ? "completed"
+        : result.status === "queued_for_later"
+            ? "queued"
+            : result.status === "blocked"
+                ? "blocked"
+                : "errored";
+    const lead = result.status === "delivered_now"
+        ? "delivered now"
+        : result.status === "queued_for_later"
+            ? "queued for later"
+            : result.status === "blocked"
+                ? "blocked"
+                : "failed";
+    return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+        scope: "shared-work",
+        phase,
+        objective: `message to ${target}`,
+        outcomeText: `${lead}\n${result.detail}`,
+    }));
+}
+function 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: {
@@ -54,12 +173,28 @@ exports.baseToolDefinitions = [
                 description: "read file contents",
                 parameters: {
                     type: "object",
-                    properties: { path: { type: "string" } },
+                    properties: {
+                        path: { type: "string" },
+                        offset: { type: "number", description: "1-based line number to start reading from" },
+                        limit: { type: "number", description: "maximum number of lines to return" },
+                    },
                     required: ["path"],
                 },
             },
         },
-        handler: (a) => fs.readFileSync(a.path, "utf-8"),
+        handler: (a) => {
+            const resolvedPath = resolveLocalToolPath(a.path);
+            const content = fs.readFileSync(resolvedPath, "utf-8");
+            exports.editFileReadTracker.add(resolvedPath);
+            const offset = a.offset ? parseInt(a.offset, 10) : undefined;
+            const limit = a.limit ? parseInt(a.limit, 10) : undefined;
+            if (offset === undefined && limit === undefined)
+                return content;
+            const lines = content.split("\n");
+            const start = offset ? offset - 1 : 0;
+            const end = limit !== undefined ? start + limit : lines.length;
+            return lines.slice(start, end).join("\n");
+        },
     },
     {
         tool: {
@@ -74,102 +209,244 @@ exports.baseToolDefinitions = [
                 },
             },
         },
-        handler: (a) => (fs.writeFileSync(a.path, a.content, "utf-8"), "ok"),
+        handler: (a) => {
+            const resolvedPath = resolveLocalToolPath(a.path);
+            fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+            fs.writeFileSync(resolvedPath, a.content, "utf-8");
+            return "ok";
+        },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "shell",
-                description: "run shell command",
+                name: "edit_file",
+                description: "surgically edit a file by replacing an exact string. the file must have been read via read_file first. old_string must match exactly one location in the file.",
                 parameters: {
                     type: "object",
-                    properties: { command: { type: "string" } },
-                    required: ["command"],
+                    properties: {
+                        path: { type: "string" },
+                        old_string: { type: "string" },
+                        new_string: { type: "string" },
+                    },
+                    required: ["path", "old_string", "new_string"],
                 },
             },
         },
-        handler: (a) => (0, child_process_1.execSync)(a.command, { encoding: "utf-8", timeout: 30000 }),
+        handler: (a) => {
+            const resolvedPath = resolveLocalToolPath(a.path);
+            if (!exports.editFileReadTracker.has(resolvedPath)) {
+                return `error: you must read the file with read_file before editing it. call read_file on ${a.path} first.`;
+            }
+            let content;
+            try {
+                content = fs.readFileSync(resolvedPath, "utf-8");
+            }
+            catch (e) {
+                return `error: could not read file: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+            }
+            // Count occurrences
+            const occurrences = [];
+            let searchFrom = 0;
+            while (true) {
+                const idx = content.indexOf(a.old_string, searchFrom);
+                if (idx === -1)
+                    break;
+                occurrences.push(idx);
+                searchFrom = idx + 1;
+            }
+            if (occurrences.length === 0) {
+                return `error: old_string not found in ${a.path}`;
+            }
+            if (occurrences.length > 1) {
+                return `error: old_string is ambiguous -- found ${occurrences.length} matches in ${a.path}. provide more context to make the match unique.`;
+            }
+            // Single unique match -- replace
+            const idx = occurrences[0];
+            const updated = content.slice(0, idx) + a.new_string + content.slice(idx + a.old_string.length);
+            fs.writeFileSync(resolvedPath, updated, "utf-8");
+            // Build contextual diff
+            const lines = updated.split("\n");
+            const prefixLines = content.slice(0, idx).split("\n");
+            const changeStartLine = prefixLines.length - 1;
+            const newStringLines = a.new_string.split("\n");
+            const changeEndLine = changeStartLine + newStringLines.length;
+            return buildContextDiff(lines, changeStartLine, changeEndLine);
+        },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "list_directory",
-                description: "list directory contents",
+                name: "glob",
+                description: "find files matching a glob pattern. returns matching paths sorted alphabetically, one per line.",
                 parameters: {
                     type: "object",
-                    properties: { path: { type: "string" } },
-                    required: ["path"],
+                    properties: {
+                        pattern: { type: "string", description: "glob pattern (e.g. **/*.ts)" },
+                        cwd: { type: "string", description: "directory to search from (defaults to process.cwd())" },
+                    },
+                    required: ["pattern"],
                 },
             },
         },
-        handler: (a) => fs
-            .readdirSync(a.path, { withFileTypes: true })
-            .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
-            .join("\n"),
+        handler: (a) => {
+            const cwd = a.cwd ? resolveLocalToolPath(a.cwd) : process.cwd();
+            const matches = fg.globSync(a.pattern, { cwd, dot: true });
+            return matches.sort().join("\n");
+        },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "git_commit",
-                description: "commit changes to git with explicit paths",
+                name: "grep",
+                description: "search file contents for lines matching a regex pattern. searches recursively when given a directory. returns matching lines with file path and line numbers.",
                 parameters: {
                     type: "object",
                     properties: {
-                        message: { type: "string" },
-                        paths: { type: "array", items: { type: "string" } },
+                        pattern: { type: "string", description: "regex pattern to search for" },
+                        path: { type: "string", description: "file or directory to search" },
+                        context_lines: { type: "number", description: "number of surrounding context lines (default 0)" },
+                        include: { type: "string", description: "glob filter to limit searched files (e.g. *.ts)" },
                     },
-                    required: ["message", "paths"],
+                    required: ["pattern", "path"],
                 },
             },
         },
         handler: (a) => {
-            try {
-                if (!a.paths || !Array.isArray(a.paths) || a.paths.length === 0) {
-                    return postIt("paths are required. specify explicit files to commit.");
+            const targetPath = resolveLocalToolPath(a.path);
+            const regex = new RegExp(a.pattern);
+            const contextLines = parseInt(a.context_lines || "0", 10);
+            const includeGlob = a.include || undefined;
+            function searchFile(filePath) {
+                let content;
+                try {
+                    content = fs.readFileSync(filePath, "utf-8");
+                }
+                catch {
+                    return [];
+                }
+                const lines = content.split("\n");
+                const matchIndices = new Set();
+                for (let i = 0; i < lines.length; i++) {
+                    if (regex.test(lines[i])) {
+                        matchIndices.add(i);
+                    }
                 }
-                for (const p of a.paths) {
-                    if (!fs.existsSync(p)) {
-                        return postIt(`path does not exist: ${p}`);
+                if (matchIndices.size === 0)
+                    return [];
+                const outputIndices = new Set();
+                for (const idx of matchIndices) {
+                    const start = Math.max(0, idx - contextLines);
+                    const end = Math.min(lines.length - 1, idx + contextLines);
+                    for (let i = start; i <= end; i++) {
+                        outputIndices.add(i);
                     }
-                    (0, child_process_1.execSync)(`git add ${p}`, { encoding: "utf-8" });
                 }
-                const diff = (0, child_process_1.execSync)("git diff --cached --stat", { encoding: "utf-8" });
-                if (!diff || diff.trim().length === 0) {
-                    return postIt("nothing was staged. check your changes or paths.");
+                const sortedIndices = [...outputIndices].sort((a, b) => a - b);
+                const results = [];
+                for (const idx of sortedIndices) {
+                    const lineNum = idx + 1;
+                    if (matchIndices.has(idx)) {
+                        results.push(`${filePath}:${lineNum}: ${lines[idx]}`);
+                    }
+                    else {
+                        results.push(`-${filePath}:${lineNum}: ${lines[idx]}`);
+                    }
                 }
-                (0, child_process_1.execSync)(`git commit -m \"${a.message}\"`, { encoding: "utf-8" });
-                return `${diff}\ncommitted`;
+                return results;
             }
-            catch (e) {
-                return `failed: ${e}`;
+            function collectFiles(dirPath) {
+                const files = [];
+                function walk(dir) {
+                    let entries;
+                    try {
+                        entries = fs.readdirSync(dir, { withFileTypes: true });
+                    }
+                    catch {
+                        return;
+                    }
+                    for (const entry of entries) {
+                        const fullPath = path.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            walk(fullPath);
+                        }
+                        else if (entry.isFile()) {
+                            files.push(fullPath);
+                        }
+                    }
+                }
+                walk(dirPath);
+                return files.sort();
+            }
+            function matchesGlob(filePath, glob) {
+                const escaped = glob
+                    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+                    .replace(/\*/g, ".*")
+                    .replace(/\?/g, ".");
+                return new RegExp(`(^|/)${escaped}$`).test(filePath);
+            }
+            const stat = fs.statSync(targetPath, { throwIfNoEntry: false });
+            if (!stat)
+                return "";
+            if (stat.isFile()) {
+                return searchFile(targetPath).join("\n");
             }
+            let files = collectFiles(targetPath);
+            if (includeGlob) {
+                files = files.filter((f) => matchesGlob(f, includeGlob));
+            }
+            const allResults = [];
+            for (const file of files) {
+                allResults.push(...searchFile(file));
+            }
+            return allResults.join("\n");
         },
     },
     {
         tool: {
             type: "function",
             function: {
-                name: "gh_cli",
-                description: "execute a GitHub CLI (gh) command. use carefully.",
+                name: "safe_workspace",
+                description: "acquire or inspect the safe harness repo workspace for local edits. returns the real workspace path, branch, and why it was chosen.",
                 parameters: {
                     type: "object",
-                    properties: {
-                        command: { type: "string" },
-                    },
+                    properties: {},
+                },
+            },
+        },
+        handler: () => {
+            const selection = (0, safe_workspace_1.ensureSafeRepoWorkspace)();
+            return [
+                `workspace: ${selection.workspaceRoot}`,
+                `branch: ${selection.workspaceBranch}`,
+                `runtime: ${selection.runtimeKind}`,
+                `cleanup_after_merge: ${selection.cleanupAfterMerge ? "yes" : "no"}`,
+                `note: ${selection.note}`,
+            ].join("\n");
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell",
+                description: "run shell command",
+                parameters: {
+                    type: "object",
+                    properties: { command: { type: "string" } },
                     required: ["command"],
                 },
             },
         },
         handler: (a) => {
-            try {
-                return (0, child_process_1.execSync)(`gh ${a.command}`, { encoding: "utf-8", timeout: 60000 });
-            }
-            catch (e) {
-                return `error: ${e}`;
-            }
+            const prepared = (0, safe_workspace_1.resolveSafeShellExecution)(a.command);
+            return (0, child_process_1.execSync)(prepared.command, {
+                encoding: "utf-8",
+                timeout: 30000,
+                ...(prepared.cwd ? { cwd: prepared.cwd } : {}),
+            });
         },
     },
     {
@@ -205,20 +482,6 @@ exports.baseToolDefinitions = [
             }
         },
     },
-    {
-        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,
-        }),
-    },
     {
         tool: {
             type: "function",
@@ -234,7 +497,7 @@ exports.baseToolDefinitions = [
         },
         handler: (a) => {
             try {
-                const result = (0, child_process_1.spawnSync)("claude", ["-p", "--dangerously-skip-permissions", "--add-dir", "."], {
+                const result = (0, child_process_1.spawnSync)("claude", ["-p", "--no-session-persistence", "--dangerously-skip-permissions", "--add-dir", "."], {
                     input: a.prompt,
                     encoding: "utf-8",
                     timeout: 60000,
@@ -374,151 +637,6 @@ exports.baseToolDefinitions = [
             return JSON.stringify(friend, null, 2);
         },
     },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board",
-                description: "show the task board grouped by status",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => {
-            const board = (0, tasks_1.getTaskModule)().getBoard();
-            return board.full || board.compact || "no tasks found";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_create",
-                description: "create a new task in the bundle task system",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        title: { type: "string" },
-                        type: { type: "string", enum: ["one-shot", "ongoing", "habit"] },
-                        category: { type: "string" },
-                        body: { type: "string" },
-                    },
-                    required: ["title", "type", "category", "body"],
-                },
-            },
-        },
-        handler: (a) => {
-            try {
-                const created = (0, tasks_1.getTaskModule)().createTask({
-                    title: a.title,
-                    type: a.type,
-                    category: a.category,
-                    body: a.body,
-                });
-                return `created: ${created}`;
-            }
-            catch (error) {
-                return `error: ${error instanceof Error ? error.message : String(error)}`;
-            }
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_update_status",
-                description: "update a task status using validated transitions",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        status: { type: "string" },
-                    },
-                    required: ["name", "status"],
-                },
-            },
-        },
-        handler: (a) => {
-            const result = (0, tasks_1.getTaskModule)().updateStatus(a.name, a.status);
-            if (!result.ok) {
-                return `error: ${result.reason ?? "status update failed"}`;
-            }
-            const archivedSuffix = result.archived && result.archived.length > 0
-                ? ` | archived: ${result.archived.join(", ")}`
-                : "";
-            return `updated: ${a.name} -> ${result.to}${archivedSuffix}`;
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_status",
-                description: "show board detail for a specific status",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        status: { type: "string" },
-                    },
-                    required: ["status"],
-                },
-            },
-        },
-        handler: (a) => {
-            const lines = (0, tasks_1.getTaskModule)().boardStatus(a.status);
-            return lines.length > 0 ? lines.join("\n") : "no tasks in that status";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_action",
-                description: "show tasks or validation issues that require action",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        scope: { type: "string" },
-                    },
-                },
-            },
-        },
-        handler: (a) => {
-            const lines = (0, tasks_1.getTaskModule)().boardAction();
-            if (!a.scope) {
-                return lines.length > 0 ? lines.join("\n") : "no action required";
-            }
-            const filtered = lines.filter((line) => line.includes(a.scope));
-            return filtered.length > 0 ? filtered.join("\n") : "no matching action items";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_deps",
-                description: "show unresolved task dependencies",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => {
-            const lines = (0, tasks_1.getTaskModule)().boardDeps();
-            return lines.length > 0 ? lines.join("\n") : "no unresolved dependencies";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "task_board_sessions",
-                description: "show tasks with active coding or sub-agent sessions",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => {
-            const lines = (0, tasks_1.getTaskModule)().boardSessions();
-            return lines.length > 0 ? lines.join("\n") : "no active sessions";
-        },
-    },
     {
         tool: {
             type: "function",
@@ -602,12 +720,448 @@ exports.baseToolDefinitions = [
             }
         },
     },
+    // -- cross-session awareness --
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "bridge_manage",
+                description: "create and manage shared live-work bridges across already-active sessions.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: {
+                            type: "string",
+                            enum: ["begin", "attach", "status", "promote_task", "complete", "cancel"],
+                        },
+                        bridgeId: { type: "string", description: "bridge id for all actions except begin" },
+                        objective: { type: "string", description: "objective for begin" },
+                        summary: { type: "string", description: "optional concise shared-work summary" },
+                        friendId: { type: "string", description: "target friend id for attach" },
+                        channel: { type: "string", description: "target channel for attach" },
+                        key: { type: "string", description: "target session key for attach (defaults to 'session')" },
+                        title: { type: "string", description: "task title override for promote_task" },
+                        category: { type: "string", description: "task category override for promote_task" },
+                        body: { type: "string", description: "task body override for promote_task" },
+                    },
+                    required: ["action"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const manager = (0, manager_1.createBridgeManager)();
+            const action = (args.action || "").trim();
+            if (action === "begin") {
+                if (!ctx?.currentSession) {
+                    return "bridge_manage begin requires an active session context.";
+                }
+                const objective = (args.objective || "").trim();
+                if (!objective)
+                    return "objective is required for bridge begin.";
+                return (0, manager_1.formatBridgeStatus)(manager.beginBridge({
+                    objective,
+                    summary: (args.summary || objective).trim(),
+                    session: ctx.currentSession,
+                }));
+            }
+            const bridgeId = (args.bridgeId || "").trim();
+            if (!bridgeId) {
+                return "bridgeId is required for this bridge action.";
+            }
+            if (action === "attach") {
+                const friendId = (args.friendId || "").trim();
+                const channel = (args.channel || "").trim();
+                const key = (args.key || "session").trim();
+                if (!friendId || !channel) {
+                    return "friendId and channel are required for bridge attach.";
+                }
+                const sessionPath = (0, config_1.resolveSessionPath)(friendId, channel, key);
+                const recall = await recallSessionSafely({
+                    sessionPath,
+                    friendId,
+                    channel,
+                    key,
+                    messageCount: 20,
+                    trustLevel: ctx?.context?.friend?.trustLevel,
+                    summarize: ctx?.summarize,
+                });
+                if (recall.kind === "missing") {
+                    return NO_SESSION_FOUND_MESSAGE;
+                }
+                return (0, manager_1.formatBridgeStatus)(manager.attachSession(bridgeId, {
+                    friendId,
+                    channel,
+                    key,
+                    sessionPath,
+                    snapshot: recall.kind === "ok" ? recall.snapshot : EMPTY_SESSION_MESSAGE,
+                }));
+            }
+            if (action === "status") {
+                const bridge = manager.getBridge(bridgeId);
+                if (!bridge)
+                    return `bridge not found: ${bridgeId}`;
+                return (0, manager_1.formatBridgeStatus)(bridge);
+            }
+            if (action === "promote_task") {
+                return (0, manager_1.formatBridgeStatus)(manager.promoteBridgeToTask(bridgeId, {
+                    title: args.title,
+                    category: args.category,
+                    body: args.body,
+                }));
+            }
+            if (action === "complete") {
+                return (0, manager_1.formatBridgeStatus)(manager.completeBridge(bridgeId));
+            }
+            if (action === "cancel") {
+                return (0, manager_1.formatBridgeStatus)(manager.cancelBridge(bridgeId));
+            }
+            return `unknown bridge action: ${action}`;
+        },
+    },
+    {
+        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.",
+                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)" },
+                        mode: { type: "string", enum: ["transcript", "status"], description: "transcript (default) or lightweight status for self/inner checks" },
+                    },
+                    required: ["friendId", "channel"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const friendId = args.friendId;
+            const channel = args.channel;
+            const key = args.key || "session";
+            const count = parseInt(args.messageCount || "20", 10);
+            const mode = args.mode || "transcript";
+            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));
+            }
+            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: "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: {
+                        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" },
+                    },
+                    required: ["friendId", "channel", "content"],
+                },
+            },
+        },
+        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 envelope = {
+                from: agentName,
+                friendId,
+                channel,
+                key,
+                content,
+                timestamp: now,
+                ...(delegatedFrom ? { delegatedFrom, obligationStatus: "pending" } : {}),
+            };
+            if (isSelf) {
+                writePendingEnvelope(pendingDir, envelope);
+                if (delegatedFrom) {
+                    try {
+                        (0, obligations_1.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 */
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        event: "repertoire.obligation_created",
+                        component: "repertoire",
+                        message: "obligation created for inner dialog delegation",
+                        meta: {
+                            friendId: delegatedFrom.friendId,
+                            channel: delegatedFrom.channel,
+                            key: delegatedFrom.key,
+                        },
+                    });
+                }
+                let wakeResponse = null;
+                try {
+                    wakeResponse = await (0, socket_client_1.requestInnerWake)(agentName);
+                }
+                catch {
+                    wakeResponse = null;
+                }
+                if (!wakeResponse?.ok) {
+                    const { runInnerDialogTurn } = await Promise.resolve().then(() => __importStar(require("../senses/inner-dialog")));
+                    if (ctx?.context?.channel.channel === "inner") {
+                        queueMicrotask(() => {
+                            void runInnerDialogTurn({ reason: "instinct" });
+                        });
+                        return renderInnerProgressStatus({
+                            queue: "queued to inner/dialog",
+                            wake: "inline scheduled",
+                            processing: "pending",
+                            surfaced: "nothing yet",
+                        });
+                    }
+                    else {
+                        const turnResult = await runInnerDialogTurn({ reason: "instinct" });
+                        const surfacedPreview = normalizeProgressOutcome((0, thoughts_1.formatSurfacedValue)((0, thoughts_1.extractThoughtResponseFromMessages)(turnResult?.messages ?? [])));
+                        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                            scope: "inner-delegation",
+                            phase: "completed",
+                            objective: "queued to inner/dialog",
+                            outcomeText: `wake: inline fallback\n${surfacedPreview}`,
+                        }));
+                    }
+                }
+                return renderInnerProgressStatus({
+                    queue: "queued to inner/dialog",
+                    wake: "daemon requested",
+                    processing: "pending",
+                    surfaced: "nothing yet",
+                });
+            }
+            const deliveryResult = await (0, cross_chat_delivery_1.deliverCrossChatMessage)({
+                friendId,
+                channel,
+                key,
+                content,
+                intent: ctx?.currentSession && ctx.currentSession.friendId !== "self"
+                    ? "explicit_cross_chat"
+                    : "generic_outreach",
+                ...(ctx?.currentSession && ctx.currentSession.friendId !== "self"
+                    ? {
+                        authorizingSession: {
+                            friendId: ctx.currentSession.friendId,
+                            channel: ctx.currentSession.channel,
+                            key: ctx.currentSession.key,
+                            trustLevel: ctx?.context?.friend?.trustLevel,
+                        },
+                    }
+                    : {}),
+            }, {
+                agentName,
+                queuePending: (message) => writePendingEnvelope(pendingDir, message),
+                deliverers: {
+                    bluebubbles: async (request) => {
+                        const { sendProactiveBlueBubblesMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/bluebubbles")));
+                        const result = await sendProactiveBlueBubblesMessageToSession({
+                            friendId: request.friendId,
+                            sessionKey: request.key,
+                            text: request.content,
+                            intent: request.intent,
+                            authorizingSession: request.authorizingSession,
+                        });
+                        if (result.delivered) {
+                            return {
+                                status: "delivered_now",
+                                detail: "sent to the active bluebubbles chat now",
+                            };
+                        }
+                        if (result.reason === "missing_target") {
+                            return {
+                                status: "blocked",
+                                detail: "bluebubbles could not resolve a routable target for that session",
+                            };
+                        }
+                        if (result.reason === "send_error") {
+                            return {
+                                status: "failed",
+                                detail: "bluebubbles send failed",
+                            };
+                        }
+                        return {
+                            status: "unavailable",
+                            detail: "live delivery unavailable right now; queued for the next active turn",
+                        };
+                    },
+                    teams: async (request) => {
+                        if (!ctx?.botApi) {
+                            return {
+                                status: "unavailable",
+                                detail: "live delivery unavailable right now; queued for the next active turn",
+                            };
+                        }
+                        const { sendProactiveTeamsMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/teams")));
+                        const result = await sendProactiveTeamsMessageToSession({
+                            friendId: request.friendId,
+                            sessionKey: request.key,
+                            text: request.content,
+                            intent: request.intent,
+                            authorizingSession: request.authorizingSession,
+                        }, {
+                            botApi: ctx.botApi,
+                        });
+                        if (result.delivered) {
+                            return {
+                                status: "delivered_now",
+                                detail: "sent to the active teams chat now",
+                            };
+                        }
+                        if (result.reason === "missing_target") {
+                            return {
+                                status: "blocked",
+                                detail: "teams could not resolve a routable target for that session",
+                            };
+                        }
+                        if (result.reason === "send_error") {
+                            return {
+                                status: "failed",
+                                detail: "teams send failed",
+                            };
+                        }
+                        return {
+                            status: "unavailable",
+                            detail: "live delivery unavailable right now; queued for the next active turn",
+                        };
+                    },
+                },
+            });
+            return renderCrossChatDeliveryStatus(`${friendId} on ${channel}/${key}`, deliveryResult);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "set_reasoning_effort",
+                description: "adjust your own reasoning depth for subsequent turns. use higher effort for complex analysis, lower for simple tasks.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        level: { type: "string", description: "the reasoning effort level to set" },
+                    },
+                    required: ["level"],
+                },
+            },
+        },
+        handler: (args, ctx) => {
+            if (!ctx?.supportedReasoningEfforts || !ctx.setReasoningEffort) {
+                return "reasoning effort adjustment is not available in this context.";
+            }
+            const level = (args.level || "").trim();
+            if (!ctx.supportedReasoningEfforts.includes(level)) {
+                return `invalid reasoning effort level "${level}". accepted levels: ${ctx.supportedReasoningEfforts.join(", ")}`;
+            }
+            ctx.setReasoningEffort(level);
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.reasoning_effort_changed",
+                message: `reasoning effort set to ${level}`,
+                meta: { level },
+            });
+            return `reasoning effort set to "${level}".`;
+        },
+        requiredCapability: "reasoning-effort",
+    },
     ...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.goInwardTool = {
+    type: "function",
+    function: {
+        name: "go_inward",
+        description: "i need to think about this privately. this takes the current thread inward -- i'll sit with it, work through it, or carry it to where it needs to go. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "what i need to think about -- the question, the thread, the thing that needs private attention",
+                },
+                answer: {
+                    type: "string",
+                    description: "if i want to say something outward before going inward -- an acknowledgment, a 'let me think about that', whatever feels right",
+                },
+                mode: {
+                    type: "string",
+                    enum: ["reflect", "plan", "relay"],
+                    description: "reflect: something to sit with. plan: something to work through. relay: something to carry across.",
+                },
+            },
+            required: ["content"],
+        },
+    },
+};
+exports.noResponseTool = {
+    type: "function",
+    function: {
+        name: "no_response",
+        description: "stay silent in this group chat — the moment doesn't call for a response. 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.finalAnswerTool = {
     type: "function",
     function: {
@@ -615,7 +1169,10 @@ exports.finalAnswerTool = {
         description: "respond to the user with your message. call this tool when you are ready to deliver your response.",
         parameters: {
             type: "object",
-            properties: { answer: { type: "string" } },
+            properties: {
+                answer: { type: "string" },
+                intent: { type: "string", enum: ["complete", "blocked", "direct_reply"] },
+            },
             required: ["answer"],
         },
     },