@wildo-ai/saas-backend-lib 1.1.12 → 1.1.13

package/dist/esm/flows-actors/services/conversational-execution.backend.service.js

@@ -74,7 +74,7 @@ import { runOutsideModelSpendFrame, runWithModelSpendFrame } from '../../runtime
 import { humanDecisionDeciderEventFields, humanDecisionDeciderRecordOfActor, humanDecisionRequesterEventFields } from '../../flows-actors/utils/human-decision-decider.backend.utils.js';
 import { humanDecisionReplyAnswerOf } from '../../flows-actors/utils/human-decision-reply-answer.backend.utils.js';
 import { sealDecisionInTransaction } from '../../compliance/approval-seals/approval-seal-store.backend.js';
-import { DecisionPresentationCheckKind, acknowledgeDecisionPresentation, decisionPresentationKeyOfRuntime, decisionStatementOf, resolveDecisionDeliverables, withDecisionPresentation, } from '../../compliance/approval-seals/decision-presentation.backend.js';
+import { DecisionPresentationCheckKind, acknowledgeDecisionPresentation, decisionPresentationKeyOfRuntime, decisionStatementOf, resolveDecisionDeliverables, resolveDecisionSubjectRecord, withDecisionPresentation, } from '../../compliance/approval-seals/decision-presentation.backend.js';
 import { ApprovalSealMeaning, ApprovalSource, isApprovalSealOutcome } from '@wildo-ai/saas-models';
 import { agentWorkOwnerOfExecution, owedRecordIsRepairableFromRow, } from '../../flows-actors/services/agent-work-decisions.backend.service.js';
 import { NO_HUMAN_DECISION_ROLE_FACTS, PENDING_DECISION_CLEARED, humanDecisionRequesterOfAuth, humanDecisionRequesterOfRow, humanDecisionRouteOfRow, announceHumanDecisionRouted, announceCapturedHumanDecision, announceHumanDecisionWithdrawn, admitHumanDecisionAnswerers, chatOfferableAnswerPredicate, collectHumanDecisionAnswerers, holdHumanDecisionActorToGrantingOrganization, HumanDecisionGrantorHoldKind, END_PENDING_DECISION_ROUTE_ATTEMPTS, isReviewerRoute, resolveHumanDecisionListingOrganizationIds, resolveHumanDecisionRoleFacts, humanDecisionSubjectOfToolCall, humanDecisionForeignKeyArgumentsEdited, answersAsOrganizationOwnStaff, HUMAN_DECISION_NAMES_NO_RECORD, HumanDecisionSubjectKind, toolApprovalDecisionRequest, toolApprovalVerdictOf, createHumanDecisionRoleFactsPorts, answeredThroughRefusalFields, lapsedActorRefusalReason, DECISION_REQUEST_REPAIR_GRACE_MS, DecisionRequestWriteOutcome, humanDecisionRequestedAuditEventId, readBackThrownDecisionRequestWrite, waitBeforeDecisionRequestRead, } from './pending-human-decision.backend.utils.js';
@@ -2473,7 +2473,8 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
          * expiry, and this block is the only path by which a client can learn it.
          */
         // #2904: the call's file deliverable, bound by its hash as every card of this decision binds it.
-        const { deliverables } = await this.decisionDeliverablesOf(systemRef, {
+        // #2914: and the record it acts on, with the fields its approval covers.
+        const { deliverables, subjectRecord } = await this.decisionPresentationBindingsOf(systemRef, {
             decisionRef, toolName: suspension.toolName, toolArgs: suspension.toolArgs,
             ...(route.organizationId ? { organizationId: route.organizationId } : {}),
         });
@@ -2487,6 +2488,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             expiresAt: pausedApprovalExpiresAt,
             ...(questionForm ? { questionForm } : {}),
             ...(deliverables ? { deliverables } : {}),
+            ...(subjectRecord ? { subjectRecord } : {}),
         });
         emitter(CoreWebSocketEvent.FLOWS_ACTORS_MESSAGE, {
             systemRef,
@@ -2691,6 +2693,16 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             return undefined;
         }
     }
