@ouro.bot/cli 0.1.0-alpha.768 → 0.1.0-alpha.769

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.769",
+      "changes": [
+        "Keep stale Sanctuary Care evidence out of current context and require provenance-qualified same-turn Docker verification before reporting or mutation.",
+        "Recognize natural whole-Sanctuary current-status requests and require all seven current reads, including notifications, before a terminal reply.",
+        "Revive provider-lane and managed-runtime external-event dead letters exactly once per generation after typed, newer recovery evidence.",
+        "Let verified fresh Docker alerts be reported while preserving unrelated Care display and policy metadata during partial incident refreshes and constraining durable status values."
+      ]
+    },
     {
       "version": "0.1.0-alpha.768",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.768",
+  "runtimeVersion": "0.1.0-alpha.769",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-08-30T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>Mendelow Cloud Butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.768</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.769</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/arc/cares.js

@@ -33,6 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CARE_INCIDENT_RECOVERY_REVIEW_RISK = void 0;
+exports.isManagedDockerCareIncidentBinding = isManagedDockerCareIncidentBinding;
+exports.projectCareEvidence = projectCareEvidence;
 exports.createCare = createCare;
 exports.readCares = readCares;
 exports.readActiveCares = readActiveCares;
@@ -48,6 +51,32 @@ const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const session_transaction_1 = require("../mind/session-transaction");
 const json_store_1 = require("./json-store");
+exports.CARE_INCIDENT_RECOVERY_REVIEW_RISK = "The verified incident recovered, but this Care still has unresolved context that needs review.";
+function isManagedDockerCareIncidentBinding(binding) {
+    return binding.source === "sanctuary-health::Docker_critical_image_disk_utilization"
+        && /^docker-image-disk-(?:100|[1-9]?[0-9])pct-[0-9]{8}T[0-9]{4}Z$/u.test(binding.incidentKey)
+        && /^[a-f0-9]{64}$/u.test(binding.classifiedRevision)
+        && binding.correlationKey === undefined
+        && binding.resolvedAt === undefined;
+}
+function projectCareEvidence(care, now = Date.now()) {
+    if (care.kind !== "system" || (care.status !== "active" && care.status !== "watching") || care.nextCheckAt === null)
+        return care;
+    const staleAt = Date.parse(care.nextCheckAt);
+    if (Number.isFinite(staleAt) && staleAt > now)
+        return care;
+    return {
+        id: care.id,
+        kind: care.kind,
+        status: care.status,
+        salience: care.salience,
+        steward: care.steward,
+        evidenceStatus: "stale",
+        recheckRequired: true,
+        staleAt: care.nextCheckAt,
+        lastAssessedAt: care.updatedAt,
+    };
+}
 function caresDir(agentRoot) {
     return path.join(agentRoot, "arc", "cares");
 }
@@ -208,11 +237,21 @@ function bindCareIncident(agentRoot, id, binding, options) {
 function upsertCareForIncident(agentRoot, input) {
     return withCareMutationLock(agentRoot, () => {
         const incident = canonicalIncidentBinding(input.incident);
-        const existing = (0, json_store_1.readJsonDir)(caresDir(agentRoot)).find((care) => care.incidentBindings?.some((binding) => binding.source === incident.source && binding.incidentKey === incident.incidentKey));
+        const existing = (0, json_store_1.readJsonDir)(caresDir(agentRoot)).find((care) => (!input.id || care.id === input.id) && care.incidentBindings?.some((binding) => binding.source === incident.source && binding.incidentKey === incident.incidentKey));
         if (existing) {
             const index = existing.incidentBindings.findIndex((binding) => binding.source === incident.source && binding.incidentKey === incident.incidentKey);
-            const unchanged = JSON.stringify(existing.incidentBindings[index]) === JSON.stringify(incident)
-                && existing.currentRisk === input.currentRisk && existing.nextCheckAt === input.nextCheckAt;
+            const requestedRisk = input.currentRisk === undefined ? existing.currentRisk : input.currentRisk === null ? null : (0, session_events_1.capStructuredRecordString)(input.currentRisk);
+            const requestedNextCheckAt = input.nextCheckAt === undefined ? existing.nextCheckAt : input.nextCheckAt;
+            const incidentStateUnchanged = JSON.stringify(existing.incidentBindings[index]) === JSON.stringify(incident)
+                && existing.currentRisk === requestedRisk
+                && existing.nextCheckAt === requestedNextCheckAt;
+            const displayUnchanged = !input.id || ((input.label === undefined || existing.label === (0, session_events_1.capStructuredRecordString)(input.label))
+                && (input.why === undefined || existing.why === (0, session_events_1.capStructuredRecordString)(input.why))
+                && (input.kind === undefined || existing.kind === input.kind)
+                && (input.status === undefined || existing.status === input.status)
+                && (input.salience === undefined || existing.salience === input.salience)
+                && (input.steward === undefined || existing.steward === input.steward));
+            const unchanged = incidentStateUnchanged && displayUnchanged;
             if (unchanged)
                 return existing;
             if (!input.expectedUpdatedAt || input.expectedUpdatedAt !== existing.updatedAt)
@@ -221,15 +260,29 @@ function upsertCareForIncident(agentRoot, input) {
             incidentBindings[index] = incident;
             const updated = {
                 ...existing,
-                currentRisk: input.currentRisk === null ? null : (0, session_events_1.capStructuredRecordString)(input.currentRisk),
-                nextCheckAt: input.nextCheckAt,
+                ...(input.id && input.label !== undefined ? { label: (0, session_events_1.capStructuredRecordString)(input.label) } : {}),
+                ...(input.id && input.why !== undefined ? { why: (0, session_events_1.capStructuredRecordString)(input.why) } : {}),
+                ...(input.id && input.kind !== undefined ? { kind: input.kind } : {}),
+                ...(input.id && input.status !== undefined ? { status: input.status } : {}),
+                ...(input.id && input.salience !== undefined ? { salience: input.salience } : {}),
+                ...(input.id && input.steward !== undefined ? { steward: input.steward } : {}),
+                currentRisk: requestedRisk,
+                nextCheckAt: requestedNextCheckAt,
                 incidentBindings,
                 updatedAt: nextUpdatedAt(existing.updatedAt),
             };
             writeCareFile(agentRoot, updated);
             return updated;
         }
-        return createCareUnlocked(agentRoot, { ...input, incidentBindings: [incident] });
+        if (input.id)
+            throw new Error("Care incident upsert target not found");
+        const { id: _id, incident: _incident, expectedUpdatedAt: _expectedUpdatedAt, ...careInput } = input;
+        return createCareUnlocked(agentRoot, {
+            label: careInput.label ?? "untitled", why: careInput.why ?? "", kind: careInput.kind ?? "system", status: careInput.status ?? "active",
+            salience: careInput.salience ?? "medium", steward: careInput.steward ?? "mine", currentRisk: careInput.currentRisk ?? null,
+            nextCheckAt: careInput.nextCheckAt ?? null, relatedFriendIds: careInput.relatedFriendIds, relatedAgentIds: careInput.relatedAgentIds,
+            relatedObligationIds: careInput.relatedObligationIds, relatedEpisodeIds: careInput.relatedEpisodeIds, incidentBindings: [incident],
+        });
     });
 }
 function resolveCareIncident(agentRoot, id, input) {
@@ -241,11 +294,40 @@ function resolveCareIncident(agentRoot, id, input) {
         const index = bindings.findIndex((binding) => binding.source === input.source && binding.incidentKey === input.incidentKey);
         if (index < 0)
             throw new Error("Care incident binding not found");
-        if (bindings[index].resolvedAt)
+        const display = input.display;
+        const requestedDisplay = display ? {
+            label: display.label === undefined ? care.label : (0, session_events_1.capStructuredRecordString)(display.label),
+            why: display.why === undefined ? care.why : (0, session_events_1.capStructuredRecordString)(display.why),
+            currentRisk: display.currentRisk === undefined ? care.currentRisk : display.currentRisk === null ? null : (0, session_events_1.capStructuredRecordString)(display.currentRisk),
+            nextCheckAt: display.nextCheckAt === undefined ? care.nextCheckAt : display.nextCheckAt,
+        } : undefined;
+        const displayUnchanged = !requestedDisplay || JSON.stringify({
+            label: care.label,
+            why: care.why,
+            currentRisk: care.currentRisk,
+            nextCheckAt: care.nextCheckAt,
+        }) === JSON.stringify(requestedDisplay);
+        if (bindings[index].resolvedAt && displayUnchanged)
             return care;
         const now = nextUpdatedAt(care.updatedAt);
-        bindings[index] = { ...bindings[index], resolvedAt: now };
-        const updated = { ...care, incidentBindings: bindings, updatedAt: now };
+        if (!bindings[index].resolvedAt)
+            bindings[index] = { ...bindings[index], resolvedAt: now };
+        const noUnresolvedBindings = bindings.every((binding) => binding.resolvedAt);
+        const unresolvedBindingsBeforeResolution = care.incidentBindings.filter((binding) => !binding.resolvedAt);
+        const soleBindingOwnsRisk = care.kind === "system" && unresolvedBindingsBeforeResolution.length === 1 && isManagedDockerCareIncidentBinding(unresolvedBindingsBeforeResolution[0]);
+        const unresolvedContextRemains = !noUnresolvedBindings || (care.currentRisk !== null && !soleBindingOwnsRisk);
+        const canonicalDisplay = requestedDisplay && requestedDisplay.currentRisk === null && unresolvedContextRemains
+            ? { ...requestedDisplay, currentRisk: exports.CARE_INCIDENT_RECOVERY_REVIEW_RISK, nextCheckAt: requestedDisplay.nextCheckAt ?? new Date(Date.parse(now) + 15 * 60_000).toISOString() }
+            : requestedDisplay;
+        const resultingRisk = canonicalDisplay ? canonicalDisplay.currentRisk : care.currentRisk;
+        const shouldResolveCare = noUnresolvedBindings && (care.currentRisk === null || soleBindingOwnsRisk) && resultingRisk === null;
+        const updated = {
+            ...care,
+            ...canonicalDisplay,
+            incidentBindings: bindings,
+            ...(shouldResolveCare ? { status: "resolved", resolvedAt: care.resolvedAt ?? now } : {}),
+            updatedAt: now,
+        };
         writeCareFile(agentRoot, updated);
         (0, runtime_1.emitNervesEvent)({
             component: "heart",

package/dist/heart/core.js

@@ -569,10 +569,10 @@ function toolResultIndicatesFailure(content) {
         || normalized.startsWith("blocked:")
         || normalized.startsWith("rejected:");
 }
-function requiredToolResultSucceeded(name, content, validate) {
+function requiredToolResultSucceeded(name, content, args, validate) {
     if (toolResultIndicatesFailure(content))
         return false;
-    return validate?.(name, content) ?? true;
+    return validate?.(name, content, args) ?? true;
 }
 function effectFingerprint(name, rawArguments) {
     let args;
@@ -1252,6 +1252,11 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             })()
             : ordinaryActiveTools;
         const candidateToolNames = new Set(candidateActiveTools.map((tool) => tool.function.name));
+        const unadvertisedRequiredTool = requiredToolCallNames.find((name) => !candidateToolNames.has(name));
+        if (unadvertisedRequiredTool) {
+            (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "required tool is not advertised for the active channel", meta: { toolName: unadvertisedRequiredTool, channel: String(channel) } });
+            throw new Error(`required tool is not advertised for this channel: ${unadvertisedRequiredTool}`);
+        }
         const forcedHistoricalToolNames = new Set(unresolvedHistoricalEffects
             .map((effect) => effect.name)
             .filter((name) => candidateToolNames.has(name)));
@@ -1942,7 +1947,14 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     done = true;
                     continue;
                 }
-                const approvalCalls = await Promise.all(validCalls.map(async (entry) => {
+                const requiredDispatchRejections = new Map();
+                for (const entry of validCalls) {
+                    const requiredArgs = entry.validated.arguments;
+                    const rejection = options?.requiredToolCalls?.validateToolCallBeforeDispatch?.(entry.call.name, requiredArgs);
+                    if (rejection)
+                        requiredDispatchRejections.set(entry.call.id, { name: entry.call.name, args: requiredArgs, message: rejection });
+                }
+                const approvalCalls = await Promise.all(validCalls.filter((entry) => !requiredDispatchRejections.has(entry.call.id)).map(async (entry) => {
                     const classification = await (0, tools_1.classifyApprovalForInvocation)(entry.call.name, entry.validated.arguments, augmentedToolContext);
                     return {
                         ...entry,
@@ -2039,6 +2051,28 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 for (const tc of result.toolCalls) {
                     if (signal?.aborted)
                         break;
+                    const requiredDispatchRejection = requiredDispatchRejections.get(tc.id);
+                    if (requiredDispatchRejection) {
+                        callbacks.onToolStart(tc.name, requiredDispatchRejection.args);
+                        callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, requiredDispatchRejection.args), false);
+                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: requiredDispatchRejection.message });
+                        providerRuntime.appendToolOutput(tc.id, requiredDispatchRejection.message);
+                        options?.toolBoundaryObserver?.({
+                            name: tc.name,
+                            reason: "dependency_rejected",
+                            globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(tc.name)?.handler === "function",
+                            invoked: false,
+                            sideEffect: false,
+                        });
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "engine",
+                            event: "engine.required_tool_dispatch_rejected",
+                            message: "required tool dependency rejected before approval and handler dispatch",
+                            meta: { toolName: tc.name },
+                        });
+                        continue;
+                    }
                     // Reject sole-call tools when mixed with other tool calls
                     const terminalProjection = (0, tools_1.resolveToolDefinition)(tc.name)?.terminalProjection;
                     const soleCallRejection = SOLE_CALL_REJECTION[tc.name]
@@ -2321,9 +2355,20 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         success = false;
                         augmentedToolContext?.habitSession?.recordError?.(toolResult);
                     }
-                    if (success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
-                        && requiredToolResultSucceeded(tc.name, toolResult, options.requiredToolCalls.validateRequiredToolResult))
+                    const validatedRequiredResult = success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
+                        ? requiredToolResultSucceeded(tc.name, toolResult, args, options.requiredToolCalls.validateRequiredToolResult)
+                        : false;
+                    if (validatedRequiredResult) {
                         dispatchedRequiredToolCalls.add(tc.name);
+                        for (const requiredName of options?.requiredToolCalls?.requiredToolCallsAfterResult?.(tc.name, args, toolResult) ?? []) {
+                            if (!candidateToolNames.has(requiredName)) {
+                                (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "dependent required tool is not advertised for the active channel", meta: { toolName: requiredName, channel: String(channel) } });
+                                throw new Error(`dependent required tool is not advertised for this channel: ${requiredName}`);
+                            }
+                            if (!requiredToolCallNames.includes(requiredName))
+                                requiredToolCallNames.push(requiredName);
+                        }
+                    }
                     if (success && currentEffectFingerprint && !toolResultIndicatesFailure(toolResult)) {
                         unresolvedHistoricalEffects = unresolvedHistoricalEffects.filter((effect) => effect.fingerprint !== currentEffectFingerprint);
                     }

package/dist/heart/daemon/daemon.js

@@ -70,6 +70,7 @@ const mailbox_types_1 = require("../mailbox/mailbox-types");
 const mailbox_read_1 = require("../mailbox/mailbox-read");
 const mailbox_view_1 = require("../mailbox/mailbox-view");
 const provider_visibility_1 = require("../provider-visibility");
+const provider_binding_resolver_1 = require("../provider-binding-resolver");
 const private_runtime_1 = require("../private-runtime");
 const socket_client_1 = require("./socket-client");
 const flight_recorder_1 = require("../../arc/flight-recorder");
@@ -1555,6 +1556,7 @@ class OuroDaemon {
     }
     async dispatchExternalEvents(records) {
         const claimed = [];
+        let failureClass;
         try {
             for (const record of records) {
                 const owner = `external-event:${record.agent}:${record.source}:${record.eventId}:generation:${record.generation}:attempt:${record.attemptCount + 1}`;
@@ -1575,6 +1577,11 @@ class OuroDaemon {
                 eventId: primary.eventId,
             }, receipt.id, primary.generation, primary.attemptCount), () => { for (const record of claimed)
                 this.queueExternalEventForPrivateRuntime(record); }, lease);
+            failureClass = wake.denialCode === "managed_runtime_unavailable"
+                ? "managed_runtime_unavailable"
+                : wake.data?.decision?.denialCode === "provider_lane_unavailable"
+                    ? "provider_lane_unavailable"
+                    : undefined;
             const denied = !wake.ok || wake.data?.decision?.executable === false;
             if (denied)
                 throw new Error(wake.error ?? wake.message ?? /* v8 ignore next -- daemon wake responses always carry an error or message @preserve */ "external-event private turn was denied");
@@ -1587,6 +1594,7 @@ class OuroDaemon {
                     (0, router_1.failExternalEventAttempt)(latest.recordPath, {
                         owner: record.claimOwner, expectedVersion: latest.version, expectedGeneration: latest.generation,
                         error: error instanceof Error ? error.message : String(error),
+                        ...(failureClass ? { failureClass } : {}),
                     });
                 }
             }
@@ -1614,6 +1622,43 @@ class OuroDaemon {
                 let record = (0, router_1.readExternalEventRecord)(status.recordPath);
                 if (record.dispatchEnabled === false)
                     continue;
+                if (record.executionState === "dead_letter") {
+                    const failure = (0, router_1.externalEventRecoveryFailure)(record);
+                    if (!failure || record.recoveryGrant?.generation === record.generation)
+                        continue;
+                    let evidence = null;
+                    try {
+                        if (failure.class === "provider_lane_unavailable") {
+                            const binding = (0, provider_binding_resolver_1.resolveEffectiveProviderBinding)({
+                                agentName: record.agent,
+                                agentRoot: path.join(this.bundlesRoot, `${record.agent}.ouro`),
+                                lane: "inner",
+                            });
+                            if (binding.ok && binding.binding.credential.status === "present"
+                                && binding.binding.readiness.status === "ready" && binding.binding.readiness.checkedAt
+                                && Date.parse(binding.binding.readiness.checkedAt) > Date.parse(failure.failedAt)) {
+                                evidence = { class: failure.class, observedAt: binding.binding.readiness.checkedAt };
+                            }
+                        }
+                        else if (this.hasManagedPrivateRuntime(record.agent) && Date.parse(now) > Date.parse(failure.failedAt)) {
+                            evidence = { class: failure.class, observedAt: now };
+                        }
+                        if (!evidence)
+                            continue;
+                        const revival = (0, router_1.reviveExternalEventAfterRecovery)(record.recordPath, { expectedVersion: record.version, expectedGeneration: record.generation, evidence, now: () => now });
+                        record = revival.record;
+                    }
+                    catch (error) {
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "daemon",
+                            event: "daemon.external_event_recovery_error",
+                            message: "external event dead-letter recovery check failed",
+                            meta: { agent: record.agent, source: record.source, eventId: record.eventId, generation: record.generation, error: error instanceof Error ? error.message : String(error) },
+                        });
+                        continue;
+                    }
+                }
                 if (record.executionState === "running" && record.claimExpiresAt && Date.parse(record.claimExpiresAt) <= Date.parse(now)) {
                     record = (0, router_1.reconcileExternalEvent)(record.recordPath);
                 }
@@ -1657,6 +1702,7 @@ class OuroDaemon {
             return {
                 ok: false,
                 error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+                denialCode: "managed_runtime_unavailable",
             };
         }
         const decision = await (0, private_runtime_1.requestPrivateTurnDecision)(this.buildPrivateRuntimeWakeRequest(command), {
@@ -1667,6 +1713,7 @@ class OuroDaemon {
             return {
                 ok: true,
                 message: `private-runtime wake denied for ${command.agent}: ${decision.deniedReason}`,
+                ...(decision.denialCode ? { denialCode: decision.denialCode } : {}),
                 data: { decision },
             };
         }

package/dist/heart/external-events/router.js

@@ -45,6 +45,8 @@ exports.claimExternalEvent = claimExternalEvent;
 exports.renewExternalEventClaim = renewExternalEventClaim;
 exports.commitExternalEventDisposition = commitExternalEventDisposition;
 exports.failExternalEventAttempt = failExternalEventAttempt;
+exports.externalEventRecoveryFailure = externalEventRecoveryFailure;
+exports.reviveExternalEventAfterRecovery = reviveExternalEventAfterRecovery;
 exports.reconcileExternalEvent = reconcileExternalEvent;
 exports.advanceExternalEventFromAwait = advanceExternalEventFromAwait;
 exports.advanceExternalEventsFromAwait = advanceExternalEventsFromAwait;
@@ -305,11 +307,19 @@ function isRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const candidate = value;
+    const failure = candidate.failureProvenance;
+    const grant = candidate.recoveryGrant;
+    const validFailure = failure === undefined || (failure !== null && typeof failure === "object"
+        && (failure.class === "provider_lane_unavailable" || failure.class === "managed_runtime_unavailable") && canonicalIso(failure.failedAt));
+    const validGrant = grant === undefined || (grant !== null && typeof grant === "object"
+        && Number.isSafeInteger(grant.generation) && grant.generation === candidate.generation && canonicalIso(grant.consumedAt));
     return candidate.schemaVersion === 2
         && typeof candidate.recordPath === "string"
         && Number.isSafeInteger(candidate.version)
         && Number.isSafeInteger(candidate.generation)
-        && typeof candidate.observationRevision === "string";
+        && typeof candidate.observationRevision === "string"
+        && validFailure
+        && validGrant;
 }
 function readExternalEventRecord(recordPath) {
     const parsed = JSON.parse(fs.readFileSync(recordPath, "utf8"));
@@ -359,6 +369,8 @@ function listExternalEventStatus(root) {
                         careId: record.disposition?.careId ?? null,
                         awaitId: record.disposition?.awaitId ?? null,
                         lastError: record.lastError,
+                        failureProvenance: record.failureProvenance ?? null,
+                        recoveryGrant: record.recoveryGrant ?? null,
                         nextAttemptAt: record.nextAttemptAt,
                         claimOwner: record.claimOwner,
                         claimExpiresAt: record.claimExpiresAt,
@@ -390,6 +402,8 @@ function listExternalEventStatus(root) {
                         careId: null,
                         awaitId: null,
                         lastError: `invalid receipt: ${error instanceof Error ? error.message : /* v8 ignore next -- filesystem and JSON parsers throw Error objects @preserve */ String(error)}`,
+                        failureProvenance: null,
+                        recoveryGrant: null,
                         nextAttemptAt: null,
                         claimOwner: null,
                         claimExpiresAt: null,
@@ -533,6 +547,8 @@ function recordExternalEventInternal(input, options = {}) {
                     claimExpiresAt: shouldWake || quietInitialReceipt ? null : existing.claimExpiresAt,
                     nextAttemptAt: shouldWake || quietInitialReceipt ? null : existing.nextAttemptAt,
                     lastError: shouldWake || quietInitialReceipt ? null : existing.lastError,
+                    ...(!shouldWake && !quietInitialReceipt && existing?.failureProvenance ? { failureProvenance: existing.failureProvenance } : {}),
+                    ...(!shouldWake && !quietInitialReceipt && existing?.recoveryGrant ? { recoveryGrant: existing.recoveryGrant } : {}),
                     disposition: shouldWake || quietInitialReceipt ? null : existing.disposition,
                     pendingObservation: shouldWake || quietInitialReceipt ? null : existing.pendingObservation,
                     dispatchEnabled: options.dispatchEnabled ?? existing?.dispatchEnabled ?? true,
@@ -1032,12 +1048,13 @@ function commitExternalEventDisposition(recordPath, input) {
             disposition: wakePending ? null : input.disposition,
             pendingObservation: null,
             pendingPrivilegedProtectiveAction: undefined,
+            ...(wakePending ? { failureProvenance: undefined, recoveryGrant: undefined } : {}),
             shouldWake: wakePending,
         }, now);
     });
 }
-function retryState(record, now, maxAttempts, baseDelayMs, error) {
-    const dead = record.attemptCount >= maxAttempts;
+function retryState(record, now, maxAttempts, baseDelayMs, error, failureClass) {
+    const dead = record.recoveryGrant?.generation === record.generation || record.attemptCount >= maxAttempts;
     return {
         ...record,
         executionState: dead ? "dead_letter" : "retry_wait",
@@ -1045,6 +1062,7 @@ function retryState(record, now, maxAttempts, baseDelayMs, error) {
         claimExpiresAt: null,
         nextAttemptAt: dead ? null : new Date(Date.parse(now) + baseDelayMs * 2 ** Math.max(0, record.attemptCount - 1)).toISOString(),
         lastError: error.slice(0, 1_000),
+        ...(dead && failureClass && !record.failureProvenance ? { failureProvenance: { class: failureClass, failedAt: now } } : {}),
         shouldWake: false,
     };
 }
@@ -1055,9 +1073,73 @@ function failExternalEventAttempt(recordPath, input) {
         const now = input.now?.() ?? new Date().toISOString();
         const maxAttempts = input.maxAttempts ?? 5;
         const baseDelayMs = input.baseDelayMs ?? 1_000;
+        if (input.failureClass !== undefined && input.failureClass !== "provider_lane_unavailable" && input.failureClass !== "managed_runtime_unavailable")
+            throw new Error("External event failure class is invalid");
         if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1 || !Number.isSafeInteger(baseDelayMs) || baseDelayMs < 1)
             throw new Error("External event retry policy is invalid");
-        return commitMutation(recordPath, retryState(record, now, maxAttempts, baseDelayMs, input.error), now);
+        return commitMutation(recordPath, retryState(record, now, maxAttempts, baseDelayMs, input.error, input.failureClass), now);
+    });
+}
+function exactLegacyProviderFailure(record) {
+    const escapedAgent = record.agent.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const canonical = new RegExp(`^private-runtime wake denied for ${escapedAgent}: provider lane resolution failed$`, "u");
+    return record.lastError && canonical.test(record.lastError)
+        ? { class: "provider_lane_unavailable", failedAt: record.updatedAt }
+        : null;
+}
+function externalEventRecoveryFailure(record) {
+    return record.failureProvenance ?? exactLegacyProviderFailure(record);
+}
+function recoveryIneligible(record, reason) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.external_event_recovery_ineligible",
+        message: "external event dead-letter recovery was ineligible or exhausted",
+        meta: { agent: record.agent, source: record.source, eventId: record.eventId, generation: record.generation, reason },
+    });
+    return { revived: false, reason, record };
+}
+function reviveExternalEventAfterRecovery(recordPath, input) {
+    return withRecordLock(recordPath, () => {
+        const record = readExternalEventRecord(recordPath);
+        assertCas(record, input);
+        if (input.evidence.class !== "provider_lane_unavailable" && input.evidence.class !== "managed_runtime_unavailable")
+            throw new Error("External event recovery evidence class is invalid");
+        if (!canonicalIso(input.evidence.observedAt))
+            throw new Error("External event recovery evidence time is invalid");
+        if (record.executionState !== "dead_letter")
+            return recoveryIneligible(record, "not_dead_letter");
+        if (record.dispatchEnabled === false)
+            return recoveryIneligible(record, "dispatch_disabled");
+        if (record.recoveryGrant?.generation === record.generation)
+            return recoveryIneligible(record, "grant_consumed");
+        const failure = externalEventRecoveryFailure(record);
+        if (!failure)
+            return recoveryIneligible(record, "ineligible_failure");
+        if (failure.class !== input.evidence.class)
+            return recoveryIneligible(record, "evidence_mismatch");
+        if (Date.parse(input.evidence.observedAt) <= Date.parse(failure.failedAt))
+            return recoveryIneligible(record, "stale_evidence");
+        const now = input.now?.() ?? new Date().toISOString();
+        if (!canonicalIso(now))
+            throw new Error("External event recovery grant consumed time is invalid");
+        const revived = commitMutation(recordPath, {
+            ...record,
+            executionState: "queued",
+            claimOwner: null,
+            claimExpiresAt: null,
+            nextAttemptAt: null,
+            shouldWake: true,
+            failureProvenance: failure,
+            recoveryGrant: { generation: record.generation, consumedAt: now },
+        }, now);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.external_event_requeued",
+            message: "requeued external event after infrastructure recovery",
+            meta: { agent: revived.agent, source: revived.source, eventId: revived.eventId, generation: revived.generation, failureClass: failure.class },
+        });
+        return { revived: true, record: revived };
     });
 }
 function reconcileExternalEvent(recordPath, options = {}) {
@@ -1084,6 +1166,8 @@ function advanceExternalEventFromAwait(recordPath, input) {
             generation: record.generation + 1,
             executionState: "queued",
             attemptCount: 0,
+            failureProvenance: undefined,
+            recoveryGrant: undefined,
             disposition: null,
             shouldWake: true,
         }, now);

