@sema-agent/client-core 0.85.0 → 0.85.2

package/dist/adapter/activeRunSelfHeal.js

@@ -1,5 +1,5 @@
 import { abortableSleep } from '../abortableSleep.js';
-import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
+import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 export const PLAN_REVIEW_GATE_KINDS = Object.freeze([PLAN_REVIEW_GATE_KIND, 'dry_run_review']);
 export const ASK_PARK_GATE_KINDS = Object.freeze(['human', 'irreversible_ask', 'policy_ask', 'tool_approval']);
@@ -45,20 +45,42 @@ function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
 }
+function errorSlot(e, key) {
+    if (e === null || e === undefined)
+        return undefined;
+    try {
+        return e[key];
+    }
+    catch {
+        return undefined;
+    }
+}
 function describeFailure(e) {
     const where = corruptStoredRowWhere(e);
     const rowNote = where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`;
-    if (typeof e === 'object' && e !== null && 'message' in e) {
-        const m = e.message;
-        if (typeof m === 'string' && m.length > 0)
-            return `${m.length > 200 ? `${m.slice(0, 200)}…` : m}${rowNote}`;
+    let m;
+    try {
+        m = typeof e === 'object' && e !== null && 'message' in e ? e.message : undefined;
     }
+    catch {
+        m = undefined;
+    }
+    if (typeof m === 'string' && m.length > 0)
+        return `${m.length > 200 ? `${m.slice(0, 200)}…` : m}${rowNote}`;
     return `the engine gave no detail${rowNote}`;
 }
 function readStatus(record) {
     const st = record?.status;
     return typeof st === 'string' && st.length > 0 ? st : null;
 }
+function readStatusGuarded(record) {
+    try {
+        return readStatus(record);
+    }
+    catch {
+        return null;
+    }
+}
 function readClaimHolder(record) {
     if (record === null || typeof record !== 'object')
         return 'unknown';
@@ -79,11 +101,129 @@ export function readCancelRequested(body) {
     const v = body.cancelRequested;
     return typeof v === 'boolean' ? v : undefined;
 }
+const REOPEN_VERDICT_KEYS = [
+    'reopened',
+    'firstSight',
+    'presented',
+    'decidedWithoutCard',
+    'pendingRowGone',
+    '_sema_decisionInFlight',
+    'dismissedByUser',
+    '_sema_noPresentationSurface',
+    '_sema_errorCode',
+];
+function snapshotReopenVerdict(raw) {
+    if (raw === null || raw === undefined)
+        return { reopened: false };
+    if (typeof raw !== 'object' && typeof raw !== 'function')
+        return raw;
+    const src = raw;
+    let nullProto = false;
+    try {
+        nullProto = Object.getPrototypeOf(raw) === null;
+    }
+    catch {
+        nullProto = false;
+    }
+    const snap = nullProto ? Object.create(null) : {};
+    const put = (k, v) => {
+        Object.defineProperty(snap, k, { value: v, enumerable: true, writable: true, configurable: true });
+    };
+    let own = [];
+    try {
+        own = Reflect.ownKeys(raw);
+    }
+    catch {
+        own = [];
+    }
+    const copied = new Set();
+    for (const k of own) {
+        let enumerable = false;
+        try {
+            enumerable = Object.prototype.propertyIsEnumerable.call(raw, k);
+        }
+        catch {
+            enumerable = false;
+        }
+        if (!enumerable)
+            continue;
+        let v;
+        let readable = true;
+        try {
+            v = src[k];
+        }
+        catch {
+            readable = false;
+        }
+        if (!readable)
+            continue;
+        put(k, v);
+        copied.add(k);
+    }
+    for (const k of REOPEN_VERDICT_KEYS) {
+        if (copied.has(k))
+            continue;
+        let v;
+        let readable = true;
+        try {
+            v = src[k];
+        }
+        catch {
+            readable = false;
+        }
+        if (readable && v !== undefined)
+            put(k, v);
+    }
+    return snap;
+}
 function reopenRefusedForDecisionInFlight(verdict) {
-    return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
+    try {
+        return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
+    }
+    catch {
+        return false;
+    }
 }
 function reopenRefusedForUserDismissal(verdict) {
-    return verdict !== null && verdict.reopened === false && verdict.dismissedByUser === true;
+    try {
+        return verdict !== null && verdict.reopened === false && verdict.dismissedByUser === true;
+    }
+    catch {
+        return false;
+    }
+}
+function reopenRefusedForNoPresentationSurface(verdict) {
+    try {
+        return (verdict !== null &&
+            verdict.reopened === false &&
+            verdict._sema_noPresentationSurface === true);
+    }
+    catch {
+        return false;
+    }
+}
+function reopenErrorCodeOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        const v = verdict._sema_errorCode;
+        return typeof v === 'string' && v.length > 0 ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function failureWireCode(e) {
+    try {
+        return effectiveWireErrorCode(e);
+    }
+    catch {
+        return undefined;
+    }
+}
+function thrownReopenVerdict(e) {
+    const code = failureWireCode(e);
+    return code !== undefined ? { reopened: false, _sema_errorCode: code } : { reopened: false };
 }
 function planReviewReopenTriggerFor(origin) {
     if (origin === 'user')
@@ -93,23 +233,57 @@ function planReviewReopenTriggerFor(origin) {
     return undefined;
 }
 function reopenDelivered(verdict) {
-    return verdict.reopened === true && verdict.presented !== false;
+    let reopened;
+    let presented;
+    try {
+        reopened = verdict.reopened;
+    }
+    catch {
+        return false;
+    }
+    if (reopened !== true)
+        return false;
+    try {
+        presented = verdict.presented;
+    }
+    catch {
+        presented = undefined;
+    }
+    return presented !== false;
+}
+function reopenedOfOutcome(outcome) {
+    try {
+        return outcome.reopened ?? null;
+    }
+    catch {
+        return null;
+    }
 }
 export function atMostOnceFailureClass(e) {
-    const status = e?.status;
+    const status = errorSlot(e, 'status');
     return typeof status === 'number' && status >= 400 && status < 500 ? 'rejected' : 'unknown';
 }
 export function readSteerDelivery(receipt) {
-    if (typeof receipt !== 'object' || receipt === null || !('delivery' in receipt))
+    try {
+        if (typeof receipt !== 'object' || receipt === null || !('delivery' in receipt))
+            return null;
+        const d = receipt.delivery;
+        return typeof d === 'string' && d.length > 0 ? d : null;
+    }
+    catch {
         return null;
-    const d = receipt.delivery;
-    return typeof d === 'string' && d.length > 0 ? d : null;
+    }
 }
 export function readSteerReceiptStatus(receipt) {
-    if (typeof receipt !== 'object' || receipt === null || !('status' in receipt))
+    try {
+        if (typeof receipt !== 'object' || receipt === null || !('status' in receipt))
+            return null;
+        const s = receipt.status;
+        return typeof s === 'string' && s.length > 0 ? s : null;
+    }
+    catch {
         return null;
-    const s = receipt.status;
-    return typeof s === 'string' && s.length > 0 ? s : null;
+    }
 }
 const CANCEL_RELEASE_WAIT_MS = 10_000;
 const RUNNING_LIVENESS_RECHECK_TIMEOUT_MS = 4_000;
@@ -227,11 +401,14 @@ async function readOwnedPendingCount(read, deps) {
             claimPollSleep(OWNED_PENDING_RECHECK_TIMEOUT_MS, recheckCtl.signal).then(() => null),
         ]);
         if (deps?.signal?.aborted === true)
-            return null;
-        return typeof count === 'number' ? count : null;
+            return { count: null };
+        return { count: typeof count === 'number' ? count : null };
     }
-    catch {
-        return null;
+    catch (e) {
+        if (deps?.signal?.aborted === true)
+            return { count: null };
+        const errorCode = failureWireCode(e);
+        return errorCode !== undefined ? { count: null, errorCode } : { count: null };
     }
     finally {
         deps?.signal?.removeEventListener('abort', onCallerAbort);
@@ -248,7 +425,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     }
     const callerAborted = () => deps?.signal?.aborted === true;
     if (pending && typeof deps?.listOwnedPendingApprovals === 'function' && !callerAborted()) {
-        const count = await readOwnedPendingCount(deps.listOwnedPendingApprovals, deps);
+        const { count } = await readOwnedPendingCount(deps.listOwnedPendingApprovals, deps);
         if (count === 0 && !callerAborted())
             pending = false;
     }
@@ -279,7 +456,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         catch (e) {
             return { kind: 'state-unknown', taskId, detail: describeFailure(e) };
         }
-        status = readStatus(record);
+        status = readStatusGuarded(record);
     }
     if (status === null) {
         return { kind: 'state-unknown', taskId, detail: 'the engine reported no status for that run' };
@@ -299,31 +476,41 @@ async function planVerdict(taskId, deps) {
     try {
         const trigger = planReviewReopenTriggerFor(deps?.submissionOrigin);
         const verdict = trigger === undefined ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, { trigger });
-        return (await verdict) ?? { reopened: false };
+        return snapshotReopenVerdict(await verdict);
     }
-    catch {
-        return { reopened: false };
+    catch (e) {
+        if (deps?.signal?.aborted === true)
+            return { reopened: false };
+        return thrownReopenVerdict(e);
     }
 }
 async function askVerdict(taskId, deps) {
     try {
-        return (await deps?.reopenAskPark?.(taskId)) ?? { reopened: false };
+        return snapshotReopenVerdict(await deps?.reopenAskPark?.(taskId));
     }
-    catch {
-        return { reopened: false };
+    catch (e) {
+        if (deps?.signal?.aborted === true)
+            return { reopened: false };
+        return thrownReopenVerdict(e);
     }
 }
 async function planReviewArm(taskId, signal, deps) {
     const verdict = await planVerdict(taskId, deps);
     if (reopenDelivered(verdict))
         return { kind: 'plan-review-reopened', taskId, firstSight: verdict.firstSight === true };
+    const inFlight = reopenRefusedForDecisionInFlight(verdict);
+    const dismissed = reopenRefusedForUserDismissal(verdict);
+    const noView = reopenRefusedForNoPresentationSurface(verdict);
+    const errorCode = inFlight || dismissed || noView ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'plan-review-reopen-failed',
         taskId,
         decidePath: signal.pendingGate?.decidePath ?? null,
-        ...(reopenRefusedForDecisionInFlight(verdict) ? { decisionInFlight: true } : {}),
+        ...(inFlight ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
-        ...(reopenRefusedForUserDismissal(verdict) ? { dismissedByUser: true } : {}),
+        ...(dismissed ? { dismissedByUser: true } : {}),
+        ...(noView ? { noPresentationSurface: true } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
     };
 }
 async function askParkArm(taskId, signal, runs, deps) {
@@ -358,29 +545,41 @@ async function askParkArm(taskId, signal, runs, deps) {
     if (verdict.reopened === false && verdict.decidedWithoutCard !== true && verdict.pendingRowGone === true && !inFlight) {
         return staleParkArm(taskId, signal, runs, deps);
     }
+    const noView = reopenRefusedForNoPresentationSurface(verdict);
+    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'ask-reopen-failed',
         taskId,
         decidePath: signal.pendingGate?.decidePath ?? null,
         ...(inFlight ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
+        ...(noView ? { noPresentationSurface: true } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
     let status = null;
     let ghost = false;
+    let errorCode;
+    let record = null;
+    let answered = false;
     const lease = claimProbeLease(deps?.signal, RUNNING_LIVENESS_RECHECK_TIMEOUT_MS);
     try {
-        status = readStatus(await durableGet.call(durable, taskId, { signal: lease.signal, ...sessionOpts(deps) }));
+        record = await durableGet.call(durable, taskId, { signal: lease.signal, ...sessionOpts(deps) });
+        answered = true;
     }
     catch (e) {
-        if (e?.status === 404)
+        if (errorSlot(e, 'status') === 404)
             ghost = true;
+        else
+            errorCode = failureWireCode(e);
     }
     finally {
         lease.release();
     }
-    return { status, ghost };
+    if (answered)
+        status = readStatusGuarded(record);
+    return errorCode !== undefined ? { status, ghost, errorCode } : { status, ghost };
 }
 async function staleParkArm(taskId, busy, runs, deps) {
     const reopenFailed = {
@@ -394,6 +593,7 @@ async function staleParkArm(taskId, busy, runs, deps) {
         taskId,
         decidePath: busy.pendingGate?.decidePath ?? null,
     };
+    const withFailureCode = (base, code) => code !== undefined ? { ...base, errorCode: code } : base;
     if (runs === undefined || typeof runs.get !== 'function')
         return reopenFailed;
     const durableGet = runs.get;
@@ -407,7 +607,7 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return reopenFailed;
     const fresh = first.status;
     if (fresh === null)
-        return reopenFailed;
+        return withFailureCode(reopenFailed, first.errorCode);
     if (RUNNING_STATES.includes(fresh))
         return runningChoiceArm(taskId, fresh, busy, false, runs, deps);
     if (PLAN_REVIEW_STATES.includes(fresh))
@@ -446,12 +646,14 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return { kind: 'ask-run-not-found', taskId };
     if (callerAborted())
         return reopenFailedAfterCard;
-    if (afterCard.status === null || !ASK_PARK_STATES.includes(afterCard.status)) {
-        return afterCard.status !== null && !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
+    if (afterCard.status === null)
+        return withFailureCode(reopenFailedAfterCard, afterCard.errorCode);
+    if (!ASK_PARK_STATES.includes(afterCard.status)) {
+        return !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
     }
-    const stillGone = await readOwnedPendingCount(recheckOwnedPending, deps);
-    if (stillGone !== 0)
-        return reopenFailedAfterCard;
+    const recheck = await readOwnedPendingCount(recheckOwnedPending, deps);
+    if (recheck.count !== 0)
+        return withFailureCode(reopenFailedAfterCard, recheck.errorCode);
     const verdict = await cancelAndConfirmRelease(taskId, runs, durableGet, deps);
     if (verdict.outcome === 'released') {
         return { kind: 'stale-park-cancelled', taskId, ...(verdict.engineStatedRelease ? { releaseConfirmedByEngine: true } : {}) };
@@ -655,6 +857,7 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow) {
 }
 const INJECTED_LEAD = 'A follow-up message sema sent on its own (not one you typed)';
 const USER_CLOSED_CARD_NOT_PUT_BACK = 'sema does not put a card you closed back on screen by itself';
+const NO_CARD_VIEW_ATTACHED = 'this session has no view attached that can show decision cards';
 function injectedSubmissionRow(outcome, following = false) {
     const lead = INJECTED_LEAD;
     const id = 'taskId' in outcome && outcome.taskId ? ` (id ${outcome.taskId})` : '';
@@ -677,22 +880,32 @@ function injectedSubmissionRow(outcome, following = false) {
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'queued') {
         const queuedOn = `${lead} is queued on an earlier reply${id} that is paused waiting for a decision`;
-        if (outcome.reopened !== null && reopenDelivered(outcome.reopened)) {
+        const reopened = reopenedOfOutcome(outcome);
+        if (reopened !== null && reopenDelivered(reopened)) {
             return `${queuedOn}; sema has shown that decision card, and the message is picked up once you answer it.`;
         }
-        if (reopenRefusedForDecisionInFlight(outcome.reopened)) {
+        if (reopenRefusedForDecisionInFlight(reopened)) {
             return `${queuedOn}; your answer to it is still on its way, and the message is picked up once that answer is applied.`;
         }
-        if (reopenRefusedForUserDismissal(outcome.reopened)) {
+        if (reopenRefusedForUserDismissal(reopened)) {
             return (`${queuedOn}; you closed that card yourself, so sema did not put it back on screen — send a message to bring it ` +
                 `back, and the message is picked up once that decision is made.`);
         }
-        return `${queuedOn} sema could not show here; the message is picked up only once that decision is made.`;
+        const noView = reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '';
+        return `${queuedOn} sema could not show here${noView}; the message is picked up only once that decision is made.`;
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'parked_for_wake') {
         return (`${lead} has not reached the model: the earlier reply${id} had already finished, so the message was set aside on it ` +
             `instead of starting a new reply, and sema did not retry it.`);
     }
+    if (outcome.kind === 'running-steered' && outcome.delivery !== 'applied') {
+        const unknown = `${lead} was accepted for the reply already in progress${id}, but how it will be delivered was not reported, ` +
+            `so sema cannot tell whether that reply will pick it up`;
+        return following
+            ? `${unknown}. sema is following that reply and will show whatever it asks for next; check what it does ` +
+                `before deciding whether anything needs to be sent again.`
+            : `${unknown} — watch that reply before deciding whether anything needs to be sent again.`;
+    }
     switch (selfHealSubmissionDisposition(outcome)) {
         case 'held-for-decision':
             return (`${lead} is on hold: this session is busy with an earlier reply${id} that is waiting on a decision. ` +
@@ -710,9 +923,13 @@ function injectedSubmissionRow(outcome, following = false) {
                     `sema is following that reply and will show whatever it asks for next; nothing for you to do now.`
                 : `${lead} was passed to the reply already in progress${id} instead of starting a new one — ` +
                     `watch that reply for what it does with it.`;
-        case 'not-delivered':
+        case 'not-delivered': {
+            const noView = (outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.noPresentationSurface === true
+                ? ` (${NO_CARD_VIEW_ATTACHED})`
+                : '';
             return (`${lead} was not delivered: this session was still busy with an earlier reply${id}, and there was no open card ` +
-                `you could answer to free it. sema did not retry, so the model has not seen it.`);
+                `you could answer to free it${noView}. sema did not retry, so the model has not seen it.`);
+        }
     }
 }
 function decisionInFlightRow(parkedOn) {
@@ -780,8 +997,9 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             const viaEngine = engineDecide && outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
+            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
             return (`The previous turn is parked waiting for your decision (run ${outcome.taskId}) and sema could ` +
-                `not reopen that card here. It did NOT cancel the run — that would have decided it for you. ` +
+                `not reopen that card here${noView}. It did NOT cancel the run — that would have decided it for you. ` +
                 (keepSessionWayOut !== null
                     ? `Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want it.${viaEngine}`
                     : `Your message was NOT sent; ${wayOut} if you no longer want it.${viaEngine}`));
@@ -797,8 +1015,9 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             const viaEngine = engineDecide && outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
+            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
             return (`The previous turn is parked waiting for a plan review (run ${outcome.taskId}) and sema could not ` +
-                `reopen that approval card. It did NOT cancel the run — that would have discarded the plan for ` +
+                `reopen that approval card${noView}. It did NOT cancel the run — that would have discarded the plan for ` +
                 (keepSessionWayOut !== null
                     ? `you. Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want that plan.${viaEngine}`
                     : `you. Your message was NOT sent; ${wayOut} if you no longer want that plan.${viaEngine}`));
@@ -816,15 +1035,18 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             }
             if (outcome.delivery === 'queued') {
                 const parked = outcome.status ? `parked (status ${outcome.status})` : 'parked';
-                const next = outcome.reopened !== null && reopenDelivered(outcome.reopened)
+                const reopened = reopenedOfOutcome(outcome);
+                const next = reopened !== null && reopenDelivered(reopened)
                     ? `sema has surfaced that decision card — answering it is what lets that run resume and pick your message up.`
-                    : reopenRefusedForDecisionInFlight(outcome.reopened)
+                    : reopenRefusedForDecisionInFlight(reopened)
                         ? `Your answer to that decision is still on its way to the engine, so sema did not show the card again; ` +
                             `that run moves on once the engine applies it.`
-                        : reopenRefusedForUserDismissal(outcome.reopened)
+                        : reopenRefusedForUserDismissal(reopened)
                             ? `You closed that decision card yourself, so sema did not put it back on screen; nothing will resume that ` +
                                 `run until that decision is made — send a message to bring the card back.`
-                            : `sema could not surface that decision card here, so nothing will resume that run until that decision is made; ` +
+                            : `sema could not surface that decision card here` +
+                                (reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '') +
+                                `, so nothing will resume that run until that decision is made; ` +
                                 `${wayOut} if you no longer want it.`;
                 return (`${handle} is not actually working right now: the engine reports it ${parked} on a decision it needs ` +
                     `from you, so it queued your message on that park instead of running it. ${next} ${textOnly} ` +

package/dist/hitl/armedGateRegistry.d.ts

@@ -9,6 +9,7 @@ export declare function gateArmedWaitMs(): number;
 export declare function waitForGateArmed(keys: readonly string[], timeoutMs: number): Promise<boolean>;
 export declare function waitForGateArmedFor(sessionKey: string, keys: readonly string[], timeoutMs: number): Promise<boolean>;
 export declare function registerArmedGateFromQuestionId(questionId: unknown): void;
+export declare function registerArmedGateFromQuestionIdFor(sessionKey: string, questionId: unknown): void;
 export declare function planReviewArmedKey(taskId: string): string;
 export declare function planReviewArmedKeyFor(sessionKey: string, taskId: string): string;
 export declare function notePlanReviewAnswered(questionId: unknown): void;

package/dist/hitl/armedGateRegistry.js

@@ -120,7 +120,7 @@ function armedKeyForQuestionIdFor(sessionKey, questionId) {
 export function registerArmedGateFromQuestionId(questionId) {
     registerArmedGateFromQuestionIdFor(DEFAULT_SESSION_KEY, questionId);
 }
-function registerArmedGateFromQuestionIdFor(sessionKey, questionId) {
+export function registerArmedGateFromQuestionIdFor(sessionKey, questionId) {
     if (typeof questionId !== 'string' || questionId.length === 0)
         return;
     if (questionId.startsWith(PLAN_REVIEW_QUESTION_ID_PREFIX) && !questionId.includes(REOPEN_ID_TAIL)) {

package/dist/hitl/planReviewWire.js

@@ -827,6 +827,12 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
     revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
     return { reopened: true, firstSight };
 }
+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 {
@@ -863,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;
@@ -878,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;
@@ -937,7 +947,8 @@ export function reopenPlanReviewCard(taskId, opts) {
         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)} 是非默认槽,` +

package/dist/host.d.ts

@@ -56,7 +56,7 @@ export interface HostPorts {
 }
 export declare function installHost(ports: HostPorts): () => void;
 export declare function installHostFor(sessionKey: string, ports: Omit<HostPorts, 'queue'>): () => void;
-export declare function hostLog(level: AdapterLogLevel, msg: string, data?: unknown): void;
+export declare function hostLog(level: AdapterLogLevel, msg: string, data?: unknown): boolean;
 export declare function hostProbe(channel: string, line: string): void;
 export declare function hostSettings(): SettingsPort | undefined;
 export declare function hostSettingsFor(sessionKey: string): SettingsPort | undefined;

package/dist/host.js

@@ -46,11 +46,20 @@ export function installHostFor(sessionKey, ports) {
         slot.state = prev;
     };
 }
