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

package/dist/senses/private-runtime.js

@@ -56,6 +56,9 @@ const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
 const tools_1 = require("../repertoire/tools");
+const tools_awaiting_1 = require("../repertoire/tools-awaiting");
+const relationship_authorization_1 = require("../repertoire/relationship-authorization");
+const run_ledger_1 = require("../heart/run-ledger");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
 const pending_1 = require("../mind/pending");
 const obligations_1 = require("../arc/obligations");
@@ -83,6 +86,9 @@ const habit_policy_1 = require("../rsvp/habit-policy");
 const daemon_health_1 = require("../heart/daemon/daemon-health");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const desk_section_1 = require("../mind/desk-section");
+const sanctuary_runtime_1 = require("./sanctuary-runtime");
+const shared_turn_1 = require("./shared-turn");
+const relationship_authorization_2 = require("../repertoire/relationship-authorization");
 const private_runtime_1 = require("../heart/private-runtime");
 exports.PRIVATE_TURN_DECISION_MAX_AGE_MS = 15 * 60_000;
 const DUPLICATE_PRIVATE_TURN_STATUS = "DUPLICATE_PRIVATE_TURN";
@@ -93,6 +99,74 @@ const DEFAULT_PRIVATE_RUNTIME_INSTINCTS = [
         enabled: true,
     },
 ];
