@sema-agent/client-core 0.112.0 → 0.113.0

package/dist/hitl/planReviewWire.js

@@ -1,5 +1,6 @@
-import { publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionResponder, unregisterLocalQuestionResponder, hasLocalQuestionResponder, hasQuestionOverlayFor, } from '../liveQuestionStore.js';
+import { deliverQuestionFrameFor, publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionResponder, unregisterLocalQuestionResponder, hasLocalQuestionResponder, hasQuestionOverlayFor, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
+import { displayUntrusted } from '../displayUntrusted.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { abortableSleep, settleWithinDeadline } from '../abortableSleep.js';
 import { clientHasVerbs, engineWireFor, noAnswerKindOf, sendOnce } from '../engineWireFor.js';
@@ -8,16 +9,18 @@ import { enqueuePlanReviewOutcome } from '../notifications.js';
 import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { readThrownExtra, wireFailureTextsOf } from '../wireFailureShape.js';
-import { appendOwnElement, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
+import { appendOwnElement, guardedRead, hostPresenceOf, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, resumeContextUnavailableContent, resumeContextUnavailableFromError } from '../resumeRefusalCopy.js';
 import { APPROVAL_STALE, REQUEST_FIELD_CONFLICT } from '../engineErrorCodes.js';
-import { refusalDeliveryOf } from './decisionRefusal.js';
+import { readDecisionRefusalReading, refusalDeliveryOf } from './decisionRefusal.js';
+import { decisionRefusalWayOutContent } from '../checkpointRowVerdict.js';
 import { directFailureVerdictOf, directSafetyStopOf } from './approvalResolution.js';
 import { __resetDecisionLedgerForTests, decisionInFlightOf, decisionKeyInFlight, decisionLedgerKeysOf, decisionOpsWithKey, decisionReadMark, dropDecisionOp, latestDecisionHandedMark, markLatestDecisionNotApplied, openDecisionOp, planDecisionKey, readMarkOf, settleDecisionOp, settleDecisionOpsOnGateLeft, } from './decisionLedger.js';
 import { denyReasonForWire, isPlanReviewModeAfter } from './hitlBridge.js';
 import { freshPlanReviewQuestionId, planReviewQuestionId, REOPEN_ID_TAIL, taskIdFromPlanReviewQuestionId } from './gateIdentity.js';
-import { isPlanReviewPark, mintPlanReviewCardFacts, notePlanReviewCardIssued, pausedCheckpointIdOf, planReviewCardFactsFrom, planReviewFactsCurrent, registeredPlanReviewCardFacts, samePlanReviewCardFacts, unknownBody, _resetPlanReviewRunsForTest, } from '../planReviewCardFacts.js';
+import { isPlanReviewPark, mintPlanReviewCardFacts, noteCardGateHandedOver, notePlanReviewCardIssued, pausedCheckpointIdOf, planReviewCardFactsFrom, planReviewCardReplacesEarlier, planReviewFactsCurrent, registeredPlanReviewCardFacts, samePlanReviewCardFacts, unknownBody, _resetPlanReviewRunsForTest, } from '../planReviewCardFacts.js';
 import { planReviewAskAgainKey, planReviewCardNoteRef, planReviewDecisionReasonRef, planReviewUnreadableNoteRef, takePlanReviewFacts, _resetPlanReviewFactsFlightsForTest, } from './planReviewCard.js';
+import { planReviewOutcomeCauseOf } from '../planReviewOutcomeCause.js';
 import { EN_MESSAGES } from '../i18n/messages.en.js';
 import { msg, renderMessage, DATA_FACE_LANGUAGE } from '../i18n/translate.js';
 import { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
@@ -132,6 +135,14 @@ function cardShapeOf(facts, submittedInPlanMode) {
     }
     return submittedInPlanMode ? 'three_choice' : 'two_choice';
 }
+const PLAN_REVIEW_HEADING_GATE_MAX = 120;
+function planReviewHeadingOf(facts, replaces, lang) {
+    const gate = facts?.checkpointId === undefined ? '' : displayUntrusted(facts.checkpointId, { max: PLAN_REVIEW_HEADING_GATE_MAX });
+    if (gate === '')
+        return renderMessage(msg('approval.planReview.heading.plain'), lang);
+    const head = msg('approval.planReview.heading.gate', { gate });
+    return renderMessage(replaces ? msg('approval.planReview.heading.replaces', { head }) : head, lang);
+}
 export function planReviewCardViewOf(frame, lang) {
     try {
         const questionId = readOwnDataNonEmptyString(frame ?? undefined, 'questionId');
@@ -140,14 +151,20 @@ export function planReviewCardViewOf(frame, lang) {
             return undefined;
         const facts = planReviewCardFactsFrom(readOwnDataValue(frame ?? undefined, '_sema_planReview'));
         if (facts === undefined || facts.taskId !== taskId) {
-            return Object.freeze({ options: OPTIONS_BY_SHAPE.withheld, note: renderMessage(planReviewUnreadableNoteRef(), lang) });
+            return Object.freeze({ options: OPTIONS_BY_SHAPE.withheld, note: renderMessage(planReviewUnreadableNoteRef(), lang), heading: planReviewHeadingOf(undefined, false, lang) });
         }
         const shape = cardShapeOf(facts, frame !== null && frame !== undefined && offeredModeFromLabels(frame) === 'three_choice');
         const noteRef = planReviewCardNoteRef(facts);
-        return Object.freeze({ facts, options: OPTIONS_BY_SHAPE[shape], ...(noteRef !== undefined ? { note: renderMessage(noteRef, lang) } : {}) });
+        const replaces = readOwnDataValue(frame ?? undefined, '_sema_planReviewReplaces') === true;
+        return Object.freeze({
+            facts,
+            options: OPTIONS_BY_SHAPE[shape],
+            ...(noteRef !== undefined ? { note: renderMessage(noteRef, lang) } : {}),
+            heading: planReviewHeadingOf(facts, replaces, lang),
+        });
     }
     catch {
-        return Object.freeze({ options: OPTIONS_BY_SHAPE.withheld, note: renderMessage(planReviewUnreadableNoteRef(), lang) });
+        return Object.freeze({ options: OPTIONS_BY_SHAPE.withheld, note: renderMessage(planReviewUnreadableNoteRef(), lang), heading: planReviewHeadingOf(undefined, false, lang) });
     }
 }
 export function planReviewEvidenceMovedOf(shown, latest) {
@@ -304,7 +321,7 @@ function planReviewQuestions(question, shape) {
         },
     ];
 }
-function planReviewQuestionFrame(questionId, question, shape, facts) {
+function planReviewQuestionFrame(questionId, question, shape, facts, sessionKey = DEFAULT_SESSION_KEY) {
     offeredModeByQuestionId.delete(questionId);
     offeredModeByQuestionId.set(questionId, shape);
     while (offeredModeByQuestionId.size > OFFERED_MODE_LEDGER_MAX) {
@@ -318,10 +335,17 @@ function planReviewQuestionFrame(questionId, question, shape, facts) {
         questionId,
         questions: planReviewQuestions(question, shape),
         ...(facts !== undefined ? { _sema_planReview: facts } : {}),
+        ...(facts !== undefined && planReviewCardReplacesEarlier(sessionKey, facts) ? { _sema_planReviewReplaces: true } : {}),
     };
 }
+function deliverPlanReviewCard(sessionKey, frame, facts) {
+    if (deliverQuestionFrameFor(sessionKey, frame) !== 'delivered')
+        return;
+    if (facts !== undefined)
+        noteCardGateHandedOver(sessionKey, facts.taskId, facts.checkpointId);
+}
 function publishArmedPlanReviewCard(inst) {
-    publishQuestionFrame(planReviewQuestionFrame(inst.questionId, ARM_QUESTION, inst.shape, inst.facts));
+    deliverPlanReviewCard(DEFAULT_SESSION_KEY, planReviewQuestionFrame(inst.questionId, ARM_QUESTION, inst.shape, inst.facts, DEFAULT_SESSION_KEY), inst.facts);
 }
 function retireArmedPlanReview(taskId, inst) {
     if (armedPlanReviews.get(taskId) === inst)
@@ -445,9 +469,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
         else if (!engineWireTarget()) {
             return false;
         }
-        const delivery = wire !== undefined || opts?.onOutcome !== undefined
-            ? { ...(wire !== undefined ? { wire } : {}), ...(opts?.onOutcome !== undefined ? { onOutcome: opts.onOutcome } : {}) }
-            : undefined;
+        const delivery = planReviewDeliveryFrom(wire, opts?.onOutcome, opts?.onAccepted);
         const { taskId } = result;
         const gateBefore = pausedCheckpointIdOf(result);
         if (gateBefore === undefined) {
@@ -463,12 +485,12 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
         void taking.pending.then((taken) => {
             try {
                 if (taken !== undefined && planReviewFactsCurrent(taken)) {
-                    presentArmedPlanReview(taken.facts, delivery);
+                    presentAfterAwait(taken.facts, delivery);
                     return;
                 }
                 const current = registeredPlanReviewCardFacts(DEFAULT_SESSION_KEY, taskId, gateBefore);
                 if (current !== undefined) {
-                    presentArmedPlanReview(current, delivery);
+                    presentAfterAwait(current, delivery);
                     return;
                 }
                 hostLog('debug', `planReviewWire: arm-superseded task=${taskId}`);
@@ -487,7 +509,17 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
         hostLog('debug', `planReviewWire: arm failed (fail-soft): ${String(e)}`);
         return false;
     }
-    function presentArmedPlanReview(facts, delivery) {
+    function presentAfterAwait(facts, delivery) {
+        if (!isPlanReviewPark(result))
+            return;
+        const presence = publishPresenceOf(opts);
+        if (presence !== 'here') {
+            hostLog('debug', `planReviewWire: arm-withheld-${presence} task=${result.taskId}`);
+            return;
+        }
+        presentArmedPlanReview(facts, delivery, () => publishPresenceOf(opts) === 'here');
+    }
+    function presentArmedPlanReview(facts, delivery, recheckHere) {
         if (!isPlanReviewPark(result))
             return;
         const { taskId } = result;
@@ -501,6 +533,10 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
                 prev.checkpointId !== undefined &&
                 prev.checkpointId === gateBefore &&
                 samePlanReviewCardFacts(prev.facts, facts)) {
+                if (recheckHere !== undefined && !recheckHere()) {
+                    hostLog('debug', `planReviewWire: arm-withheld-after-retire task=${taskId}`);
+                    return;
+                }
                 hostLog('debug', `planReviewWire: arm replayed — re-presenting the still-armed card for task ${taskId}`);
                 publishArmedPlanReviewCard(prev);
                 return;
@@ -508,6 +544,10 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             hostLog('debug', `planReviewWire: arm-retire task=${taskId} card=${prev.questionId}`);
             retireArmedPlanReview(taskId, prev);
         }
+        if (recheckHere !== undefined && !recheckHere()) {
+            hostLog('debug', `planReviewWire: arm-withheld-after-retire task=${taskId}`);
+            return;
+        }
         const issuedBefore = notePlanReviewCardIssued(DEFAULT_SESSION_KEY, taskId);
         const questionId = issuedBefore || hadArmedInstance ? freshPlanReviewQuestionId(taskId, reopenIdSuffix()) : planReviewQuestionId(taskId);
         const instance = Object.freeze({ questionId, ...(gateBefore !== undefined ? { checkpointId: gateBefore } : {}), facts, shape });
@@ -569,6 +609,11 @@ export function planReviewOutcomeTail(taskId, decision, effect, cause) {
             return `Do not state the result as fact: tell the user the ${decision} was submitted but its effect could not be confirmed; the background task list or the next notification of task ${JSON.stringify(taskId)} shows where it stands.`;
     }
 }
+function planReviewDeliveryFrom(wire, onOutcome, onAccepted) {
+    if (wire === undefined && onOutcome === undefined && onAccepted === undefined)
+        return undefined;
+    return { ...(wire !== undefined ? { wire } : {}), ...(onOutcome !== undefined ? { onOutcome } : {}), ...(onAccepted !== undefined ? { onAccepted } : {}) };
+}
 function planReviewDecisionTimedOutOutcome(decision) {
     return (`The plan_review ${decision} was sent, but no answer came back from the engine within the time limit this host allows for it — ` +
         `it may have taken effect (${decision === 'approve' ? 'an approval keeps the engine busy until the resumed work finishes' : 'the engine may still be applying it'}).`);
@@ -666,11 +711,34 @@ function noteEngineRefusedGate(id) {
         engineRefusedGateIds.delete(oldest.value);
     }
 }
+function wireGateOf(decision, gate) {
+    if (gate === undefined)
+        return undefined;
+    if (decision === 'approve')
+        return gate;
+    return engineRefusedGateIds.has(gate) ? undefined : gate;
+}
+function planReviewWireBodyOf(decision, reason, mode, gate) {
+    const withReason = reason !== undefined ? { reason } : {};
+    const withMode = mode !== undefined ? { permissionModeAfter: mode } : {};
+    if (decision === 'approve')
+        return gate === undefined ? undefined : Object.freeze({ decision, ...withReason, ...withMode, checkpointId: gate });
+    return Object.freeze({ decision, ...withReason, ...withMode, ...(gate !== undefined ? { checkpointId: gate } : {}) });
+}
 function planReviewDecisionReasonSegment(reason, card) {
     if (reason === undefined)
         return '';
     try {
-        return ` ${renderMessage(planReviewDecisionReasonRef(reason, card), DATA_FACE_LANGUAGE)}`;
+        const ref = planReviewDecisionReasonRef(reason, card);
+        return ref === undefined ? '' : ` ${renderMessage(ref, DATA_FACE_LANGUAGE)}`;
+    }
+    catch {
+        return '';
+    }
+}
+function planReviewSentWithoutGateSegment() {
+    try {
+        return ` ${renderMessage(msg('approval.planReview.decision.sentWithoutGateId'), DATA_FACE_LANGUAGE)}`;
     }
     catch {
         return '';
@@ -723,13 +791,43 @@ function bodyWordOf(body, key) {
         return undefined;
     }
 }
-function bodySaysReparked(body) {
-    try {
-        return body !== null && typeof body === 'object' && body.retriable === true;
-    }
-    catch {
-        return false;
-    }
+function planReviewAcceptanceOf(body) {
+    const obj = body !== null && typeof body === 'object' ? body : undefined;
+    const str = (key) => (obj === undefined ? undefined : guardedRead(() => readOwnDataNonEmptyString(obj, key)));
+    const isTrue = (key) => obj !== undefined && guardedRead(() => readOwnDataValue(obj, key)) === true;
+    const taskId = str('taskId');
+    const sessionId = str('sessionId');
+    const status = str('status');
+    const checkpointId = str('checkpointId');
+    const engine = Object.freeze({
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(status !== undefined ? { status } : {}),
+        ...(isTrue('decisionCommitted') ? { decisionCommitted: true } : {}),
+        ...(checkpointId !== undefined ? { checkpointId } : {}),
+    });
+    const errorCode = str('errorCode');
+    return Object.freeze({ engine, reparked: isTrue('retriable'), ...(errorCode !== undefined ? { errorCode } : {}) });
+}
+function acceptanceSettled(a) {
+    return a !== undefined && a.engine.decisionCommitted === true && !a.reparked;
+}
+function planReviewAcceptedPayloadOf(taskId, dispatchNo, semanticDecision, cardId, a, wireGate, card) {
+    const body = card?.body;
+    const decided = acceptanceSettled(a) && semanticDecision !== 'ask_again' && wireGate !== undefined && body !== undefined && body.kind === 'shown'
+        ? Object.freeze({ verdict: semanticDecision === 'approve' ? 'approved' : 'rejected', plan: body.markdown })
+        : undefined;
+    return Object.freeze({
+        taskId,
+        dispatchNo,
+        decision: semanticDecision,
+        ...(cardId !== undefined ? { questionId: cardId } : {}),
+        engine: a.engine,
+        ...(decided !== undefined ? { decided } : {}),
+    });
+}
+function planReviewDeliveryOf(a, semanticDecision) {
+    return acceptanceSettled(a) && semanticDecision !== 'approve' ? 'follow' : 'submit';
 }
 function askAgainReasonOf(card, opts) {
     try {
@@ -741,9 +839,17 @@ function askAgainReasonOf(card, opts) {
         return renderMessage(msg('approval.planReview.askAgain.unknown'), DATA_FACE_LANGUAGE);
     }
 }
+function planReviewDecisionWordOf(raw) {
+    return raw === 'approve' || raw === 'reject' || raw === 'ask_again' ? raw : undefined;
+}
 async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, card, cardId) {
+    const word = planReviewDecisionWordOf(decision);
+    if (word === undefined) {
+        hostLog('error', `planReviewWire: decision-word-refused typeof=${typeof decision}`);
+        return;
+    }
     if (typeof taskId === 'string' && planReviewOpsOf(taskId).some((op) => op.phase === 'posting')) {
-        hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
+        hostLog('error', `planReviewWire: decidePlanReview(${word}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
     }
     let op = typeof taskId === 'string' ? claimablePlanReviewDecisionOp(taskId) : undefined;
@@ -770,11 +876,11 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
         settleDecisionOp(mine, 'package');
     };
     const dispatchNo = ++decideDispatchSeq;
-    hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${decision} mode=${permissionModeAfter ?? '-'}`);
+    hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${word} mode=${permissionModeAfter ?? '-'}`);
     try {
-        const wireDecision = decision === 'ask_again' ? 'reject' : decision;
-        const wireOpts = decision === 'ask_again' ? { ...opts, reason: askAgainReasonOf(card, opts) } : opts;
-        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, decision, cardId);
+        const wireDecision = word === 'ask_again' ? 'reject' : word;
+        const wireOpts = word === 'ask_again' ? { ...opts, reason: askAgainReasonOf(card, opts) } : opts;
+        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, word, cardId);
     }
     finally {
         releaseLatch();
@@ -797,14 +903,17 @@ function planReviewClientsFor(resolved) {
 }
 async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, card, semanticDecision, cardId) {
     let outcome;
-    let decisionReason;
+    let cause;
+    let unsentProven = false;
+    let acceptance;
+    let wayOut;
     const gateBefore = card?.checkpointId;
     const approvalWithheld = decision !== 'approve' ? undefined : card === undefined ? 'card_missing' : card.body.kind !== 'shown' || card.checkpointId === undefined ? 'card_withholds' : undefined;
     let effect = 'unconfirmed';
-    let stillParkedCause;
     let statusSeen;
     const wire = opts?.wire;
     const resolved = engineWireFor(wire, DEFAULT_SESSION_KEY, usablePlanReviewWireClient);
+    const wireGate = wireGateOf(decision, gateBefore);
     const badMode = permissionModeAfter !== undefined && !isPlanReviewModeAfter(permissionModeAfter);
     if (badMode) {
         hostLog('error', `planReviewWire: ${decision} NOT sent — permissionModeAfter must be "default" or "acceptEdits"`);
@@ -814,7 +923,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
     else if (approvalWithheld !== undefined) {
         hostLog('debug', `planReviewWire: not-sent decision=${decision} reason=${approvalWithheld}`);
         effect = 'not_sent';
-        decisionReason = approvalWithheld;
+        cause = approvalWithheld;
         outcome = renderMessage(msg('approval.planReview.decision.notSent', { decision }), DATA_FACE_LANGUAGE);
     }
     else if (resolved.kind === 'no-target') {
@@ -836,7 +945,6 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
         }
         else {
             const client = clients.decide;
-            const checkpointId = gateBefore !== undefined && !engineRefusedGateIds.has(gateBefore) ? gateBefore : undefined;
             const repullRow = async () => {
                 const probe = clients.repull();
                 if (!probe)
@@ -854,87 +962,97 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             try {
                 const mode = isPlanReviewModeAfter(permissionModeAfter) ? permissionModeAfter : undefined;
                 const reason = denyReasonForWire(opts?.reason, `plan-review ${taskId}`);
-                const reqBody = { decision };
-                if (reason !== undefined)
-                    reqBody.reason = reason;
-                if (mode !== undefined)
-                    reqBody.permissionModeAfter = mode;
-                if (checkpointId !== undefined)
-                    reqBody.checkpointId = checkpointId;
-                let body;
-                try {
-                    body = await sendOnce(undefined, () => client.assistant.planReview(taskId, reqBody));
+                const wireBody = planReviewWireBodyOf(decision, reason, mode, wireGate);
+                if (wireBody === undefined) {
+                    effect = 'not_sent';
+                    cause = 'card_withholds';
+                    outcome = renderMessage(msg('approval.planReview.decision.notSent', { decision }), DATA_FACE_LANGUAGE);
                 }
-                catch (e1) {
-                    const conflict = e1;
-                    const defaultConflict = mode === 'default' && conflict?.status === 400 && conflict?.errorCode === REQUEST_FIELD_CONFLICT;
-                    if (defaultConflict && !directFailureVerdictOf(e1, directSafetyStopOf(e1)).yields) {
-                        hostLog('debug', 'planReviewWire: permissionModeAfter "default" refused as not applicable — re-sending the approval without the key (same meaning)');
-                        body = await sendOnce(undefined, () => client.assistant.planReview(taskId, { decision, ...(reason !== undefined ? { reason } : {}), ...(checkpointId !== undefined ? { checkpointId } : {}) }));
+                else {
+                    const firstSent = { ...wireBody };
+                    let body;
+                    try {
+                        body = await sendOnce(undefined, () => client.assistant.planReview(taskId, firstSent));
                     }
-                    else {
-                        throw e1;
+                    catch (e1) {
+                        const conflict = e1;
+                        const defaultConflict = mode === 'default' && conflict?.status === 400 && conflict?.errorCode === REQUEST_FIELD_CONFLICT;
+                        if (defaultConflict && !directFailureVerdictOf(e1, directSafetyStopOf(e1)).yields) {
+                            hostLog('debug', 'planReviewWire: permissionModeAfter "default" refused as not applicable — re-sending the approval without the key (same meaning)');
+                            const { permissionModeAfter: _modeDropped, ...resend } = wireBody;
+                            body = await sendOnce(undefined, () => client.assistant.planReview(taskId, resend));
+                        }
+                        else {
+                            throw e1;
+                        }
                     }
-                }
-                finally {
-                    releaseLatch();
-                }
-                hostLog('debug', `planReviewWire: ${decision} → ok (dispatch #${dispatchNo}) ${JSON.stringify(body).slice(0, 200)}`);
-                let postStatus;
-                let gateAfter;
-                let gateKindAfter;
-                try {
-                    const post = await repullRow();
-                    if (post !== undefined) {
-                        postStatus = bodyWordOf(post, 'status');
-                        gateAfter = pausedCheckpointIdOf(post?.result);
-                        gateKindAfter = pausedGateKindOf(post?.result);
+                    finally {
+                        releaseLatch();
+                    }
+                    const accepted = planReviewAcceptanceOf(body);
+                    acceptance = accepted;
+                    hostLog('debug', `planReviewWire: ${decision} → ok (dispatch #${dispatchNo}) ${JSON.stringify(accepted).slice(0, 200)}`);
+                    const onAccepted = opts?.onAccepted;
+                    if (onAccepted !== undefined) {
+                        const payload = planReviewAcceptedPayloadOf(taskId, dispatchNo, semanticDecision, cardId, accepted, wireGate, card);
+                        invokeHostCallbackIsolated(`planReviewWire: onAccepted task=${taskId}`, () => onAccepted(payload));
+                    }
+                    let postStatus;
+                    let gateAfter;
+                    let gateKindAfter;
+                    try {
+                        const post = await repullRow();
+                        if (post !== undefined) {
+                            postStatus = bodyWordOf(post, 'status');
+                            gateAfter = pausedCheckpointIdOf(post?.result);
+                            gateKindAfter = pausedGateKindOf(post?.result);
+                        }
+                    }
+                    catch (e) {
+                        hostLog('debug', `planReviewWire: post-decide status re-pull failed (fail-soft): ${String(e)}`);
+                    }
+                    const bodyStatus = accepted.engine.status;
+                    const effective = postStatus ?? bodyStatus;
+                    statusSeen = effective;
+                    effect = planReviewSettledVerdict({ decision, postStatus, bodyStatus, reparked: accepted.reparked, gateBefore, gateAfter, gateKindAfter });
+                    const code = accepted.errorCode;
+                    if (effect === 'still_parked' && postStatus === 'needs_review' && !accepted.reparked) {
+                        outcome =
+                            `The plan_review ${decision} returned HTTP 200 but the session is STILL locked on the same review gate ` +
+                                `(post-decide status: needs_review). The decision did NOT take effect (known engine issue, RB-471 family). ` +
+                                `Tell the user plainly that the ${decision} did not go through; the reliable exits today are approving the plan or cancelling the task.`;
+                    }
+                    else if (effect === 'still_parked') {
+                        outcome =
+                            `The plan_review ${decision} was NOT applied: the engine could not continue the task and put the plan back to wait for a decision` +
+                                `${code !== undefined ? ` (engine code: ${code})` : ''}. Tell the user plainly that the ${decision} did not go through.`;
+                    }
+                    else if (effect === 'advanced') {
+                        outcome = planReviewAdvancedOutcome(decision, effective === 'needs_review' ? 'needs_review' : 'suspended');
+                    }
+                    else if (effect === 'took_effect') {
+                        outcome =
+                            `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — ${effective === 'completed' ? 'final status' : 'status'}: ${effective} ` +
+                                `(${postStatus !== undefined ? 'post-decide re-checked: task left the review gate' : "from the decision's own reply; the post-decide re-check was unavailable"}).`;
+                    }
+                    else if (effective === 'needs_review' && (gateBefore === undefined || gateAfter === undefined || postStatus !== 'needs_review')) {
+                        outcome =
+                            `The plan_review ${decision} returned HTTP 200 and the task is waiting at a plan review gate again (post-decide status: needs_review), ` +
+                                `but it could not be told whether this is the same review (the ${decision} did not take effect) or a new plan written after it (it did).`;
+                    }
+                    else if (effective === 'suspended' || effective === 'needs_review') {
+                        outcome =
+                            `The plan_review ${decision} was accepted by the engine (HTTP 200) and the task is paused again (post-decide status: ${effective}), ` +
+                                `${gateKindAfter !== undefined ? `at a '${gateKindAfter}' pause that is not an approval card` : 'but the pause it stopped at was not reported'} — what the ${decision} led to could not be confirmed.`;
+                    }
+                    else if (effective !== undefined) {
+                        outcome =
+                            `The plan_review ${decision} was accepted by the engine (HTTP 200), but the task then reported status ${effective}` +
+                                `${code !== undefined ? ` (engine code: ${code})` : ''} — not a completion; what the ${decision} led to could not be confirmed.`;
+                    }
+                    else {
+                        outcome = `The plan_review ${decision} was accepted by the engine (HTTP 200) but its effect is unconfirmed — final status: unknown (post-decide verification unavailable). Do not treat this as ${decision === 'approve' ? 'an approval that resumed the task' : 'a discarded plan'}.`;
                     }
-                }
-                catch (e) {
-                    hostLog('debug', `planReviewWire: post-decide status re-pull failed (fail-soft): ${String(e)}`);
-                }
-                const bodyStatus = bodyWordOf(body, 'status');
-                const effective = postStatus ?? bodyStatus;
-                statusSeen = effective;
-                effect = planReviewSettledVerdict({ decision, postStatus, bodyStatus, reparked: bodySaysReparked(body), gateBefore, gateAfter, gateKindAfter });
-                const code = bodyWordOf(body, 'errorCode');
-                if (effect === 'still_parked' && postStatus === 'needs_review' && !bodySaysReparked(body)) {
-                    outcome =
-                        `The plan_review ${decision} returned HTTP 200 but the session is STILL locked on the same review gate ` +
-                            `(post-decide status: needs_review). The decision did NOT take effect (known engine issue, RB-471 family). ` +
-                            `Tell the user plainly that the ${decision} did not go through; the reliable exits today are approving the plan or cancelling the task.`;
-                }
-                else if (effect === 'still_parked') {
-                    outcome =
-                        `The plan_review ${decision} was NOT applied: the engine could not continue the task and put the plan back to wait for a decision` +
-                            `${code !== undefined ? ` (engine code: ${code})` : ''}. Tell the user plainly that the ${decision} did not go through.`;
-                }
-                else if (effect === 'advanced') {
-                    outcome = planReviewAdvancedOutcome(decision, effective === 'needs_review' ? 'needs_review' : 'suspended');
-                }
-                else if (effect === 'took_effect') {
-                    outcome =
-                        `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — ${effective === 'completed' ? 'final status' : 'status'}: ${effective} ` +
-                            `(${postStatus !== undefined ? 'post-decide re-checked: task left the review gate' : "from the decision's own reply; the post-decide re-check was unavailable"}).`;
-                }
-                else if (effective === 'needs_review' && (gateBefore === undefined || gateAfter === undefined || postStatus !== 'needs_review')) {
-                    outcome =
-                        `The plan_review ${decision} returned HTTP 200 and the task is waiting at a plan review gate again (post-decide status: needs_review), ` +
-                            `but it could not be told whether this is the same review (the ${decision} did not take effect) or a new plan written after it (it did).`;
-                }
-                else if (effective === 'suspended' || effective === 'needs_review') {
-                    outcome =
-                        `The plan_review ${decision} was accepted by the engine (HTTP 200) and the task is paused again (post-decide status: ${effective}), ` +
-                            `${gateKindAfter !== undefined ? `at a '${gateKindAfter}' pause that is not an approval card` : 'but the pause it stopped at was not reported'} — what the ${decision} led to could not be confirmed.`;
-                }
-                else if (effective !== undefined) {
-                    outcome =
-                        `The plan_review ${decision} was accepted by the engine (HTTP 200), but the task then reported status ${effective}` +
-                            `${code !== undefined ? ` (engine code: ${code})` : ''} — not a completion; what the ${decision} led to could not be confirmed.`;
-                }
-                else {
-                    outcome = `The plan_review ${decision} was accepted by the engine (HTTP 200) but its effect is unconfirmed — final status: unknown (post-decide verification unavailable). Do not treat this as ${decision === 'approve' ? 'an approval that resumed the task' : 'a discarded plan'}.`;
                 }
             }
             catch (e) {
@@ -959,40 +1077,34 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                             'This is NOT a rejection of the plan and NOT a failure of the task; the answer just given simply had nothing left to act on.';
                 }
                 else if (status === 409 && refusedCode === APPROVAL_STALE) {
-                    let untrusted = false;
-                    if (checkpointId !== undefined) {
-                        const bag = readThrownExtra(e);
-                        const noCurrentPending = bag.state === 'object' &&
-                            (() => {
-                                try {
-                                    return Object.getOwnPropertyDescriptor(bag.value, 'currentPending') === undefined;
-                                }
-                                catch {
-                                    return false;
-                                }
-                            })();
-                        if (noCurrentPending) {
-                            try {
-                                const row = await repullRow();
-                                untrusted = row !== undefined && pausedCheckpointIdOf(row?.result) === checkpointId;
-                            }
-                            catch {
-                                untrusted = false;
-                            }
+                    let verdict = 'gate_moved';
+                    if (wireGate !== undefined && planReviewCurrentGateReadingOf(readThrownExtra(e)) === 'absent') {
+                        try {
+                            const row = await repullRow();
+                            const rowGate = pausedCheckpointIdOf(row?.result);
+                            verdict =
+                                row !== undefined && rowGate === wireGate
+                                    ? 'gate_untrusted'
+                                    : row !== undefined && rowGate === undefined && bodyWordOf(row, 'status') === 'needs_review'
+                                        ? 'unreadable'
+                                        : 'gate_moved';
+                        }
+                        catch {
+                            verdict = 'gate_moved';
                         }
                     }
-                    if (untrusted && checkpointId !== undefined)
-                        noteEngineRefusedGate(checkpointId);
-                    hostLog('debug', `planReviewWire: approval-stale decision=${decision} reason=${untrusted ? 'gate_untrusted' : 'gate_moved'}`);
+                    if (verdict === 'gate_untrusted' && wireGate !== undefined)
+                        noteEngineRefusedGate(wireGate);
+                    hostLog('debug', `planReviewWire: approval-stale decision=${decision} reason=${verdict}`);
                     effect = 'not_applied';
-                    decisionReason = untrusted ? 'gate_untrusted' : 'gate_moved';
+                    cause = verdict === 'unreadable' ? undefined : verdict;
                     outcome = renderMessage(msg('approval.planReview.decision.refused', { decision }), DATA_FACE_LANGUAGE);
                 }
                 else if (checkpointUnsupportedVersionFromError(e) !== null) {
                     const cu = checkpointUnsupportedVersionFromError(e);
                     hostLog('debug', `planReviewWire: ${decision} → 409 checkpoint.unsupported_version (the server cannot continue this parked review in its stored form; still pending)`);
                     effect = 'still_parked';
-                    stillParkedCause = 'stored_form_unsupported';
+                    cause = 'stored_form_unsupported';
                     outcome = `This ${decision} was not applied. ${checkpointUnsupportedVersionContent(cu, { parkKind: 'plan_review', runId: taskId })}`;
                 }
                 else if (resumeContextUnavailableFromError(e) !== null) {
@@ -1011,7 +1123,11 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     const failureTexts = wireFailureTextsOf(e);
                     hostLog('debug', `planReviewWire: ${decision} → ${status} ${failureTexts.log.slice(0, 200)}`);
                     effect = refusalDeliveryOf(e, { route: 'plan_review' }).delivery === 'refused' ? 'not_applied' : 'unconfirmed';
-                    outcome = `${`The plan_review decision failed: HTTP ${status} ${failureTexts.reason}`.trim()}${decideFailureNote(e)}`;
+                    const engineWayOut = status === 409 ? readDecisionRefusalReading(e, { route: 'plan_review' }).wayOut : undefined;
+                    const wayOutClause = engineWayOut === undefined ? undefined : decisionRefusalWayOutContent(engineWayOut);
+                    if (wayOutClause !== undefined)
+                        wayOut = engineWayOut;
+                    outcome = `${`The plan_review decision failed: HTTP ${status} ${failureTexts.reason}`.trim()}${decideFailureNote(e)}${wayOutClause === undefined ? '' : ` — ${wayOutClause}.`}`;
                 }
                 else if (noAnswer === 'time-limit' || noAnswer === 'deadline') {
                     hostLog('debug', `planReviewWire: ${decision} sent but no answer within the request time limit (task ${taskId})`);
@@ -1024,18 +1140,32 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 else {
                     const failureTexts = wireFailureTextsOf(e);
                     hostLog('debug', `planReviewWire: ${decision} could not reach the engine: ${failureTexts.log}`);
+                    unsentProven = true;
                     outcome = `The plan_review decision could not reach the engine: ${failureTexts.reason}`;
                 }
             }
         }
     }
-    outcome = `${outcome}${planReviewDecisionReasonSegment(decisionReason, card)}`;
-    const tail = planReviewOutcomeTail(taskId, decision, effect, stillParkedCause);
+    const outcomeCause = planReviewOutcomeCauseOf(effect, cause);
+    const sentWithoutGate = gateBefore !== undefined && wireGate === undefined && effect !== 'not_sent' && !unsentProven;
+    outcome = `${outcome}${planReviewDecisionReasonSegment(outcomeCause, card)}${sentWithoutGate ? planReviewSentWithoutGateSegment() : ''}`;
+    const tail = planReviewOutcomeTail(taskId, decision, effect, outcomeCause);
     const prompt = `<plan-review-outcome>\n${outcome}\n${tail}\n</plan-review-outcome>`;
     const onOutcome = opts?.onOutcome;
+    const meta = {
+        taskId,
+        dispatchNo,
+        decision: semanticDecision,
+        effect,
+        ...(outcomeCause !== undefined ? { cause: outcomeCause } : {}),
+        ...(cardId !== undefined ? { questionId: cardId } : {}),
+        delivery: planReviewDeliveryOf(acceptance, semanticDecision),
+        ...(sentWithoutGate ? { gateIdOmitted: true } : {}),
+        ...(wayOut !== undefined ? { wayOut } : {}),
+    };
     settle(effect === 'not_sent' || effect === 'still_parked');
     try {
-        const delivered = enqueuePlanReviewOutcome(prompt, { taskId, dispatchNo, decision: semanticDecision, effect, ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}), ...(cardId !== undefined ? { questionId: cardId } : {}) });
+        const delivered = enqueuePlanReviewOutcome(prompt, meta);
         if (!delivered) {
             if (onOutcome !== undefined) {
                 hostLog('debug', `planReviewWire: outcome queue port not installed for task ${taskId} — outcome handed to the host's onOutcome callback only`);
@@ -1050,12 +1180,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
     }
     if (onOutcome !== undefined) {
         invokeHostCallbackIsolated(`planReviewWire: onOutcome callback (task ${taskId})`, () => onOutcome({
-            taskId,
-            dispatchNo,
-            decision: semanticDecision,
-            effect,
-            ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}),
-            ...(cardId !== undefined ? { questionId: cardId } : {}),
+            ...meta,
             detail: outcome,
             tail,
             prompt,
@@ -1137,6 +1262,9 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         hostLog('debug', `planReviewWire: reopen-superseded task=${taskId}`);
         return Promise.resolve(refusedReopen('not_presented'));
     }
+    const early = reopenPresenceRefusal(taskId, opts, 'before');
+    if (early !== undefined)
+        return Promise.resolve(early);
     const facts = taken.facts;
     const markBefore = dismissalEntryFor(sessionKey, taskId);
     const settleOnReceipt = (receipt, firstSight) => receipt.then((presented) => {
@@ -1158,8 +1286,11 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         samePlanReviewCardFacts(armed.facts, facts)) {
         hostLog('debug', `planReviewWire: reopen for task ${taskId} reusing the canonical responder (path=reopen-canonical)`);
         retireActiveReopen(sessionKey, canonicalId);
+        const lateReuse = reopenPresenceRefusal(taskId, opts, 'after-retire');
+        if (lateReuse !== undefined)
+            return Promise.resolve(lateReuse);
         const receipt = waitForGateArmedFor(sessionKey, [armed.questionId], receiptMs);
-        publishQuestionFrameFor(sessionKey, planReviewQuestionFrame(armed.questionId, ARM_QUESTION, armed.shape, armed.facts));
+        deliverPlanReviewCard(sessionKey, planReviewQuestionFrame(armed.questionId, ARM_QUESTION, armed.shape, armed.facts, sessionKey), armed.facts);
         return settleOnReceipt(receipt, firstSight);
     }
     retireActiveReopen(sessionKey, canonicalId);
@@ -1168,11 +1299,12 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         hostLog('debug', `planReviewWire: reopen-retire-armed task=${taskId} card=${armedId}`);
     }
     publishQuestionFrameFor(sessionKey, { type: 'question_complete', questionId: armedId });
+    const lateFresh = reopenPresenceRefusal(taskId, opts, 'after-retire');
+    if (lateFresh !== undefined)
+        return Promise.resolve(lateFresh);
     const questionId = freshPlanReviewQuestionId(taskId, reopenIdSuffix());
     hostLog('debug', `planReviewWire: path=reopen-fresh task=${taskId} card=${questionId}`);
-    const delivery = opts?.wire !== undefined || opts?.onOutcome !== undefined
-        ? { ...(opts.wire !== undefined ? { wire: opts.wire } : {}), ...(opts.onOutcome !== undefined ? { onOutcome: opts.onOutcome } : {}) }
-        : undefined;
+    const delivery = planReviewDeliveryFrom(opts?.wire, opts?.onOutcome, opts?.onAccepted);
     const deliver = opts?.deliverDecision ??
         ((tid, decision, reason, card) => {
             hostLog('debug', `planReviewWire: reopen responder delivering ${decision} for task ${tid} (path=reopen-default)`);
@@ -1220,12 +1352,32 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
     unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
     activeReopenResponders.set(activeKey, { questionId, unregister: () => unregister(), shape });
     const receipt = waitForGateArmedFor(sessionKey, [questionId], receiptMs);
-    publishQuestionFrameFor(sessionKey, planReviewQuestionFrame(questionId, REOPEN_QUESTION, shape, facts));
+    deliverPlanReviewCard(sessionKey, planReviewQuestionFrame(questionId, REOPEN_QUESTION, shape, facts, sessionKey), facts);
     return settleOnReceipt(receipt, firstSight);
 }
 function refusedReopen(cause) {
     return { reopened: false, _sema_reopenRefusal: cause };
 }
+function publishPresenceOf(opts) {
+    return hostPresenceOf(opts, (ask) => {
+        const got = { answered: false };
+        invokeHostCallbackIsolated('planReviewWire: stillHere', () => {
+            got.answer = ask();
+            got.answered = true;
+            return got.answer;
+        });
+        if (!got.answered)
+            throw new Error('stillHere did not answer');
+        return got.answer;
+    });
+}
+function reopenPresenceRefusal(taskId, opts, stage) {
+    const presence = publishPresenceOf(opts);
+    if (presence === 'here')
+        return undefined;
+    hostLog('debug', `planReviewWire: reopen-withheld-${presence} task=${taskId} at=${stage}`);
+    return refusedReopen(presence === 'left' ? 'conversation_left' : 'conversation_unconfirmed');
+}
 function noPresentationSurfaceVerdict(taskId, sessionKey) {
     const verdict = { reopened: false, _sema_noPresentationSurface: true };
     hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — nothing is subscribed to question frames for session ` +
@@ -1333,7 +1485,8 @@ export function reopenPlanReviewCard(taskId, opts) {
             return Promise.resolve(refusedReopen('invalid_call'));
         }
         const injected = opts;
-        if (opts?.mintFreshQuestionId === false && (injected?.deliverDecision !== undefined || injected?.wire !== undefined || injected?.onOutcome !== undefined)) {
+        if (opts?.mintFreshQuestionId === false &&
+            (injected?.deliverDecision !== undefined || injected?.wire !== undefined || injected?.onOutcome !== undefined || injected?.onAccepted !== undefined)) {
             hostLog('error', `planReviewWire: plan_review reopen for task ${taskId} refused — mintFreshQuestionId:false reuses the armed card's responder and its delivery, ` +
                 'so deliverDecision / wire / onOutcome cannot be given with it; drop mintFreshQuestionId:false to deliver through the injected path');
             return Promise.resolve(refusedReopen('invalid_call'));
@@ -1464,3 +1617,26 @@ export async function readPlanReviewCardFacts(taskId, opts) {
         return mintPlanReviewCardFacts(taskId, checkpointId, unknownBody('unreadable'));
     }
 }
+function planReviewCurrentGateReadingOf(bag) {
+    if (bag.state !== 'object')
+        return 'malformed';
+    try {
+        const d = Object.getOwnPropertyDescriptor(bag.value, 'currentPending');
+        if (d === undefined)
+            return 'absent';
+        if (!Object.hasOwn(d, 'value'))
+            return 'malformed';
+        const slot = d.value;
+        if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
+            return 'malformed';
+        const checkpointId = readOwnDataNonEmptyString(slot, 'checkpointId');
+        return checkpointId === undefined ? 'malformed' : { checkpointId };
+    }
+    catch {
+        return 'malformed';
+    }
+}
+export function readPlanReviewCurrentGate(e) {
+    const reading = planReviewCurrentGateReadingOf(readThrownExtra(e));
+    return typeof reading === 'object' ? reading.checkpointId : undefined;
+}