@ouro.bot/cli 0.1.0-alpha.742 → 0.1.0-alpha.744

package/dist/heart/session-events.js

@@ -50,6 +50,8 @@ exports.migrateToolNames = migrateToolNames;
 exports.sanitizeProviderMessages = sanitizeProviderMessages;
 exports.stampIngressTime = stampIngressTime;
 exports.getIngressTime = getIngressTime;
+exports.stampIngressRelations = stampIngressRelations;
+exports.getIngressRelations = getIngressRelations;
 exports.projectProviderMessages = projectProviderMessages;
 exports.annotateMessageTimestamps = annotateMessageTimestamps;
 exports.bestEventTimestamp = bestEventTimestamp;
@@ -860,6 +862,21 @@ function getIngressTime(msg) {
     const value = msg._ingressAt;
     return typeof value === "string" ? value : null;
 }
+function stampIngressRelations(msg, relations) {
+    ;
+    msg._ingressRelations = structuredClone(relations);
+}
+function getIngressRelations(msg) {
+    const value = msg._ingressRelations;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const relations = value;
+    return {
+        replyToEventId: typeof relations.replyToEventId === "string" ? relations.replyToEventId : null,
+        threadRootEventId: typeof relations.threadRootEventId === "string" ? relations.threadRootEventId : null,
+        references: Array.isArray(relations.references) ? relations.references.filter((item) => typeof item === "string") : [],
+    };
+}
 function createEventTime(role, recordedAt, captureKind, ingressAt) {
     if (captureKind === "migration") {
         return {
@@ -890,7 +907,7 @@ function createEventTime(role, recordedAt, captureKind, ingressAt) {
         recordedAtSource: "save",
     };
 }
-function buildEventFromMessage(message, sequence, recordedAt, captureKind, sourceMessageIndex, legacyVersion, ingressAt) {
+function buildEventFromMessage(message, sequence, recordedAt, captureKind, sourceMessageIndex, legacyVersion, ingressAt, ingressRelations) {
     const normalized = normalizeMessage(message);
     const role = normalized.role;
     const cappedContent = truncateLargeEventContent(normalized.content, exports.EVENT_CONTENT_MAX_CHARS).content;
@@ -905,9 +922,9 @@ function buildEventFromMessage(message, sequence, recordedAt, captureKind, sourc
         attachments: [],
         time: createEventTime(role, recordedAt, captureKind, ingressAt),
         relations: {
-            replyToEventId: null,
-            threadRootEventId: null,
-            references: [],
+            replyToEventId: ingressRelations?.replyToEventId ?? null,
+            threadRootEventId: ingressRelations?.threadRootEventId ?? null,
+            references: ingressRelations?.references ?? [],
             toolCallId: role === "tool" ? normalized.toolCallId : null,
             supersedesEventId: null,
             redactsEventId: null,
@@ -1205,6 +1222,7 @@ function buildCanonicalSessionEnvelope(options) {
     const existing = options.existing;
     // Callers pass pre-sanitized messages + pre-captured ingress times.
     const currentIngressTimes = options.currentIngressTimes ?? options.currentMessages.map(getIngressTime);
+    const currentIngressRelations = options.currentIngressRelations ?? options.currentMessages.map(getIngressRelations);
     const previousMessages = options.previousMessages;
     const currentMessages = options.currentMessages;
     const trimmedMessages = options.trimmedMessages;
@@ -1249,7 +1267,7 @@ function buildCanonicalSessionEnvelope(options) {
             // Create a new event. Use nextEventSequence(events) instead of
             // `events.length + 1` so that any gap (from pruning, archive replay,
             // or self-heal dedup) cannot collide with an existing id.
-            const event = buildEventFromMessage(currentMessages[i], nextEventSequence(events), options.recordedAt, "live", null, null, currentIngressTimes[i]);
+            const event = buildEventFromMessage(currentMessages[i], nextEventSequence(events), options.recordedAt, "live", null, null, currentIngressTimes[i], currentIngressRelations[i]);
             events.push(event);
             currentEventIds.push(event.id);
         }

package/dist/heart/steward-policy.js

@@ -0,0 +1,302 @@
+"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.readStewardPolicy = readStewardPolicy;
+exports.updateStewardPolicy = updateStewardPolicy;
+exports.readRoutineActionReceipts = readRoutineActionReceipts;
+exports.inspectRoutineActionGrant = inspectRoutineActionGrant;
+exports.consumeRoutineActionGrant = consumeRoutineActionGrant;
+exports.transitionRoutineActionReceipt = transitionRoutineActionReceipt;
+exports.recoverRoutineActionReceipts = recoverRoutineActionReceipts;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+const session_transaction_1 = require("../mind/session-transaction");
+const EMPTY_POLICY = { schemaVersion: 1, version: 0, desiredStates: {}, routineActionGrants: {}, updatedAt: null };
+function policyDir(agentRoot) {
+    return path.join(agentRoot, "state", "policy");
+}
+function policyPath(agentRoot) {
+    return path.join(policyDir(agentRoot), "steward.json");
+}
+function receiptsPath(agentRoot) {
+    return path.join(policyDir(agentRoot), "action-receipts.ndjson");
+}
+function auditPath(agentRoot) {
+    return path.join(policyDir(agentRoot), "policy-audit.ndjson");
+}
+function ensureDirectory(agentRoot) {
+    fs.mkdirSync(policyDir(agentRoot), { recursive: true, mode: 0o700 });
+    fs.chmodSync(policyDir(agentRoot), 0o700);
+}
+function appendReceipt(filePath, value) {
+    const creating = !fs.existsSync(filePath);
+    const fd = fs.openSync(filePath, "a", 0o600);
+    try {
+        fs.writeFileSync(fd, `${JSON.stringify(value)}\n`, "utf8");
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.chmodSync(filePath, 0o600);
+    if (creating) {
+        const directory = fs.openSync(path.dirname(filePath), fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW);
+        try {
+            fs.fsyncSync(directory);
+        }
+        finally {
+            fs.closeSync(directory);
+        }
+    }
+}
+function requireText(value, label) {
+    const result = value.trim();
+    if (!result)
+        throw new Error(`${label} must be nonempty`);
+    return result;
+}
+function optionalExpiry(value, now) {
+    if (!value)
+        return undefined;
+    const epoch = Date.parse(value);
+    if (!Number.isFinite(epoch) || new Date(epoch).toISOString() !== value || epoch <= Date.parse(now))
+        throw new Error("policy expiry must be a future canonical timestamp");
+    return value;
+}
+function validateStewardPolicy(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("steward policy is invalid");
+    const candidate = value;
+    if (candidate.schemaVersion !== 1 || !Number.isInteger(candidate.version) || candidate.version < 0 || typeof candidate.desiredStates !== "object" || !candidate.desiredStates || typeof candidate.routineActionGrants !== "object" || !candidate.routineActionGrants) {
+        throw new Error("steward policy is invalid");
+    }
+    return candidate;
+}
+function readStewardPolicy(agentRoot) {
+    const filePath = policyPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return structuredClone(EMPTY_POLICY);
+    return validateStewardPolicy(JSON.parse(fs.readFileSync(filePath, "utf8")));
+}
+function updateStewardPolicy(agentRoot, input) {
+    if (input.actor.trustLevel !== "family")
+        throw new Error("steward policy mutation requires family authority");
+    const authorizingSessionEvent = requireText(input.actor.sessionEventId, "authorizing session event");
+    const issuer = requireText(input.actor.friendId, "issuer");
+    return (0, session_transaction_1.withImmediateSessionTurnLease)(policyPath(agentRoot), (lease) => {
+        const snapshot = (0, session_transaction_1.readSessionTransaction)(policyPath(agentRoot), lease);
+        const current = snapshot.value === null ? structuredClone(EMPTY_POLICY) : validateStewardPolicy(snapshot.value);
+        if (current.version !== input.expectedVersion)
+            throw new Error(`steward policy version changed: expected ${input.expectedVersion}, got ${current.version}`);
+        const now = input.now ?? new Date().toISOString();
+        const expiresAt = optionalExpiry(input.mutation.expiresAt, now);
+        const version = current.version + 1;
+        const next = { ...current, version, desiredStates: { ...current.desiredStates }, routineActionGrants: { ...current.routineActionGrants }, updatedAt: now };
+        if (input.mutation.kind === "set_desired_state") {
+            next.desiredStates[requireText(input.mutation.key, "desired state key")] = {
+                value: requireText(input.mutation.value, "desired state value"),
+                provenance: input.mutation.provenance,
+                version,
+                source: requireText(input.mutation.source, "desired state source"),
+                ...(expiresAt ? { expiresAt } : {}),
+            };
+        }
+        else {
+            if (input.mutation.provenance !== "stated" && input.mutation.provenance !== "installed_explicit_policy")
+                throw new Error("routine action grants require explicit authority");
+            if (!Number.isInteger(input.mutation.maxCount) || input.mutation.maxCount < 1 || !Number.isFinite(input.mutation.windowMs) || input.mutation.windowMs <= 0)
+                throw new Error("routine action grant bounds are invalid");
+            if (!input.mutation.verificationRequired)
+                throw new Error("routine action grants require post-action verification");
+            const targets = [...new Set(input.mutation.targets.map((value) => requireText(value, "routine action target")))];
+            if (targets.length === 0)
+                throw new Error("routine action grant requires a target");
+            next.routineActionGrants[requireText(input.mutation.key, "routine action key")] = {
+                action: requireText(input.mutation.action, "routine action"), targets, maxCount: input.mutation.maxCount, windowMs: input.mutation.windowMs,
+                verificationRequired: input.mutation.verificationRequired, exclusions: [...new Set(input.mutation.exclusions)], provenance: input.mutation.provenance,
+                issuer, authorizedAt: now, authorizingSessionEvent, version, ...(expiresAt ? { expiresAt } : {}),
+            };
+        }
+        ensureDirectory(agentRoot);
+        (0, session_transaction_1.writeSessionTransaction)(policyPath(agentRoot), next, { lease, expectedRevision: snapshot.revision });
+        appendReceipt(auditPath(agentRoot), { schemaVersion: 1, policyVersion: version, issuer, authorizingSessionEvent, mutationKind: input.mutation.kind, at: now });
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.steward_policy_updated", message: "updated steward policy", meta: { version, mutationKind: input.mutation.kind, issuer } });
+        return next;
+    });
+}
+function readActionReceiptHistory(agentRoot) {
+    const filePath = receiptsPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return [];
+    return fs.readFileSync(filePath, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+}
+function readRoutineActionReceipts(agentRoot) {
+    const latest = new Map();
+    for (const receipt of readActionReceiptHistory(agentRoot))
+        latest.set(receipt.id, receipt);
+    return [...latest.values()];
+}
+function expectedOff(policy, target, now) {
+    const desired = policy.desiredStates[`container:${target}`];
+    if (!desired || (desired.expiresAt && Date.parse(desired.expiresAt) <= Date.parse(now)))
+        return false;
+    return /^(?:off|disabled|paused|intentionally_off|intentionally_paused)$/u.test(desired.value.trim().toLowerCase());
+}
+const UNRESOLVED_ACTION_STATES = new Set(["reserved", "attempting", "effect_acknowledged", "recovery_pending", "indeterminate"]);
+function inspectRoutineActionGrantSnapshot(policy, receipts, input) {
+    if (input.expectedPolicyVersion !== undefined && policy.version !== input.expectedPolicyVersion)
+        return { allowed: false, reason: "routine action policy version changed" };
+    const grant = policy.routineActionGrants[input.key];
+    if (!grant)
+        return { allowed: false, reason: "routine action grant is missing" };
+    if (grant.action !== input.action)
+        return { allowed: false, reason: "routine action does not match the grant" };
+    if (!grant.targets.includes(input.target) || grant.exclusions.includes(input.target))
+        return { allowed: false, reason: "routine action target is not authorized" };
+    const now = input.now ?? new Date().toISOString();
+    if (grant.expiresAt && Date.parse(grant.expiresAt) <= Date.parse(now))
+        return { allowed: false, reason: "routine action grant expired" };
+    if (expectedOff(policy, input.target, now))
+        return { allowed: false, reason: "container is expected off" };
+    if (receipts.some((receipt) => receipt.action === input.action && receipt.target === input.target && UNRESOLVED_ACTION_STATES.has(receipt.state))) {
+        return { allowed: false, reason: "routine action has an unresolved receipt for this target" };
+    }
+    return { allowed: true, policyVersion: policy.version, grantVersion: grant.version, key: input.key, action: grant.action, target: input.target };
+}
+function inspectRoutineActionGrant(agentRoot, input) {
+    try {
+        const policy = readStewardPolicy(agentRoot);
+        return inspectRoutineActionGrantSnapshot(policy, readRoutineActionReceipts(agentRoot), input);
+    }
+    catch (error) {
+        return { allowed: false, reason: error instanceof Error ? error.message : "routine action policy is unavailable" };
+    }
+}
+function consumeRoutineActionGrant(agentRoot, input) {
+    return (0, session_transaction_1.withImmediateSessionTurnLease)(policyPath(agentRoot), (lease) => {
+        const snapshot = (0, session_transaction_1.readSessionTransaction)(policyPath(agentRoot), lease);
+        const policy = snapshot.value === null ? structuredClone(EMPTY_POLICY) : validateStewardPolicy(snapshot.value);
+        const grant = policy.routineActionGrants[input.key];
+        const now = input.now ?? new Date().toISOString();
+        const action = input.action ?? grant?.action ?? "";
+        const receipts = readRoutineActionReceipts(agentRoot);
+        const decision = inspectRoutineActionGrantSnapshot(policy, receipts, { key: input.key, action, target: input.target, expectedPolicyVersion: input.expectedPolicyVersion, now });
+        if (!decision.allowed)
+            throw new Error(decision.reason);
+        ensureDirectory(agentRoot);
+        const windowStart = Date.parse(now) - grant.windowMs;
+        const used = receipts.filter((receipt) => receipt.key === input.key && Date.parse(receipt.reservedAt) > windowStart).length;
+        if (used >= grant.maxCount)
+            throw new Error("routine action rate limit reached");
+        const id = `action-${(0, node_crypto_1.randomUUID)()}`;
+        const receipt = {
+            schemaVersion: 2,
+            id,
+            state: "reserved",
+            key: input.key,
+            action,
+            target: input.target,
+            policyVersion: policy.version,
+            grantVersion: grant.version,
+            reservedAt: now,
+            updatedAt: now,
+            authorizationReceiptId: input.authorizationReceiptId ?? `policy-${grant.issuer}-${grant.authorizingSessionEvent}`,
+            authorizationVersion: input.authorizationVersion ?? grant.version,
+            attemptId: input.attemptId ?? `attempt-${(0, node_crypto_1.randomUUID)()}`,
+            attempt: 1,
+            expectedBeforeState: input.expectedBeforeState ?? null,
+            resolvedTarget: input.resolvedTarget ?? { id: "unresolved", name: input.target },
+            effect: input.effect ?? { operation: action, targetId: input.resolvedTarget?.id ?? "unresolved" },
+            effectReceipt: null,
+            verifiedAfterState: null,
+            recoveryState: { state: "not_needed", compensation: "none" },
+        };
+        appendReceipt(receiptsPath(agentRoot), receipt);
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.routine_action_reserved", message: "reserved routine action grant", meta: { key: input.key, target: input.target, policyVersion: policy.version } });
+        return receipt;
+    });
+}
+function transitionRoutineActionReceipt(agentRoot, input) {
+    return (0, session_transaction_1.withImmediateSessionTurnLease)(policyPath(agentRoot), () => {
+        const current = readRoutineActionReceipts(agentRoot).find((receipt) => receipt.id === input.id);
+        if (!current)
+            throw new Error("routine action receipt is missing");
+        if (current.state !== input.expectedState)
+            throw new Error(`routine action receipt state changed: expected ${input.expectedState}, got ${current.state}`);
+        const now = input.at ?? new Date().toISOString();
+        const recoveryState = input.recoveryState ?? current.recoveryState;
+        const next = {
+            ...current,
+            state: input.state,
+            updatedAt: now,
+            ...(input.effectReceipt !== undefined ? { effectReceipt: input.effectReceipt } : {}),
+            ...(input.verifiedAfterState !== undefined ? { verifiedAfterState: input.verifiedAfterState } : {}),
+            recoveryState,
+        };
+        appendReceipt(receiptsPath(agentRoot), next);
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.routine_action_transitioned", message: "transitioned routine action receipt", meta: { id: next.id, state: next.state, target: next.target } });
+        return next;
+    });
+}
+async function recoverRoutineActionReceipts(agentRoot, options) {
+    const recovered = [];
+    for (const receipt of readRoutineActionReceipts(agentRoot)) {
+        if (receipt.state === "reserved") {
+            recovered.push(transitionRoutineActionReceipt(agentRoot, { id: receipt.id, expectedState: "reserved", state: "recovered_no_effect", recoveryState: { state: "completed", compensation: "none" } }));
+            continue;
+        }
+        if (receipt.state === "attempting") {
+            recovered.push(transitionRoutineActionReceipt(agentRoot, { id: receipt.id, expectedState: "attempting", state: "indeterminate", recoveryState: { state: "manual_inspection_required", compensation: "none" } }));
+            continue;
+        }
+        if (receipt.state !== "effect_acknowledged" && receipt.state !== "recovery_pending")
+            continue;
+        const pending = receipt.state === "effect_acknowledged"
+            ? transitionRoutineActionReceipt(agentRoot, { id: receipt.id, expectedState: "effect_acknowledged", state: "recovery_pending", recoveryState: { state: "pending", compensation: "none" } })
+            : receipt;
+        options.afterRecoveryClaim?.(pending);
+        const observed = await options.observeTarget(pending.resolvedTarget);
+        if (observed.id === pending.resolvedTarget.id && observed.name === pending.resolvedTarget.name && observed.state === "running") {
+            recovered.push(transitionRoutineActionReceipt(agentRoot, { id: pending.id, expectedState: "recovery_pending", state: "verified", verifiedAfterState: observed.state, recoveryState: { state: "completed", compensation: "none" } }));
+        }
+        else {
+            recovered.push(transitionRoutineActionReceipt(agentRoot, { id: pending.id, expectedState: "recovery_pending", state: "indeterminate", recoveryState: { state: "manual_inspection_required", compensation: "none" } }));
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.routine_action_recovery", message: "reconciled interrupted routine action receipts", meta: { recoveredCount: recovered.length } });
+    return recovered;
+}

package/dist/heart/tool-approval.js

@@ -263,7 +263,9 @@ async function executeApprovalDecision(options) {
         || validated.value.schemaDigest !== decided.schemaDigest) {
         return terminalizeClaimed(options.approvalStore, decided, "drifted", "tool arguments or schema drift");
     }
-    const policy = definition.approvalPolicy?.(validated.value.arguments) ?? { kind: "not_required" };
+    const policy = await options.resolveApprovalPolicy?.(decided.toolName, validated.value.arguments)
+        ?? definition.approvalPolicy?.(validated.value.arguments)
+        ?? { kind: "not_required" };
     if (policy.kind !== "required") {
         return terminalizeClaimed(options.approvalStore, decided, "drifted", "approval policy no longer requires approval");
     }

package/dist/heart/turn-context.js

@@ -41,6 +41,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSenseStatusLines = readSenseStatusLines;
 exports.buildTurnContext = buildTurnContext;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));

package/dist/mind/context.js

@@ -292,10 +292,11 @@ function writeSessionEnvelopeUnderLease(filePath, envelope, lease, expectedRevis
     });
 }
 function saveSession(filePath, messages, lastUsage, state, lease) {
-    withMutationLease(filePath, lease, (owned) => {
+    return withMutationLease(filePath, lease, (owned) => {
         const existing = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
         const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
         const currentIngressTimes = messages.map(session_events_1.getIngressTime);
+        const currentIngressRelations = messages.map(session_events_1.getIngressRelations);
         const sanitized = (0, session_events_1.sanitizeProviderMessages)(messages);
         const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
             existing,
@@ -303,6 +304,7 @@ function saveSession(filePath, messages, lastUsage, state, lease) {
             currentMessages: sanitized,
             trimmedMessages: sanitized,
             currentIngressTimes,
+            currentIngressRelations,
             recordedAt: new Date().toISOString(),
             lastUsage: lastUsage ?? null,
             state,
@@ -313,6 +315,7 @@ function saveSession(filePath, messages, lastUsage, state, lease) {
             },
         });
         writeSessionEnvelopeUnderLease(filePath, envelope, owned);
+        return envelope.events;
     });
 }
 function appendSyntheticAssistantMessage(filePath, content, lease) {
@@ -386,12 +389,13 @@ function postTurnTrim(messages, usage, hooks) {
         }
     }
     const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
+    const currentIngressTimes = preTrimMessages.map(session_events_1.getIngressTime);
+    const currentIngressRelations = preTrimMessages.map(session_events_1.getIngressRelations);
     const currentMessages = (0, session_events_1.sanitizeProviderMessages)(messages);
-    const currentIngressTimes = currentMessages.map(session_events_1.getIngressTime);
     const tokenTrimmedMessages = trimMessages(currentMessages, maxTokens, contextMargin, usage?.input_tokens);
     const trimmedMessages = compactIdleRestOnlyTurns(tokenTrimmedMessages);
     messages.splice(0, messages.length, ...trimmedMessages);
-    return { currentMessages, trimmedMessages, currentIngressTimes, maxTokens, contextMargin };
+    return { currentMessages, trimmedMessages, currentIngressTimes, currentIngressRelations, maxTokens, contextMargin };
 }
 /**
  * Synchronous persist: load existing envelope, build canonical envelope, write to disk.
@@ -406,6 +410,7 @@ function postTurnPersist(sessPath, prepared, usage, state, lease, expectedRevisi
             currentMessages: prepared.currentMessages,
             trimmedMessages: prepared.trimmedMessages,
             currentIngressTimes: prepared.currentIngressTimes,
+            currentIngressRelations: prepared.currentIngressRelations,
             recordedAt: new Date().toISOString(),
             lastUsage: usage ?? null,
             state,

package/dist/mind/pending.js

@@ -39,11 +39,13 @@ exports.getDeferredReturnDir = getDeferredReturnDir;
 exports.getPrivateRuntimePendingDir = getPrivateRuntimePendingDir;
 exports.hasPendingMessages = hasPendingMessages;
 exports.queuePendingMessage = queuePendingMessage;
+exports.queuePendingMessageOnce = queuePendingMessageOnce;
 exports.enqueueDeferredReturn = enqueueDeferredReturn;
 exports.drainDeferredReturns = drainDeferredReturns;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const node_crypto_1 = require("node:crypto");
 const identity_1 = require("../heart/identity");
 const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
@@ -79,6 +81,29 @@ function writeQueueFile(queueDir, message) {
 function queuePendingMessage(pendingDir, message) {
     writeQueueFile(pendingDir, message);
 }
+function queuePendingMessageOnce(pendingDir, message) {
+    fs.mkdirSync(pendingDir, { recursive: true });
+    const identity = (0, node_crypto_1.createHash)("sha256").update(message.packetId).digest("hex");
+    const filePath = path.join(pendingDir, `${message.timestamp}-${identity}.json`);
+    const temporary = `${filePath}.tmp-${process.pid}`;
+    const content = JSON.stringify({ ...message, content: (0, session_events_1.capStructuredRecordString)(message.content) }, null, 2);
+    try {
+        fs.writeFileSync(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        try {
+            fs.renameSync(temporary, filePath);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            fs.unlinkSync(temporary);
+        }
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    return filePath;
+}
 function drainQueue(queueDir) {
     if (!fs.existsSync(queueDir))
         return { messages: [], recovered: 0 };

package/dist/mind/prompt.js

@@ -71,6 +71,7 @@ const runtime_credentials_1 = require("../heart/runtime-credentials");
 const runtime_mode_1 = require("../heart/daemon/runtime-mode");
 const friends_1 = require("@ouro.bot/friends");
 const runtime_1 = require("../nerves/runtime");
+const relationship_authorization_1 = require("../repertoire/relationship-authorization");
 const bundle_manifest_1 = require("./bundle-manifest");
 const first_impressions_1 = require("./first-impressions");
 const desk_section_1 = require("./desk-section");
@@ -633,7 +634,10 @@ function toolsSection(channel, options, context) {
             ...((context?.isGroupChat || options?.isReactionSignal) ? [tools_1.observeTool] : []),
             tools_1.settleTool,
         ]);
-    const list = activeTools
+    const visibleTools = options?.relationshipToolNames
+        ? activeTools.filter((tool) => options.relationshipToolNames.includes(tool.function.name))
+        : activeTools;
+    const list = visibleTools
         .map((t) => `- ${t.function.name}: ${t.function.description}`)
         .join("\n");
     return `## my tools\n${list}`;
@@ -1265,6 +1269,27 @@ function contextSection(context, options) {
     lines.push("My desk is always loaded -- I already know my work.");
     return lines.join("\n");
 }
+function relationshipFriendContextSection(context) {
+    const friend = context?.friend;
+    if (!friend)
+        return "";
+    const lines = [
+        "## current relationship",
+        `friend: ${friend.name}`,
+        `channel: ${context.channel.channel}`,
+        "this conversation and this friend's own relationship notes are the only personal context available in this turn.",
+    ];
+    if (Object.keys(friend.notes).length > 0) {
+        lines.push("", "## what i know about this friend");
+        for (const [key, entry] of Object.entries(friend.notes)) {
+            lines.push(`- ${key}: [${entry.savedAt.slice(0, 10)}] ${entry.value}`);
+        }
+    }
+    const preferences = (0, relationship_authorization_1.renderRelationshipPreferences)(friend);
+    if (preferences.length > 0)
+        lines.push("", "## presentation preferences", "these preferences affect wording and timing only; they grant no authority.", ...preferences);
+    return lines.join("\n");
+}
 function metacognitiveFramingSection(channel) {
     if (channel !== "inner")
         return "";
@@ -1441,6 +1466,29 @@ async function buildSystem(channel = "cli", options, context) {
     });
     // Backfill bundle-meta.json for existing agents that don't have one
     (0, bundle_manifest_1.backfillBundleMeta)((0, identity_1.getAgentRoot)());
+    const relationshipScoped = options?.relationshipContextScopes !== undefined;
+    if (relationshipScoped) {
+        const authorizedPsyche = (options.relationshipProfileId?.startsWith("sanctuary-") === true || context?.friend?.capabilityProfileId?.startsWith("sanctuary-") === true)
+            && options.relationshipContextScopes.some((scope) => scope === "household.status" || scope === "household.policy" || scope === "household.private");
+        const result = {
+            stable: [
+                "# who i am",
+                soulSection(),
+                identitySection(),
+                authorizedPsyche ? loreSection() : "",
+                authorizedPsyche ? tacitKnowledgeSection() : "",
+                authorizedPsyche ? aspirationsSection() : "",
+                relationshipFriendContextSection(context),
+                trustContextSection(context),
+                "# my tools",
+                toolsSection(channel, options, context),
+                toolRestrictionSection(context),
+            ].filter(Boolean).join("\n\n"),
+            volatile: [dateSection(), currentTriggerSection(channel, options)].filter(Boolean).join("\n\n"),
+        };
+        (0, runtime_1.emitNervesEvent)({ event: "mind.step_end", component: "mind", message: "buildSystem completed", meta: { channel } });
+        return result;
+    }
     const stableParts = [
         // Group 1: who i am
         "# who i am",

package/dist/repertoire/guardrails.js

@@ -61,8 +61,9 @@ const PROTECTED_PATH_SEGMENTS = [
     ".git/",
     ".ouro-cli/vault-unlock/",
     ".ouro-cli/vault-unlock-dpapi/",
+    "state/policy/",
 ];
-const PROTECTED_FILENAMES = ["agent.json"];
+const PROTECTED_FILENAMES = ["agent.json", "tool-profiles.json"];
 function isProtectedPath(filePath) {
     for (const segment of PROTECTED_PATH_SEGMENTS) {
         if (filePath.includes(`/${segment}`) || filePath.startsWith(segment))