@sema-agent/client-core 0.112.1 → 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,15 +9,16 @@ 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';
@@ -133,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');
@@ -141,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) {
@@ -305,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) {
@@ -319,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)
@@ -446,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) {
@@ -464,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}`);
@@ -488,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;
@@ -502,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;
@@ -509,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 });
@@ -570,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'}).`);
@@ -747,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 {
@@ -831,6 +905,8 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
     let outcome;
     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';
@@ -913,7 +989,14 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     finally {
                         releaseLatch();
                     }
-                    hostLog('debug', `planReviewWire: ${decision} → ok (dispatch #${dispatchNo}) ${JSON.stringify(body).slice(0, 200)}`);
+                    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;
@@ -928,12 +1011,12 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     catch (e) {
                         hostLog('debug', `planReviewWire: post-decide status re-pull failed (fail-soft): ${String(e)}`);
                     }
-                    const bodyStatus = bodyWordOf(body, 'status');
+                    const bodyStatus = accepted.engine.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)) {
+                    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). ` +
@@ -994,33 +1077,27 @@ 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 (wireGate !== 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) === wireGate;
-                            }
-                            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 && wireGate !== undefined)
+                    if (verdict === 'gate_untrusted' && wireGate !== undefined)
                         noteEngineRefusedGate(wireGate);
-                    hostLog('debug', `planReviewWire: approval-stale decision=${decision} reason=${untrusted ? 'gate_untrusted' : 'gate_moved'}`);
+                    hostLog('debug', `planReviewWire: approval-stale decision=${decision} reason=${verdict}`);
                     effect = 'not_applied';
-                    cause = 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) {
@@ -1046,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})`);
@@ -1066,13 +1147,25 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
         }
     }
     const outcomeCause = planReviewOutcomeCauseOf(effect, cause);