+function callDiagnosticPort(call) {
+    try {
+        call();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function hostLog(level, msg, data) {
-    hostSlot(DEFAULT_SESSION_KEY).state.log?.(level, msg, data);
+    return callDiagnosticPort(() => hostSlot(DEFAULT_SESSION_KEY).state.log?.(level, msg, data));
 }
 export function hostProbe(channel, line) {
-    hostSlot(DEFAULT_SESSION_KEY).state.probe?.(channel, line);
+    callDiagnosticPort(() => hostSlot(DEFAULT_SESSION_KEY).state.probe?.(channel, line));
 }
 export function hostSettings() {
     return hostSettingsFor(DEFAULT_SESSION_KEY);

package/dist/index.d.ts

@@ -169,7 +169,7 @@ export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
 export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
-export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
+export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, registerArmedGateFromQuestionIdFor, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';
 export * from './hitl/approvalDecisionNoteAudit.js';

package/dist/index.js

@@ -155,7 +155,7 @@ export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
 export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
-export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
+export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, registerArmedGateFromQuestionIdFor, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';
 export * from './hitl/approvalDecisionNoteAudit.js';

package/dist/request/taskRequest.d.ts

@@ -71,6 +71,8 @@ export interface TaskRequestOmission {
     readonly cause: TaskRequestOmissionCause;
 }
 export declare function taskRequestOmissionCauseDetail(cause: unknown): string;
+export declare const TASK_REQUEST_OMISSION_CAUSE_NOTICES: Readonly<Record<TaskRequestOmissionCause, string>>;
+export declare function taskRequestOmissionCauseNotice(cause: unknown): string;
 export interface TaskRequestAssembly {
     readonly request: TaskRequestLike;
     readonly omitted: readonly TaskRequestOmission[];