+    /** Whether a gated tool declares that its approval of a row replaces its earlier approval of that row (#2914). */
+    approvalReplacesEarlierApprovalOfRow(systemRef, toolName) {
+        try {
+            const resolved = this.resolveApprovalGatedFunctionTool(systemRef, toolName);
+            return resolved.kind === GatedFunctionToolResolutionKind.FOUND && resolved.functionTool.approvalReplacesEarlierApprovalOfRow === true;
+        }
+        catch {
+            return false;
+        }
+    }
     /** The argument a gated tool declares names its file deliverable (#2904), when it declares one. */
     deliverableFileArgumentOf(systemRef, toolName) {
         try {
@@ -2702,8 +2714,45 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
         }
     }
     /**
-     * A gated call's file deliverable, bound by its content hash (#2904): the ONE resolution the announcement, the history,
-     * the inbox and the act read, so they agree on the presentation and its id. Nothing for a tool that declares none.
+     * What a gated call's presentation binds beyond its arguments: its file deliverable, bound by its content hash (#2904),
+     * and the record it acts on with the fields its approval covers (#2914). The ONE resolution the announcement, the
+     * history, the inbox and the act read, so they agree on the presentation and its id. Nothing for a tool that declares
+     * neither.
+     */
+    async decisionPresentationBindingsOf(systemRef, call) {
+        const [deliverables, subjectRecord] = await Promise.all([this.decisionDeliverablesOf(systemRef, call), this.decisionSubjectRecordOf(systemRef, call)]);
+        return { ...deliverables, ...(subjectRecord ? { subjectRecord } : {}) };
+    }
+    /**
+     * The record a gated call acts on, with the fields its tool declares the approval covers (#2914,
+     * `FunctionTool.sealedRecordFields`), read as the system. Undefined for a tool that declares none.
+     */
+    async decisionSubjectRecordOf(systemRef, call) {
+        let tool;
+        try {
+            const resolved = this.resolveApprovalGatedFunctionTool(systemRef, call.toolName);
+            tool = resolved.kind === GatedFunctionToolResolutionKind.FOUND ? resolved.functionTool : undefined;
+        }
+        catch {
+            return undefined;
+        }
+        if (!tool?.sealedRecordFields)
+            return undefined;
+        return resolveDecisionSubjectRecord({
+            sealedFields: tool.sealedRecordFields,
+            resourceType: tool.argumentsResource?.resourceType,
+            rowIdArgument: tool.argumentsResource?.rowIdArgument,
+            toolArgs: call.toolArgs,
+            ...(call.organizationId ? { organizationId: call.organizationId } : {}),
+            readRow: (resourceType, rowId) => this.systemAccess.readAsSystem(resourceType, { _id: rowId }, { suppressSystemAudit: true }),
+            onReadFailure: (error) => this.logger.warn('[ConversationalExecution] The record a decision is about could not be read; it is shown and sealed with no record values', {
+                systemRef, decisionRef: call.decisionRef, toolName: call.toolName, ...projectCaughtErrorLogFields(error),
+            }),
+        });
+    }
+    /**
+     * A gated call's file deliverable, bound by its content hash (#2904). Nothing for a tool that declares none. Read through
+     * {@link decisionPresentationBindingsOf}, never alone.
      */
     async decisionDeliverablesOf(systemRef, call) {
         const deliverableArgument = this.deliverableFileArgumentOf(systemRef, call.toolName);
@@ -2801,7 +2850,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
                 const presented = withDecisionPresentation({
                     decisionRef: pause.decisionRef, plane: HumanDecision_Plane.CONVERSATIONAL, toolName: pause.toolName,
                     toolArgs: pause.toolArgs ?? {}, ...(question ? { request: question } : {}),
-                }, decisionPresentationKeyOfRuntime(this.appConfig), pause.deliverables);
+                }, decisionPresentationKeyOfRuntime(this.appConfig), pause.deliverables, pause.subjectRecord);
                 return { presentation: presented.presentation, presentationId: presented.presentationId };
             })() : {}),
         };
@@ -2826,7 +2875,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             if (!row || row.status !== FlowsActors_Status.AWAITING_APPROVAL || !row.pausedApproval)
                 return undefined;
             const paused = parseFlowActorPausedApproval(row.pausedApproval);