+class StaleRelationshipAwaitError extends Error {
+    reason;
+    constructor(reason) {
+        super(`Relationship await authority ${reason}`);
+        this.reason = reason;
+    }
+}
+function exactFriendFileIsMissing(agentRoot, friendId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(friendId))
+        throw new Error("Relationship await authority friend id is invalid");
+    try {
+        fs.lstatSync(path.join(agentRoot, "friends", `${friendId}.json`));
+        return false;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+}
+function relationshipAwaitCoordinates(awaitFile) {
+    const values = [awaitFile.filed_for_friend_id, awaitFile.filed_from, awaitFile.filed_from_key];
+    if (!awaitFile.request_id) {
+        if (awaitFile.filed_from === "external-event" && awaitFile.filed_for_friend_id && awaitFile.filed_from_key) {
+            if (Buffer.byteLength(awaitFile.filed_for_friend_id) > 256 || Buffer.byteLength(awaitFile.filed_from_key) > 1_024)
+                throw new Error("Relationship await provenance is invalid");
+            return { friendId: awaitFile.filed_for_friend_id, channel: awaitFile.filed_from, key: awaitFile.filed_from_key, requestId: null };
+        }
+        const isSystemAwait = awaitFile.filed_for_friend_id === null
+            && awaitFile.filed_from_key === null
+            && (awaitFile.filed_from === null || awaitFile.filed_from === "unknown" || awaitFile.filed_from === "cli");
+        if (isSystemAwait)
+            return null;
+        throw new Error("Relationship await provenance is incomplete or legacy");
+    }
+    if (values.some((value) => value === null))
+        throw new Error("Relationship await provenance is incomplete or legacy");
+    const [friendId, channel, key] = values;
+    if (channel !== "telegram" || Buffer.byteLength(friendId) > 256 || Buffer.byteLength(channel) > 64 || Buffer.byteLength(key) > 1_024 || Buffer.byteLength(awaitFile.request_id) > 256) {
+        throw new Error("Relationship await provenance is invalid");
+    }
+    return { friendId, channel, key, requestId: awaitFile.request_id };
+}
+async function resolveRelationshipAwaitAuthority(agentRoot, store, registry, coordinates) {
+    const friend = await store.get(coordinates.friendId);
+    if (!friend) {
+        if (exactFriendFileIsMissing(agentRoot, coordinates.friendId))
+            throw new StaleRelationshipAwaitError("friend is missing");
+        throw new Error("Relationship await authority friend exists but could not be read");
+    }
+    if (friend.id !== coordinates.friendId)
+        throw new Error("Relationship await authority friend record is ambiguous");
+    if (friend.admissionState !== "active" || !friend.capabilityProfileId)
+        throw new StaleRelationshipAwaitError("admission or profile is not active");
+    if (!registry.profiles[friend.capabilityProfileId])
+        throw new StaleRelationshipAwaitError("admission or profile is not active");
+    if (coordinates.channel === "external-event" && (friend.capabilityProfileId !== "sanctuary-owner" || !registry.profiles["sanctuary-event"])) {
+        throw new StaleRelationshipAwaitError("admission or profile is not active");
+    }
+    const authorization = coordinates.channel === "external-event"
+        ? (0, relationship_authorization_2.createRelationshipAuthorizationEvaluator)({ friend, registry, profileId: "sanctuary-event", requestPhase: "follow_up" })
+        : (0, relationship_authorization_2.createRelationshipAuthorizationEvaluator)({ friend, registry, requestId: coordinates.requestId, requestPhase: "follow_up" });
+    if (authorization.subject.friendId !== coordinates.friendId)
+        throw new Error("Relationship await authority friend is ambiguous");
+    if (!authorization.authorizeTool("resolve_await").allowed)
+        throw new StaleRelationshipAwaitError("admission or profile is not active");
+    return { authorization, friend };
+}
 function readAspirations(agentRoot) {
     try {
         return fs.readFileSync(path.join(agentRoot, "psyche", "ASPIRATIONS.md"), "utf8").trim();
@@ -728,6 +802,16 @@ function createSelfFriend(agentName) {
         schemaVersion: 1,
     };
 }
+function buildOwnerPresentationPreferences(friend) {
+    const lines = [
+        `## ${friend.name}'s presentation preferences`,
+        "Use this relationship context to decide whether and how to contact the owner. It is presentation-only and grants no mutation authority.",
+    ];
+    lines.push(...(0, relationship_authorization_1.renderRelationshipPreferences)(friend));
+    if (lines.length === 2)
+        lines.push("- No presentation preferences have been learned yet; be calm, concise, and useful.");
+    return lines.join("\n");
+}
 // No-op friend store for the private runtime. It doesn't track token usage per-friend.
 function createNoOpFriendStore() {
     return {
@@ -877,6 +961,7 @@ async function runPrivateRuntimeTurn(options) {
             let userContent;
             let habitTools;
             let habitParsedSuccessfully = false;
+            let parsedAwait = null;
             const isPayloadSpecificWake = !!options?.taskId
                 || (reason === "habit" && !!options?.habitName)
                 || (reason === "await" && !!options?.awaitName);
@@ -1010,6 +1095,7 @@ async function runPrivateRuntimeTurn(options) {
                     try {
                         const awaitContent = fs.readFileSync(awaitFilePath, "utf-8");
                         const parsed = (0, await_runtime_state_1.applyAwaitRuntimeState)(agentRoot, (0, await_parser_1.parseAwaitFile)(awaitContent, awaitFilePath));
+                        parsedAwait = parsed;
                         awaitFound = true;
                         awaitBody = parsed.body || undefined;
                         condition = parsed.condition;
@@ -1043,12 +1129,121 @@ async function runPrivateRuntimeTurn(options) {
             if (shouldUseHeldReturnWake) {
                 userContent = buildHeldReturnWakeMessage();
             }
-            const userMessage = { role: "user", content: userContent };
             // ── Session loader: wraps existing session logic ──────────────────
             const innerCapabilities = (0, friends_1.getChannelCapabilities)("inner");
             const selfFriend = createSelfFriend(agentName);
             const selfContext = { friend: selfFriend, channel: innerCapabilities };
             const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
+            const relationshipAwaitCoordinatesValue = parsedAwait ? relationshipAwaitCoordinates(parsedAwait) : null;
+            const relationshipAwait = relationshipAwaitCoordinatesValue
+                ? await (async () => {
+                    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+                    const assertLiveBinding = () => {
+                        const binding = relationshipAwaitCoordinatesValue.channel === "external-event"
+                            ? parsedAwait.wake_at && (0, tools_awaiting_1.hasActiveExternalEventAwait)(agentName, { recordPath: relationshipAwaitCoordinatesValue.key, awaitName: parsedAwait.name, wakeAt: parsedAwait.wake_at })
+                                ? { active: true }
+                                : { active: false, reason: "external event disposition is no longer active" }
+                            : (0, tools_awaiting_1.inspectRelationshipFollowUp)(agentRoot, {
+                                friendId: relationshipAwaitCoordinatesValue.friendId,
+                                channel: relationshipAwaitCoordinatesValue.channel,
+                                key: relationshipAwaitCoordinatesValue.key,
+                                requestId: relationshipAwaitCoordinatesValue.requestId,
+                                awaitName: parsedAwait.name,
+                                now: now().getTime(),
+                            });
+                        if (!binding.active) {
+                            (0, tools_awaiting_1.cancelStaleAwait)(agentRoot, agentName, parsedAwait.name, binding.reason);
+                            throw new Error(`Relationship await authority binding is missing, stale, or ambiguous: ${binding.reason}`);
+                        }
+                    };
+                    assertLiveBinding();
+                    const store = new friends_1.FileFriendStore(path.join(agentRoot, "friends"));
+                    const resolve = () => resolveRelationshipAwaitAuthority(agentRoot, store, (0, relationship_authorization_2.loadRelationshipCapabilityRegistry)(agentRoot), relationshipAwaitCoordinatesValue);
+                    const resolveOrCancel = async () => {
+                        try {
+                            return await resolve();
+                        }
+                        catch (error) {
+                            if (error instanceof StaleRelationshipAwaitError)
+                                (0, tools_awaiting_1.cancelStaleAwait)(agentRoot, agentName, parsedAwait.name, error.reason);
+                            throw error;
+                        }
+                    };
+                    const initial = await resolveOrCancel();
+                    return {
+                        store,
+                        context: { friend: initial.friend, channel: innerCapabilities },
+                        currentSession: {
+                            friendId: relationshipAwaitCoordinatesValue.friendId,
+                            channel: relationshipAwaitCoordinatesValue.channel,
+                            key: relationshipAwaitCoordinatesValue.key,
+                            sessionPath: relationshipAwaitCoordinatesValue.channel === "telegram"
+                                ? (0, shared_turn_1.getSenseSessionPath)(agentName, relationshipAwaitCoordinatesValue.friendId, "telegram", relationshipAwaitCoordinatesValue.key, agentRoot)
+                                : sessionFilePath,
+                        },
+                        relationshipAuthorization: {
+                            ...(relationshipAwaitCoordinatesValue.requestId ? { requestId: relationshipAwaitCoordinatesValue.requestId } : {}),
+                            profileId: initial.authorization.profileId,
+                            authorizedContextScopes: initial.authorization.authorizedContextScopes,
+                            advertisedToolNames: relationshipAwaitCoordinatesValue.channel === "external-event" ? ["resolve_await"] : initial.authorization.advertisedToolNames,
+                            authorizeTool: async (name, args) => {
+                                assertLiveBinding();
+                                const decision = (await resolveOrCancel()).authorization.authorizeTool(name, args);
+                                return relationshipAwaitCoordinatesValue.channel !== "external-event" || name === "resolve_await"
+                                    ? decision
+                                    : { ...decision, allowed: false, reason: "external event await wake is resolve-only" };
+                            },
+                        },
+                    };
+                })()
+                : undefined;
+            const externalEventRelationship = options?.externalEvent
+                ? await (async () => {
+                    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+                    const store = new friends_1.FileFriendStore(path.join(agentRoot, "friends"));
+                    const registry = (0, relationship_authorization_2.loadRelationshipCapabilityRegistry)(agentRoot);
+                    const resolve = () => (0, relationship_authorization_2.resolveProfileScopedRelationshipAuthorization)({
+                        store,
+                        registry,
+                        relationshipProfileId: "sanctuary-owner",
+                        profileId: "sanctuary-event",
+                    });
+                    const initial = await resolve();
+                    const initialDisposition = initial.authorizeTool("external_event_disposition");
+                    if (!initialDisposition.allowed)
+                        throw new Error(`external event relationship authority denied: ${initialDisposition.reason}`);
+                    const owners = (await store.listAll()).filter((friend) => friend.capabilityProfileId === "sanctuary-owner");
+                    const [owner] = owners;
+                    if (owners.length !== 1 || !owner)
+                        throw new Error("external event owner presentation context must resolve to exactly one Friend");
+                    return {
+                        store,
+                        context: { friend: owner, channel: innerCapabilities },
+                        ownerPresentationPreferences: buildOwnerPresentationPreferences(owner),
+                        relationshipAuthorization: {
+                            profileId: initial.profileId,
+                            authorizedContextScopes: initial.authorizedContextScopes,
+                            advertisedToolNames: initial.advertisedToolNames,
+                            authorizeTool: async (name) => (await resolve()).authorizeTool(name),
+                        },
+                        externalEventAuthority: {
+                            authorizeDisposition: () => {
+                                const decision = initial.authorizeTool("external_event_disposition");
+                                return decision.allowed ? { allowed: true, reason: "relationship-authorized" } : { allowed: false, reason: decision.reason };
+                            },
+                        },
+                        externalEventEffects: {
+                            deliverOwnerDecision: async (input) => {
+                                const { sendTelegramExternalEventDecision } = await Promise.resolve().then(() => __importStar(require("./telegram")));
+                                await sendTelegramExternalEventDecision(agentName, input);
+                            },
+                        },
+                    };
+                })()
+                : undefined;
+            if (externalEventRelationship)
+                userContent = `${userContent}\n\n${externalEventRelationship.ownerPresentationPreferences}`;
+            const userMessage = { role: "user", content: userContent };
             // ── Habit tool enforcement ───────────────────────────────────────
             let habitToolsResolved;
             if (habitTools !== undefined) {
@@ -1076,6 +1271,12 @@ async function runPrivateRuntimeTurn(options) {
             if (options?.noSend === true) {
                 habitToolsResolved = [];
             }
+            const externalEventToolsResolved = options?.externalEvent
+                ? (0, tools_1.getSanctuaryRelationshipTools)(externalEventRelationship.relationshipAuthorization.advertisedToolNames)
+                : undefined;
+            const relationshipAwaitToolsResolved = relationshipAwait
+                ? (0, tools_1.getSanctuaryRelationshipTools)(relationshipAwait.relationshipAuthorization.advertisedToolNames)
+                : undefined;
             const effectiveHabitSession = options?.noSend === true
                 ? reduceHabitSessionToNoSend(options.habitSession)
                 : options?.habitSession;
@@ -1105,71 +1306,117 @@ async function runPrivateRuntimeTurn(options) {
             const traceId = (0, nerves_1.createTraceId)();
             // Attention queue: built when pending messages are drained, shared with tool context
             let attentionQueue = [];
-            const result = await (0, pipeline_1.handleInboundTurn)({
-                channel: "inner",
-                sessionKey: "dialog",
-                capabilities: innerCapabilities,
-                messages: [userMessage],
-                continuityIngressTexts: [],
-                callbacks,
-                sessionTurnLease,
-                friendResolver: { resolve: () => Promise.resolve(selfContext) },
-                sessionLoader,
-                pendingDir,
-                friendStore: createNoOpFriendStore(),
-                enforceTrustGate: trust_gate_1.enforceTrustGate,
-                drainPending: pending_1.drainPending,
-                runAgent: core_1.runAgent,
-                postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
-                    const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
-                    return (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
-                },
-                accumulateFriendTokens: friends_1.accumulateFriendTokens,
-                signal: options?.signal,
-                /* v8 ignore start -- attention queue: callback invoked by pipeline during pending drain; tested via attention-queue unit tests @preserve */
-                onPendingDrained: (drained) => {
-                    const outstandingObligations = (0, obligations_1.listActiveReturnObligations)(agentName);
-                    const builtAttentionQueue = (0, attention_queue_1.buildAttentionQueue)({
-                        drainedPending: drained,
-                        outstandingObligations,
-                        friendNameResolver: (friendId) => {
-                            try {
-                                const raw = fs.readFileSync(path.join((0, identity_1.getAgentRoot)(agentName), "friends", friendId + ".json"), "utf-8");
-                                const parsed = JSON.parse(raw);
-                                return typeof parsed.name === "string" ? parsed.name : null;
-                            }
-                            catch {
-                                return null;
-                            }
-                        },
-                        packetResolver: (packetId) => {
-                            try {
-                                return (0, packets_1.readPonderPacket)((0, identity_1.getAgentRoot)(agentName), packetId);
-                            }
-                            catch {
-                                return null;
-                            }
+            const externalRunStartedAt = now().toISOString();
+            const externalRunBase = options?.externalEvent ? {
+                agent: agentName,
+                triggerType: "inbound",
+                sourceKind: "private-runtime",
+                senseOrHabit: "external-event",
+                target: { source: options.externalEvent.source, eventId: options.externalEvent.eventId, generation: options.externalEvent.generation, observationRevision: options.externalEvent.observationRevision },
+                idempotencyScope: { recordPath: options.externalEvent.recordPath, generation: options.externalEvent.generation, observationRevision: options.externalEvent.observationRevision },
+                startedAt: externalRunStartedAt,
+            } : null;
+            if (externalRunBase)
+                (0, run_ledger_1.appendRunLedgerRecordNonFatal)((0, identity_1.getAgentRoot)(agentName), (0, run_ledger_1.createRunLedgerRecord)({ ...externalRunBase, lifecycle: "started" }));
+            let result;
+            try {
+                result = await (0, pipeline_1.handleInboundTurn)({
+                    channel: "inner",
+                    sessionKey: "dialog",
+                    capabilities: innerCapabilities,
+                    messages: [userMessage],
+                    continuityIngressTexts: [],
+                    callbacks,
+                    sessionTurnLease,
+                    friendResolver: { resolve: () => Promise.resolve(selfContext) },
+                    sessionLoader,
+                    pendingDir,
+                    friendStore: createNoOpFriendStore(),
+                    enforceTrustGate: trust_gate_1.enforceTrustGate,
+                    drainPending: pending_1.drainPending,
+                    runAgent: core_1.runAgent,
+                    postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                        const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
+                        return (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
+                    },
+                    accumulateFriendTokens: friends_1.accumulateFriendTokens,
+                    signal: options?.signal,
+                    /* v8 ignore start -- attention queue: callback invoked by pipeline during pending drain; tested via attention-queue unit tests @preserve */
+                    onPendingDrained: (drained) => {
+                        const outstandingObligations = (0, obligations_1.listActiveReturnObligations)(agentName);
+                        const builtAttentionQueue = (0, attention_queue_1.buildAttentionQueue)({
+                            drainedPending: drained,
+                            outstandingObligations,
+                            friendNameResolver: (friendId) => {
+                                try {
+                                    const raw = fs.readFileSync(path.join((0, identity_1.getAgentRoot)(agentName), "friends", friendId + ".json"), "utf-8");
+                                    const parsed = JSON.parse(raw);
+                                    return typeof parsed.name === "string" ? parsed.name : null;
+                                }
+                                catch {
+                                    return null;
+                                }
+                            },
+                            packetResolver: (packetId) => {
+                                try {
+                                    return (0, packets_1.readPonderPacket)((0, identity_1.getAgentRoot)(agentName), packetId);
+                                }
+                                catch {
+                                    return null;
+                                }
+                            },
+                        });
+                        attentionQueue.splice(0, attentionQueue.length, ...builtAttentionQueue);
+                        const attentionFrame = (0, attention_queue_1.buildAttentionQueueStatusFrame)(attentionQueue);
+                        return attentionFrame ? [attentionFrame] : [];
+                    },
+                    /* v8 ignore stop */
+                    runAgentOptions: {
+                        traceId,
+                        toolChoiceRequired: true,
+                        mcpManager,
+                        ...(options?.externalEvent
+                            ? { tools: externalEventToolsResolved }
+                            : relationshipAwaitToolsResolved !== undefined ? { tools: relationshipAwaitToolsResolved }
+                                : habitToolsResolved !== undefined ? { tools: habitToolsResolved } : {}),
+                        toolContext: {
+                            signin: async () => undefined,
+                            delegatedOrigins: attentionQueue,
+                            ...(relationshipAwait ? {
+                                friendStore: relationshipAwait.store,
+                                context: relationshipAwait.context,
+                                currentSession: relationshipAwait.currentSession,
+                                relationshipAuthorization: relationshipAwait.relationshipAuthorization,
+                            } : {}),
+                            ...(options?.externalEvent ? {
+                                currentExternalEvent: Object.freeze({ ...options.externalEvent }),
+                                friendStore: externalEventRelationship.store,
+                                context: externalEventRelationship.context,
+                                relationshipAuthorization: externalEventRelationship.relationshipAuthorization,
+                                externalEventAuthority: externalEventRelationship.externalEventAuthority,
+                                externalEventEffects: externalEventRelationship.externalEventEffects,
+                                ...(["sanctuary-health", "sanctuary-usenet"].includes(options.externalEvent.source) ? (0, sanctuary_runtime_1.createSanctuaryToolContext)(agentName) : {}),
+                            } : {}),
+                            ...(options?.noSend ? { noSend: true } : {}),
+                            ...(effectiveHabitSession ? { habitSession: effectiveHabitSession } : {}),
                         },
-                    });
-                    attentionQueue.splice(0, attentionQueue.length, ...builtAttentionQueue);
-                    const attentionFrame = (0, attention_queue_1.buildAttentionQueueStatusFrame)(attentionQueue);
-                    return attentionFrame ? [attentionFrame] : [];
-                },
-                /* v8 ignore stop */
-                runAgentOptions: {
-                    traceId,
-                    toolChoiceRequired: true,
-                    mcpManager,
-                    ...(habitToolsResolved !== undefined && { tools: habitToolsResolved }),
-                    toolContext: {
-                        signin: async () => undefined,
-                        delegatedOrigins: attentionQueue,
-                        ...(options?.noSend ? { noSend: true } : {}),
                         ...(effectiveHabitSession ? { habitSession: effectiveHabitSession } : {}),
                     },
-                    ...(effectiveHabitSession ? { habitSession: effectiveHabitSession } : {}),
-                },
-            });
+                });
+                if (externalRunBase) {
+                    const lifecycle = result.turnOutcome === "settled" || result.turnOutcome === "observed" || result.turnOutcome === "rested"
+                        ? "completed"
+                        : result.turnOutcome === "errored" ? "error"
+                            : result.turnOutcome === "blocked" || result.turnOutcome === "suspended" ? "blocked"
+                                : "skipped";
+                    (0, run_ledger_1.appendRunLedgerRecordNonFatal)((0, identity_1.getAgentRoot)(agentName), (0, run_ledger_1.createRunLedgerRecord)({ ...externalRunBase, lifecycle, endedAt: now().toISOString(), usage: (0, run_ledger_1.usageMetadataFromUsageData)(result.usage, result.usage ? "provider" : "reported-unavailable"), ...(result.turnOutcome === "errored" ? { errorName: "AgentTurnError" } : {}) }));
+                }
+            }
+            catch (error) {
+                if (externalRunBase)
+                    (0, run_ledger_1.appendRunLedgerRecordNonFatal)((0, identity_1.getAgentRoot)(agentName), (0, run_ledger_1.createRunLedgerRecord)({ ...externalRunBase, lifecycle: "error", endedAt: now().toISOString(), errorName: error instanceof Error ? error.name : "UnknownError" }));
+                throw error;
+            }
             // Post-turn routeDelegatedCompletion removed: delivery is now inline via surface tool.
             // settle in the private runtime produces no CompletionMetadata, so routeDelegatedCompletion
             // would be a no-op. The routing infrastructure is reused by the surface handler.

package/dist/senses/sanctuary-health-acceptance-probe.js

@@ -65,7 +65,7 @@ const TARGET_ENDPOINT = "https://books.mendelow.cloud/";
 const CRON_MARKER = "# ouro:habit:sanctuary:sanctuary:sanctuary-health";
 const CRON_COMMAND = "*/15 * * * * /usr/local/bin/node /opt/ouro/dist/heart/daemon/ouro-entry.js poke sanctuary --habit sanctuary-health --trigger cron";
 const PROCESS_ENTRY = "/opt/ouro/dist/senses/sanctuary-health-acceptance-probe-entry.js";
-const LABELS = ["unit-16f-cron-fingerprint", "unit-16g-health-transition", "unit-16h-daily-digest"];
+const LABELS = ["unit-16f-cron-fingerprint", "unit-16g-health-transition", "unit-16h-acceptance-delivery-probe"];
 function digestBytes(value) {
     return (0, node_crypto_1.createHash)("sha256").update(value).digest("hex");
 }
@@ -505,7 +505,7 @@ async function runSanctuaryHealthAcceptanceProbe(input, dependencies = createSan
     const cronBefore = fs.readFileSync(cronPath, "utf8");
     const cronFingerprintBefore = digestBytes(cronBefore);
     const cronRegisteredBefore = canonicalCron(cronBefore);
-    const effectiveNow = input.label === "unit-16h-daily-digest" ? exactLocalDailyBoundary(dependencies.now()) : dependencies.now();
+    const effectiveNow = input.label === "unit-16h-acceptance-delivery-probe" ? exactLocalDailyBoundary(dependencies.now()) : dependencies.now();
     let fixture;
     let expectedIncidentDigest = "";
     let realCheckEquivalent = false;
@@ -539,7 +539,7 @@ async function runSanctuaryHealthAcceptanceProbe(input, dependencies = createSan
         else
             await (0, sanctuary_health_1.withSanctuaryHealthStateLease)(statePath, async (lease) => {
                 expectedIncidentDigest = await normalizeWorkingState({ workspace, statePath, deps: dependencies, effectiveNow });
-                if (input.label === "unit-16h-daily-digest") {
+                if (input.label === "unit-16h-acceptance-delivery-probe") {
                     const state = readHealthState(statePath);
                     state.incidents[`endpoint:${TARGET_ENDPOINT}`] = { id: `endpoint:${TARGET_ENDPOINT}`, summary: `${TARGET_ENDPOINT} returned 503` };
                     state.lastDigestDay = localDay(new Date(effectiveNow.getTime() - 36 * 60 * 60 * 1_000));
@@ -570,8 +570,8 @@ async function runSanctuaryHealthAcceptanceProbe(input, dependencies = createSan
                 }
                 else {
                     fixture = await createSanctuaryHealthAcceptanceLoopbackFixture([503, 503], dependencies.ambientFetch, dependencies.createLoopbackServer);
-                    await runPhase("digest-boundary", "acceptance", 503, fixture.fetch, effectiveNow);
-                    await runPhase("digest-repeat", "acceptance", 503, fixture.fetch, effectiveNow);
+                    await runPhase("delivery-probe-first", "acceptance", 503, fixture.fetch, effectiveNow);
+                    await runPhase("delivery-probe-repeat", "acceptance", 503, fixture.fetch, effectiveNow);
                 }
                 await closeServer(fixture.server);
                 socketAbsent = fixture.server.address() === null;
@@ -602,7 +602,7 @@ async function runSanctuaryHealthAcceptanceProbe(input, dependencies = createSan
             cronDegradedBefore: !cronRegisteredBefore,
             cronDegradedAfter: !cronRegisteredAfter,
             fixtureSequenceDigest: digestJson(observedFixtureSequence),
-            clockMode: input.label === "unit-16h-daily-digest" ? "local-daily-boundary" : "ambient",
+            clockMode: input.label === "unit-16h-acceptance-delivery-probe" ? "local-daily-boundary" : "ambient",
             effectiveNow: effectiveNow.toISOString(),
             phases,
             providerInvocationCount,
@@ -615,6 +615,8 @@ async function runSanctuaryHealthAcceptanceProbe(input, dependencies = createSan
             productionRestored: beforeStateDigest === restoredStateDigest && cronFingerprintBefore === cronFingerprintAfter
                 && cronRegisteredBefore && cronRegisteredAfter && socketAbsent && realCheckEquivalent,
             schedulerReceipt,
+            acceptanceOnly: true,
+            productionScheduleChanged: false,
         };
         if (input.label === "unit-16f-cron-fingerprint")
             receipt.productionRestored = cronFingerprintBefore === cronFingerprintAfter