@ouro.bot/cli 0.1.0-alpha.741 → 0.1.0-alpha.743

package/dist/repertoire/tools-continuity.js

@@ -1,14 +1,216 @@
 "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");
 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 reason once for this receipt; silent and act only record the disposition.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        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, or none only for a fresh observation with no applicable policy" },
+                        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: "Short plain-language reason for the decision" },
+                        nextWake: { type: "string", enum: ["on_change", "on_escalation", "on_recovery", "at"] },
+                        wakeAt: { type: "string", description: "ISO time required when nextWake=at" },
+                        awaitId: { type: "string", description: "Existing await receipt required when nextWake=at" },
+                        careId: { type: "string", description: "Existing Care adopted for this incident, if any" },
+                        actionRefs: { type: "array", items: { type: "string" } },
+                        verificationRefs: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["recordPath", "expectedGeneration", "classifiedRevision", "classification", "stewardPolicyKind", "decision", "reason", "nextWake"],
+                },
+            },
+        },
+        handler: (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();
+            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") {
+                if (record.transition !== "opened")
+                    throw new Error("External event no-policy disposition requires a fresh observation");
+                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"}`);
+            const finish = async () => {
+                if (decision === "ask" || decision === "report") {
+                    if (Buffer.byteLength(reason, "utf8") > 1_200)
+                        throw new Error("External event owner message must be phone-sized");
+                    if (!ctx?.externalEventEffects)
+                        throw new Error("External event owner delivery is unavailable");
+                    await ctx.externalEventEffects.deliverOwnerDecision({ source: record.source, eventId: record.eventId, generation: record.generation, text: reason });
+                }
+                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,
+                    },
+                });
+                (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 } });
+                return JSON.stringify(handled, null, 2);
+            };
+            return finish();
+        },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "records the agent's classification on an existing external-event receipt" },
+    },
     {
         tool: {
             type: "function",
@@ -115,17 +317,24 @@ exports.continuityToolDefinitions = [
             type: "function",
             function: {
                 name: "care_manage",
-                description: "Create, update, or resolve a care. Cares are things I watch over — people, projects, missions, system health.",
+                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"], description: "What to do" },
+                        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" },
                         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: "Optional Care updatedAt value for CAS fencing" },
+                        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"],
                 },
@@ -146,8 +355,8 @@ exports.continuityToolDefinitions = [
                     relatedAgentIds: [],
                     relatedObligationIds: [],
                     relatedEpisodeIds: [],
-                    currentRisk: null,
-                    nextCheckAt: null,
+                    currentRisk: a.currentRisk ? String(a.currentRisk) : null,
+                    nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null,
                 });
             }
             else if (a.action === "update") {
@@ -158,11 +367,57 @@ exports.continuityToolDefinitions = [
                     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("Care incident binding requires expectedUpdatedAt");
+                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("Care incident resolution requires expectedUpdatedAt");
+                result = (0, cares_1.resolveCareIncident)(agentRoot, a.id, {
+                    source: a.source,
+                    incidentKey: a.incidentKey,
+                    expectedUpdatedAt: a.expectedUpdatedAt,
+                });
+            }
+            else if (a.action === "upsert_incident") {
+                result = (0, cares_1.upsertCareForIncident)(agentRoot, {
+                    label: a.label ?? "untitled",
+                    why: a.why ?? "",
+                    kind: a.kind ?? "system",
+                    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,
+                    ...(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);
         },

package/dist/repertoire/tools-notes.js

@@ -44,6 +44,7 @@ const friends_1 = require("@ouro.bot/friends");
 const diary_1 = require("../mind/diary");
 const record_paths_1 = require("../mind/record-paths");
 const provenance_trust_1 = require("../mind/provenance-trust");
+const relationship_authorization_1 = require("./relationship-authorization");
 const CLAUDE_READ_ONLY_TOOLS = "Read,Grep,Glob,LS";
 function bundleRelativeLocator(filePath, ctx) {
     const agentRoot = ctx?.agentRoot ?? (0, identity_1.getAgentRoot)();
@@ -386,12 +387,13 @@ exports.notesToolDefinitions = [
             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.",
+                description: "save something i learned about my friend. use type 'name' to update their display name, 'tool_preference' for presentation preferences, or 'note' for general context. For Sanctuary relationships, preference source is stated (the person said or confirmed it), observed (a revisable pattern i inferred), or default (a fallback until better evidence), and only communication or timing are accepted. Other agents retain their existing integration-preference behavior and do not persist this provenance field. desired state and action authority belong in steward policy. notes and preferences improve orientation but never grant authority. set override=true when replacing an existing value.",
                 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')" },
+                        key: { type: "string", description: "category key (required for tool_preference and note; Sanctuary relationship preferences use communication or timing)" },
+                        source: { type: "string", enum: ["stated", "observed", "default"], description: "preference provenance; required for Sanctuary relationship preferences" },
                         content: { type: "string", description: "the value to save" },
                         override: { type: "string", enum: ["true", "false"], description: "set to 'true' to overwrite an existing value" },
                     },
@@ -415,6 +417,18 @@ exports.notesToolDefinitions = [
             const friendId = ctx.context.friend?.id;
             if (!friendId)
                 return "i can't save notes -- no friend identity available";
+            const actor = ctx.relationshipAuthorization?.actor;
+            const isSanctuaryRelationship = ctx.context.friend?.capabilityProfileId?.startsWith("sanctuary-") === true;
+            const preferenceSource = a.source;
+            if (isSanctuaryRelationship && a.type === "tool_preference" && !["stated", "observed", "default"].includes(String(preferenceSource))) {
+                return "i need exact preference provenance: source must be stated, observed, or default";
+            }
+            if (isSanctuaryRelationship && a.type === "tool_preference" && !["communication", "timing"].includes(a.key ?? "")) {
+                return "Sanctuary relationship preferences are limited to communication or timing; desired state and action authority belong in steward policy";
+            }
+            if (actor?.trustLevel === "friend" && (actor.friendId !== friendId || a.type !== "tool_preference" || !["communication", "timing"].includes(a.key ?? ""))) {
+                return "household members may only save their own communication or timing preferences; preferences never grant authority";
+            }
             // Validate parameters (input-shape guards stay harness-side so we keep the
             // first-person tool wording; applyFriendNote does the record mutation).
             if (!a.content)
@@ -426,9 +440,21 @@ exports.notesToolDefinitions = [
                 return "i need a key for tool_preference or note type";
             // Record-domain logic lives in @ouro.bot/friends; this wrapper maps the
             // structured FriendOpResult back to the tool's first-person strings.
+            if (isSanctuaryRelationship && a.type === "tool_preference" && preferenceSource) {
+                const current = await ctx.friendStore.get(friendId);
+                if (!current)
+                    return "i can't find the friend record on disk";
+                if (current.relationshipPolicy?.preferences[a.key] && a.override !== "true")
+                    return `relationship preference '${a.key}' already exists; call again with override: true to replace it`;
+                const sourceKind = preferenceSource === "observed" ? "observed pattern" : preferenceSource === "default" ? "default fallback" : "explicit turn";
+                const turnSource = `${ctx.currentSession?.channel ?? "relationship"} ${sourceKind} ${actor?.sessionEventId ?? "unknown-event"}`;
+                await ctx.friendStore.put(friendId, (0, relationship_authorization_1.withRelationshipPreference)(current, { category: a.key, value: a.content, provenance: preferenceSource, source: turnSource }));
+                return `saved preference: source=${turnSource}; provenance=${preferenceSource}; category=${a.key}; value=${a.content}; this changes presentation only and grants no authority`;
+            }
+            const storedKey = a.key;
             const result = await (0, friends_1.applyFriendNote)(ctx.friendStore, friendId, {
                 type: a.type,
-                ...(a.key !== undefined ? { key: a.key } : {}),
+                ...(storedKey !== undefined ? { key: storedKey } : {}),
                 content: a.content,
                 override: a.override === "true",
             });