@ouro.bot/cli 0.1.0-alpha.60 → 0.1.0-alpha.600

package/dist/repertoire/tools-notes.js

@@ -0,0 +1,421 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notesToolDefinitions = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const skills_1 = require("./skills");
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const diary_1 = require("../mind/diary");
+const provenance_trust_1 = require("../mind/provenance-trust");
+exports.notesToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "list_skills",
+                description: "list all available skills",
+                parameters: { type: "object", properties: {} },
+            },
+        },
+        handler: () => JSON.stringify((0, skills_1.listSkills)()),
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "load_skill",
+                description: "load a skill by name, returns its content",
+                parameters: {
+                    type: "object",
+                    properties: { name: { type: "string" } },
+                    required: ["name"],
+                },
+            },
+        },
+        handler: (a) => {
+            try {
+                return (0, skills_1.loadSkill)(a.name);
+            }
+            catch (e) {
+                return `error: ${e}`;
+            }
+        },
+        summaryKeys: ["name"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "claude",
+                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" } },
+                    required: ["prompt"],
+                },
+            },
+        },
+        handler: (a) => {
+            try {
+                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,
+                });
+                if (result.error)
+                    return `error: ${result.error}`;
+                if (result.status !== 0)
+                    return `claude exited with code ${result.status}: ${result.stderr}`;
+                return result.stdout || "(no output)";
+            }
+            catch (e) {
+                return `error: ${e}`;
+            }
+        },
+        summaryKeys: ["prompt"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "web_search",
+                description: "search the web using perplexity. returns ranked results with titles, urls, and snippets",
+                parameters: {
+                    type: "object",
+                    properties: { query: { type: "string" } },
+                    required: ["query"],
+                },
+            },
+        },
+        handler: async (a) => {
+            try {
+                const key = (0, config_1.getIntegrationsConfig)().perplexityApiKey;
+                if (!key)
+                    return "error: perplexityApiKey not configured in the agent vault runtime/config item";
+                const res = await fetch("https://api.perplexity.ai/search", {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${key}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ query: a.query, max_results: 5 }),
+                });
+                if (!res.ok)
+                    return `error: ${res.status} ${res.statusText}`;
+                const data = (await res.json());
+                if (!data.results?.length)
+                    return "no results found";
+                return data.results
+                    .map((r) => `${r.title}\n${r.url}\n${r.snippet}`)
+                    .join("\n\n");
+            }
+            catch (e) {
+                return `error: ${e}`;
+            }
+        },
+        summaryKeys: ["query"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "search_notes",
+                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. Search written notes before asking the human something the notes may already answer.",
+                parameters: {
+                    type: "object",
+                    properties: { query: { type: "string" } },
+                    required: ["query"],
+                },
+            },
+        },
+        handler: async (a) => {
+            try {
+                const query = (a.query || "").trim();
+                if (!query)
+                    return "query is required";
+                const resultLines = [];
+                // Search diary entries
+                const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)());
+                for (const fact of hits) {
+                    let meta = `source=${fact.source}, createdAt=${fact.createdAt}`;
+                    if (fact.provenance) {
+                        if (fact.provenance.channel)
+                            meta += `, channel=${fact.provenance.channel}`;
+                        if (fact.provenance.friendName)
+                            meta += `, friend=${fact.provenance.friendName}`;
+                        if (fact.provenance.trust)
+                            meta += `, trust=${fact.provenance.trust}`;
+                    }
+                    const tag = (0, provenance_trust_1.classifyProvenanceTrust)(fact.provenance) === "external" ? "diary/external" : "diary";
+                    resultLines.push(`[${tag}] ${fact.text} (${meta})`);
+                }
+                // 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 search_notes-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: "diary_write",
+                description: "Write an entry in my diary -- something I learned, noticed, or concluded that I want available 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: {
+                        entry: { type: "string" },
+                        about: { type: "string" },
+                    },
+                    required: ["entry"],
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            const entry = (a.entry || "").trim();
+            if (!entry)
+                return "entry is required";
+            let provenance;
+            if (ctx?.context) {
+                const p = { tool: "diary_write" };
+                const channel = ctx.context.channel?.channel;
+                if (channel)
+                    p.channel = channel;
+                const friendId = ctx.context.friend?.id;
+                if (friendId)
+                    p.friendId = friendId;
+                const friendName = ctx.context.friend?.name;
+                if (friendName)
+                    p.friendName = friendName;
+                const trust = ctx.context.friend?.trustLevel;
+                if (trust)
+                    p.trust = trust;
+                provenance = p;
+            }
+            const result = await (0, diary_1.saveDiaryEntry)({
+                text: entry,
+                source: "tool:diary_write",
+                about: typeof a.about === "string" ? a.about : undefined,
+                provenance,
+            });
+            return `saved diary entry (added=${result.added}, skipped=${result.skipped})`;
+        },
+        summaryKeys: ["entry", "about"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "friend_list",
+                description: "list all friends with id, name, and trust level. use this when i need to see who i know — e.g. for cross-chat outreach decisions, screener triage, or just orienting on the friend graph.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        trust: { type: "string", enum: ["family", "friend", "stranger"], description: "optional trust filter; omit to list all" },
+                        limit: { type: "string", description: "max records to return, 1-200. defaults to 50." },
+                    },
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            /* v8 ignore start -- friend_list defensive plumbing: ctx + listAll guards, trust/limit branch fan-out, and empty-set status messages aren't all combined in tests; full coverage lives at the friend-store unit-test layer @preserve */
+            if (!ctx?.friendStore)
+                return "i can't list friends -- friend store not available";
+            if (!ctx.friendStore.listAll)
+                return "the configured friend store does not support listing.";
+            const all = await ctx.friendStore.listAll();
+            const trustFilter = a.trust;
+            const filtered = trustFilter
+                ? all.filter((f) => (f.trustLevel ?? "friend") === trustFilter)
+                : all;
+            const limitRaw = a.limit ? Number.parseInt(a.limit, 10) : 50;
+            const limit = Number.isFinite(limitRaw) ? Math.min(200, Math.max(1, limitRaw)) : 50;
+            const ordered = [...filtered].sort((left, right) => left.name.localeCompare(right.name)).slice(0, limit);
+            if (ordered.length === 0) {
+                return trustFilter ? `no friends with trust level '${trustFilter}'.` : "no friends recorded yet.";
+            }
+            /* v8 ignore stop */
+            /* v8 ignore start -- formatting branches: externalIds presence + pluralization + trust suffix variants depend on specific friend-record shapes not exhaustively combined in tests @preserve */
+            const lines = ordered.map((friend) => {
+                const externals = friend.externalIds && friend.externalIds.length > 0
+                    ? ` [${friend.externalIds.map((id) => `${id.provider}:${id.externalId}`).join(", ")}]`
+                    : "";
+                return `- ${friend.id} (${friend.trustLevel ?? "friend"}): ${friend.name}${externals}`;
+            });
+            return `${ordered.length} friend${ordered.length === 1 ? "" : "s"}${trustFilter ? ` with trust=${trustFilter}` : ""}:\n${lines.join("\n")}`;
+            /* v8 ignore stop */
+        },
+        summaryKeys: ["trust", "limit"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "get_friend_note",
+                description: "read a specific friend record by friend id. use this when i need notes/context about someone not currently active",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string" },
+                    },
+                    required: ["friendId"],
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            const friendId = (a.friendId || "").trim();
+            if (!friendId)
+                return "friendId is required";
+            if (!ctx?.friendStore)
+                return "i can't read friend notes -- friend store not available";
+            const friend = await ctx.friendStore.get(friendId);
+            if (!friend)
+                return `friend not found: ${friendId}`;
+            return JSON.stringify(friend, null, 2);
+        },
+        summaryKeys: ["friendId"],
+    },
+    {
+        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.",
+                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: 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"],
+    },
+];

