@sema-agent/client-core 0.95.0 → 0.96.0

package/dist/hitl/noAllowCause.d.ts

@@ -1,9 +1,10 @@
-export type NoAllowCause = 'no_allow_rule' | 'ask_rule' | 'budget' | 'other';
+export type NoAllowCause = 'no_allow_rule' | 'ask_rule' | 'engine_ask_rule' | 'budget' | 'other';
 export interface RuleLadderNoAllowFacts {
     readonly allowed?: boolean;
     readonly denied?: boolean;
     readonly askRuleMatched?: boolean;
     readonly budgetExhausted?: boolean;
     readonly noRuleMatched?: boolean;
+    readonly noAskRuleMatched?: boolean;
 }
 export declare function noAllowCauseOf(card: object | null | undefined, ladder: RuleLadderNoAllowFacts | null | undefined): NoAllowCause | undefined;

package/dist/hitl/noAllowCause.js

@@ -18,8 +18,9 @@ export function noAllowCauseOf(card, ladder) {
     if (ladderSays(ladder, 'budgetExhausted'))
         return 'budget';
     const standing = automaticAnswerVerdict(card, 'standing_rule');
-    if (standing.kind === 'must_ask' && (standing.askClass === 'ask_rule' || standing.origin === 'ask_rule'))
-        return 'ask_rule';
+    if (standing.kind === 'must_ask' && (standing.askClass === 'ask_rule' || standing.origin === 'ask_rule')) {
+        return ladderSays(ladder, 'noAskRuleMatched') || ladderSays(ladder, 'noRuleMatched') ? 'engine_ask_rule' : 'ask_rule';
+    }
     if (ladderSays(ladder, 'noRuleMatched') && standing.kind === 'may_answer')
         return 'no_allow_rule';
     return 'other';

package/dist/hitl/parkResolver.d.ts

@@ -28,6 +28,7 @@ export type GateOutcome = {
     reason: string;
     code?: GateFailureCode | undefined;
     errorCode?: string | undefined;
+    blockedBy?: string | undefined;
     retriable?: true;
     retryExhausted?: true;
     currentPending?: GateCurrentPending | undefined;

package/dist/hitl/parkResolver.js

@@ -1,8 +1,7 @@
 import { putOwnKey, readOwnDataValue } from '../ownKey.js';
-import { ApprovalStaleError, NotFoundError, ParkedResumeStartupError } from '@sema-agent/sdk';
-import { DecideTransportRetryExhaustedError, GATE_FAILURE_CODES, HitlBridge, NO_QUESTION_OVERLAY_REASON, findPendingForTask, hitlSafetyCodeOf, isNoDecisionSurfaceReason, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
-import { ASK_GONE, CHECKPOINT_UNSUPPORTED_VERSION, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isDecideAlreadyResolvedCode, isDecideParkMovedCode, refusalSaysStillPending } from '../engineErrorCodes.js';
-import { isHitlSafetyErrorLike } from './parkOwnership.js';
+import { DecideTransportRetryExhaustedError, GATE_FAILURE_CODES, HitlBridge, NO_QUESTION_OVERLAY_REASON, findPendingForTask, hitlSafetyCodeOf, isNoDecisionSurfaceReason, readDecideCurrentPending, readWireCodes, } from './hitlBridge.js';
+import { DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isRefusedParkCode, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -35,62 +34,17 @@ function alreadyResolvedReasonToken(reason) {
 }
 export function isAlreadyResolvedFailure(failure) {
     try {
-        return alreadyResolvedFailureVerdict(failure);
+        const r = readDecisionRefusalAsk(failure);
+        return r.reading === 'settled' || (r.reading === 'not_settled' && (r.gateMoved || r.wordingHint));
     }
     catch {
         return false;
     }
 }
-const ALREADY_RESOLVED_TYPED_ERROR_NAMES = Object.freeze([ApprovalStaleError.name, NotFoundError.name]);
-const PARKED_RESUME_STARTUP_TYPED_ERROR_NAME = ParkedResumeStartupError.name;
-function decideFailureFactsOf(failure) {
-    if (typeof failure !== 'object' || failure === null)
-        return undefined;
-    const o = failure;
-    const ec = o.errorCode;
-    const errorCode = typeof ec === 'string' && ec.length > 0 ? ec : undefined;
-    const retriable = refusalSaysStillPending(failure);
-    if (Object.hasOwn(failure, 'kind') && o.kind === 'failed') {
-        const safety = isGateFailureCode(o.safetyCode) ? o.safetyCode : undefined;
-        const code = isGateFailureCode(o.code) ? o.code : safety;
-        return { code, safetySignal: safety !== undefined, errorCode, retriable, typedErrorName: undefined, reason: o.reason };
-    }
-    const name = o.name;
-    return {
-        code: isGateFailureCode(o.code) ? o.code : undefined,
-        safetySignal: isHitlSafetyErrorLike(failure),
-        errorCode,
-        retriable,
-        typedErrorName: typeof name === 'string' ? name : undefined,
-        reason: String(failure),
-    };
-}
-function alreadyResolvedFailureVerdict(failure) {
-    const f = decideFailureFactsOf(failure);
-    if (f === undefined)
-        return false;
-    if (f.code !== undefined)
-        return f.code === 'no_pending';
-    if (f.safetySignal)
-        return false;
-    if (isDecideAlreadyResolvedCode(f.errorCode))
-        return true;
-    if (f.typedErrorName !== undefined && ALREADY_RESOLVED_TYPED_ERROR_NAMES.includes(f.typedErrorName))
-        return true;
-    if (f.typedErrorName === PARKED_RESUME_STARTUP_TYPED_ERROR_NAME && !isDecideParkMovedCode(f.errorCode))
-        return false;
-    if (isCodeClassifiedGateFailure(f.errorCode, f.retriable))
-        return false;
-    if (isDecideParkMovedCode(f.errorCode))
-        return true;
-    if (f.errorCode === ASK_GONE)
-        return true;
-    return isAlreadyResolvedGateReason(f.reason);
-}
 export function isGateStandingErrorCode(code, retriable) {
     return (code === RESUME_POLICY_FOLD_CODE ||
         code === 'corrupt' ||
-        (code === CHECKPOINT_UNSUPPORTED_VERSION && retriable === true) ||
+        (isRefusedParkCode(code) && retriable === true) ||
         code === DECIDE_WORKFLOW_PARKS_UNREADABLE ||
         code === DECIDE_WORKFLOW_PARK_FORKED);
 }
@@ -193,7 +147,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
     catch (e) {
         const code = hitlSafetyCodeOf(e);
         const currentPending = readDecideCurrentPending(e);
-        const wireCode = readWireErrorCode(e);
+        const wireCodes = readWireCodes(e);
         const wireRetriable = typeof e === 'object' && e !== null && refusalSaysStillPending(e);
         const failureTexts = wireFailureTextsOf(e);
         hostLog('debug', `liveHitlAskWire: decide failed: ${failureTexts.log}`);
@@ -205,7 +159,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
             ...(code !== undefined ? { code } : {}),
             ...(thrownIsInstanceOf(e, DecideTransportRetryExhaustedError) ? { retryExhausted: true } : {}),
             ...(currentPending !== undefined ? { currentPending } : {}),
-            ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
+            ...wireCodes,
             ...(wireRetriable ? { retriable: true } : {}),
         };
     }

package/dist/hitl/parkRowBirthWait.d.ts

@@ -35,5 +35,6 @@ export interface ParkRowBirthWaitDeps<Row> {
     now?: () => number;
     sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
     signal?: AbortSignal;
+    onFailure?: (log: string) => void;
 }
 export declare function waitForParkRowBirth<Row>(deps: ParkRowBirthWaitDeps<Row>): Promise<ParkRowWaitVerdict<Row>>;

package/dist/hitl/parkRowBirthWait.js

@@ -1,5 +1,5 @@
 import { abortableSleep } from '../abortableSleep.js';
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { reasonOfThrownWithSink } from '../hostCallbackGuard.js';
 function parkRowPollDelay(ms, signal) {
     return abortableSleep(ms, signal ?? new AbortController().signal);
 }
@@ -17,7 +17,7 @@ export async function waitForParkRowBirth(deps) {
             return await deps.probe(attempt, signal);
         }
         catch (e) {
-            return { kind: 'unborn', reason: `probe threw: ${wireFailureTextsOf(e).reason}` };
+            return { kind: 'unborn', reason: `probe threw: ${reasonOfThrownWithSink(e, (log) => deps.onFailure?.(log))}` };
         }
     };
     const probeWithinRemaining = async (attempt, remainingMs) => {

package/dist/hitl/planReviewWire.d.ts

@@ -62,6 +62,7 @@ export interface PlanReviewDeliveryOptions {
 }
 export interface DecidePlanReviewOptions extends PlanReviewDeliveryOptions {
     reason?: string;
+    parkedResult?: unknown;
 }
 export interface PlanReviewDecisionHandle {
     settle(): void;

package/dist/hitl/planReviewWire.js

@@ -13,7 +13,7 @@ import { denyReasonForWire, isPlanReviewModeAfter } from './hitlBridge.js';
 import { planReviewQuestionId, REOPEN_ID_TAIL, taskIdFromPlanReviewQuestionId } from './gateIdentity.js';
 import { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, registerArmedGateFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
-import { PLAN_REVIEW_GATE_KIND } from '../adapter/activeRunSelfHeal.js';
+import { PLAN_REVIEW_GATE_KIND, durableDecideLegOf } from '../adapter/activeRunSelfHeal.js';
 import { readRunTerminal, runTerminalGateKind } from '../runTerminal.js';
 const PLAN_REVIEW_RESUME_TIMEOUT_MS = 6 * 60 * 60_000;
 export const PLAN_REVIEW_APPROVE_LABEL = 'Yes, approve and run the plan';
@@ -130,6 +130,18 @@ function pausedCheckpointIdOf(carrier) {
         return undefined;
     }
 }
+function pausedGateKindOf(carrier) {
+    try {
+        const read = readRunTerminal(carrier);
+        if (read === null || read.kind !== 'paused')
+            return undefined;
+        const kind = runTerminalGateKind(read);
+        return typeof kind === 'string' && kind.length > 0 ? kind : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 const armedPlanReviewTaskIds = new Set();
 const offerModeAfterByTask = new Map();
 export function _resetArmedPlanReviewsForTest() {
@@ -470,7 +482,53 @@ export function __resetPlanReviewDecisionLatchForTests() {
     planReviewDecisionOps.length = 0;
 }
 export async function decidePlanReview(taskId, decision, permissionModeAfter, opts) {
-    return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, undefined);
+    return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, parkedGateIdentityOf(opts));
+}
+function parkedGateIdentityOf(opts) {
+    try {
+        return opts !== null && typeof opts === 'object' ? pausedCheckpointIdOf(opts.parkedResult) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function planReviewSettledVerdict(r) {
+    const status = r.postStatus ?? r.bodyStatus;
+    const gateMoved = r.gateBefore !== undefined && r.gateAfter !== undefined && r.gateAfter !== r.gateBefore;
+    if (r.reparked)
+        return status !== 'completed' && !gateMoved ? { effect: 'still_parked', proven: true } : { effect: 'unconfirmed', proven: false };
+    if (status === 'completed')
+        return { effect: 'took_effect', proven: false };
+    const newGateHasCard = () => {
+        const leg = durableDecideLegOf({ gateKind: r.gateKindAfter ?? null });
+        return leg === 'approval' || leg === 'plan_review';
+    };
+    if (status === 'suspended' && r.postStatus === 'suspended' && newGateHasCard())
+        return { effect: 'advanced', proven: false };
+    if (status === 'needs_review' && r.postStatus === 'needs_review' && r.gateBefore !== undefined && r.gateAfter !== undefined) {
+        if (r.gateAfter === r.gateBefore)
+            return { effect: 'still_parked', proven: true };
+        if (newGateHasCard())
+            return { effect: 'advanced', proven: false };
+    }
+    return { effect: 'unconfirmed', proven: false };
+}
+function bodyWordOf(body, key) {
+    try {
+        const v = body !== null && typeof body === 'object' ? body[key] : undefined;
+        return typeof v === 'string' && v.length > 0 ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function bodySaysReparked(body) {
+    try {
+        return body !== null && typeof body === 'object' && body.retriable === true;
+    }
+    catch {
+        return false;
+    }
 }
 async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, gateBefore) {
     if (typeof taskId === 'string' && planReviewDecisionOps.some((op) => op.taskId === taskId && op.phase === 'posting')) {
@@ -586,6 +644,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;
+                let gateKindAfter;
                 try {
                     const probe = clients.repull();
                     if (probe) {
@@ -601,35 +660,54 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                         else {
                             post = (await probe.runs.get(taskId));
                         }
-                        postStatus = typeof post?.status === 'string' ? post.status : undefined;
+                        postStatus = bodyWordOf(post, 'status');
                         gateAfter = pausedCheckpointIdOf(post?.result);
+                        gateKindAfter = pausedGateKindOf(post?.result);
                     }
                 }
                 catch (e) {
                     hostLog('debug', `planReviewWire: post-decide status re-pull failed (fail-soft): ${String(e)}`);
                 }
-                const effective = postStatus ?? (typeof body?.status === 'string' ? body.status : undefined);
+                const bodyStatus = bodyWordOf(body, 'status');
+                const effective = postStatus ?? bodyStatus;
                 statusSeen = effective;
-                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;
+                const verdict = planReviewSettledVerdict({ postStatus, bodyStatus, reparked: bodySaysReparked(body), gateBefore, gateAfter, gateKindAfter });
+                effect = verdict.effect;
+                stillParkedProven = verdict.proven;
+                const code = bodyWordOf(body, 'errorCode');
+                if (effect === 'still_parked' && postStatus === 'needs_review' && !bodySaysReparked(body)) {
                     outcome =
                         `The plan_review ${decision} returned HTTP 200 but the session is STILL locked on the same review gate ` +
                             `(post-decide status: needs_review). The decision did NOT take effect (known engine issue, RB-471 family). ` +
                             `Tell the user plainly that the ${decision} did not go through; the reliable exits today are approving the plan or cancelling the task.`;
                 }
-                else if (effective === 'suspended') {
-                    effect = 'advanced';
-                    outcome = planReviewAdvancedOutcome(decision, 'suspended');
+                else if (effect === 'still_parked') {
+                    outcome =
+                        `The plan_review ${decision} was NOT applied: the engine could not continue the task and put the plan back to wait for a decision` +
+                            `${code !== undefined ? ` (engine code: ${code})` : ''}. Tell the user plainly that the ${decision} did not go through.`;
+                }
+                else if (effect === 'advanced') {
+                    outcome = planReviewAdvancedOutcome(decision, effective === 'needs_review' ? 'needs_review' : 'suspended');
+                }
+                else if (effect === 'took_effect') {
+                    outcome =
+                        `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — final status: ${effective} ` +
+                            `(${postStatus !== undefined ? 'post-decide re-checked: task left the review gate' : "from the decision's own reply; the post-decide re-check was unavailable"}).`;
+                }
+                else if (effective === 'needs_review' && (gateBefore === undefined || gateAfter === undefined || postStatus !== 'needs_review')) {
+                    outcome =
+                        `The plan_review ${decision} returned HTTP 200 and the task is waiting at a plan review gate again (post-decide status: needs_review), ` +
+                            `but it could not be told whether this is the same review (the ${decision} did not take effect) or a new plan written after it (it did).`;
+                }
+                else if (effective === 'suspended' || effective === 'needs_review') {
+                    outcome =
+                        `The plan_review ${decision} was accepted by the engine (HTTP 200) and the task is paused again (post-decide status: ${effective}), ` +
+                            `${gateKindAfter !== undefined ? `at a '${gateKindAfter}' pause that is not an approval card` : 'but the pause it stopped at was not reported'} — what the ${decision} led to could not be confirmed.`;
                 }
                 else if (effective !== undefined) {
-                    effect = 'took_effect';
-                    outcome = `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — final status: ${effective} (post-decide re-checked: task left the review gate).`;
+                    outcome =
+                        `The plan_review ${decision} was accepted by the engine (HTTP 200), but the task then reported status ${effective}` +
+                            `${code !== undefined ? ` (engine code: ${code})` : ''} — not a completion; what the ${decision} led to could not be confirmed.`;
                 }
                 else {
                     outcome = `The plan_review ${decision} was accepted by the engine (HTTP 200) but its effect is unconfirmed — final status: unknown (post-decide verification unavailable). Do not treat this as ${decision === 'approve' ? 'an approval that resumed the task' : 'a discarded plan'}.`;
@@ -678,10 +756,10 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     outcome = `This ${decision} was not applied. ${corruptStoredRowContent(where)}`;
                 }
                 else if (typeof status === 'number') {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    hostLog('debug', `planReviewWire: ${decision} → ${status} ${msg.slice(0, 200)}`);
+                    const failureTexts = wireFailureTextsOf(e);
+                    hostLog('debug', `planReviewWire: ${decision} → ${status} ${failureTexts.log.slice(0, 200)}`);
                     effect = (status >= 400 && status < 500) || (typeof refusedCode === 'string' && isUnavailableFaceCode(refusedCode)) ? 'not_applied' : 'unconfirmed';
-                    outcome = `${`The plan_review decision failed: HTTP ${status} ${msg}`.trim()}${decideFailureNote(e)}`;
+                    outcome = `${`The plan_review decision failed: HTTP ${status} ${failureTexts.reason}`.trim()}${decideFailureNote(e)}`;
                 }
                 else if (noAnswer === 'time-limit' || noAnswer === 'deadline') {
                     hostLog('debug', `planReviewWire: ${decision} sent but no answer within the request time limit (task ${taskId})`);

package/dist/hitl/replayedApproval.d.ts

@@ -24,6 +24,7 @@ export interface ReplayPendingBasis {
 }
 export declare function settledApprovalDisposition(frame: object, settled: ReplayPendingBasis['settled']): ReplayedApprovalDisposition | undefined;
 export declare function replayedApprovalDisposition(frame: object, basis: ReplayPendingBasis): ReplayedApprovalDisposition;
+export declare function replayedApprovalClosesCardFrame(disposition: ReplayedApprovalDisposition | null | undefined): boolean;
 export declare function replayedApprovalSentence(disposition: ReplayedApprovalDisposition | undefined, opts?: {
     readonly toolName?: string;
 }): string | undefined;

package/dist/hitl/replayedApproval.js

@@ -2,6 +2,7 @@ import { APPROVAL_SETTLED_HOWS, hasLedgerPositionKey } from './gateLedger.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { projectCrashConverged } from './crashConverged.js';
 import { quoteUntrustedForSentence } from '../displayUntrusted.js';
+import { readOwnDataValue } from '../ownKey.js';
 const live = (basis) => Object.freeze({ kind: 'live', basis });
 const unknown = (why) => Object.freeze({ kind: 'unknown', why });
 const decided = (row) => Object.freeze(row === undefined
@@ -162,6 +163,19 @@ const SETTLED_PHRASE = Object.freeze({
 });
 const settledRepeat = (what, how) => `${sentenceInitial(what)} was ${SETTLED_PHRASE[how]} earlier, so this repeated copy of it was not raised as a new question and no decision was sent for it.`;
 const decidedPlain = (what) => `${sentenceInitial(what)} is no longer listed by the engine as waiting for a decision, so no decision was sent for it.`;
+export function replayedApprovalClosesCardFrame(disposition) {
+    try {
+        if (typeof disposition !== 'object' || disposition === null)
+            return false;
+        if (readOwnDataValue(disposition, 'kind') !== 'decided')
+            return false;
+        const cause = readOwnDataValue(disposition, 'cause');
+        return typeof cause === 'string' && Object.hasOwn(STOPPED_BY_CAUSE, cause);
+    }
+    catch {
+        return false;
+    }
+}
 const unconfirmed = (what) => `Whether ${what} is still waiting for a decision could not be confirmed, so no decision was sent for it.`;
 function guardedGet(o, key) {
     try {

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,7 +1,7 @@
 import { CONFIG_LEGACY_TOOL_NAME, RULES_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
 import { ruleCompileVerdict } from '../ruleCompileVerdict.js';
-import { protocolSegmentOf } from '../protocolSegment.js';
+import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { PREFIXES_IN_PROSE, REFUSED_NAME_CLASSES, REFUSED_NAME_FIX, RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
 import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from '../generated/toolNameTables.js';
 import { isEngineRefusedToolName } from '../engineRefusedToolName.js';
@@ -96,18 +96,20 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
         }
         let why = withheldWhyOf(r);
         if (why === undefined) {
-            const grammar = ruleCompileVerdict(r, 'deny');
+            const grammar = ruleCompileVerdict(r, 'deny').kind;
             if (grammar === 'unknown')
                 return unreadable();
             if (grammar === 'refused')
                 why = 'not_a_tool_name';
         }
         if (why === undefined && COVERING_NAMESPACE_PREFIXES.some((p) => r.startsWith(p))) {
-            const segment = protocolSegmentOf(r);
-            if (segment.kind === 'empty' || segment.kind === 'unminted')
-                why = 'not_a_tool_name';
-            else if (segment.kind === 'unknown')
+            const verdict = ruleToolNameVerdictOf(r);
+            if (verdict.kind === 'unknown')
                 return unreadable();
+            if (verdict.kind === 'unmintable_segment')
+                why = 'not_a_tool_name';
+            else if (verdict.kind === 'retired' || verdict.kind === 'unprefixed_namespace')
+                why = 'legacy_tool_name';
         }
         if (why === undefined && mounted !== undefined && !mounted.has(r))
             why = 'not_in_roster';

package/dist/hitl/standingRows.d.ts

@@ -0,0 +1,18 @@
+export type StandingRowWhy = 'given' | 'card_unreadable' | 'remember_refused' | 'remember_unreadable' | 'route_cannot_carry' | 'classes_unreadable' | 'not_deployment_list_question' | 'evidence_unreadable' | 'offers_unreadable' | 'engine_lane_closed' | 'args_unavailable' | 'grant_binding' | 'tool_name_unreadable' | 'rule_cannot_clear' | 'host_fact_missing' | 'face_not_generic' | 'rule_not_sent';
+export type StandingPersistentRow = 'engine_offer' | 'local_whole_tool' | 'none';
+export interface StandingRowsWhy {
+    readonly session: StandingRowWhy;
+    readonly persistent: StandingRowWhy;
+    readonly deploymentList: StandingRowWhy;
+}
+export interface StandingRows {
+    readonly sessionRow: boolean;
+    readonly persistentRow: StandingPersistentRow;
+    readonly deploymentListSessionRow: boolean;
+    readonly why: StandingRowsWhy;
+}
+export interface StandingRowsHostFacts {
+    readonly cardFace?: string;
+    readonly wholeToolRuleSent?: boolean;
+}
+export declare function standingRowsOf(card: object | null | undefined, host?: StandingRowsHostFacts | null): StandingRows;

package/dist/hitl/standingRows.js

@@ -0,0 +1,127 @@
+import { readAskClassPairState } from './askClassPair.js';
+import { automaticAnswerVerdict } from './automaticAnswerVerdict.js';
+import { readRuleOffers } from './toolApprovalWire.js';
+const DEPLOYMENT_LIST_ASK_CLASSES = Object.freeze(['ask_rule']);
+const UNREADABLE = Symbol('unreadable');
+function ownData(v, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasKey(v, key) {
+    try {
+        return { inCard: key in v };
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function present(v, key) {
+    try {
+        const inCard = key in v;
+        return { inCard, value: inCard ? v[key] : undefined };
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function freezeRows(sessionRow, persistentRow, deploymentListSessionRow, why) {
+    return Object.freeze({ sessionRow, persistentRow, deploymentListSessionRow, why: Object.freeze({ ...why }) });
+}
+function allClosed(why) {
+    return freezeRows(false, 'none', false, { session: why, persistent: why, deploymentList: why });
+}
+function persistentRowOf(card, host, evidenceUnreadable) {
+    if (evidenceUnreadable)
+        return { row: 'none', why: 'evidence_unreadable' };
+    for (const key of ['ruleOffers', 'ruleOffersReadOnly']) {
+        const p = hasKey(card, key);
+        if (p === UNREADABLE)
+            return UNREADABLE;
+        if (!p.inCard)
+            continue;
+        const offers = readRuleOffers(ownData(card, key));
+        if (offers === undefined || offers.length === 0)
+            return { row: 'none', why: 'offers_unreadable' };
+        return { row: 'engine_offer', why: 'given' };
+    }
+    const absence = present(card, 'ruleOffersAbsence');
+    if (absence === UNREADABLE)
+        return UNREADABLE;
+    if (absence.inCard)
+        return { row: 'none', why: 'engine_lane_closed' };
+    const blind = present(card, 'argsUnavailable');
+    if (blind === UNREADABLE)
+        return UNREADABLE;
+    if (blind.inCard)
+        return { row: 'none', why: 'args_unavailable' };
+    if (ownData(card, 'grantBinding') !== 'none')
+        return { row: 'none', why: 'grant_binding' };
+    const tool = ownData(card, 'toolName');
+    if (typeof tool !== 'string' || tool.length === 0)
+        return { row: 'none', why: 'tool_name_unreadable' };
+    if (automaticAnswerVerdict(card, 'standing_rule').kind !== 'may_answer')
+        return { row: 'none', why: 'rule_cannot_clear' };
+    if (typeof host !== 'object' || host === null)
+        return { row: 'none', why: 'host_fact_missing' };
+    const face = ownData(host, 'cardFace');
+    if (typeof face !== 'string')
+        return { row: 'none', why: 'host_fact_missing' };
+    if (face !== 'generic')
+        return { row: 'none', why: 'face_not_generic' };
+    const sent = ownData(host, 'wholeToolRuleSent');
+    if (typeof sent !== 'boolean')
+        return { row: 'none', why: 'host_fact_missing' };
+    if (!sent)
+        return { row: 'none', why: 'rule_not_sent' };
+    return { row: 'local_whole_tool', why: 'given' };
+}
+export function standingRowsOf(card, host) {
+    if (typeof card !== 'object' || card === null)
+        return allClosed('card_unreadable');
+    try {
+        const refused = present(card, 'rememberRefused');
+        if (refused === UNREADABLE)
+            return allClosed('card_unreadable');
+        if (refused.inCard)
+            return allClosed(refused.value === true ? 'remember_refused' : 'remember_unreadable');
+        const evidence = present(card, 'unreadableEvidence');
+        if (evidence === UNREADABLE)
+            return allClosed('card_unreadable');
+        let evidenceUnreadable = false;
+        if (evidence.inCard) {
+            const list = ownData(card, 'unreadableEvidence');
+            if (!Array.isArray(list) || !list.every((k) => typeof k === 'string'))
+                return allClosed('card_unreadable');
+            if (list.includes('rememberRefused'))
+                return allClosed('remember_unreadable');
+            evidenceUnreadable = list.length > 0;
+        }
+        const sessionRow = ownData(card, 'allowSessionCarried') === true;
+        const sessionWhy = sessionRow ? 'given' : 'route_cannot_carry';
+        let deploymentList;
+        if (!sessionRow) {
+            deploymentList = 'route_cannot_carry';
+        }
+        else {
+            const pair = readAskClassPairState(card);
+            deploymentList =
+                pair.state !== 'pair'
+                    ? 'classes_unreadable'
+                    : pair.classes.every((c) => DEPLOYMENT_LIST_ASK_CLASSES.includes(c))
+                        ? 'given'
+                        : 'not_deployment_list_question';
+        }
+        const persistent = persistentRowOf(card, host, evidenceUnreadable);
+        if (persistent === UNREADABLE)
+            return allClosed('card_unreadable');
+        return freezeRows(sessionRow, persistent.row, deploymentList === 'given', { session: sessionWhy, persistent: persistent.why, deploymentList });
+    }
+    catch {
+        return allClosed('card_unreadable');
+    }
+}

package/dist/hitl/toolApprovalWire.d.ts

@@ -40,8 +40,9 @@ export type FsApprovalOutcome = {
     stage: HitlFailureStage;
     gatedCallId?: string | undefined;
     reason: string;
-    code?: 'no_pending' | undefined;
+    code?: 'no_pending' | 'wrong_gate' | undefined;
     errorCode?: string | undefined;
+    blockedBy?: string | undefined;
     retriable?: true;
     safetyCode?: HitlSafetyCode | undefined;
     retryExhausted?: true;
@@ -68,7 +69,6 @@ export type DenialLimitKind = SdkDenialLimitKind;
 export type DenialLimitFallback = SdkDenialLimitFallback;
 export { RULE_OFFERS_ABSENCE_REASONS };
 export declare const ASK_ORIGIN_WORDS: readonly string[];
-export declare const APPROVAL_MANDATE_WORDS: readonly ["operator_always", "tool_marks", "probe_mandate", "probe_unanswered", "write_protection", "write_protection_unresolved"];
 export type WireRuleOffer = {
     kind: 'single';
     rule: string;
@@ -141,6 +141,7 @@ export interface ApprovalCardRequest {
     probeCause?: unknown;
     probeReason?: string;
     rememberRefused?: true;
+    allowSessionCarried?: true;
     ruleEvidence?: unknown;
     requiresRealApproval?: true;
     irreversibleParkGate?: true;
@@ -157,6 +158,8 @@ export interface ApprovalCardRequest {
     askClass?: string;
     classes?: readonly string[];
     boundGrants?: BoundSkillGrantsWire;
+    grantBinding?: ApprovalGrantBinding;
+    unreadableEvidence?: readonly string[];
     classifierNoRuling?: string;
     priorCardsForCall?: readonly ApprovalPriorCard[];
 }
@@ -245,7 +248,7 @@ export declare function approvalIsMandated(v: ApprovalMandatedFacts | undefined
 export declare function readApprovalMandate(v: {
     readonly mandate?: string;
 } | undefined | null): ApprovalMandateWord | undefined;
-export declare function toolPermissionRequestAskBits(card: object | null | undefined): Pick<ToolPermissionRequest, 'mandated' | 'mandate' | 'origin' | 'ruleOffersAbsence' | 'askClass' | 'classes'>;
+export declare function toolPermissionRequestAskBits(card: object | null | undefined): Pick<ToolPermissionRequest, 'mandated' | 'mandate' | 'origin' | 'ruleOffersAbsence' | 'askClass' | 'classes' | 'rememberRefused'>;
 export declare function isFromSubagent(frame: ToolApprovalFrame): boolean;
 export type ToolApprovalRespondDecision = 'allow' | 'allow_session' | 'deny';
 export interface RespondToolApprovalOpts {
@@ -299,6 +302,12 @@ interface ToolApprovalRespondRefusalFields {
     status?: number;
     errorCode?: string;
     message?: string;
+    retriable?: true;
+    extra?: {
+        readonly cause?: string;
+        readonly field?: string;
+    };
+    unreadable?: true;
 }
 export type ToolApprovalRespondRefusal = (ToolApprovalRespondRefusalFields & {
     status: number;
@@ -312,6 +321,7 @@ export declare function isToolApprovalFrame(ev: unknown): ev is ToolApprovalFram
 export declare function askProbeReasonDetail(card: Pick<ApprovalCardRequest, 'probeReason' | 'probeCause'> | null | undefined): string | undefined;
 export declare function readApprovalRememberRefused(v: unknown): boolean;
 export declare function readApprovalBoundGrants(v: unknown): BoundSkillGrantsWire | undefined;
+export type ApprovalGrantBinding = 'bound' | 'none' | 'unreadable';
 export declare function readApprovalClassifierNoRuling(v: unknown): string | undefined;
 export declare function classifierNoRulingDetail(word: string | undefined): string;
 export declare function approvalBoundGrantsDetail(grants: BoundSkillGrantsWire | null | undefined): string | undefined;
@@ -319,6 +329,8 @@ export declare function approvalPriorCardsDetail(card: Pick<ApprovalCardRequest,
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOffer[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOffer[] | undefined;
+export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'grantBinding' | 'unreadableEvidence'>;
+export declare function approvalCardFactsOfV1(card: object | null | undefined): Readonly<ApprovalCardV1Facts> | undefined;
 export interface ToolApprovalFrameLaneOpts {
     approvalDecisionNoteCapable?: boolean;
     respondFreeFormRulesCapable?: boolean;