@sema-agent/client-core 0.84.1 → 0.85.1

package/dist/hitl/planReviewWire.js

@@ -1,7 +1,7 @@
 import { publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionResponder, unregisterLocalQuestionResponder, hasLocalQuestionResponder, hasQuestionOverlayFor, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { abortableSleep, settleWithinDeadline } from '../abortableSleep.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
+import { clientHasVerbs, engineWireFor, noAnswerKindOf, sendOnce } from '../engineWireFor.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
 import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
@@ -102,6 +102,18 @@ export function isPlanReviewPark(result) {
     const taskId = result?.taskId;
     return typeof taskId === 'string' && taskId.length > 0;
 }
+function pausedCheckpointIdOf(carrier) {
+    try {
+        const read = readRunTerminal(carrier);
+        if (read === null || read.kind !== 'paused')
+            return undefined;
+        const id = read.checkpointId;
+        return typeof id === 'string' && id.length > 0 ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 const armedPlanReviewTaskIds = new Set();
 const offerModeAfterByTask = new Map();
 export function _resetArmedPlanReviewsForTest() {
@@ -239,6 +251,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             ? { ...(wire !== undefined ? { wire } : {}), ...(opts?.onOutcome !== undefined ? { onOutcome: opts.onOutcome } : {}) }
             : undefined;
         const { taskId } = result;
+        const gateBefore = pausedCheckpointIdOf(result);
         retireActiveReopen(DEFAULT_SESSION_KEY, planReviewQuestionId(taskId));
         if (armedPlanReviewTaskIds.has(taskId)) {
             if (hasLocalQuestionResponder(planReviewQuestionId(taskId))) {
@@ -274,7 +287,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             offerModeAfterByTask.delete(taskId);
             notePlanReviewAnswered(questionId);
             hostLog('debug', `planReviewWire: arm responder delivering ${decided} for task ${taskId} (path=arm)`);
-            void (delivery === undefined ? decidePlanReview(taskId, decided, modeAfter) : decidePlanReview(taskId, decided, modeAfter, delivery));
+            void decidePlanReviewFor(taskId, decided, modeAfter, delivery, gateBefore);
             return { ok: true };
         });
         publishPlanReviewCard(taskId);
@@ -312,108 +325,186 @@ 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'}).`);
 }
-function isRequestTimeout(e) {
-    try {
-        return typeof e === 'object' && e !== null && e.name === 'TimeoutError';
-    }
-    catch {
-        return false;
-    }
+function planReviewDecisionConnectionLostOutcome(decision) {
+    return (`The plan_review ${decision} got no answer from the engine: the connection failed before an answer came back, and the request may already have reached the engine — ` +
+        `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'}).`);
+}
+function planReviewAdvancedOutcome(decision, postStatus) {
+    return (`The plan was ${decision === 'approve' ? 'approved' : 'rejected'} and the task advanced to a NEW approval gate ` +
+        `(post-decide status: ${postStatus}) — the next approval card will surface it; this is not a completion yet.`);
 }
 function usablePlanReviewWireClient(client) {
     if (client === null || typeof client !== 'object')
         return false;
-    const c = client;
-    return typeof c.assistant?.planReview === 'function' && typeof c.runs?.get === 'function';
+    return clientHasVerbs(client, [['assistant', 'planReview'], ['runs', 'get']]);
 }
 const PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS = 15_000;
-const decideInFlight = new Map();
+const planReviewDecisionOps = [];
+const MAX_PLAN_REVIEW_DECISION_OPS = 32;
+let planReviewLedgerClock = 0;
 let decideDispatchSeq = 0;
+function planReviewOpsOf(taskId) {
+    return planReviewDecisionOps.filter((op) => op.taskId === taskId);
+}
+function settlePlanReviewDecisionOp(op) {
+    if (op.settledAt === null)
+        op.settledAt = ++planReviewLedgerClock;
+}
+function pushPlanReviewDecisionOp(op) {
+    planReviewDecisionOps.push(op);
+    while (planReviewDecisionOps.length > MAX_PLAN_REVIEW_DECISION_OPS) {
+        let victim = planReviewDecisionOps.findIndex((o) => o.settledAt !== null && !o.ownCallOpen);
+        if (victim < 0)
+            victim = planReviewDecisionOps.findIndex((o) => o !== op && o.phase === 'handed');
+        if (victim < 0)
+            break;
+        planReviewDecisionOps.splice(victim, 1);
+    }
+}
+function dropPlanReviewDecisionOp(op) {
+    const i = planReviewDecisionOps.indexOf(op);
+    if (i >= 0)
+        planReviewDecisionOps.splice(i, 1);
+}
+export function notePlanReviewDecisionHandedOver(taskId) {
+    if (typeof taskId !== 'string' || taskId === '')
+        return null;
+    if (planReviewDecisionOps.some((op) => op.taskId === taskId && op.settledAt === null))
+        return null;
+    const op = { taskId, handedAt: ++planReviewLedgerClock, settledAt: null, phase: 'handed', notApplied: false, ownCallOpen: false };
+    pushPlanReviewDecisionOp(op);
+    return {
+        settle: () => {
+            if (op.phase !== 'handed')
+                return;
+            settlePlanReviewDecisionOp(op);
+        },
+        revoke: () => {
+            if (op.phase !== 'handed' || op.settledAt !== null)
+                return;
+            dropPlanReviewDecisionOp(op);
+        },
+    };
+}
+export function planReviewPendingReadMark() {
+    return ++planReviewLedgerClock;
+}
+export function planReviewDecisionInFlight(taskId, pendingReadStartedAt) {
+    if (typeof taskId !== 'string' || taskId === '')
+        return false;
+    const mark = typeof pendingReadStartedAt === 'number' && Number.isFinite(pendingReadStartedAt) ? pendingReadStartedAt : undefined;
+    return planReviewDecisionOps.some((op) => op.taskId === taskId && (op.settledAt === null || (mark !== undefined && op.settledAt > mark && !op.notApplied)));
+}
+export function notePlanReviewDecisionNotApplied(taskId) {
+    if (typeof taskId !== 'string' || taskId === '')
+        return;
+    const ops = planReviewOpsOf(taskId);
+    if (ops.some((op) => op.settledAt === null))
+        return;
+    let latest;
+    for (const op of ops)
+        if (latest === undefined || op.handedAt > latest.handedAt)
+            latest = op;
+    if (latest !== undefined)
+        latest.notApplied = true;
+}
+export function notePlanReviewGateLeft(taskId) {
+    if (typeof taskId !== 'string' || taskId === '')
+        return;
+    for (const op of planReviewOpsOf(taskId))
+        settlePlanReviewDecisionOp(op);
+}
+export function latestPlanReviewDecisionMark(taskId) {
+    if (typeof taskId !== 'string' || taskId === '')
+        return null;
+    let mark = null;
+    for (const op of planReviewOpsOf(taskId))
+        if (mark === null || op.handedAt > mark)
+            mark = op.handedAt;
+    return mark;
+}
 export function __resetPlanReviewDecisionLatchForTests() {
-    decideInFlight.clear();
+    planReviewDecisionOps.length = 0;
 }
 export async function decidePlanReview(taskId, decision, permissionModeAfter, opts) {
-    if (decideInFlight.has(taskId)) {
+    return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, undefined);
+}
+async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, gateBefore) {
+    if (typeof taskId === 'string' && planReviewDecisionOps.some((op) => op.taskId === taskId && op.phase === 'posting')) {
         hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
     }
-    const token = {};
-    decideInFlight.set(taskId, token);
+    let op = planReviewDecisionOps.find((o) => o.taskId === taskId && o.phase === 'handed' && o.settledAt === null);
+    if (op === undefined) {
+        op = { taskId: typeof taskId === 'string' ? taskId : String(taskId), handedAt: ++planReviewLedgerClock, settledAt: null, phase: 'posting', notApplied: false, ownCallOpen: true };
+        pushPlanReviewDecisionOp(op);
+    }
+    else {
+        op.phase = 'posting';
+        op.ownCallOpen = true;
+    }
+    const mine = op;
     const releaseLatch = () => {
-        if (decideInFlight.get(taskId) === token)
-            decideInFlight.delete(taskId);
+        if (mine.phase === 'posting')
+            mine.phase = 'landed';
+    };
+    const settle = (notApplied) => {
+        if (notApplied)
+            mine.notApplied = true;
+        settlePlanReviewDecisionOp(mine);
     };
     const dispatchNo = ++decideDispatchSeq;
     hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${decision} mode=${permissionModeAfter ?? '-'}`);
     try {
-        await decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, opts);
+        await decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, gateBefore);
     }
     finally {
         releaseLatch();
+        settlePlanReviewDecisionOp(mine);
+        mine.ownCallOpen = false;
     }
 }
-function planReviewClientsFor(wire, cfg) {
-    if (wire !== undefined) {
-        let injected;
-        try {
-            injected = typeof wire === 'object' && wire !== null ? wire.client : undefined;
-        }
-        catch {
-            injected = undefined;
-        }
-        if (!usablePlanReviewWireClient(injected))
-            return null;
-        const client = injected;
+function planReviewClientsFor(resolved) {
+    if (resolved.kind === 'injected') {
+        const client = resolved.client;
         return { decide: client, repull: () => client };
     }
-    if (!cfg)
-        return null;
-    const decide = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-        timeoutMs: PLAN_REVIEW_RESUME_TIMEOUT_MS,
-    });
+    const decide = resolved.make({ timeoutMs: PLAN_REVIEW_RESUME_TIMEOUT_MS });
     if (!decide)
         return null;
     return {
         decide,
-        repull: () => makeEngineWireClient({
-            baseUrl: cfg.baseUrl,
-            ...(cfg.token ? { token: cfg.token } : {}),
-            principal: cfg.principal,
-            timeoutMs: 15_000,
-        }),
+        repull: () => resolved.make({ timeoutMs: 15_000 }),
     };
 }
-async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, opts) {
+async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, gateBefore) {
     let outcome;
     let effect = 'unconfirmed';
+    let stillParkedProven = false;
     let statusSeen;
     const wire = opts?.wire;
-    const cfg = wire === undefined ? engineWireTarget() : null;
+    const resolved = engineWireFor(wire, DEFAULT_SESSION_KEY, usablePlanReviewWireClient);
     const badMode = permissionModeAfter !== undefined && (decision !== 'approve' || !isPlanReviewModeAfter(permissionModeAfter));
     if (badMode) {
         hostLog('error', `planReviewWire: ${decision} NOT sent — permissionModeAfter is only valid with approve and must be "default" or "acceptEdits"`);
         effect = 'not_sent';
         outcome = `The plan_review ${decision} could NOT be sent: the post-approval permission mode given with it is not valid for this decision (it only applies to an approval, and must be "default" or "acceptEdits"). Tell the user plainly that the decision did not go through; the plan is still waiting.`;
     }
-    else if (wire === undefined && !cfg) {
+    else if (resolved.kind === 'no-target') {
         hostLog('error', `planReviewWire: ${decision} NOT sent — engineWireTarget() unavailable`);
         effect = 'not_sent';
         outcome = `The plan_review ${decision} could NOT be sent: no engine connection is configured on this host. Tell the user plainly that the decision did not go through.`;
     }
+    else if (resolved.kind === 'injected-unusable') {
+        hostLog('error', `planReviewWire: ${decision} NOT sent — the engine client supplied by the host is not usable (needs assistant.planReview and runs.get)`);
+        effect = 'not_sent';
+        outcome = `The plan_review ${decision} could NOT be sent: the engine client supplied by the host cannot send it (it lacks the plan-review verb). Tell the user plainly that the decision did not go through.`;
+    }
     else {
-        const clients = planReviewClientsFor(wire, cfg);
+        const clients = planReviewClientsFor(resolved);
         if (!clients) {
-            if (wire !== undefined) {
-                hostLog('error', `planReviewWire: ${decision} NOT sent — the engine client supplied by the host is not usable (needs assistant.planReview and runs.get)`);
-                outcome = `The plan_review ${decision} could NOT be sent: the engine client supplied by the host cannot send it (it lacks the plan-review verb). Tell the user plainly that the decision did not go through.`;
-            }
-            else {
-                hostLog('error', `planReviewWire: ${decision} NOT sent — makeEngineWireClient() returned null`);
-                outcome = `The plan_review ${decision} could NOT be sent: the engine client could not be constructed. Tell the user plainly that the decision did not go through.`;
-            }
+            hostLog('error', `planReviewWire: ${decision} NOT sent — makeEngineWireClient() returned null`);
+            outcome = `The plan_review ${decision} could NOT be sent: the engine client could not be constructed. Tell the user plainly that the decision did not go through.`;
             effect = 'not_sent';
         }
         else {
@@ -428,13 +519,13 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     reqBody.permissionModeAfter = mode;
                 let body;
                 try {
-                    body = await client.assistant.planReview(taskId, reqBody);
+                    body = await sendOnce(undefined, () => client.assistant.planReview(taskId, reqBody));
                 }
                 catch (e1) {
                     const conflict = e1;
                     if (mode === 'default' && conflict?.status === 400 && conflict?.errorCode === 'request.field_conflict') {
                         hostLog('debug', 'planReviewWire: permissionModeAfter "default" refused as not applicable — re-sending the approval without the key (same meaning)');
-                        body = await client.assistant.planReview(taskId, reason !== undefined ? { decision, reason } : { decision });
+                        body = await sendOnce(undefined, () => client.assistant.planReview(taskId, reason !== undefined ? { decision, reason } : { decision }));
                     }
                     else {
                         throw e1;
@@ -445,6 +536,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 }
                 hostLog('debug', `planReviewWire: ${decision} → ok (dispatch #${dispatchNo}) ${JSON.stringify(body).slice(0, 200)}`);
                 let postStatus;
+                let gateAfter;
                 try {
                     const probe = clients.repull();
                     if (probe) {
@@ -461,6 +553,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                             post = (await probe.runs.get(taskId));
                         }
                         postStatus = typeof post?.status === 'string' ? post.status : undefined;
+                        gateAfter = pausedCheckpointIdOf(post?.result);
                     }
                 }
                 catch (e) {
@@ -468,8 +561,14 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 }
                 const effective = postStatus ?? (typeof body?.status === 'string' ? body.status : undefined);
                 statusSeen = effective;
-                if (effective === 'needs_review') {
+                const gateMoved = postStatus === 'needs_review' && gateBefore !== undefined && gateAfter !== undefined && gateAfter !== gateBefore;
+                if (effective === 'needs_review' && gateMoved) {
+                    effect = 'advanced';
+                    outcome = planReviewAdvancedOutcome(decision, 'needs_review');
+                }
+                else if (effective === 'needs_review') {
                     effect = 'still_parked';
+                    stillParkedProven = postStatus === 'needs_review' && gateBefore !== undefined && gateAfter !== undefined && gateAfter === gateBefore;
                     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). ` +
@@ -477,9 +576,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 }
                 else if (effective === 'suspended') {
                     effect = 'advanced';
-                    outcome =
-                        `The plan was ${decision === 'approve' ? 'approved' : 'rejected'} and the task advanced to a NEW approval gate ` +
-                            `(post-decide status: suspended) — the next approval card will surface it; this is not a completion yet.`;
+                    outcome = planReviewAdvancedOutcome(decision, 'suspended');
                 }
                 else if (effective !== undefined) {
                     effect = 'took_effect';
@@ -492,9 +589,11 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             catch (e) {
                 const status = e?.status;
                 const refusedCode = e?.errorCode;
+                const noAnswer = typeof status === 'number' || typeof e !== 'object' ? null : noAnswerKindOf(e);
                 if (status === 400 && refusedCode === 'request.field_conflict' && permissionModeAfter === 'acceptEdits') {
                     hostLog('debug', 'planReviewWire: approve + acceptEdits refused (request.field_conflict) — NOT re-sent with a different mode');
                     effect = 'still_parked';
+                    stillParkedProven = true;
                     outcome =
                         'The plan approval was NOT applied: the engine refused "auto-accept edits" for this task (it was not started read-only in plan mode, so that option does not apply). ' +
                             'Nothing changed engine-side — the plan is still waiting for review. Tell the user plainly, and that approving with "manually approve edits" will go through.';
@@ -518,10 +617,14 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     effect = status >= 400 && status < 500 ? 'not_applied' : 'unconfirmed';
                     outcome = `${`The plan_review decision failed: HTTP ${status} ${msg}`.trim()}${decideFailureNote(e)}`;
                 }
-                else if (isRequestTimeout(e)) {
+                else if (noAnswer === 'time-limit' || noAnswer === 'deadline') {
                     hostLog('debug', `planReviewWire: ${decision} sent but no answer within the request time limit (task ${taskId})`);
                     outcome = planReviewDecisionTimedOutOutcome(decision);
                 }
+                else if (noAnswer === 'connection-lost') {
+                    hostLog('debug', `planReviewWire: ${decision} got no answer — the connection failed and it cannot be told whether the request reached the engine (task ${taskId})`);
+                    outcome = planReviewDecisionConnectionLostOutcome(decision);
+                }
                 else {
                     outcome = `The plan_review decision could not reach the engine: ${String(e)}`;
                 }
@@ -531,6 +634,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
     const tail = planReviewOutcomeTail(taskId, decision, effect);
     const prompt = `<plan-review-outcome>\n${outcome}\n${tail}\n</plan-review-outcome>`;
     const onOutcome = opts?.onOutcome;
+    settle(effect === 'not_sent' || (effect === 'still_parked' && stillParkedProven));
     try {
         const delivered = enqueuePlanReviewOutcome(prompt, { taskId, dispatchNo, decision, effect });
         if (!delivered) {
@@ -723,7 +827,13 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
     revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
     return { reopened: true, firstSight };
 }
-async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark) {
+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 ` +
+        `${JSON.stringify(sessionKey)} (onQuestionFrameFor), so the card has nowhere to render`);
+    return verdict;
+}
+async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark, recheckReadStart) {
     const refusedByUser = { reopened: false, dismissedByUser: true };
     try {
         let fresh = false;
@@ -740,7 +850,8 @@ async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, ma
             }
         }
         let handedOver = false;
-        if (!decideInFlight.has(taskId)) {
+        const ledgerSaysInFlight = planReviewDecisionInFlight(taskId, recheckReadStart);
+        if (!ledgerSaysInFlight) {
             try {
                 handedOver = opts.decisionHandedOver?.(taskId) === true;
             }
@@ -749,7 +860,7 @@ async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, ma
                 return { reopened: false };
             }
         }
-        if (decideInFlight.has(taskId) || handedOver) {
+        if (ledgerSaysInFlight || handedOver) {
             hostLog('debug', `planReviewWire: reopen for task ${taskId} refused after the dismissal check — a decision for this task went out while the check was reading`);
             return { reopened: false, _sema_decisionInFlight: true };
         }
@@ -758,6 +869,11 @@ async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, ma
             hostLog('debug', `planReviewWire: reopen for task ${taskId} not minted — the dismissal record changed while it was being checked (stale evaluation)`);
             return await staleDismissalVerdict(current, sessionKey, taskId, receiptMs);
         }
+        if (!hasQuestionOverlayFor(sessionKey)) {
+            if (fresh)
+                dropDismissalEntry(sessionKey, taskId, mark);
+            return noPresentationSurfaceVerdict(taskId, sessionKey);
+        }
         if (!fresh) {
             hostLog('debug', `planReviewWire: automatic reopen for task ${taskId} refused — the user closed this gate's card (no newer gate instance proven)`);
             return refusedByUser;
@@ -773,8 +889,7 @@ async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, ma
         putDismissalEntry(sessionKey, taskId, reopening);
         let verdict = { reopened: false };
         try {
-            if (hasQuestionOverlayFor(sessionKey))
-                verdict = await mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
+            verdict = await mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
         }
         finally {
             const presented = verdict.reopened === true;
@@ -822,14 +937,18 @@ export function reopenPlanReviewCard(taskId, opts) {
         if (typeof taskId !== 'string' || taskId.length === 0) {
             return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
         }
-        if (decideInFlight.has(taskId)) {
+        const readStart = typeof opts?.pendingReadStartedAt === 'number' && Number.isFinite(opts.pendingReadStartedAt) ? opts.pendingReadStartedAt : undefined;
+        if (planReviewDecisionInFlight(taskId, readStart)) {
             hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — a decision for this task is in flight (its answer is still being delivered)`);
             const refused = { reopened: false, _sema_decisionInFlight: true };
             return receiptMs === undefined ? refused : Promise.resolve(refused);
         }
+        const guardStartedAt = planReviewPendingReadMark();
+        const recheckReadStart = readStart === undefined ? guardStartedAt : Math.min(readStart, guardStartedAt);
         const sessionKey = opts?.sessionKey ?? DEFAULT_SESSION_KEY;
         if (!hasQuestionOverlayFor(sessionKey)) {
-            return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
+            const noSurface = noPresentationSurfaceVerdict(taskId, sessionKey);
+            return receiptMs === undefined ? noSurface : Promise.resolve(noSurface);
         }
         if (sessionKey !== DEFAULT_SESSION_KEY && opts?.deliverDecision === undefined && opts?.wire === undefined) {
             hostLog('error', `planReviewWire: plan_review 卡未重开 —— sessionKey=${JSON.stringify(sessionKey)} 是非默认槽,` +
@@ -846,7 +965,7 @@ export function reopenPlanReviewCard(taskId, opts) {
                     hostLog('debug', `planReviewWire: automatic reopen for task ${taskId} refused — the user closed this gate's card`);
                     return { reopened: false, dismissedByUser: true };
                 }
-                return reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark);
+                return reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark, recheckReadStart);
             }
         }
         return mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);

package/dist/hitl/rosterMountedNames.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRosterView } from '../toolRoster.js';
+export declare function rosterMountedNames(roster: ToolRosterView | null | undefined): ReadonlySet<string> | 'absent' | 'unreadable';