package/dist/heart/private-runtime/decision-renderer.js

@@ -57,6 +57,7 @@ function sanitizePrivateDecision(row, ledgerPath) {
         ? row
         : {};
     const deniedReason = stringField(record.deniedReason);
+    const denialCode = record.denialCode === "provider_lane_unavailable" ? record.denialCode : undefined;
     const duplicateOf = stringField(record.duplicateOf);
     const error = stringField(record.error);
     return {
@@ -76,6 +77,7 @@ function sanitizePrivateDecision(row, ledgerPath) {
         decidedAt: stringField(record.decidedAt),
         ledgerLocator: ledgerLocatorField(record.ledgerLocator, ledgerPath),
         ...(deniedReason ? { deniedReason } : {}),
+        ...(denialCode ? { denialCode } : {}),
         ...(duplicateOf ? { duplicateOf } : {}),
         ...(error ? { error } : {}),
     };

package/dist/heart/private-runtime/ledger.js

@@ -137,6 +137,7 @@ function mismatchDecision(candidate, existing) {
         result: "deny",
         executable: false,
         deniedReason: "idempotency-key fingerprint mismatch",
+        denialCode: undefined,
         duplicateOf: existing.receiptId,
     };
 }
@@ -159,6 +160,7 @@ function ledgerWriteFailedDecision(candidate, ledgerPath, error) {
         result: "deny",
         executable: false,
         deniedReason: "ledger write failed",
+        denialCode: undefined,
         ledgerLocator: { path: ledgerPath },
         error: String(error),
     };
@@ -194,7 +196,8 @@ function recordPrivateTurnDecision(decision, deps = {}) {
             if (latestSameFingerprint
                 && latestSameFingerprint.result === candidate.result
                 && latestSameFingerprint.executable === candidate.executable
-                && latestSameFingerprint.deniedReason === candidate.deniedReason) {
+                && latestSameFingerprint.deniedReason === candidate.deniedReason
+                && latestSameFingerprint.denialCode === candidate.denialCode) {
                 return latestSameFingerprint;
             }
             if (priorExecutable && !candidate.executable) {

package/dist/heart/private-runtime/policy.js

@@ -167,12 +167,6 @@ async function requestPrivateTurnDecision(request, deps = {}) {
     let evaluation;
     try {
         providerLane = await resolveProviderLaneMetadata(normalizedRequest, deps);
-        requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
-        evaluation = await evaluatePolicy(normalizedRequest, {
-            requestFingerprint,
-            idempotencyKey,
-            providerLane,
-        }, deps);
     }
     catch (error) {
         providerLane = {
@@ -181,13 +175,30 @@ async function requestPrivateTurnDecision(request, deps = {}) {
             model: "-",
             source: "agent.json",
         };
-        requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
         evaluation = {
             result: "deny",
             reason: error instanceof Error ? error.message : String(error),
             deniedReason: "provider lane resolution failed",
+            denialCode: "provider_lane_unavailable",
         };
     }
+    requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
+    if (evaluation === undefined) {
+        try {
+            evaluation = await evaluatePolicy(normalizedRequest, {
+                requestFingerprint,
+                idempotencyKey,
+                providerLane,
+            }, deps);
+        }
+        catch (error) {
+            evaluation = {
+                result: "deny",
+                reason: error instanceof Error ? error.message : String(error),
+                deniedReason: "private runtime policy evaluation failed",
+            };
+        }
+    }
     const result = evaluation.result;
     emitPolicyEvaluated(deps, { request: normalizedRequest, result, requestFingerprint, idempotencyKey });
     const reason = evaluation.reason ?? normalizedRequest.reason;
@@ -208,7 +219,10 @@ async function requestPrivateTurnDecision(request, deps = {}) {
         executable: result === "allow",
         decidedAt: nowIso(deps),
         ledgerLocator: { path: deps.ledgerPath ?? "" },
-        ...(result === "deny" ? { deniedReason: evaluation.deniedReason ?? reason } : {}),
+        ...(result === "deny" ? {
+            deniedReason: evaluation.deniedReason ?? reason,
+            ...(evaluation.denialCode ? { denialCode: evaluation.denialCode } : {}),
+        } : {}),
     };
     return (0, ledger_1.recordPrivateTurnDecision)(decision, deps);
 }

package/dist/heart/start-of-turn-packet.js

@@ -42,6 +42,7 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 const bundle_state_1 = require("./bundle-state");
 const tempo_1 = require("./tempo");
+const cares_1 = require("../arc/cares");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const context_loss_sentinel_1 = require("./context-loss-sentinel");
 const orientation_frame_1 = require("./orientation-frame");
@@ -82,11 +83,14 @@ function buildObligationsSection(obligations) {
     })
         .join("\n");
 }
-function buildCaresSection(cares) {
+function buildCaresSection(cares, now) {
     if (cares.length === 0)
         return "";
     return cares
-        .map((c) => {
+        .map((care) => {
+        const c = (0, cares_1.projectCareEvidence)(care, now);
+        if ("recheckRequired" in c)
+            return `- system care [${c.salience}] evidence stale; recheck required`;
         const parts = [`- ${c.label}`];
         if (c.salience !== "low") {
             parts.push(` [${c.salience}]`);
@@ -192,7 +196,7 @@ function buildStartOfTurnPacket(view, opts) {
     const packet = {
         plotLine: buildPlotLine(view.recentEpisodes, tempo),
         obligations: buildObligationsSection(effectiveObligations),
-        cares: buildCaresSection(view.activeCares),
+        cares: buildCaresSection(view.activeCares, opts?.careEvidenceNow ?? Date.now()),
         presence: buildPresenceSection(view.peerPresence),
         arcResume: opts?.flightRecorderResume ? (0, flight_recorder_1.formatFlightRecorderResume)(opts.flightRecorderResume) : undefined,
         recoverySentinel: opts?.recoverySentinel,

package/dist/repertoire/tools-continuity.js

@@ -45,24 +45,6 @@ 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");
-function presentCare(care) {
-    const staleAt = care.nextCheckAt ? Date.parse(care.nextCheckAt) : Number.NaN;
-    if (care.kind !== "system" || !["active", "watching"].includes(care.status) || care.nextCheckAt === null)
-        return care;
-    if (Number.isFinite(staleAt) && staleAt >= Date.now())
-        return care;
-    return {
-        id: care.id,
-        kind: care.kind,
-        status: care.status,
-        salience: care.salience,
-        steward: care.steward,
-        evidenceStatus: "stale",
-        recheckRequired: true,
-        staleAt: care.nextCheckAt,
-        lastAssessedAt: care.updatedAt,
-    };
-}
 exports.continuityToolDefinitions = [
     // ── Continuity tools ──────────────────────────────────────────────
     {
@@ -326,7 +308,8 @@ exports.continuityToolDefinitions = [
         },
         handler: (a) => {
             const agentRoot = (0, identity_1.getAgentRoot)();
-            const cares = (a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot)).map(presentCare);
+            const now = Date.now();
+            const cares = (a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot)).map((care) => (0, cares_1.projectCareEvidence)(care, now));
             (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_cares", message: `queried ${cares.length} cares`, meta: { count: cares.length } });
             return JSON.stringify(cares, null, 2);
         },
@@ -346,6 +329,7 @@ exports.continuityToolDefinitions = [
                         why: { type: "string", description: "Why this matters" },
                         salience: { type: "string", description: "low, medium, high, or critical" },
                         kind: { type: "string", description: "person, agent, project, mission, or system" },
+                        status: { type: "string", enum: ["active", "watching", "resolved", "dormant"], description: "active, watching, resolved, or dormant" },
                         stewardship: { type: "string", description: "mine, shared, or delegated" },
                         source: { type: "string", description: "Machine evidence source for an incident binding" },
                         incidentKey: { type: "string", description: "Stable incident key within the source" },
@@ -367,7 +351,7 @@ exports.continuityToolDefinitions = [
                     label: a.label ?? "untitled",
                     why: a.why ?? "",
                     kind: a.kind ?? "project",
-                    status: "active",
+                    status: a.status ?? "active",
                     salience: a.salience ?? "medium",
                     steward: a.stewardship ?? "mine",
                     relatedFriendIds: [],
@@ -412,22 +396,33 @@ exports.continuityToolDefinitions = [
                     source: a.source,
                     incidentKey: a.incidentKey,
                     expectedUpdatedAt: a.expectedUpdatedAt,
+                    ...((a.label !== undefined || a.why !== undefined || a.currentRisk !== undefined || a.nextCheckAt !== undefined) ? {
+                        display: {
+                            ...(a.label !== undefined ? { label: String(a.label) } : {}),
+                            ...(a.why !== undefined ? { why: String(a.why) } : {}),
+                            ...(a.currentRisk !== undefined ? { currentRisk: a.currentRisk ? String(a.currentRisk) : null } : {}),
+                            ...(a.nextCheckAt !== undefined ? { nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null } : {}),
+                        },
+                    } : {}),
                 });
             }
             else if (a.action === "upsert_incident") {
                 result = (0, cares_1.upsertCareForIncident)(agentRoot, {
-                    label: a.label ?? "untitled",
-                    why: a.why ?? "",
-                    kind: a.kind ?? "system",
-                    status: "active",
-                    salience: a.salience ?? "medium",
-                    steward: a.stewardship ?? "mine",
+                    ...(a.id ? { id: String(a.id) } : {}),
+                    ...(!a.id ? {
+                        label: a.label ?? "untitled", why: a.why ?? "", kind: a.kind ?? "system", status: a.status ?? "active",
+                        salience: a.salience ?? "medium", steward: a.stewardship ?? "mine",
+                    } : {
+                        ...(a.label !== undefined ? { label: String(a.label) } : {}), ...(a.why !== undefined ? { why: String(a.why) } : {}),
+                        ...(a.kind !== undefined ? { kind: a.kind } : {}), ...(a.status !== undefined ? { status: a.status } : {}),
+                        ...(a.salience !== undefined ? { salience: a.salience } : {}), ...(a.stewardship !== undefined ? { steward: a.stewardship } : {}),
+                    }),
                     relatedFriendIds: [],
                     relatedAgentIds: [],
                     relatedObligationIds: [],
                     relatedEpisodeIds: [],
-                    currentRisk: a.currentRisk ? String(a.currentRisk) : null,
-                    nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null,
+                    ...(!a.id || a.currentRisk !== undefined ? { currentRisk: a.currentRisk ? String(a.currentRisk) : null } : {}),
+                    ...(!a.id || a.nextCheckAt !== undefined ? { nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null } : {}),
                     ...(a.expectedUpdatedAt ? { expectedUpdatedAt: String(a.expectedUpdatedAt) } : {}),
                     incident: {
                         source: a.source,

package/dist/senses/pipeline.js

@@ -72,6 +72,7 @@ const provider_visibility_1 = require("../heart/provider-visibility");
 const orientation_frame_1 = require("../heart/orientation-frame");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const context_loss_sentinel_1 = require("../heart/context-loss-sentinel");
+const cares_1 = require("../arc/cares");
 const VOICE_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
 function pendingExpirationReason(channel, message, now) {
     /* v8 ignore start -- pending expiry edge permutations are covered by the stale voice queue tests; this helper keeps defensive non-voice fallbacks @preserve */
@@ -809,11 +810,14 @@ async function handleInboundTurn(input) {
                 : undefined);
         // Step 4b: Continuity pipeline — derive tempo, build start-of-turn packet, snapshot obligations
         let renderedStartOfTurnPacket;
+        const careEvidenceNow = Date.now();
+        const activeCaresSnapshot = ctx.activeCares;
         const preTurnObligationIds = new Set(pendingObligations.map((ob) => `${ob.id}:${ob.status}`));
         try {
             const agentRoot = (0, identity_1.getAgentRoot)();
             const agentName = (0, identity_1.getAgentName)();
-            const { recentEpisodes, activeCares } = ctx;
+            const { recentEpisodes } = ctx;
+            const projectedCares = activeCaresSnapshot.map((care) => (0, cares_1.projectCareEvidence)(care, careEvidenceNow));
             const tempoState = (0, tempo_1.deriveTempo)({
                 activeSessions: sessionActivity.length + 1,
                 openObligations: pendingObligations.length,
@@ -823,15 +827,15 @@ async function handleInboundTurn(input) {
                     : 0,
                 hasBlockers: false, // obligations use specific statuses, not "blocked"
                 highSalienceEpisodes: recentEpisodes.filter((ep) => ep.salience === "high" || ep.salience === "critical").length,
-                activeCareCount: activeCares.length,
-                atRiskCareCount: activeCares.filter((c) => c.currentRisk != null).length,
+                activeCareCount: activeCaresSnapshot.length,
+                atRiskCareCount: projectedCares.filter((care) => !("recheckRequired" in care) && care.currentRisk != null).length,
             });
             const temporalView = (0, temporal_view_1.buildTemporalView)(agentRoot, {
                 tempo: tempoState.mode,
                 preloaded: {
                     recentEpisodes,
                     activeObligations: pendingObligations,
-                    activeCares,
+                    activeCares: activeCaresSnapshot,
                 },
             });
             const startOfTurnPacket = (0, start_of_turn_packet_1.buildStartOfTurnPacket)(temporalView, {
@@ -843,6 +847,7 @@ async function handleInboundTurn(input) {
                 friendContactTiming,
                 flightRecorderResume: ctx.flightRecorderResume,
                 recoverySentinel: ctx.recoverySentinel,
+                careEvidenceNow,
             });
             /* v8 ignore next 3 -- syncFailure propagation tested in sync.test.ts @preserve */
             if (syncFailure) {
@@ -928,6 +933,8 @@ async function handleInboundTurn(input) {
             currentUserMessages,
             resolvedContext,
             runAgentOptions,
+            activeCares: activeCaresSnapshot,
+            careEvidenceNow,
         }));
         const checkpointCurrentAsk = selectCheckpointCurrentAsk({
             currentUserMessage: runAgentOptions.toolContext?.currentUserMessage ?? currentUserMessage,

package/dist/senses/sanctuary-full-visibility-contract.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSanctuaryCurrentStatusIntent = isSanctuaryCurrentStatusIntent;
 exports.sanctuaryFullVisibilityEmptyResponse = sanctuaryFullVisibilityEmptyResponse;
 exports.sanctuaryFullVisibilityRequiredToolCalls = sanctuaryFullVisibilityRequiredToolCalls;
+exports.sanctuaryStaleDockerCareRequiredToolCalls = sanctuaryStaleDockerCareRequiredToolCalls;
+const node_crypto_1 = require("node:crypto");
+const cares_1 = require("../arc/cares");
 const runtime_1 = require("../nerves/runtime");
-const REQUIRED_TOOL_NAMES = ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers", "unraid_get_storage", "sanctuary_get_download_queue"];
+const REQUIRED_TOOL_NAMES = ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers", "unraid_get_storage", "unraid_get_notifications", "sanctuary_get_download_queue"];
 const WHOLE_STATUS_REQUESTS = new Set(["what are you working on", "what's going on with sanctuary"]);
-function unsupportedCurrentClaim(answer, queueUnavailable) {
+function unsupportedCurrentClaim(answer, queueUnavailable, authorizedDockerClaims) {
     if (queueUnavailable && answer.trim().length === 0)
         return "Give Ari the current results that did complete and say plainly that the download queue is currently unavailable; do not return an empty answer.";
     if (queueUnavailable) {
@@ -21,6 +25,9 @@ function unsupportedCurrentClaim(answer, queueUnavailable) {
     const unsupported = answer.replace(/docker\.img/giu, "docker image").split(/[,;!?\n]|(?<!\d)\.(?!\d)/u).some((sentence) => {
         if (!/docker image(?: disk)?/iu.test(sentence))
             return false;
+        const normalizedSentence = sentence.normalize("NFKC").trim().toLocaleLowerCase("en-US");
+        if (authorizedDockerClaims.some((claim) => claim.normalize("NFKC").replace(/[.!?]+$/u, "").trim().toLocaleLowerCase("en-US") === normalizedSentence))
+            return false;
         const uncertaintyOnly = /\b(?:cannot|can't|unable to) (?:currently )?(?:verify|measure)\b|\b(?:unknown|unverified)\b|\bneeds? (?:a )?(?:fresh |authoritative )*(?:check|measurement)\b/iu.test(sentence);
         const stateClaim = /\b\d+(?:\.\d+)?\s*%|\bfull\b|\b(?:no|out of) space\b|\bwrites? (?:will |may )?fail\b|\b(?:healthy|unhealthy|running|stopped)\b/iu.test(sentence);
         return stateClaim || !uncertaintyOnly;
@@ -59,6 +66,19 @@ function successfulCurrentResult(name, result) {
         const parsed = JSON.parse(result);
         if (name === "query_cares")
             return { valid: Array.isArray(parsed), queueUnavailable: false };
+        if (name === "unraid_get_notifications") {
+            const root = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+            const error = root?.error && typeof root.error === "object" && !Array.isArray(root.error) ? root.error : null;
+            const unavailable = root?.ok === false
+                && JSON.stringify(Object.keys(root).sort()) === JSON.stringify(["error", "ok"])
+                && !!error && JSON.stringify(Object.keys(error).sort()) === JSON.stringify(["code", "degraded", "message"])
+                && ["unauthorized", "forbidden", "timeout", "transport", "graphql", "invalid_response"].includes(String(error.code))
+                && typeof error.message === "string" && Buffer.byteLength(error.message, "utf8") <= 512 && error.degraded === true;
+            if (unavailable)
+                return { valid: true, queueUnavailable: false };
+            const data = root?.data && typeof root.data === "object" && !Array.isArray(root.data) ? root.data : null;
+            return { valid: root?.ok === true && Array.isArray(data?.unacknowledged) && typeof data.truncated === "boolean", queueUnavailable: false };
+        }
         if (name === "sanctuary_get_download_queue") {
             if (exactQueueUnavailableResult(parsed))
                 return { valid: true, queueUnavailable: true };
@@ -80,23 +100,37 @@ function successfulCurrentResult(name, result) {
     }
 }
 function normalizedRequest(request) {
-    return request.normalize("NFKC").trim().toLocaleLowerCase("en-US").replaceAll("’", "'").replace(/[?!.\s]+$/gu, "");
+    return request.normalize("NFKC").trim().toLocaleLowerCase("en-US").replace(/[‘’]/gu, "'").replace(/[^a-z0-9']+/gu, " ").trim();
+}
+function isSanctuaryCurrentStatusIntent(request) {
+    const normalized = normalizedRequest(request);
+    if (WHOLE_STATUS_REQUESTS.has(normalized))
+        return true;
+    if (["what's up", "everything good", "anything wrong"].includes(normalized))
+        return true;
+    if (!normalized || /\b(?:yesterday|tomorrow|document|movie request)\b/u.test(normalized))
+        return false;
+    if (/^do you care about\b/u.test(normalized) || /\b(?:plex|jellyfin|sonarr|radarr|docker labels?)\b/u.test(normalized))
+        return false;
+    const wholeScope = /\b(?:anything|everything|what(?:'s| is)|things?)\b/u.test(normalized);
+    const current = /\b(?:now|right now|currently|going on|status)\b/u.test(normalized);
+    const concern = /\b(?:care about|should (?:i|we) know about|working on|going on|status)\b/u.test(normalized);
+    return wholeScope && current && concern;
 }
 function sanctuaryFullVisibilityEmptyResponse(request) {
-    return WHOLE_STATUS_REQUESTS.has(normalizedRequest(request))
+    return isSanctuaryCurrentStatusIntent(request)
         ? "I couldn't finish a trustworthy Sanctuary status check because a current check was unavailable. I won't guess or reuse old alerts; please try again shortly."
         : undefined;
 }
-function sanctuaryFullVisibilityRequiredToolCalls(request, advertisedToolNames) {
-    const normalized = normalizedRequest(request);
-    if (!WHOLE_STATUS_REQUESTS.has(normalized) || !REQUIRED_TOOL_NAMES.every((name) => advertisedToolNames.includes(name)))
+function sanctuaryFullVisibilityRequiredToolCalls(request, _advertisedToolNames, authorizedDockerClaims = () => []) {
+    if (!isSanctuaryCurrentStatusIntent(request))
         return undefined;
     (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_full_visibility_reads_required", message: "required current Sanctuary visibility reads", meta: { toolCount: REQUIRED_TOOL_NAMES.length } });
     let queueUnavailable = false;
     const completed = new Set();
     return {
         names: REQUIRED_TOOL_NAMES,
-        retryMessage: "Before answering, read current active work, cares, system health, service state, storage, and the download queue. Current tool facts outrank care history; a stale care is a recheck item, not a present-tense fact. Then give Ari one compact household summary; do not ask him to choose a status slice.",
+        retryMessage: "Before answering, read current active work, cares, system health, service state, storage, notifications, and the download queue. Current tool facts outrank care history; a stale care is a recheck item, not a present-tense fact. Then give Ari one compact household summary; do not ask him to choose a status slice.",
         requireSuccessfulResults: true,
         validateRequiredToolResult: (name, result) => {
             const validation = successfulCurrentResult(name, result);
@@ -106,7 +140,163 @@ function sanctuaryFullVisibilityRequiredToolCalls(request, advertisedToolNames)
                 completed.add(name);
             return validation.valid;
         },
-        validateTerminalAnswer: (answer) => unsupportedCurrentClaim(answer, queueUnavailable),
+        validateTerminalAnswer: (answer) => unsupportedCurrentClaim(answer, queueUnavailable, authorizedDockerClaims()),
         emptyResponseFallback: () => REQUIRED_TOOL_NAMES.every((name) => completed.has(name)) ? sanctuaryFullVisibilityEmptyResponse(request) : undefined,
     };
 }
+const SAFE_LABEL = "Docker image disk utilization";
+const INCONCLUSIVE_RISK = "Docker image disk utilization verification is inconclusive.";
+const ACTIVE_RISK = "A fresh Unraid notification reports high Docker image disk utilization.";
+function qualifyingDockerCare(care, now) {
+    if ((0, cares_1.projectCareEvidence)(care, now) === care)
+        return undefined;
+    const binding = care.incidentBindings?.find(cares_1.isManagedDockerCareIncidentBinding);
+    return binding ? {
+        id: care.id, updatedAt: care.updatedAt, currentRisk: care.currentRisk, nextCheckAt: care.nextCheckAt, salience: care.salience, steward: care.steward, binding: { ...binding },
+        hasOtherUnresolvedBindings: care.incidentBindings.some((candidate) => candidate !== binding && !candidate.resolvedAt),
+    } : undefined;
+}
+function canonicalNotification(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const notification = value;
+    return typeof notification.id === "string"
+        && typeof notification.createdAt === "string"
+        && Number.isFinite(Date.parse(notification.createdAt))
+        && new Date(notification.createdAt).toISOString() === notification.createdAt
+        && typeof notification.title === "string"
+        && typeof notification.summary === "string"
+        && typeof notification.severity === "string"
+        && typeof notification.degraded === "boolean"
+        ? notification
+        : undefined;
+}
+function notificationRevision(notification) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({
+        id: notification.id,
+        createdAt: notification.createdAt,
+        severity: notification.severity,
+        title: notification.title,
+        summary: notification.summary,
+        degraded: notification.degraded,
+    })).digest("hex");
+}
+function dockerObservation(result, care) {
+    try {
+        const parsed = JSON.parse(result);
+        const data = parsed?.ok === true && parsed.data && typeof parsed.data === "object" && !Array.isArray(parsed.data) ? parsed.data : undefined;
+        if (!data || data.truncated !== false || !Array.isArray(data.unacknowledged))
+            return { outcome: "inconclusive" };
+        const boundary = Math.max(Date.parse(care.updatedAt), Date.parse(care.nextCheckAt));
+        const related = data.unacknowledged.map(canonicalNotification).filter((item) => !!item).filter((item) => {
+            const text = `${item.title} ${item.summary}`;
+            return item.degraded === false && Date.parse(String(item.createdAt)) > boundary && /docker/iu.test(text) && /image/iu.test(text) && /(?:disk|utilization)/iu.test(text);
+        });
+        if (related.length !== 1)
+            return { outcome: "inconclusive" };
+        const notification = related[0];
+        const text = `${notification.title} ${notification.summary}`;
+        const revision = notificationRevision(notification);
+        if (/\b(?:recover(?:ed|y)?|resolved|normal|healthy|cleared)\b/iu.test(text))
+            return { outcome: "fresh_recovered", revision };
+        if (/\b(?:critical|warning|error|full|high|9[0-9]%|100%)\b/iu.test(`${notification.severity} ${text}`)) {
+            return { outcome: "fresh_active", revision, risk: ACTIVE_RISK };
+        }
+        return { outcome: "inconclusive" };
+    }
+    catch {
+        return { outcome: "inconclusive" };
+    }
+}
+function mutationFor(care, observation, now) {
+    const common = {
+        id: care.id,
+        source: care.binding.source,
+        incidentKey: care.binding.incidentKey,
+        expectedUpdatedAt: care.updatedAt,
+        label: SAFE_LABEL,
+        why: observation.outcome === "inconclusive" ? "Current Unraid notification evidence was inconclusive." : "Current Unraid notification evidence was checked.",
+    };
+    if (observation.outcome === "fresh_recovered") {
+        const unresolvedContextRemains = care.hasOtherUnresolvedBindings;
+        return {
+            ...common,
+            action: "resolve_incident",
+            currentRisk: unresolvedContextRemains ? cares_1.CARE_INCIDENT_RECOVERY_REVIEW_RISK : "",
+            nextCheckAt: unresolvedContextRemains ? new Date(now + 15 * 60_000).toISOString() : "",
+        };
+    }
+    return {
+        ...common,
+        action: "upsert_incident",
+        kind: "system",
+        status: observation.outcome === "fresh_active" ? "active" : "watching",
+        salience: care.salience,
+        stewardship: care.steward,
+        classifiedRevision: observation.outcome === "fresh_active" ? observation.revision : care.binding.classifiedRevision,
+        currentRisk: observation.outcome === "fresh_active" ? observation.risk : INCONCLUSIVE_RISK,
+        nextCheckAt: new Date(now + 15 * 60_000).toISOString(),
+    };
+}
+function exactMutation(expected, actual) {
+    return Object.keys(expected).length === Object.keys(actual).length
+        && Object.entries(expected).every(([key, value]) => actual[key] === value);
+}
+function sanctuaryStaleDockerCareRequiredToolCalls(activeCares, now, _advertisedToolNames) {
+    const cares = activeCares.map((care) => qualifyingDockerCare(care, now)).filter((care) => !!care);
+    if (cares.length === 0)
+        return undefined;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_stale_docker_care_verification_required", message: "stale Docker Care requires current notification verification", meta: { careCount: cares.length } });
+    let verifierComplete = false;
+    let mutations = [];
+    const completed = new Set();
+    return {
+        names: ["unraid_get_notifications"],
+        get retryMessage() {
+            return mutations.length === 0
+                ? "Recheck the stale Docker image disk Care from current notifications, then apply every exact evidence-bounded Care update before answering."
+                : `Apply these exact evidence-bounded care_manage arguments before answering: ${JSON.stringify(mutations)}.`;
+        },
+        requireSuccessfulResults: true,
+        validateRequiredToolResult: (name, result, args) => {
+            if (name === "unraid_get_notifications")
+                return Buffer.byteLength(result, "utf8") <= 1_000_000;
+            if (name !== "care_manage")
+                return false;
+            const expected = mutations.find((candidate) => exactMutation(candidate, args));
+            if (!expected)
+                return false;
+            try {
+                const care = JSON.parse(result);
+                const binding = care.incidentBindings?.find((candidate) => candidate.source === expected.source && candidate.incidentKey === expected.incidentKey);
+                const resolved = expected.action === "resolve_incident" ? !!binding?.resolvedAt : binding?.classifiedRevision === expected.classifiedRevision;
+                const updatedUnderCas = typeof care.updatedAt === "string" && Date.parse(care.updatedAt) > Date.parse(expected.expectedUpdatedAt);
+                const wholeCareResolutionValid = expected.action !== "resolve_incident" || expected.currentRisk !== "" || care.incidentBindings?.some((candidate) => !candidate.resolvedAt) || care.status === "resolved";
+                if (care.id !== expected.id || care.label !== SAFE_LABEL || care.why !== expected.why || care.currentRisk !== (expected.currentRisk || null) || care.nextCheckAt !== (expected.nextCheckAt || null) || (expected.status && care.status !== expected.status) || !resolved || !updatedUnderCas || !wholeCareResolutionValid)
+                    return false;
+                completed.add(care.id);
+                return completed.size === mutations.length;
+            }
+            catch {
+                return false;
+            }
+        },
+        validateToolCallBeforeDispatch: (name, args) => {
+            if (name !== "care_manage")
+                return undefined;
+            if (!verifierComplete)
+                return "Read current Unraid notifications before mutating stale Docker Care.";
+            return mutations.some((candidate) => exactMutation(candidate, args)) ? undefined : `Only these exact evidence-bounded stale Docker Care mutations are authorized in this turn: ${JSON.stringify(mutations)}.`;
+        },
+        requiredToolCallsAfterResult: (name, _args, result) => {
+            if (name !== "unraid_get_notifications")
+                return [];
+            mutations = cares.map((care) => mutationFor(care, dockerObservation(result, care), now));
+            verifierComplete = true;
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_stale_docker_care_verification_completed", message: "current notification verification produced bounded Care outcomes", meta: { careCount: cares.length, mutationCount: mutations.length } });
+            return ["care_manage"];
+        },
+        expectedMutations: () => mutations.map((mutation) => ({ ...mutation })),
+        currentRiskClaims: () => mutations.filter((mutation) => mutation.currentRisk === ACTIVE_RISK).map((mutation) => mutation.currentRisk),
+    };
+}

package/dist/senses/sanctuary-storage-optimization-contract.js

@@ -11,13 +11,12 @@ function normalizedRequest(request) {
         .replace(/[^a-z0-9']+/gu, " ")
         .trim();
 }
-function sanctuaryStorageOptimizationRequiredToolCalls(request, advertisedToolNames) {
+function sanctuaryStorageOptimizationRequiredToolCalls(request, _advertisedToolNames) {
     const normalized = normalizedRequest(request);
     const hasStorageSubject = /\b(?:space|storage)\b/u.test(normalized);
     const hasUsageDiagnosis = /\b(?:using|taking up|find what|diagnos(?:e|is))\b/u.test(normalized);
     const hasShrinkIntent = /\b(?:make it smaller|shrink|reclaim|free up|reduce|optimi[sz])\b/u.test(normalized);
-    const advertised = new Set(advertisedToolNames);
-    if (!hasStorageSubject || !hasUsageDiagnosis || !hasShrinkIntent || !REQUIRED_TOOL_NAMES.every((name) => advertised.has(name)))
+    if (!hasStorageSubject || !hasUsageDiagnosis || !hasShrinkIntent)
         return undefined;
     const names = [...REQUIRED_TOOL_NAMES];
     (0, runtime_1.emitNervesEvent)({

package/dist/senses/telegram.js

@@ -1078,23 +1078,46 @@ function createTelegramSenseApp(options) {
                 authorizeTool: async (name, args) => (await options.resolveRelationshipAuthorization(relationshipCoordinates)).authorizeTool(name, args),
             };
         };
-        return async ({ runAgentOptions }) => {
+        return async ({ runAgentOptions, activeCares = [], careEvidenceNow = Date.now() }) => {
             const relationshipAuthorization = await resolveLiveRelationshipAuthorization();
-            const storageOptimization = options.agentName === "sanctuary" && relationshipAuthorization.profileId === "sanctuary-owner"
+            const isSanctuaryOwner = options.agentName === "sanctuary" && relationshipAuthorization.profileId === "sanctuary-owner";
+            const storageOptimization = isSanctuaryOwner
                 ? (0, sanctuary_storage_optimization_contract_1.sanctuaryStorageOptimizationRequiredToolCalls)(input.userMessage, relationshipAuthorization.advertisedToolNames)
                 : undefined;
-            const fullVisibility = options.agentName === "sanctuary" && relationshipAuthorization.profileId === "sanctuary-owner" && !storageOptimization
-                ? (0, sanctuary_full_visibility_contract_1.sanctuaryFullVisibilityRequiredToolCalls)(input.userMessage, relationshipAuthorization.advertisedToolNames)
+            const staleDockerCare = isSanctuaryOwner
+                ? (0, sanctuary_full_visibility_contract_1.sanctuaryStaleDockerCareRequiredToolCalls)(activeCares, careEvidenceNow, relationshipAuthorization.advertisedToolNames)
+                : undefined;
+            const fullVisibility = isSanctuaryOwner
+                ? (0, sanctuary_full_visibility_contract_1.sanctuaryFullVisibilityRequiredToolCalls)(input.userMessage, relationshipAuthorization.advertisedToolNames, () => staleDockerCare?.currentRiskClaims() ?? [])
                 : undefined;
             if (input.fullVisibilityProgress && fullVisibility)
                 input.fullVisibilityProgress.fallback = fullVisibility.emptyResponseFallback;
-            const requiredToolCalls = storageOptimization ?? (fullVisibility ? {
-                names: fullVisibility.names,
-                retryMessage: fullVisibility.retryMessage,
-                requireSuccessfulResults: fullVisibility.requireSuccessfulResults,
-                validateRequiredToolResult: fullVisibility.validateRequiredToolResult,
-                validateTerminalAnswer: fullVisibility.validateTerminalAnswer,
-            } : undefined);
+            const contracts = [storageOptimization, fullVisibility, staleDockerCare].filter(Boolean);
+            const ownedNames = contracts.map((contract) => new Set(contract.names));
+            const requiredToolCalls = contracts.length === 0 ? undefined : {
+                names: [...new Set(contracts.flatMap((contract) => [...contract.names]))],
+                get retryMessage() { return contracts.map((contract) => contract.retryMessage).join(" "); },
+                requireSuccessfulResults: true,
+                validateRequiredToolResult: (name, result, args) => contracts.every((contract, index) => {
+                    if (!ownedNames[index].has(name))
+                        return true;
+                    return contract.validateRequiredToolResult?.(name, result, args) ?? true;
+                }),
+                validateToolCallBeforeDispatch: (name, args) => contracts.map((contract) => contract.validateToolCallBeforeDispatch?.(name, args)).find((rejection) => rejection !== undefined),
+                requiredToolCallsAfterResult: (name, args, result) => {
+                    const added = new Set();
+                    contracts.forEach((contract, index) => {
+                        if (!ownedNames[index].has(name) || !contract.requiredToolCallsAfterResult)
+                            return;
+                        for (const requiredName of contract.requiredToolCallsAfterResult(name, args, result)) {
+                            ownedNames[index].add(requiredName);
+                            added.add(requiredName);
+                        }
+                    });
+                    return [...added];
+                },
+                validateTerminalAnswer: (answer) => contracts.map((contract) => contract.validateTerminalAnswer?.(answer)).find((rejection) => rejection !== undefined),
+            };
             return {
                 ...runAgentOptions,
                 ...(requiredToolCalls ? { requiredToolCalls } : {}),

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.768",
+  "version": "0.1.0-alpha.769",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.768",
+      "version": "0.1.0-alpha.769",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.768",
+  "version": "0.1.0-alpha.769",
   "engines": {
     "node": ">=22"
   },