package/dist/repertoire/tools-obligations.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.obligationToolDefinitions = void 0;
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const json_store_1 = require("../arc/json-store");
+const obligations_1 = require("../arc/obligations");
+/**
+ * `let_go` lets the agent release a held work item from its attention loop.
+ *
+ * Two stores need release semantics:
+ *   1. ReturnObligations at `arc/obligations/inner/<id>.json` (status: queued|running|returned|deferred)
+ *      — these are what surface in the "held work items" section of the prompt.
+ *   2. Outer Obligations at `arc/obligations/<id>.json` (status: pending|...|fulfilled)
+ *      — these surface as "i owe <friend>: ..." in the commitments section.
+ *
+ * The pre-existing path to terminal state for both is the `surface` tool, which fulfills
+ * an obligation as a side-effect of delivering a response. When work is resolved EXTERNALLY
+ * (e.g. a PR merged fixed the underlying issue), there is no response to surface — the
+ * agent has no way to clear the item, so it cycles in the prompt every turn.
+ *
+ * `let_go` is the missing primitive: dismissal WITHOUT delivery.
+ */
+function outerObligationsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "obligations");
+}
+function readOuterObligation(agentRoot, id) {
+    return (0, json_store_1.readJsonFile)(outerObligationsDir(agentRoot), id) ?? null;
+}
+function letGo(args, agentRoot, agentName) {
+    if (typeof args.id !== "string" || args.id.trim().length === 0) {
+        return JSON.stringify({ error: "id is required" });
+    }
+    const id = args.id.trim();
+    const reason = typeof args.reason === "string" && args.reason.trim().length > 0
+        ? args.reason.trim()
+        : null;
+    // 1. ReturnObligation (inner) first — these are what slugger sees in "held work items".
+    const ret = (0, obligations_1.readReturnObligation)(agentName, id);
+    if (ret) {
+        if (ret.status === "returned" || ret.status === "deferred") {
+            return JSON.stringify({ kind: "return_obligation", id, already: ret.status });
+        }
+        (0, obligations_1.advanceReturnObligation)(agentName, id, {
+            status: "returned",
+            returnedAt: Date.now(),
+            returnTarget: "surface",
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.obligation_let_go",
+            message: "agent let go of return obligation",
+            meta: { kind: "return_obligation", id, reason: reason ?? null },
+        });
+        return JSON.stringify({ kind: "return_obligation", let_go: id, reason });
+    }
+    // 2. Outer Obligation — these surface as "i owe ..." in commitments.
+    const outer = readOuterObligation(agentRoot, id);
+    if (outer) {
+        if (outer.status === "fulfilled") {
+            return JSON.stringify({ kind: "obligation", id, already: "fulfilled" });
+        }
+        (0, obligations_1.fulfillObligation)(agentRoot, id);
+        if (reason !== null) {
+            // Persist the dismissal reason as the obligation's latestNote so future-me
+            // can read why this was released (the nerves event also captures it).
+            (0, obligations_1.advanceObligation)(agentRoot, id, { latestNote: reason });
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.obligation_let_go",
+            message: "agent let go of outer obligation",
+            meta: { kind: "obligation", id, reason: reason ?? null },
+        });
+        return JSON.stringify({ kind: "obligation", let_go: id, reason });
+    }
+    return JSON.stringify({ error: `no obligation found with id "${id}"` });
+}
+exports.obligationToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "let_go",
+                description: "release a held work item from my attention. for items that have been resolved externally, no longer apply, or are stale and just cycling in my prompt with nothing to act on. takes the id i see in the 'held work items' section (or any obligation id from arc/obligations/). optional reason is recorded for future me. idempotent — calling on an already-released item returns the existing status, not an error.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "the obligation id — the bracketed id in 'held work items' (e.g. '1775976317954-s5pno43r'), or any obligation file's id from arc/obligations/.",
+                        },
+                        reason: {
+                            type: "string",
+                            description: "optional one-line reason i'm letting go (e.g. 'resolved externally by PR #701').",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+        },
+        handler: (args) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const agentName = (0, identity_1.getAgentName)();
+            return letGo({ id: args.id, reason: args.reason }, agentRoot, agentName);
+        },
+    },
+];