package/dist/hitl/rosterMountedNames.js

@@ -0,0 +1,38 @@
+export function rosterMountedNames(roster) {
+    if (roster === undefined || roster === null)
+        return 'absent';
+    try {
+        if (typeof roster !== 'object' || Array.isArray(roster))
+            return 'unreadable';
+        const entries = roster.entries;
+        if (!Array.isArray(entries))
+            return 'unreadable';
+        const names = new Set();
+        const n = entries.length;
+        for (let i = 0; i < n; i++) {
+            if (!Object.hasOwn(entries, i))
+                return 'unreadable';
+            const row = entries[i];
+            if (typeof row !== 'object' || row === null)
+                return 'unreadable';
+            const name = row.name;
+            if (typeof name !== 'string' || name.length === 0)
+                return 'unreadable';
+            names.add(name);
+            const aliases = row.aliases;
+            if (aliases === undefined)
+                continue;
+            if (!Array.isArray(aliases))
+                return 'unreadable';
+            for (const a of aliases) {
+                if (typeof a !== 'string')
+                    return 'unreadable';
+                names.add(a);
+            }
+        }
+        return names;
+    }
+    catch {
+        return 'unreadable';
+    }
+}

package/dist/hitl/sessionPolicyDeliverable.d.ts

@@ -1,5 +1,6 @@
 import type { SessionPermissionRules } from '@sema-agent/sdk';
