@ouro.bot/cli 0.1.0-alpha.98 → 0.1.0-alpha.981

package/dist/repertoire/tools-continuity.js

@@ -0,0 +1,588 @@
+"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.continuityToolDefinitions = void 0;
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const identity_1 = require("../heart/identity");
+const router_1 = require("../heart/external-events/router");
+const runtime_1 = require("../nerves/runtime");
+const episodes_1 = require("../arc/episodes");
+const cares_1 = require("../arc/cares");
+const presence_1 = require("../arc/presence");
+const intentions_1 = require("../arc/intentions");
+const steward_policy_1 = require("../heart/steward-policy");
+const await_parser_1 = require("../heart/awaiting/await-parser");
+const externalEventDispositionProperties = {
+    recordPath: { type: "string", description: "Exact receipt path from the external-event message" },
+    expectedGeneration: { type: "number", description: "Exact generation shown in the external-event turn" },
+    classifiedRevision: { type: "string", description: "Exact observation revision investigated in this turn" },
+    classification: { type: "string", enum: ["expected", "needs_attention", "adopted", "snoozed", "dismissed_until_change", "resolved"] },
+    stewardPolicyKind: { type: "string", enum: ["current", "none"], description: "Use current with the exact live policy key/version when one applies; otherwise use none. Any event may be closed with none." },
+    stewardPolicyKey: { type: "string", description: "Exact current policy key used for this decision" },
+    stewardPolicyVersion: { type: "number", description: "Exact current policy version used for this decision" },
+    decision: { type: "string", enum: ["silent", "act", "ask", "report"] },
+    reason: { type: "string", description: "Internal audit note for the decision; never shown to the owner" },
+    owner_message: { type: "string", description: "Required for ask or report: the exact short plain message the owner reads, as you would text a friend. No ids, leases, generations, revisions or receipts." },
+    nextWake: { type: "string", enum: ["on_change", "on_escalation", "on_recovery", "at"], description: "Use on_change unless you already called await_condition for this exact event and are supplying its awaitId" },
+    wakeAt: { type: "string", description: "ISO time required only when nextWake=at" },
+    awaitId: { type: "string", description: "Existing await_condition receipt required when nextWake=at; never invent one" },
+    careId: { type: "string", description: "Existing Care adopted for this incident, if any" },
+    actionRefs: { type: "array", items: { type: "string" } },
+    verificationRefs: { type: "array", items: { type: "string" } },
+};
+const externalEventDispositionRequired = ["recordPath", "expectedGeneration", "classifiedRevision", "classification", "stewardPolicyKind", "decision", "reason", "nextWake"];
+const externalEventDispositionBatchSchema = {
+    type: "array",
+    minItems: 1,
+    maxItems: 32,
+    description: "All exact leases from one coalesced external-event turn",
+    items: { type: "object", properties: externalEventDispositionProperties, required: externalEventDispositionRequired, additionalProperties: false },
+};
+// The owner reads owner_message verbatim, so internal bookkeeping words never reach them.
+const OWNER_MESSAGE_FORBIDDEN = /\b(generation|lease|revision|receipt|disposition|claimOwner|recordPath)s?\b|[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/iu;
+function prepareExternalEventDisposition(a, ctx) {
+    const agentName = (0, identity_1.getAgentName)();
+    const agentEventRoot = path.resolve((0, router_1.getExternalEventRoot)(), agentName);
+    const recordPath = path.resolve(String(a.recordPath ?? ""));
+    const relative = path.relative(agentEventRoot, recordPath);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative) || !recordPath.endsWith(".json")) {
+        throw new Error("External event receipt does not belong to the current agent");
+    }
+    const record = (0, router_1.readExternalEventRecord)(recordPath);
+    if (record.agent !== agentName)
+        throw new Error("External event receipt does not belong to the current agent");
+    const turnContext = ctx?.currentExternalEvent;
+    const turnEvent = turnContext
+        ? [turnContext, ...(turnContext.relatedEvents ?? [])].find((event) => path.resolve(event.recordPath) === recordPath)
+        : undefined;
+    const expectedGeneration = Number(a.expectedGeneration);
+    const classifiedRevision = String(a.classifiedRevision ?? "");
+    if (!turnEvent || turnEvent.recordPath !== recordPath || turnEvent.agent !== agentName
+        || turnEvent.generation !== expectedGeneration || turnEvent.observationRevision !== classifiedRevision
+        || record.generation !== expectedGeneration || record.observationRevision !== classifiedRevision
+        || record.executionState !== "running" || record.claimOwner !== turnEvent.claimOwner) {
+        throw new Error("External event disposition is not authorized for this exact turn lease");
+    }
+    const classification = String(a.classification);
+    const decision = String(a.decision);
+    const nextWake = String(a.nextWake);
+    const policyVersion = Number(a.stewardPolicyVersion);
+    const policyKind = String(a.stewardPolicyKind ?? "");
+    const reason = String(a.reason ?? "").trim();
+    const ownerText = String(a.owner_message ?? "").trim();
+    if (!reason || (policyKind !== "none" && (!Number.isSafeInteger(policyVersion) || policyVersion < 1))
+        || !["current", "none"].includes(policyKind)
+        || !["expected", "needs_attention", "adopted", "snoozed", "dismissed_until_change", "resolved"].includes(classification)
+        || !["silent", "act", "ask", "report"].includes(decision)
+        || !["on_change", "on_escalation", "on_recovery", "at"].includes(nextWake)) {
+        throw new Error("External event disposition is invalid");
+    }
+    const wake = nextWake === "at" ? { kind: "at", at: String(a.wakeAt ?? "") } : { kind: nextWake };
+    const actionRefs = Array.isArray(a.actionRefs) ? a.actionRefs.map(String) : [];
+    const verificationRefs = Array.isArray(a.verificationRefs) ? a.verificationRefs.map(String) : [];
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const policy = (0, steward_policy_1.readStewardPolicy)(agentRoot);
+    let stewardPolicy;
+    if (policyKind === "none") {
+        stewardPolicy = { kind: "none" };
+    }
+    else {
+        const key = String(a.stewardPolicyKey ?? "").trim();
+        if (!key)
+            throw new Error("External event disposition is invalid");
+        if (policy.version !== policyVersion || (!policy.desiredStates[key] && !policy.routineActionGrants[key])) {
+            throw new Error("External event steward policy is not the exact current key/version");
+        }
+        stewardPolicy = { kind: "current", key, version: policyVersion };
+    }
+    if (typeof a.careId === "string" && a.careId) {
+        const care = (0, cares_1.readCares)(agentRoot).find((candidate) => candidate.id === a.careId);
+        const binding = care?.incidentBindings?.find((candidate) => candidate.source === record.source && candidate.incidentKey === record.eventId && candidate.classifiedRevision === classifiedRevision);
+        if (!care || !binding)
+            throw new Error("External event Care does not belong to this agent and incident revision");
+    }
+    if (classification === "adopted" && !(typeof a.careId === "string" && a.careId)) {
+        throw new Error("External event adopted disposition requires a Care");
+    }
+    if (nextWake === "at") {
+        const awaitId = typeof a.awaitId === "string" ? a.awaitId : "";
+        if (!/^[A-Za-z0-9_-]+$/u.test(awaitId))
+            throw new Error("External event timed disposition requires a current pending Await");
+        const awaitPath = path.join(agentRoot, "awaiting", `${awaitId}.md`);
+        let pendingAwait;
+        try {
+            const stat = fs.lstatSync(awaitPath);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                throw new Error("unsafe Await");
+            pendingAwait = (0, await_parser_1.parseAwaitFile)(fs.readFileSync(awaitPath, "utf8"), awaitPath);
+        }
+        catch {
+            throw new Error("External event timed disposition requires a current pending Await");
+        }
+        const expectedOwnerId = ctx?.context?.friend.id;
+        if (pendingAwait.filed_from !== "external-event" || pendingAwait.filed_from_key !== record.recordPath
+            || (expectedOwnerId && pendingAwait.filed_for_friend_id !== expectedOwnerId)) {
+            throw new Error("External event timed disposition Await is not owned by this exact external event");
+        }
+        if (pendingAwait.status !== "pending" || pendingAwait.wake_at !== String(a.wakeAt)) {
+            throw new Error("External event timed disposition Await does not match the exact wake time");
+        }
+    }
+    const authority = ctx?.externalEventAuthority?.authorizeDisposition({
+        event: turnEvent,
+        classification,
+        decision,
+        stewardPolicy,
+        nextWake,
+        wakeAt: nextWake === "at" ? String(a.wakeAt) : null,
+        awaitId: typeof a.awaitId === "string" && a.awaitId ? a.awaitId : null,
+        careId: typeof a.careId === "string" && a.careId ? a.careId : null,
+        actionRefs,
+        verificationRefs,
+    });
+    if (!authority?.allowed)
+        throw new Error(`External event disposition authority denied: ${authority?.reason ?? "authority unavailable"}`);
+    return {
+        recordPath,
+        finish: async () => {
+            let ownerMessage;
+            if (decision === "ask" || decision === "report") {
+                if (!ownerText)
+                    throw new Error("ask and report need owner_message: the short plain text the owner will read");
+                if (Buffer.byteLength(ownerText, "utf8") > 1_200)
+                    throw new Error("External event owner message must be phone-sized");
+                if (OWNER_MESSAGE_FORBIDDEN.test(ownerText))
+                    throw new Error("owner_message must be plain words for the owner, with no internal ids, leases, generations, revisions, receipts or hidden characters");
+                if (!ctx?.externalEventEffects)
+                    throw new Error("External event owner delivery is unavailable");
+                // The whole dispatched batch shares one owner message; the delivery port settles later decisions as covered by it.
+                const relatedEvents = [turnContext, ...(turnContext.relatedEvents ?? [])]
+                    .filter((event) => path.resolve(event.recordPath) !== recordPath)
+                    .map((event) => ({ source: event.source, eventId: event.eventId, generation: event.generation }));
+                const delivered = await ctx.externalEventEffects.deliverOwnerDecision({ source: record.source, eventId: record.eventId, generation: record.generation, text: ownerText, relatedEvents });
+                ownerMessage = { status: delivered.status, effectKey: delivered.effectKey };
+            }
+            const handled = (0, router_1.commitExternalEventDisposition)(recordPath, {
+                owner: turnEvent.claimOwner,
+                expectedVersion: record.version,
+                expectedGeneration: record.generation,
+                disposition: {
+                    classifiedRevision,
+                    classification: classification,
+                    stewardPolicy,
+                    decision: decision,
+                    reason,
+                    nextWake: wake,
+                    careId: typeof a.careId === "string" && a.careId ? a.careId : null,
+                    awaitId: typeof a.awaitId === "string" && a.awaitId ? a.awaitId : null,
+                    actionRefs,
+                    verificationRefs,
+                    ...(ownerMessage ? { ownerMessage } : {}),
+                },
+            });
+            ctx?.externalEventAuthority?.recordCommittedDisposition?.(turnEvent);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.external_event_disposition", message: "external event disposition recorded", meta: { agentName, eventId: record.eventId, generation: record.generation, classification, decision, ...(ownerMessage ? { ownerMessage: ownerMessage.status } : {}) } });
+            return handled;
+        },
+    };
+}
+exports.continuityToolDefinitions = [
+    // ── Continuity tools ──────────────────────────────────────────────
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "external_event_disposition",
+                description: "Classify the exact external-event generation I just investigated. An ask or report is the sole owner-delivery path and sends owner_message once for this receipt; reason stays internal. silent and act only record the disposition. In a batch, only the first ask or report sends a message and the later ones are recorded as covered by it, so write that first owner_message to cover every listed incident.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        ...externalEventDispositionProperties,
+                        batch: externalEventDispositionBatchSchema,
+                    },
+                    oneOf: [
+                        { type: "object", properties: externalEventDispositionProperties, required: externalEventDispositionRequired },
+                        { type: "object", properties: { batch: externalEventDispositionBatchSchema }, required: ["batch"] },
+                    ],
+                    additionalProperties: false,
+                },
+            },
+        },
+        handler: (a, ctx) => {
+            const input = a;
+            if (input.batch !== undefined) {
+                if (Object.keys(input).some((key) => key !== "batch"))
+                    throw new Error("External event disposition single and batch forms are mutually exclusive");
+                if (!Array.isArray(input.batch) || input.batch.length < 1 || input.batch.length > 32)
+                    throw new Error("External event disposition batch must contain 1 to 32 items");
+                if (input.batch.some((item) => !item || typeof item !== "object" || Array.isArray(item)))
+                    throw new Error("External event disposition batch item is invalid");
+                const recordPaths = input.batch.map((item) => path.resolve(String(item.recordPath ?? "")));
+                if (new Set(recordPaths).size !== recordPaths.length)
+                    throw new Error("External event disposition batch contains a duplicate receipt");
+                const activeFrame = ctx?.currentExternalEvent
+                    ? [ctx.currentExternalEvent, ...(ctx.currentExternalEvent.relatedEvents ?? [])]
+                    : [];
+                const activeRecordPaths = new Set(activeFrame.map((event) => path.resolve(event.recordPath)));
+                if (activeRecordPaths.size !== recordPaths.length || recordPaths.some((recordPath) => !activeRecordPaths.has(recordPath))) {
+                    throw new Error("External event disposition batch must contain every lease in the active turn frame");
+                }
+                const prepared = input.batch.map((item) => prepareExternalEventDisposition(item, ctx));
+                return (async () => {
+                    const results = [];
+                    for (const item of prepared) {
+                        try {
+                            results.push({ recordPath: item.recordPath, ok: true, record: await item.finish() });
+                        }
+                        catch (error) {
+                            results.push({ recordPath: item.recordPath, ok: false, error: (error instanceof Error ? error.message : String(error)).slice(0, 500) });
+                        }
+                    }
+                    return JSON.stringify({ results }, null, 2);
+                })();
+            }
+            const prepared = prepareExternalEventDisposition(input, ctx);
+            return prepared.finish().then((handled) => JSON.stringify(handled, null, 2));
+        },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "records the agent's classification on an existing external-event receipt" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_episodes",
+                description: "Query recent episodes from my continuity log. Returns timestamped records of significant events (obligation shifts, coding milestones, bridge events, care events, turning points).",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        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" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            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: "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: {
+                        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 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);
+        },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes continuity episode state" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_presence",
+                description: "Check who's around — my own availability/lane and known peer agents.",
+                parameters: { type: "object", properties: {} },
+            },
+        },
+        handler: () => {
+            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: "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: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const now = Date.now();
+            const cares = (a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot)).map((care) => (0, cares_1.projectCareEvidence)(care, now));
+            (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: "care_manage",
+                description: "Create, update, or resolve a care, or bind and resolve one machine incident within it. Cares are things I watch over — people, projects, missions, system health.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["create", "update", "resolve", "bind_incident", "resolve_incident", "upsert_incident"], 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" },
+                        status: { type: "string", enum: ["active", "watching", "resolved", "dormant"], description: "active, watching, resolved, or dormant" },
+                        stewardship: { type: "string", description: "mine, shared, or delegated" },
+                        source: { type: "string", description: "Machine evidence source for an incident binding" },
+                        incidentKey: { type: "string", description: "Stable incident key within the source" },
+                        classifiedRevision: { type: "string", description: "Observation revision classified by the agent" },
+                        correlationKey: { type: "string", description: "Optional key relating several incidents to one concern" },
+                        expectedUpdatedAt: { type: "string", description: "The Care's current updatedAt, copied from the last care_manage result. Required for bind_incident and resolve_incident; optional for update." },
+                        currentRisk: { type: "string", description: "Current material risk for this Care, or an empty string to clear it" },
+                        nextCheckAt: { type: "string", description: "Exact ISO time of the next owned check" },
+                    },
+                    required: ["action"],
+                },
+            },
+        },
+        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: a.status ?? "active",
+                    salience: a.salience ?? "medium",
+                    steward: a.stewardship ?? "mine",
+                    relatedFriendIds: [],
+                    relatedAgentIds: [],
+                    relatedObligationIds: [],
+                    relatedEpisodeIds: [],
+                    currentRisk: a.currentRisk ? String(a.currentRisk) : null,
+                    nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null,
+                });
+            }
+            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;
+                if (a.currentRisk !== undefined)
+                    updates.currentRisk = a.currentRisk || null;
+                if (a.nextCheckAt !== undefined)
+                    updates.nextCheckAt = a.nextCheckAt || null;
+                result = (0, cares_1.updateCare)(agentRoot, a.id, updates);
+            }
+            else if (a.action === "resolve") {
+                result = (0, cares_1.resolveCare)(agentRoot, a.id);
+            }
+            else if (a.action === "bind_incident") {
+                if (!a.expectedUpdatedAt)
+                    throw new Error("bind_incident requires expectedUpdatedAt: copy the Care's current updatedAt from the last care_manage result");
+                result = (0, cares_1.bindCareIncident)(agentRoot, a.id, {
+                    source: a.source,
+                    incidentKey: a.incidentKey,
+                    classifiedRevision: a.classifiedRevision,
+                    ...(a.correlationKey ? { correlationKey: a.correlationKey } : {}),
+                }, { expectedUpdatedAt: a.expectedUpdatedAt });
+            }
+            else if (a.action === "resolve_incident") {
+                if (!a.expectedUpdatedAt)
+                    throw new Error("resolve_incident requires expectedUpdatedAt: copy the Care's current updatedAt from the last care_manage result");
+                result = (0, cares_1.resolveCareIncident)(agentRoot, a.id, {
+                    source: a.source,
+                    incidentKey: a.incidentKey,
+                    expectedUpdatedAt: a.expectedUpdatedAt,
+                    ...((a.label !== undefined || a.why !== undefined || a.currentRisk !== undefined || a.nextCheckAt !== undefined) ? {
+                        display: {
+                            ...(a.label !== undefined ? { label: String(a.label) } : {}),
+                            ...(a.why !== undefined ? { why: String(a.why) } : {}),
+                            ...(a.currentRisk !== undefined ? { currentRisk: a.currentRisk ? String(a.currentRisk) : null } : {}),
+                            ...(a.nextCheckAt !== undefined ? { nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null } : {}),
+                        },
+                    } : {}),
+                });
+            }
+            else if (a.action === "upsert_incident") {
+                result = (0, cares_1.upsertCareForIncident)(agentRoot, {
+                    ...(a.id ? { id: String(a.id) } : {}),
+                    ...(!a.id ? {
+                        label: a.label ?? "untitled", why: a.why ?? "", kind: a.kind ?? "system", status: a.status ?? "active",
+                        salience: a.salience ?? "medium", steward: a.stewardship ?? "mine",
+                    } : {
+                        ...(a.label !== undefined ? { label: String(a.label) } : {}), ...(a.why !== undefined ? { why: String(a.why) } : {}),
+                        ...(a.kind !== undefined ? { kind: a.kind } : {}), ...(a.status !== undefined ? { status: a.status } : {}),
+                        ...(a.salience !== undefined ? { salience: a.salience } : {}), ...(a.stewardship !== undefined ? { steward: a.stewardship } : {}),
+                    }),
+                    relatedFriendIds: [],
+                    relatedAgentIds: [],
+                    relatedObligationIds: [],
+                    relatedEpisodeIds: [],
+                    ...(!a.id || a.currentRisk !== undefined ? { currentRisk: a.currentRisk ? String(a.currentRisk) : null } : {}),
+                    ...(!a.id || a.nextCheckAt !== undefined ? { nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null } : {}),
+                    ...(a.expectedUpdatedAt ? { expectedUpdatedAt: String(a.expectedUpdatedAt) } : {}),
+                    incident: {
+                        source: a.source,
+                        incidentKey: a.incidentKey,
+                        classifiedRevision: a.classifiedRevision,
+                        ...(a.correlationKey ? { correlationKey: a.correlationKey } : {}),
+                    },
+                });
+            }
+            (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);
+        },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "creates or updates care state" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_relationships",
+                description: "Query known agent relationships — familiarity, trust, shared missions, interaction history.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        agentName: { type: "string", description: "Specific agent name to query (omit for all)" },
+                    },
+                },
+            },
+        },
+        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: "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: {
+                        content: { type: "string", description: "What I want to keep track of" },
+                        salience: { type: "string", description: "low, medium, or high (default: low)" },
+                        nudgeAfter: { type: "string", description: "ISO timestamp — nudge me after this time" },
+                    },
+                    required: ["content"],
+                },
+            },
+        },
+        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);
+        },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes intention state" },
+    },
+    {
+        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);
+        },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "updates intention state" },
+    },
+];