package/dist/repertoire/tools-runtime.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const socket_client_1 = require("../heart/daemon/socket-client");
+async function restartRuntime(args, agentName) {
+    if (typeof args.reason !== "string" || args.reason.trim().length === 0) {
+        return JSON.stringify({ error: "reason is required (one-line audit string)" });
+    }
+    const reason = args.reason.trim();
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.runtime_restart_requested",
+        message: "agent requested runtime restart",
+        meta: { agent: agentName, reason },
+    });
+    try {
+        const response = await (0, socket_client_1.sendDaemonCommand)(socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, {
+            kind: "daemon.restart",
+            reason,
+            requestedBy: agentName,
+        });
+        return JSON.stringify({
+            requested: true,
+            reason,
+            detail: response.message ?? "daemon restart requested",
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: "failed to reach daemon socket",
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+exports.runtimeToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "restart_runtime",
+                description: "ask my runtime (the daemon hosting me) to restart itself. for when something is wedged — stale state, recovery queue jammed, version mismatch, or i just need a fresh boot. under launchctl the daemon auto-respawns, so i come back on the other side with a clean slate. takes a one-line reason that lands in the audit log. i will NOT see this tool's response — my process exits with the daemon and i wake up fresh.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        reason: {
+                            type: "string",
+                            description: "one-line audit reason (e.g. 'bluebubbles recovery queue wedged for 4h', 'picking up daemon version update').",
+                        },
+                    },
+                    required: ["reason"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const agentName = (0, identity_1.getAgentName)();
+            return restartRuntime({ reason: args.reason }, agentName);
+        },
+    },
+];