-export type SessionPolicyWithheldWhy = 'ask_no_bucket' | 'qualified_deny' | 'peer_wide' | 'wildcard' | 'not_a_tool_name' | 'legacy_tool_name';
+import type { ToolRosterView } from '../toolRoster.js';
+export type SessionPolicyWithheldWhy = 'ask_no_bucket' | 'qualified_deny' | 'peer_wide' | 'wildcard' | 'not_a_tool_name' | 'legacy_tool_name' | 'not_in_roster';
 export declare const SESSION_POLICY_WITHHELD_WHY: readonly SessionPolicyWithheldWhy[];
 export interface SessionPolicyWithheldRule {
     readonly rule: string;
@@ -11,7 +12,10 @@ export interface SessionPolicyDeliverability {
     readonly withheld: readonly SessionPolicyWithheldRule[];
     readonly unreadable?: true;
 }
+export interface SessionPolicyDeliverableOptions {
+    readonly roster?: ToolRosterView;
+}
 export declare function isEngineRefusedToolName(name: string): boolean;
-export declare function sessionPolicyDeliverable(behavior: 'deny' | 'ask', rules: readonly string[]): SessionPolicyDeliverability;
+export declare function sessionPolicyDeliverable(behavior: 'deny' | 'ask', rules: readonly string[], opts?: SessionPolicyDeliverableOptions): SessionPolicyDeliverability;
 export declare function sessionPolicyWithheldNotice(why: SessionPolicyWithheldWhy): string;
 export declare function legacyToolNameFailureNoteOf(code: string | undefined): string | undefined;

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,47 +1,8 @@
 import { CONFIG_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
-const COVERING_NAMESPACE_PREFIXES = ['mcp__', 'a2a__'];
-const ENGINE_RETIRED_TOOL_NAMES = new Map([
-    ['read_file', 'Read'],
-    ['edit_file', 'Edit'],
-    ['write_file', 'Write'],
-    ['bash', 'Bash'],
-    ['bash_readonly', null],
-    ['glob', 'Glob'],
-    ['grep', 'Grep'],
-    ['web_fetch', 'WebFetch'],
-    ['tool_search', 'ToolSearch'],
-    ['skill', 'Skill'],
-    ['present_plan', 'ExitPlanMode'],
-    ['enter_plan_mode', 'EnterPlanMode'],
-    ['spawn_subagent', 'Agent'],
-    ['CronCancel', 'CronDelete'],
-    ['lsp', 'LSP'],
-    ['submit_output', 'StructuredOutput'],
-    ['repo_map', 'RepoMap'],
-    ['read_tool_result', 'ReadToolResult'],
-    ['report_blocked', 'ReportBlocked'],
-    ['declare_done', 'DeclareDone'],
-    ['run_workflow', 'Workflow'],
-    ['RunWorkflow', 'Workflow'],
-    ['Task', 'Agent'],
-    ['BashOutput', 'TaskOutput'],
-    ['AgentOutputTool', 'TaskOutput'],
-    ['BashOutputTool', 'TaskOutput'],
-    ['AgentOutput', 'TaskOutput'],
-    ['WorkflowStatus', null],
-    ['KillShell', 'TaskStop'],
-    ['KillBash', 'TaskStop'],
-    ['ListMcpResources', 'ListMcpResourcesTool'],
-    ['ReadMcpResource', 'ReadMcpResourceTool'],
-    ['ReadMcpResourceDir', 'ReadMcpResourceDirTool'],
-    ['MultiEdit', null],
-    ['Fork', null],
-    ['Sleep', null],
-    ['Remember', null],
-    ['remember', null],
-    ['Recall', null],
-    ['recall', null],
-]);
+import { rosterMountedNames } from './rosterMountedNames.js';
+import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from '../generated/toolNameTables.js';
+const COVERING_NAMESPACE_PREFIXES = CORE_PROTOCOL_PREFIXES;
+const ENGINE_RETIRED_TOOL_NAMES = CORE_RETIRED_TOOL_CURRENT_NAMES;
 const PREFIXES_IN_PROSE = COVERING_NAMESPACE_PREFIXES.map((prefix) => `"${prefix}"`).join(' or ');
 const WITHHELD_NOTICE = {
     ask_no_bucket: 'Not written to this session’s rule record: that record only holds rules that block outright, and this rule asks before running instead — recording it as a block would change what it means.',
@@ -50,6 +11,7 @@ const WITHHELD_NOTICE = {
     wildcard: 'Not written to this session’s rule record: this rule uses a wildcard (*), and an engine that matches that record by exact tool name would block none of the tools it covers.',
     not_a_tool_name: 'Not written to this session’s rule record: this entry is not exactly one tool name — it is empty, not text, or has spaces around the name.',
     legacy_tool_name: `Not written to this session’s rule record: unless a tool by exactly this name is available, the engine refuses it — it is a retired tool name, or it contains "__" but does not start with ${PREFIXES_IN_PROSE} — and with it in that record every later run of this session would fail at startup until that entry is removed from the record. If the tool still exists, use its current name; a server or agent-peer tool name starts with ${PREFIXES_IN_PROSE}.`,
+    not_in_roster: 'Not written to this session’s rule record: the tool roster supplied for this check has no tool by exactly this name, as a name or an alias, with letter case counted — it may be misspelled, or name a tool this deployment does not provide — so recorded as it is it would block nothing here.',
 };
 export const SESSION_POLICY_WITHHELD_WHY = Object.freeze(Object.keys(WITHHELD_NOTICE));
 const MAX_RULES = 10_000;
@@ -83,7 +45,21 @@ export function isEngineRefusedToolName(name) {
         return true;
     return name.includes('__') && !COVERING_NAMESPACE_PREFIXES.some((prefix) => name.startsWith(prefix));
 }
-export function sessionPolicyDeliverable(behavior, rules) {
+function suppliedRosterNames(opts) {
+    if (opts === undefined || opts === null)
+        return 'absent';
+    let roster;
+    try {
+        if (typeof opts !== 'object')
+            return 'unreadable';
+        roster = opts.roster;
+    }
+    catch {
+        return 'unreadable';
+    }
+    return rosterMountedNames(roster);
+}
+export function sessionPolicyDeliverable(behavior, rules, opts) {
     const entries = [];
     try {
         if (behavior !== 'deny' && behavior !== 'ask')
@@ -105,6 +81,10 @@ export function sessionPolicyDeliverable(behavior, rules) {
     catch {
         return unreadable();
     }
+    const known = suppliedRosterNames(opts);
+    if (known === 'unreadable')
+        return unreadable();
+    const mounted = known === 'absent' ? undefined : known;
     const withheld = [];
     if (behavior === 'ask') {
         for (const r of entries)
@@ -117,7 +97,7 @@ export function sessionPolicyDeliverable(behavior, rules) {
             withheld.push({ rule: '', why: 'not_a_tool_name' });
             continue;
         }
-        const why = withheldWhyOf(r);
+        const why = withheldWhyOf(r) ?? (mounted !== undefined && !mounted.has(r) ? 'not_in_roster' : undefined);
         if (why === undefined)
             exact.push(r);
         else {