-    outcome = `${outcome}${planReviewDecisionReasonSegment(outcomeCause, card)}${gateBefore !== undefined && wireGate === undefined && effect !== 'not_sent' && !unsentProven ? planReviewSentWithoutGateSegment() : ''}`;
+    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, ...(outcomeCause !== undefined ? { cause: outcomeCause } : {}), ...(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`);
@@ -1087,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,
-            ...(outcomeCause !== undefined ? { cause: outcomeCause } : {}),
-            ...(cardId !== undefined ? { questionId: cardId } : {}),
+            ...meta,
             detail: outcome,
             tail,
             prompt,
@@ -1174,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) => {
@@ -1195,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);
@@ -1205,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)`);
@@ -1257,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 ` +
@@ -1370,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'));
@@ -1501,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;
+}

package/dist/hitl/sessionPolicyWire.js

@@ -6,7 +6,7 @@ import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { CORRUPT_ROW_ERROR_CODE, RULES_INERT_ENTRY, RULES_INVALID_SHAPE, isRulesRefusalCode } from '../engineErrorCodes.js';
 import { deniedEntryToolName } from '../engineToolDirectory.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
-import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_RULE_TOOL_NAME_VERDICTS } from '../generated/engineFactTables.js';
+import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_RULE_TOOL_NAME_VERDICTS, CORE_SESSION_RULES_GRAMMAR } from '../generated/engineFactTables.js';
 const EARLIER_GRAMMAR_REASON = 'earlier_grammar';
 const _inertReasonPin = true;
 void _inertReasonPin;
@@ -234,7 +234,7 @@ function receiptMismatch(sent, receipt, sentRev, receiptRev, sentGrammar, receip
     if (receiptRev <= sentRev) {
         return `policy write receipt did not advance the version stamp (sent with ${sentRev}, receipt says ${receiptRev})`;
     }
-    if (sentGrammar !== undefined && (receiptGrammar === undefined || receiptGrammar < sentGrammar)) {
+    if (receiptGrammar === undefined || receiptGrammar < sentGrammar) {
         return `policy write receipt does not carry the rule-grammar stamp that was sent (sent ${sentGrammar}, receipt ${receiptGrammar === undefined ? 'carries none' : `says ${receiptGrammar}`}) — the stored entries may now read differently`;
     }
     for (const field of SESSION_POLICY_RULE_FIELDS) {
@@ -342,7 +342,14 @@ function earlierGrammarOutcome(failure) {
     };
 }
 function rulesWithStamp(rules, grammar) {
-    return grammar === undefined ? rules : { ...rules, grammar };
+    return { ...rules, grammar };
+}
+const GRAMMAR_BEFORE_STAMP = 0;
+function writeGrammarOf(read) {
+    const stamp = grammarStampOf(read);
+    if (stamp !== undefined)
+        return stamp;
+    return read.rev >= 1 ? GRAMMAR_BEFORE_STAMP : CORE_SESSION_RULES_GRAMMAR;
 }
 function grammarStampOf(read) {
     return Object.hasOwn(read, 'grammar') ? read.grammar : undefined;
@@ -361,9 +368,10 @@ async function attemptTighten(facade, req, opts) {
         if (earlier.length > 0)
             return { done: { kind: 'refused', why: 'earlier_grammar_rows', entries: earlier } };
     }
+    const declared = writeGrammarOf(read);
     let receipt;
     try {
-        receipt = await facade.putPolicy(req.sessionId, { rules: rulesWithStamp(rules, stamp), expectedRev: read.rev }, opts);
+        receipt = await facade.putPolicy(req.sessionId, { rules: rulesWithStamp(rules, declared), expectedRev: read.rev }, opts);
     }
     catch (e) {
         const failure = classifySessionPolicyFailure(e);
@@ -389,7 +397,7 @@ async function attemptTighten(facade, req, opts) {
     if (!narrowed.ok) {
         return { done: { kind: 'unknown', why: 'write_receipt_unreadable', message: narrowed.detail } };
     }
-    const mismatch = receiptMismatch(rules, narrowed.rules, read.rev, narrowed.rev, stamp, narrowed.grammar);
+    const mismatch = receiptMismatch(rules, narrowed.rules, read.rev, narrowed.rev, declared, narrowed.grammar);
     if (mismatch !== null)
         return { done: { kind: 'unknown', why: 'write_receipt_mismatch', message: mismatch } };
     return { done: { kind: 'written', rev: narrowed.rev } };
@@ -626,9 +634,10 @@ async function attemptRemoval(facade, sessionId, mounted, opts) {
         if (earlier.length > 0)
             return { done: { kind: 'refused', why: 'earlier_grammar_rows', entries: earlier } };
     }
+    const declared = writeGrammarOf(read);
     let receipt;
     try {
-        receipt = await facade.putPolicy(sessionId, { rules: rulesWithStamp(next, stamp), expectedRev: read.rev }, opts);
+        receipt = await facade.putPolicy(sessionId, { rules: rulesWithStamp(next, declared), expectedRev: read.rev }, opts);
     }
     catch (e) {
         const failure = classifySessionPolicyFailure(e);
@@ -651,7 +660,7 @@ async function attemptRemoval(facade, sessionId, mounted, opts) {
     }
     if (!narrowed.ok)
         return { done: { kind: 'write_unconfirmed', why: 'write_receipt_unreadable', message: narrowed.detail } };
-    const mismatch = receiptMismatch(next, narrowed.rules, read.rev, narrowed.rev, stamp, narrowed.grammar) ??
+    const mismatch = receiptMismatch(next, narrowed.rules, read.rev, narrowed.rev, declared, narrowed.grammar) ??
         (removed.some((e) => {
             const r = Object.hasOwn(narrowed.rules, e.field) ? narrowed.rules[e.field] : undefined;
             return r !== undefined && r.includes(e.rule);

package/dist/hitl/subagentSource.d.ts

@@ -1 +1,2 @@
 export declare function subagentSourceSessionOf(carrier: object | null | undefined): string | undefined;
+export declare function livePendingRowSourceSessionOf(row: object | null | undefined): string | undefined;

package/dist/hitl/subagentSource.js

@@ -11,3 +11,14 @@ export function subagentSourceSessionOf(carrier) {
     const retired = slotReadOf(carrier, 'sourceTaskId');
     return retired.presence === 'present' ? nonEmpty(retired.value) : undefined;
 }
+export function livePendingRowSourceSessionOf(row) {
+    if (typeof row !== 'object' || row === null)
+        return undefined;
+    const current = slotReadOf(row, 'sourceSessionId');
+    if (current.presence === 'present')
+        return nonEmpty(current.value);
+    if (current.presence !== 'absent')
+        return undefined;
+    const retired = slotReadOf(row, 'originTaskId');
+    return retired.presence === 'present' ? nonEmpty(retired.value) : undefined;
+}