@ouro.bot/cli 0.1.0-alpha.814 → 0.1.0-alpha.816

package/dist/repertoire/relationship-authorization.js

@@ -33,6 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.routineActionRequester = routineActionRequester;
+exports.authorizeRestartApprovalRequester = authorizeRestartApprovalRequester;
+exports.authorizeRoutineActionRequester = authorizeRoutineActionRequester;
 exports.renderRelationshipPreferences = renderRelationshipPreferences;
 exports.withRelationshipPreference = withRelationshipPreference;
 exports.loadRelationshipCapabilityRegistry = loadRelationshipCapabilityRegistry;
@@ -43,7 +46,132 @@ exports.authorizeRelationshipAccess = authorizeRelationshipAccess;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const router_1 = require("../heart/external-events/router");
 const runtime_1 = require("../nerves/runtime");
+function routineActionRequester(ctx, eventTarget) {
+    const relationship = ctx?.relationshipAuthorization;
+    if (!relationship)
+        return null;
+    if (ctx?.currentExternalEvent) {
+        if (!eventTarget || relationship.profileId !== "sanctuary-event")
+            return null;
+        const events = [ctx.currentExternalEvent, ...(ctx.currentExternalEvent.relatedEvents ?? [])].filter((event) => event.schemaVersion === 1 && event.source === "sanctuary-health" && event.eventId === `container:${eventTarget.target.id}:availability`);
+        if (events.length !== 1)
+            return null;
+        const event = events[0];
+        return {
+            kind: "owner_event", friendId: eventTarget.friendId, profileId: relationship.profileId,
+            event: { schemaVersion: 1, recordPath: event.recordPath, agent: event.agent, source: event.source, eventId: event.eventId, generation: event.generation, observationRevision: event.observationRevision, claimOwner: event.claimOwner },
+            target: { ...eventTarget.target },
+        };
+    }
+    const actor = relationship.actor;
+    const session = ctx?.currentSession;
+    if (!actor || !session || session.channel !== "telegram" || session.friendId !== actor.friendId
+        || [actor.friendId, actor.sessionEventId, relationship.requestId, session.key].some((value) => typeof value !== "string" || !value.trim()))
+        return null;
+    const kind = actor.trustLevel === "family" && relationship.profileId === "sanctuary-owner" ? "owner"
+        : actor.trustLevel === "friend" && relationship.profileId === "sanctuary-household" ? "household_request" : null;
+    if (!kind)
+        return null;
+    return { kind, friendId: actor.friendId, profileId: relationship.profileId, requestId: relationship.requestId, sessionEventId: actor.sessionEventId, origin: { friendId: session.friendId, channel: session.channel, key: session.key } };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function authorizeRestartApprovalRequester(ctx, args, binding) {
+    return authorizeRoutineActionRequester(ctx, args, {
+        requester: {
+            kind: "owner", friendId: binding.friendId, profileId: "sanctuary-owner", requestId: binding.requestId,
+            sessionEventId: binding.sessionEventId, origin: { friendId: binding.friendId, channel: "telegram", key: binding.sessionKey },
+        },
+        profileVersion: binding.profileVersion,
+    });
+}
+async function authorizeRoutineActionRequester(ctx, args, expected) {
+    if (!isRecord(args) || Object.keys(args).length !== 1 || typeof args.container !== "string"
+        || !args.container || args.container !== args.container.trim() || Buffer.byteLength(args.container) > 128 || args.container.includes("\uFFFD")
+        || !ctx?.agentRoot || !ctx.relationshipAuthorization)
+        return { allowed: false, reason: "routine action requires one exact target and current relationship" };
+    const target = args.container;
+    const agentRoot = ctx.agentRoot;
+    const relationship = ctx.relationshipAuthorization;
+    const sanctuary = ctx.sanctuary;
+    const initialRequester = routineActionRequester(ctx);
+    const event = ctx.currentExternalEvent && structuredClone(ctx.currentExternalEvent);
+    if (!initialRequester && (!event || event.source !== "sanctuary-health" || relationship.profileId !== "sanctuary-event"))
+        return { allowed: false, reason: "routine action requires a current human request or health event" };
+    const unchanged = () => ctx.agentRoot === agentRoot && ctx.relationshipAuthorization === relationship && ctx.sanctuary === sanctuary
+        && args.container === target && Object.keys(args).length === 1
+        && (0, node_util_1.isDeepStrictEqual)(initialRequester, routineActionRequester(ctx)) && (0, node_util_1.isDeepStrictEqual)(event, ctx.currentExternalEvent);
+    let authorization;
+    try {
+        authorization = await relationship.authorizeTool("unraid_restart_container", { container: target });
+    }
+    catch {
+        return { allowed: false, reason: "routine relationship authorization is unavailable" };
+    }
+    if (!authorization?.allowed)
+        return { allowed: false, reason: authorization?.allowed === false ? authorization.reason : "routine relationship authorization is unavailable" };
+    if (typeof authorization.profileVersion !== "number" || !Number.isSafeInteger(authorization.profileVersion) || authorization.profileVersion < 1
+        || typeof authorization.receiptId !== "string" || !authorization.receiptId.trim())
+        return { allowed: false, reason: "routine relationship authorization is not versioned" };
+    if (expected && authorization.profileVersion !== expected.profileVersion)
+        return { allowed: false, reason: "routine relationship profile version changed" };
+    if (!unchanged() || (authorization.profileId !== undefined && authorization.profileId !== relationship.profileId))
+        return { allowed: false, reason: "routine request binding changed during authorization" };
+    if (!event) {
+        if (!initialRequester || initialRequester.kind === "owner_event"
+            || (authorization.friendId !== undefined && authorization.friendId !== initialRequester.friendId)
+            || (authorization.requestId !== undefined && authorization.requestId !== initialRequester.requestId)
+            || (expected && !(0, node_util_1.isDeepStrictEqual)(expected.requester, initialRequester)))
+            return { allowed: false, reason: "routine request binding does not match live authorization" };
+        return { allowed: true, requester: initialRequester, receiptId: authorization.receiptId, profileVersion: authorization.profileVersion };
+    }
+    if (!sanctuary || authorization.profileId !== "sanctuary-event" || typeof authorization.friendId !== "string" || !authorization.friendId.trim())
+        return { allowed: false, reason: "current health event authorization is unavailable" };
+    let eventTarget;
+    if (expected) {
+        if (expected.requester.kind !== "owner_event" || expected.requester.target.name !== target)
+            return { allowed: false, reason: "current health event target binding changed" };
+        eventTarget = expected.requester.target;
+    }
+    else {
+        let listed;
+        try {
+            listed = await sanctuary.listContainers();
+        }
+        catch {
+            return { allowed: false, reason: "current health event container status is unavailable" };
+        }
+        if (!isRecord(listed) || listed.ok !== true || !isRecord(listed.data) || listed.data.truncated !== false || !Array.isArray(listed.data.containers))
+            return { allowed: false, reason: "current health event container status is invalid" };
+        const matches = listed.data.containers.filter((value) => isRecord(value) && value.name === target);
+        const container = matches[0];
+        if (matches.length !== 1 || !container || typeof container.id !== "string" || !container.id.trim()
+            || container.state !== "exited" || container.degraded !== false)
+            return { allowed: false, reason: "current health event target is not exactly stopped" };
+        eventTarget = { id: container.id, name: target };
+    }
+    const requester = routineActionRequester(ctx, { friendId: authorization.friendId, target: eventTarget });
+    if (!requester || requester.kind !== "owner_event" || !unchanged() || (expected && !(0, node_util_1.isDeepStrictEqual)(expected.requester, requester)))
+        return { allowed: false, reason: "current health event target or request binding changed" };
+    let current;
+    try {
+        current = (0, router_1.readExternalEventRecord)(requester.event.recordPath);
+    }
+    catch {
+        return { allowed: false, reason: "current health event record is unavailable" };
+    }
+    const lease = requester.event;
+    if (current.agent !== lease.agent || current.source !== lease.source || current.eventId !== lease.eventId || current.eventType !== "health.observed"
+        || current.generation !== lease.generation || current.observationRevision !== lease.observationRevision || current.claimOwner !== lease.claimOwner
+        || current.executionState !== "running" || !(Date.parse(current.claimExpiresAt ?? "") > Date.now())
+        || current.transition === "recovered" || current.pendingObservation !== null)
+        return { allowed: false, reason: "current health event claim or observation changed" };
+    return { allowed: true, requester, receiptId: authorization.receiptId, profileVersion: authorization.profileVersion };
+}
 function renderRelationshipPreferences(friend) {
     const now = Date.now();
     return Object.entries(friend.relationshipPolicy?.preferences ?? {})

package/dist/repertoire/tools-base.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = exports.renderInnerProgressStatus = exports.speakTool = exports.restTool = exports.settleTool = exports.observeTool = exports.ponderTool = void 0;
-exports.routineActionRequester = routineActionRequester;
+exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = exports.routineActionRequester = exports.renderInnerProgressStatus = exports.speakTool = exports.restTool = exports.settleTool = exports.observeTool = exports.ponderTool = void 0;
+exports.routineActionDenied = routineActionDenied;
+const runtime_1 = require("../nerves/runtime");
 const tools_files_1 = require("./tools-files");
 const tools_shell_1 = require("./tools-shell");
 const tools_notes_1 = require("./tools-notes");
@@ -40,17 +41,12 @@ Object.defineProperty(exports, "speakTool", { enumerable: true, get: function ()
 // Re-export renderInnerProgressStatus for consumers
 var tools_session_2 = require("./tools-session");
 Object.defineProperty(exports, "renderInnerProgressStatus", { enumerable: true, get: function () { return tools_session_2.renderInnerProgressStatus; } });
-function routineActionRequester(ctx) {
-    const actor = ctx?.relationshipAuthorization?.actor;
-    if (!actor)
-        return null;
-    if (actor.trustLevel === "family")
-        return { kind: "owner", friendId: actor.friendId };
-    const requestId = ctx?.relationshipAuthorization?.requestId;
-    const session = ctx?.currentSession;
-    if (actor.trustLevel !== "friend" || !requestId || !session || session.friendId !== actor.friendId)
-        return null;
-    return { kind: "household_request", friendId: actor.friendId, requestId, origin: { friendId: session.friendId, channel: session.channel, key: session.key } };
+var relationship_authorization_1 = require("./relationship-authorization");
+Object.defineProperty(exports, "routineActionRequester", { enumerable: true, get: function () { return relationship_authorization_1.routineActionRequester; } });
+function routineActionDenied(reason) {
+    const message = reason.slice(0, 500);
+    (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.routine_action_denied", message: "routine action denied", meta: { reason: message } });
+    return JSON.stringify({ ok: false, error: { code: "routine_action_denied", message, degraded: true } });
 }
 // Tracks which file paths have been read via read_file in this session.
 // edit_file requires a file to be read first (must-read-first guard).

package/dist/repertoire/tools-steward-policy.js

@@ -16,7 +16,7 @@ exports.stewardPolicyToolDefinition = {
         type: "function",
         function: {
             name: "steward_policy_manage",
-            description: "Read or update the household steward's typed desired-state and routine-action policy. Updates require the current authenticated family request. expectedVersion is optional; omit it to apply against the current policy version, or supply a version from read for explicit stale-write detection.",
+            description: "Read or update the household steward's typed desired-state and routine-action policy. Updates require the current authenticated owner Telegram request and fresh authorization. expectedVersion is optional; omit it to apply against the current policy version, or supply a version from read for explicit stale-write detection.",
             parameters: {
                 type: "object",
                 properties: {
@@ -48,13 +48,20 @@ exports.stewardPolicyToolDefinition = {
             (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.steward_policy_tool_call", message: "read steward policy", meta: { action: "read" } });
             return JSON.stringify((0, steward_policy_1.readStewardPolicy)(ctx.agentRoot));
         }
-        const actor = ctx.relationshipAuthorization?.actor;
+        const relationship = ctx.relationshipAuthorization;
+        const actor = relationship.actor;
         if (!actor)
             throw new Error("steward policy mutation requires authenticated relationship authority");
-        const expectedVersion = args.expectedVersion === undefined
-            ? (0, steward_policy_1.readStewardPolicy)(ctx.agentRoot).version
-            : Number(args.expectedVersion);
-        if (!Number.isInteger(expectedVersion) || expectedVersion < 0)
+        const { friendId, trustLevel, sessionEventId } = actor;
+        const { profileId, requestId } = relationship;
+        const sessionKey = ctx.currentSession?.key;
+        if (trustLevel !== "family" || profileId !== "sanctuary-owner" || typeof requestId !== "string" || !requestId.trim()
+            || typeof sessionKey !== "string" || !sessionKey.trim() || !sessionEventId.trim()
+            || ctx.currentSession?.friendId !== friendId || ctx.currentSession.channel !== "telegram" || ctx.currentExternalEvent) {
+            throw new Error("steward policy mutation requires a current authenticated owner Telegram request and session");
+        }
+        const expectedVersion = args.expectedVersion === undefined ? undefined : Number(args.expectedVersion);
+        if (expectedVersion !== undefined && (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0))
             throw new Error("expectedVersion must be a nonnegative integer");
         let mutation;
         if (args.action === "set_desired_state") {
@@ -85,11 +92,28 @@ exports.stewardPolicyToolDefinition = {
         }
         else
             throw new Error("steward policy action is invalid");
-        const result = (0, steward_policy_1.updateStewardPolicy)(ctx.agentRoot, { expectedVersion, actor, mutation });
-        (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.steward_policy_tool_call", message: "updated steward policy", meta: { action: args.action } });
-        return JSON.stringify(result);
+        const agentRoot = ctx.agentRoot;
+        return Promise.resolve(relationship.authorizeTool("steward_policy_manage", args)).then((authorization) => {
+            if (!authorization.allowed)
+                throw new Error(`steward policy authorization denied: ${authorization.reason}`);
+            if (typeof authorization.profileVersion !== "number" || !Number.isSafeInteger(authorization.profileVersion) || authorization.profileVersion < 1 || !authorization.receiptId.trim()) {
+                throw new Error("steward policy owner authorization is not versioned");
+            }
+            if (ctx.relationshipAuthorization !== relationship || relationship.profileId !== profileId || relationship.requestId !== requestId
+                || relationship.actor?.friendId !== friendId || relationship.actor.trustLevel !== trustLevel || relationship.actor.sessionEventId !== sessionEventId
+                || ctx.currentSession?.friendId !== friendId || ctx.currentSession.key !== sessionKey || ctx.currentSession.channel !== "telegram" || ctx.currentExternalEvent) {
+                throw new Error("steward policy owner authorization or session changed before mutation");
+            }
+            const result = (0, steward_policy_1.updateStewardPolicy)(agentRoot, {
+                expectedVersion: expectedVersion ?? (0, steward_policy_1.readStewardPolicy)(agentRoot).version,
+                actor: { friendId, trustLevel, sessionEventId, authorization: { profileId, requestId, sessionKey, receiptId: authorization.receiptId, profileVersion: authorization.profileVersion } },
+                mutation,
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.steward_policy_tool_call", message: "updated steward policy", meta: { action: args.action } });
+            return JSON.stringify(result);
+        });
     },
     riskProfile: (args) => args.action === "read"
         ? { mutates: "none", risk: "low" }
-        : { mutates: "durable_state_write", risk: "high", reason: "updates typed household steward policy under authenticated family authority" },
+        : { mutates: "durable_state_write", risk: "high", reason: "updates typed household steward policy under current authenticated owner authority" },
 };

package/dist/repertoire/tools-unraid.js

@@ -7,6 +7,8 @@ const node_crypto_1 = require("node:crypto");
 const runtime_1 = require("../nerves/runtime");
 const unraid_client_1 = require("./unraid-client");
 const tools_base_1 = require("./tools-base");
+const relationship_authorization_1 = require("./relationship-authorization");
+const approval_store_1 = require("../heart/approval-store");
 const steward_policy_1 = require("../heart/steward-policy");
 const obligations_1 = require("../arc/obligations");
 exports.SANCTUARY_CONTAINERS_QUERY = `query SanctuaryContainers {
@@ -140,9 +142,11 @@ function liveSourceIdentityDigest(value) {
     return (0, node_crypto_1.createHash)("sha256").update(prefixedId).digest("hex");
 }
 function createUnraidReadTools(client) {
-    const listContainers = async () => {
+    const listContainers = async (signal) => {
         try {
-            const data = await client.read(exports.SANCTUARY_CONTAINERS_QUERY, {});
+            const data = signal
+                ? await client.read(exports.SANCTUARY_CONTAINERS_QUERY, {}, signal)
+                : await client.read(exports.SANCTUARY_CONTAINERS_QUERY, {});
             return { ok: true, data: mapContainers(data) };
         }
         catch (error) {
@@ -309,16 +313,14 @@ const emptyParameters = { type: "object", properties: {}, additionalProperties:
 function missingRuntime() {
     return JSON.stringify({ ok: false, error: { code: "invalid_response", message: "Sanctuary runtime is unavailable", degraded: true } });
 }
-function householdRepairObligation(ctx, target) {
-    const requester = (0, tools_base_1.routineActionRequester)(ctx);
-    if (requester?.kind !== "household_request")
+function householdRepairObligation(selection, target) {
+    if (selection?.kind !== "standing" || selection.requester.kind !== "household_request")
         return null;
-    if (!ctx.agentRoot)
-        throw new Error("household repair request tracking is unavailable");
-    const existing = (0, obligations_1.findPendingObligationForRequest)(ctx.agentRoot, { requestId: requester.requestId, owedTo: requester.origin });
+    const { agentRoot, requester } = selection;
+    const existing = (0, obligations_1.findPendingObligationForRequest)(agentRoot, { requestId: requester.requestId, owedTo: requester.origin });
     if (existing)
         return existing;
-    return (0, obligations_1.createObligation)(ctx.agentRoot, {
+    return (0, obligations_1.createObligation)(agentRoot, {
         origin: requester.origin,
         owedTo: requester.origin,
         requestId: requester.requestId,
@@ -328,12 +330,12 @@ function householdRepairObligation(ctx, target) {
         nextAction: `Restart ${target} under the Butler's standing grant and verify recovery`,
     });
 }
-async function runTrackedRestart(ctx, target, routine) {
-    const obligation = householdRepairObligation(ctx, target);
+async function runTrackedRestart(ctx, target, execution) {
+    const obligation = householdRepairObligation(ctx.routineActionSelection, target);
     if (obligation && ctx.agentRoot)
         (0, obligations_1.advanceObligation)(ctx.agentRoot, obligation.id, { status: "updating_runtime", latestNote: `Starting the requested restart of ${target}` });
     try {
-        const result = await ctx.sanctuary.restartContainer({ container: target }, routine ? { routine } : undefined);
+        const result = await ctx.sanctuary.restartContainer({ container: target }, execution);
         if (obligation && ctx.agentRoot) {
             const succeeded = !!result && typeof result === "object" && !Array.isArray(result) && result.ok === true;
             if (succeeded)
@@ -439,33 +441,78 @@ exports.unraidToolDefinitions = [
             },
         },
         handler: async (args, ctx) => {
+            if (ctx?.routineActionSelection?.kind === "denied")
+                return (0, tools_base_1.routineActionDenied)(ctx.routineActionSelection.reason);
             if (!ctx?.sanctuary)
                 return missingRuntime();
+            if (!ctx.routineActionSelection && !ctx.restartApproval && (ctx.relationshipAuthorization || ctx.currentExternalEvent))
+                return (0, tools_base_1.routineActionDenied)("routine action requires its standing selection or owner approval");
             const target = String(args.container);
-            let routine;
+            let execution;
+            if (ctx.restartApproval) {
+                const approval = ctx.restartApproval;
+                const unchanged = () => ctx.restartApproval === approval && !ctx.routineActionSelection && !ctx.currentExternalEvent
+                    && ctx.agentRoot === approval.agentRoot && !!approval.ownerBinding && !!approval.target && approval.target.name === target
+                    && !!approval.sessionPath && ctx.currentSession?.sessionPath === approval.sessionPath;
+                const reauthorize = async () => {
+                    if (!unchanged())
+                        return { allowed: false, reason: "restart approval binding changed" };
+                    const authorization = await (0, relationship_authorization_1.authorizeRestartApprovalRequester)(ctx, args, approval.ownerBinding);
+                    if (!authorization.allowed)
+                        return authorization;
+                    if (!unchanged())
+                        return { allowed: false, reason: "restart approval binding changed" };
+                    if ((0, approval_store_1.canonicalApprovalArguments)(args).digest !== approval.argumentDigest)
+                        return { allowed: false, reason: "restart approval arguments changed" };
+                    return authorization;
+                };
+                const authorization = await reauthorize();
+                if (!authorization.allowed)
+                    return (0, tools_base_1.routineActionDenied)(authorization.reason);
+                execution = {
+                    approval: {
+                        target: approval.target,
+                        reauthorize: async () => {
+                            const current = await reauthorize();
+                            if (!current.allowed)
+                                return current;
+                            const decision = (0, steward_policy_1.inspectRoutineActionGrant)(approval.agentRoot, {
+                                key: `unraid.restart:${target}`, action: "unraid.container.restart", target,
+                                requester: current.requester, authorizationVersion: current.profileVersion,
+                            });
+                            if (decision.allowed || !decision.approvalFallback)
+                                return { allowed: false, reason: decision.allowed ? "restart approval no longer has owner fallback" : decision.reason };
+                            return { allowed: true };
+                        },
+                    },
+                };
+            }
             if (ctx.routineActionSelection) {
-                if (!ctx.agentRoot || !(0, tools_base_1.routineActionRequester)(ctx))
-                    return JSON.stringify({ ok: false, error: { code: "approval_required", message: "routine action authorization is unavailable", degraded: true } });
-                const { key, expectedPolicyVersion } = ctx.routineActionSelection;
+                if (!ctx.agentRoot)
+                    return (0, tools_base_1.routineActionDenied)("routine action authorization is unavailable");
+                if (ctx.agentRoot !== ctx.routineActionSelection.agentRoot)
+                    return (0, tools_base_1.routineActionDenied)("routine action agent root changed");
+                const { key, expectedPolicyVersion, expectedDesiredStateVersion, expectedGrantVersion, requester, authorizationVersion } = ctx.routineActionSelection;
                 if (ctx.routineActionSelection.target !== target)
-                    return JSON.stringify({ ok: false, error: { code: "approval_required", message: "routine action arguments changed", degraded: true } });
-                const decision = (0, steward_policy_1.inspectRoutineActionGrant)(ctx.agentRoot, { key, action: "unraid.container.restart", target, expectedPolicyVersion });
+                    return (0, tools_base_1.routineActionDenied)("routine action arguments changed");
+                const decision = (0, steward_policy_1.inspectRoutineActionGrant)(ctx.agentRoot, { key, action: "unraid.container.restart", target, expectedPolicyVersion, expectedDesiredStateVersion, expectedGrantVersion, requester, authorizationVersion });
                 if (!decision.allowed)
-                    return JSON.stringify({ ok: false, error: { code: "approval_required", message: decision.reason, degraded: true } });
-                routine = {
-                    key,
-                    expectedPolicyVersion: decision.policyVersion,
-                    reauthorize: async () => {
-                        const authorization = await ctx.relationshipAuthorization.authorizeTool("unraid_restart_container", { container: target });
-                        if (!authorization.allowed)
-                            return authorization;
-                        if (!Number.isInteger(authorization.profileVersion) || Number(authorization.profileVersion) < 1)
-                            return { allowed: false, reason: "relationship capability profile is not versioned" };
-                        return { allowed: true, receiptId: authorization.receiptId, profileVersion: Number(authorization.profileVersion) };
-                    },
-                };
+                    return (0, tools_base_1.routineActionDenied)(decision.reason);
+                execution = { routine: {
+                        key,
+                        expectedPolicyVersion: decision.policyVersion,
+                        expectedDesiredStateVersion: decision.desiredStateVersion,
+                        expectedGrantVersion: decision.grantVersion,
+                        requester: structuredClone(decision.requester),
+                        reauthorize: async () => {
+                            const authorization = await (0, relationship_authorization_1.authorizeRoutineActionRequester)(ctx, { container: target }, { requester, profileVersion: authorizationVersion });
+                            if (!authorization.allowed)
+                                return authorization;
+                            return { allowed: true, receiptId: authorization.receiptId, profileVersion: authorization.profileVersion };
+                        },
+                    } };
             }
-            return JSON.stringify(await runTrackedRestart(ctx, target, routine));
+            return JSON.stringify(await runTrackedRestart(ctx, target, execution));
         },
         riskProfile: { mutates: "external_side_effect", risk: "high", reason: "restarts one existing allowlisted Docker container" },
         approvalPolicy: () => ({

package/dist/repertoire/tools.js

@@ -37,6 +37,7 @@ const tools_unraid_1 = require("./tools-unraid");
 const tools_flow_1 = require("./tools-flow");
 const tools_steward_policy_1 = require("./tools-steward-policy");
 const steward_policy_1 = require("../heart/steward-policy");
+const relationship_authorization_1 = require("./relationship-authorization");
 const tool_approval_1 = require("../heart/tool-approval");
 function safeGetAgentRoot() {
     try {
@@ -200,34 +201,33 @@ function resolveToolDefinition(toolName, selection) {
 function approvalPolicyForToolName(name, args, selection) {
     return resolveToolDefinition(name, selection)?.approvalPolicy?.(args) ?? { kind: "not_required" };
 }
-async function routineActionInvocation(name, args, ctx) {
-    const target = typeof args.container === "string" ? args.container : "";
-    if (name !== "unraid_restart_container" || !ctx?.agentRoot || !(0, tools_base_1.routineActionRequester)(ctx) || !target)
-        return null;
-    const relationshipAuthorization = ctx.relationshipAuthorization;
-    if (!relationshipAuthorization)
-        return null;
-    let authorization;
-    try {
-        authorization = await relationshipAuthorization.authorizeTool(name, args);
-    }
-    catch {
-        return null;
-    }
-    if (!authorization.allowed || !Number.isInteger(authorization.profileVersion) || Number(authorization.profileVersion) < 1)
-        return null;
+async function routineActionInvocation(args, ctx) {
+    const agentRoot = ctx?.agentRoot;
+    const relationship = ctx?.relationshipAuthorization;
+    const sanctuary = ctx?.sanctuary;
+    const target = typeof args?.container === "string" ? args.container : "";
+    const authorization = await (0, relationship_authorization_1.authorizeRoutineActionRequester)(ctx, args);
+    if (!authorization.allowed)
+        return { kind: "denied", reason: authorization.reason };
+    const currentRequester = (0, tools_base_1.routineActionRequester)(ctx, authorization.requester.kind === "owner_event" ? { friendId: authorization.requester.friendId, target: authorization.requester.target } : undefined);
+    if (!ctx || !agentRoot || ctx.agentRoot !== agentRoot || ctx.relationshipAuthorization !== relationship || ctx.sanctuary !== sanctuary
+        || args.container !== target || Object.keys(args).length !== 1 || !(0, node_util_1.isDeepStrictEqual)(currentRequester, authorization.requester))
+        return { kind: "denied", reason: "routine request binding changed after authorization" };
     const key = `unraid.restart:${target}`;
-    const decision = (0, steward_policy_1.inspectRoutineActionGrant)(ctx.agentRoot, { key, action: "unraid.container.restart", target });
-    return decision.allowed ? { key, target, expectedPolicyVersion: decision.policyVersion } : null;
+    const decision = (0, steward_policy_1.inspectRoutineActionGrant)(agentRoot, { key, action: "unraid.container.restart", target, requester: authorization.requester, authorizationVersion: authorization.profileVersion });
+    if (!decision.allowed)
+        return decision.approvalFallback ? null : { kind: "denied", reason: decision.reason };
+    return Object.freeze({ kind: "standing", agentRoot, key, target, expectedPolicyVersion: decision.policyVersion, expectedDesiredStateVersion: decision.desiredStateVersion, expectedGrantVersion: decision.grantVersion, requester: structuredClone(decision.requester), authorizationVersion: decision.authorizationVersion });
 }
 async function classifyApprovalForInvocation(name, args, ctx) {
     const fallback = approvalPolicyForToolName(name, args, ctx?.toolSelection);
     if (name !== "unraid_restart_container" || fallback.kind !== "required")
         return { policy: fallback };
-    const routineActionSelection = await routineActionInvocation(name, args, ctx);
+    const routineActionSelection = await routineActionInvocation(args, ctx);
     return routineActionSelection ? { policy: { kind: "not_required" }, routineActionSelection } : { policy: fallback };
 }
 async function approvalPolicyForInvocation(name, args, ctx) {
+    // An approval requirement is not execution authority; dispatch needs the full classification.
     return (await classifyApprovalForInvocation(name, args, ctx)).policy;
 }
 const findDefinition = resolveToolDefinition;
@@ -334,6 +334,9 @@ async function preflightToolCall(name, args, ctx) {
                 return { kind: "rejected_before_handler", text: `invalid tool arguments: ${validation.reason}` };
         }
         (0, tool_arguments_1.assertRelationshipToolOwner)(ctx);
+        if (name === "unraid_restart_container" && ctx?.routineActionSelection?.kind === "denied") {
+            return { kind: "rejected_before_handler", text: (0, tools_base_1.routineActionDenied)(ctx.routineActionSelection.reason) };
+        }
         const relationship = ctx?.relationshipAuthorization;
         const decision = await relationship?.authorizeTool(name, args);
         if (decision && (!decision.allowed || !relationship.advertisedToolNames.includes(name)