-            const { deliverables } = row.pendingDecisionRef ? await this.decisionDeliverablesOf(execution.systemRef, {
+            const { deliverables, subjectRecord } = row.pendingDecisionRef ? await this.decisionPresentationBindingsOf(execution.systemRef, {
                 decisionRef: row.pendingDecisionRef, toolName: paused.pendingToolName, toolArgs: paused.pendingToolArgs,
                 ...(row.pendingDecisionOrganizationId ? { organizationId: row.pendingDecisionOrganizationId } : {}),
             }) : {};
@@ -2840,6 +2889,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
                 ...(paused.expiresAt ? { expiresAt: paused.expiresAt } : {}),
                 ...(paused.questionForm ? { questionForm: paused.questionForm } : {}),
                 ...(deliverables ? { deliverables } : {}),
+                ...(subjectRecord ? { subjectRecord } : {}),
             });
         }
         catch (error) {
@@ -2945,9 +2995,10 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
         // #2865: an erasure's ending CANCELS the work whatever its outcome (see DECISION_ENDED_BY_ERASURE); every other
         // ending ends it as its outcome says.
         const transition = params.erasure ? DECISION_ENDED_BY_ERASURE : DECISION_ENDING_TRANSITION[params.outcome];
-        if (params.decisionRef && !params.teardown)
-            await this.repayOwedCorrectionBeforeOverwrite(params.resourceType, params.row, params.decisionRef, params.erasure);
-        const transaction = params.teardown?.transaction ?? params.erasure?.transaction;
+        if (params.decisionRef && !params.teardown) {
+            await this.repayOwedCorrectionBeforeOverwrite(params.resourceType, params.row, params.decisionRef, params.erasure, params.deletion?.transaction);
+        }
+        const transaction = params.teardown?.transaction ?? params.erasure?.transaction ?? params.deletion?.transaction;
         const writeOptions = {
             ...(params.scopeContext ? { scopeContext: params.scopeContext } : {}),
             ...(transaction ? { transaction } : {}),
@@ -2991,7 +3042,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             if (ended !== null && ended !== undefined) {
                 // #2821: ending the decision ends its work, as the status this write set. Not for a teardown: the row is being
                 // deleted or scrubbed, and an erasure must not write new data about its subject.
-                if (params.decisionRef && !params.teardown) {
+                if (params.decisionRef && !params.teardown && !params.deletion) {
                     const workRef = row.pendingDecisionWorkRef ?? params.decisionRef;
                     if (params.erasure) {
                         // After the erasure commits: the log is a write of its own, and a rolled-back erasure ended nothing.
@@ -3044,7 +3095,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
                 // A teardown cannot read an unreadable row as "nothing waits": it is about to delete or scrub that row, so the
                 // decision would stay requested forever. It fails the teardown instead, as the settler contract asks (#2582
                 // review F6). Every other ending treats the row as gone, as before.
-                if (params.teardown || params.erasure)
+                if (params.teardown || params.erasure || params.deletion)
                     throw error;
                 return null;
             });
@@ -3154,7 +3205,9 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
      */
     async repayOwedCorrectionBeforeOverwrite(resourceType, row, decisionRef, 
     /** An erasure's repay: inside its transaction, without the erased person, and a failure fails the erasure. */
-    erasure) {
+    erasure, 
+    /** A deletion's transaction (#2297): the repay joins it, and a failure fails the deletion (it has aborted the transaction). */
+    deletionTransaction) {
         const owed = row.pendingCorrectionRecordRef;
         if (!owed || owed === decisionRef || !this.agentWorkDecisions)
             return;
@@ -3162,6 +3215,10 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             await this.agentWorkDecisions.repairOwedRecordOfExecution(resourceType, row, erasure);
             return;
         }
+        if (deletionTransaction) {
+            await this.agentWorkDecisions.repairOwedRecordOfExecution(resourceType, row, undefined, { transaction: deletionTransaction });
+            return;
+        }
         const repaid = await this.agentWorkDecisions.repairOwedRecordOfExecution(resourceType, row).catch(() => undefined);
         if (!repaid) {
             this.logger.error('[ConversationalExecution] A previous decision\'s agent-work record is still owed and could not be written; this settle overwrites what it would be repaired from', {
@@ -3222,10 +3279,12 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
                 decidedAt: params.decidedAt,
                 recordSource: AgentWorkDecisionRecordSource.SETTLEMENT,
                 ...(row.pendingDecisionOrganizationId ? { routeOrganizationId: row.pendingDecisionOrganizationId } : {}),
-            }, { executionResourceType: params.resourceType, executionId: row.executionId });
+            }, { executionResourceType: params.resourceType, executionId: row.executionId }, params.transaction ? { transaction: params.transaction } : undefined);
             return true;
         }
         catch (error) {
+            if (params.transaction)
+                throw error;
             this.logger.warn('[ConversationalExecution] A settled decision could not be recorded yet; the repair sweep will write it from the row', {
                 executionId: row.executionId, decisionRef: params.decisionRef, ...projectCaughtErrorLogFields(error),
             });
@@ -4357,7 +4416,9 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
         // Rebuilt from the row, as the card and the announcement build it, and compared with the presentation the door echoed.
         // After the predicate admitted them, so saying it changed discloses nothing. A file deliverable is bound again here,
         // from the file as it is now (#2904): a card shown before its recorded hash changed carries another id, and is stale.
-        const deliverable = await this.decisionDeliverablesOf(systemRef, {
+        // #2914: so is the record the call acts on, from the row as it is now: a card read before one of its sealed values
+        // changed carries another id, and is stale.
+        const deliverable = await this.decisionPresentationBindingsOf(systemRef, {
             decisionRef, toolName: paused.pendingToolName, toolArgs: paused.pendingToolArgs,
             ...(route.organizationId ? { organizationId: route.organizationId } : {}),
         });
@@ -4366,6 +4427,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
                 decisionRef, plane: HumanDecision_Plane.CONVERSATIONAL, toolName: paused.pendingToolName,
                 toolArgs: (paused.pendingToolArgs ?? {}), ...(question ? { request: question } : {}),
                 ...(deliverable.deliverables ? { deliverables: deliverable.deliverables } : {}),
+                ...(deliverable.subjectRecord ? { subjectRecord: deliverable.subjectRecord } : {}),
             },
             ...(params.presentationId !== undefined ? { echoedPresentationId: params.presentationId } : {}),
             ...(params.sentCardContent !== undefined ? { sentCardContent: params.sentCardContent } : {}),
@@ -4710,6 +4772,11 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             presentation: presentationCheck.presentation,
             // #2904: the file the presentation binds; the seal attests it only when the presentation it seals binds it.
             ...(deliverable.bound ? { deliverableFile: deliverable.bound } : {}),
+            // #2914: an approval of a tool that REPLACES its earlier approval of the record (a month signed off again after a
+            // reopen) supersedes the latest seal of that tool on that record, when this answer supersedes none of its own.
+            ...(!question && sealedCallSubject.kind === HumanDecisionSubjectKind.RECORD && this.approvalReplacesEarlierApprovalOfRow(systemRef, paused.pendingToolName)
+                ? { replacesEarlierApprovalOfSubject: { toolName: paused.pendingToolName } }
+                : {}),
             statement: decisionStatementOf({
                 optionRef: question ? (params.answer?.optionRef ?? HumanDecision_ToolApprovalOption.DENY) : (approved ? HumanDecision_ToolApprovalOption.APPROVE : HumanDecision_ToolApprovalOption.DENY),
                 ...(question && params.answer ? { values: params.answer.values } : {}),
@@ -4982,7 +5049,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
         for (let attempt = 0;; attempt += 1) {
             // A record still owed for a decision that ended EARLIER is written first: the withdrawal below overwrites the
             // columns it is repaired from, and the deletion removes them.
-            if (!(await this.repayOwedRecordBeforeDeletion(owner.resourceType, row)))
+            if (!(await this.repayOwedRecordBeforeDeletion(owner.resourceType, row, params.transaction)))
                 return DeletedExecutionDecisionSettlement.RECORD_NOT_WRITTEN;
             if (!holdsPendingDecision(row))
                 return DeletedExecutionDecisionSettlement.NOTHING_OWED;
@@ -4993,6 +5060,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
                 withdrawnByUserId: params.deletedBy.initiatorIds?.userId,
                 throughDelegatedClient: !!params.deletedBy.delegatingClientId,
                 requestContext: params.deletedBy,
+                ...(params.transaction ? { transaction: params.transaction } : {}),
             });
             if (withdrawal.ended) {
                 return withdrawal.recordWritten ? DeletedExecutionDecisionSettlement.SETTLED : DeletedExecutionDecisionSettlement.RECORD_NOT_WRITTEN;
@@ -5000,7 +5068,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             // Missed: the row moved under the write. Read what it holds now, under the same owner, and settle that.
             const fresh = await this.systemAccess.readAsSystem(owner.resourceType, {
                 executionId: row.executionId, ...owner.ownerFields,
-            }, { suppressSystemAudit: true });
+            }, { suppressSystemAudit: true, ...(params.transaction ? { transaction: params.transaction } : {}) });
             if (!fresh)
                 return DeletedExecutionDecisionSettlement.NOTHING_OWED;
             row = fresh;
@@ -5205,13 +5273,14 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
      * nothing is owed, or the record now exists, or the row cannot carry it (a marker without the resolution it names
      * is a record already lost, which keeping the row would not recover — the repair logs it at ERROR).
      */
-    async repayOwedRecordBeforeDeletion(resourceType, row) {
+    async repayOwedRecordBeforeDeletion(resourceType, row, transaction) {
         if (!row.pendingCorrectionRecordRef || !this.agentWorkDecisions)
             return true;
         const resolution = row;
         if (!owedRecordIsRepairableFromRow(resourceType, resolution))
             return true;
-        return (await this.agentWorkDecisions.repairOwedRecordOfExecution(resourceType, resolution)) !== undefined;
+        // Inside the deletion's transaction (#2297) a failure throws (it has aborted the transaction) and fails the deletion.
+        return (await this.agentWorkDecisions.repairOwedRecordOfExecution(resourceType, resolution, undefined, transaction ? { transaction } : undefined)) !== undefined;
     }
     /**
      * The part of a withdrawal that follows reading the row: end the pause WITHDRAWN and record it. Shared by the work
@@ -5222,7 +5291,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
      * won the compare-and-swap; `recordWritten` says whether the agent-work record now exists.
      */
     async withdrawHeldDecision(params) {
-        const { owner, row } = params;
+        const { owner, row, transaction } = params;
         if (!holdsPendingDecision(row) || !row.pausedApproval || !row.pendingDecisionRef)
             return { ended: false };
         const toolName = this.pendingToolNameOf(row.pausedApproval);
@@ -5231,17 +5300,53 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
             resourceType: owner.resourceType, executionId: row.executionId, rawPausedApproval: row.pausedApproval,
             decisionRef: row.pendingDecisionRef, outcome: HumanDecision_Outcome.WITHDRAWN, decidedByUserId: params.withdrawnByUserId, toolName, scopeContext: owner.scopeContext, row, decidedAt: withdrawnAt,
             ...(params.throughDelegatedClient ? { announceExcept: null } : {}),
+            ...(transaction ? { deletion: { transaction } } : {}),
         });
         if (!endedOn)
             return { ended: false };
-        this.recordDecisionResolved({ row: endedOn, requester: humanDecisionRequesterOfRow(endedOn), outcome: HumanDecision_Outcome.WITHDRAWN, toolName, requestContext: params.requestContext });
+        if (transaction) {
+            this.recordDecisionResolvedAfterCommit(transaction, owner.resourceType, endedOn, toolName, params.requestContext);
+        }
+        else {
+            this.recordDecisionResolved({ row: endedOn, requester: humanDecisionRequesterOfRow(endedOn), outcome: HumanDecision_Outcome.WITHDRAWN, toolName, requestContext: params.requestContext });
+        }
         const recordWritten = await this.recordAgentWorkSettlement({
             resourceType: owner.resourceType, row: endedOn, decisionRef: row.pendingDecisionRef, outcome: HumanDecision_Outcome.WITHDRAWN,
             decidedAt: withdrawnAt, rawPausedApproval: row.pausedApproval, ...(toolName ? { toolName } : {}),
             ...(params.withdrawnByUserId ? { deciderUserId: params.withdrawnByUserId } : {}),
+            ...(transaction ? { transaction } : {}),
         });
         return { ended: true, recordWritten };
     }
+    /**
+     * The RESOLVED row of a decision WITHDRAWN inside a transaction (#2297), recorded once it commits: capturable, so an
+     * attempt the framework captures keeps it (and the chat cards' outcome note) with its commit, and the outbox relay
+     * writes it once when this effect never runs. A transaction that rolls back recorded nothing. The holders'
+     * announcement is the ending write's own (`endPendingDecision`), so this one tells nobody.
+     */
+    recordDecisionResolvedAfterCommit(transaction, resourceType, endedOn, toolName, requestContext) {
+        const record = (capture) => this.recordDecisionResolved({
+            row: endedOn, requester: humanDecisionRequesterOfRow(endedOn), outcome: HumanDecision_Outcome.WITHDRAWN, toolName, requestContext, ...(capture ? { capture } : {}),
+        });
+        const noticeOutcome = this.decisionNoticeOutcomeOf(endedOn, HumanDecision_Outcome.WITHDRAWN);
+        registerTransactionPostCommitEffect(transaction, capturablePostCommitEffect({
+            key: ['human-decision-deletion-resolved', resourceType, String(endedOn.pendingDecisionRef)].join(':'),
+            execute: async () => { void record(); },
+            capture: decisionEndingCapture({
+                effect: 'human-decision-deletion-resolved',
+                auditLogs: () => this.auditLogs,
+                record: (view) => record({ auditLogs: view }),
+                tellAnnouncement: () => undefined,
+                ...(noticeOutcome && this.decisionNoticeStays
+                    ? { noticeOutcome: { payload: noticeOutcome, record: (payload) => this.decisionNoticeStays.recordDecisionOutcome(payload) } }
+                    : {}),
+                subjectId: endedOn.executionId,
+                onFailure: (error) => this.logger.warn('[ConversationalExecution] A decision a deletion withdrew could not be recorded; the outbox relay writes it', {
+                    executionId: endedOn.executionId, decisionRef: endedOn.pendingDecisionRef, ...projectCaughtErrorLogFields(error),
+                }),
+            }),
+        }));
+    }
     /**
      * The one entry every REST verb reaches (#1594 D6): ANSWER goes to `answerPendingDecision`, every move to
      * `movePendingDecision`. The act string comes from a URL, so an unknown one is refused like any refusal.
@@ -6207,6 +6312,7 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
         }
         const cards = [];
         const deliverablesByDecision = new Map();
+        const subjectRecordsByDecision = new Map();
         for (const [executionId, resourceType] of candidates) {
             const row = await this.systemAccess.readAsSystem(resourceType, { executionId }, { suppressSystemAudit: true }).catch(() => null);
             const described = row ? this.decisionCardOfRow(row, new Date()) : undefined;
@@ -6239,12 +6345,14 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
                 continue;
             cards.push({ ...card, permittedActs });
             // #2904: the call's file deliverable, bound by its hash as the act that answers it binds it.
-            const resolved = await this.decisionDeliverablesOf(card.systemRef, {
+            const resolved = await this.decisionPresentationBindingsOf(card.systemRef, {
                 decisionRef: card.decisionRef, toolName: card.toolName, toolArgs: card.toolArgs,
                 ...(route.organizationId ? { organizationId: route.organizationId } : {}),
             });
             if (resolved.deliverables)
                 deliverablesByDecision.set(card.decisionRef, resolved.deliverables);
+            if (resolved.subjectRecord)
+                subjectRecordsByDecision.set(card.decisionRef, resolved.subjectRecord);
         }
         // Decisions held by another plane's host (#1612, #2539), re-checked by that host with the same predicate.
         for (const host of this.humanDecisionHosts ?? [])
@@ -6254,7 +6362,9 @@ let ConversationalExecutionBackendService = class ConversationalExecutionBackend
         const presentationKey = decisionPresentationKeyOfRuntime(this.appConfig);
         // Soonest deadline first: that is the one a person must not miss.
         return cards
-            .map((card) => withDecisionPresentation(card, presentationKey, card.plane === HumanDecision_Plane.CONVERSATIONAL ? deliverablesByDecision.get(card.decisionRef) : undefined))
+            .map((card) => card.plane === HumanDecision_Plane.CONVERSATIONAL
+            ? withDecisionPresentation(card, presentationKey, deliverablesByDecision.get(card.decisionRef), subjectRecordsByDecision.get(card.decisionRef))
+            : withDecisionPresentation(card, presentationKey))
             .sort((a, b) => (a.expiresAt ?? '\uffff').localeCompare(b.expiresAt ?? '\uffff'));
     }
     /**