@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/hitl/hitlBridge.d.ts

@@ -46,7 +46,7 @@ export interface PlanReviewOutcome {
 export declare const PLAN_REVIEW_MODE_AFTER_WORDS: readonly ["default", "acceptEdits"];
 export type PlanReviewModeAfter = (typeof PLAN_REVIEW_MODE_AFTER_WORDS)[number];
 export declare function isPlanReviewModeAfter(v: string | undefined): v is PlanReviewModeAfter;
-export declare const GATE_FAILURE_CODES: readonly ["no_pending", "binding_mismatch", "wrong_gate", "bad_plan_edit", "bad_plan_mode", "empty_answer"];
+export declare const GATE_FAILURE_CODES: readonly ["no_pending", "binding_mismatch", "wrong_gate", "bad_plan_edit", "bad_plan_mode", "empty_answer", "binding_missing"];
 export type HitlSafetyCode = (typeof GATE_FAILURE_CODES)[number];
 export type HitlFailureStage = 'fetch' | 'input' | 'card' | 'decide' | 'orchestration';
 export declare const NO_APPROVAL_CARD_PORT_REASON = "no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)";
@@ -76,6 +76,10 @@ export type WireErrorCodeReading = {
     readonly state: 'unreadable';
 };
 export declare function readWireErrorCodeReading(e: unknown): WireErrorCodeReading;
+export declare function readWireCodes(e: unknown): {
+    readonly errorCode?: string;
+    readonly blockedBy?: string;
+};
 export declare function __setDecideTimeoutRetryBudgetForTests(ms?: number): void;
 export declare class DecideTransportRetryExhaustedError extends Error {
     readonly attempts: number;
@@ -116,7 +120,7 @@ export type FindPendingOutcome = {
 } | {
     ok: false;
     reason: string;
-    code?: 'no_pending';
+    code?: 'no_pending' | 'wrong_gate';
 };
 export declare function findPendingForTask(client: HitlClientLike, taskId: string, matches: (toolName: string | undefined) => boolean, opts?: {
     signal?: AbortSignal;

package/dist/hitl/hitlBridge.js

@@ -3,9 +3,9 @@ import { eventSeq } from '../adapter/types.js';
 import { hostLog } from '../host.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { abortableSleep } from '../abortableSleep.js';
-import { readOwnDataValue } from '../ownKey.js';
-import { THROWN_SLOT_UNREADABLE, readThrownSlot, thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
-import { decisionConflictOf } from './decisionConflict.js';
+import { ownDataField, readOwnDataValue } from '../ownKey.js';
+import { THROWN_SLOT_UNREADABLE, readBlockedBy, readThrownSlot, thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
 import { suspendedReopenOf } from './suspendedReopen.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 const MAX_DENY_REASON_CHARS = 4096;
@@ -29,14 +29,15 @@ export const PLAN_REVIEW_MODE_AFTER_WORDS = Object.freeze(['default', 'acceptEdi
 export function isPlanReviewModeAfter(v) {
     return v !== undefined && PLAN_REVIEW_MODE_AFTER_WORDS.includes(v);
 }
-export const GATE_FAILURE_CODES = [
+export const GATE_FAILURE_CODES = Object.freeze([
     'no_pending',
     'binding_mismatch',
     'wrong_gate',
     'bad_plan_edit',
     'bad_plan_mode',
     'empty_answer',
-];
+    'binding_missing',
+]);
 export const NO_APPROVAL_CARD_PORT_REASON = 'no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)';
 export const APPROVAL_CARD_PORT_KEY_MISMATCH_REASON = 'no approval card port installed for the default session key, but a non-default sessionKey has one — likely a keyed-install/default-read mismatch (installApprovalCardPortFor vs the zero-arg default-key read), not a missing install';
 export const NO_QUESTION_OVERLAY_REASON = 'no question overlay mounted (print/non-REPL mode)';
@@ -54,7 +55,13 @@ export class HitlSafetyError extends Error {
 export function hitlSafetyCodeOf(e) {
     if (!thrownIsInstanceOf(e, HitlSafetyError))
         return undefined;
-    const raw = readThrownSlot(e, 'code');
+    let raw;
+    try {
+        raw = ownDataField(e, 'code');
+    }
+    catch {
+        return undefined;
+    }
     return typeof raw === 'string' && GATE_FAILURE_CODES.includes(raw) ? raw : undefined;
 }
 const _gateCurrentPendingReadonlyPin = true;
@@ -87,11 +94,28 @@ export function readWireErrorCode(e) {
 export function readWireErrorCodeReading(e) {
     if (e === null || e === undefined)
         return { state: 'absent' };
-    const raw = readThrownSlot(e, 'errorCode');
-    if (raw === THROWN_SLOT_UNREADABLE)
+    let raw;
+    try {
+        if (typeof e === 'object' || typeof e === 'function') {
+            raw = ownDataField(e, 'errorCode');
+            if (raw === undefined && !Object.hasOwn(e, 'errorCode'))
+                void e.errorCode;
+        }
+    }
+    catch {
         return { state: 'unreadable' };
+    }
     return typeof raw === 'string' && raw.length > 0 ? { state: 'code', code: raw } : { state: 'absent' };
 }
+export function readWireCodes(e) {
+    const reading = readWireErrorCodeReading(e);
+    if (reading.state !== 'code')
+        return {};
+    if (reading.code !== RESUME_POLICY_FOLD_CODE)
+        return { errorCode: reading.code };
+    const folded = readBlockedBy(e);
+    return folded.kind === 'named' ? { errorCode: reading.code, blockedBy: folded.code } : { errorCode: reading.code };
+}
 const DECIDE_TRANSPORT_RETRY_BACKOFF_MS = 750;
 const DECIDE_RETRY_BACKOFF_MAX_MS = 5_000;
 const DECIDE_ATTEMPT_TIMEOUT_CAP_MS = 60_000;
@@ -224,10 +248,21 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
         hostLog('debug', `hitlBridge: approvals.list failed: ${t.log}`);
         return { ok: false, reason: `approvals.list failed: ${t.reason}` };
     }
-    const decidable = rows.filter((r) => askParkForeignGateKind(r) === null);
+    const readings = rows.map((r) => ({ r, foreign: askParkForeignGateKind(r) }));
+    const decidable = readings.filter((x) => x.foreign === null).map((x) => x.r);
     const identityRow = callId !== undefined
         ? decidable.find((r) => r.taskId === taskId && (r.boundCallId === callId || r.toolCallId === callId))
         : undefined;
+    const identityForeign = callId !== undefined && identityRow === undefined
+        ? readings.find((x) => x.r.taskId === taskId && (x.r.boundCallId === callId || x.r.toolCallId === callId) && x.foreign !== null)
+        : undefined;
+    if (identityForeign !== undefined) {
+        return {
+            ok: false,
+            reason: `the pending row this park names (call ${callId}) is parked on a '${String(identityForeign.foreign)}' gate — not an approval this leg decides; refusing to decide a different row`,
+            code: 'wrong_gate',
+        };
+    }
     const identityConflicts = identityRow !== undefined && !identityAccepts(identityRow);
     const pool = identityConflicts ? decidable.filter((r) => identityAccepts(r)) : decidable;
     const pending = (identityConflicts ? undefined : identityRow) ??
@@ -286,7 +321,7 @@ export class HitlBridge {
         if (p.boundCallId === undefined || p.boundInputHash === undefined) {
             throw new HitlSafetyError(`pending checkpoint ${p.id ?? '<no-id>'} is missing D-1 binding fields ` +
                 `(boundCallId=${String(p.boundCallId)}, boundInputHash=${String(p.boundInputHash)}) — ` +
-                'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_mismatch');
+                'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_missing');
         }
         return { boundCallId: p.boundCallId, boundInputHash: p.boundInputHash };
     }
@@ -500,7 +535,7 @@ function bindingMismatchReading(e) {
     const name = readThrownSlot(e, 'name');
     const family = (code.state === 'code' && code.code === 'approval_binding_mismatch') || name === 'ApprovalBindingMismatchError';
     if (family)
-        return decisionConflictOf(e) !== 'answer_invalid' ? 'mismatch' : 'not';
+        return 'mismatch';
     if (code.state === 'unreadable')
         return 'unreadable';
     return 'not';

package/dist/hitl/localAllowRule.d.ts

@@ -6,6 +6,7 @@ export interface LocalAllowRuleDeps {
     bashRuleContentHasDangerousBarePrefix(ruleContent: string): boolean;
     isDangerousBashPermission(toolName: string, ruleContent: string): boolean;
     isDangerousPowerShellPermission(toolName: string, ruleContent: string): boolean;
+    onFailure?(log: string): void;
 }
 export type LocalAllowRuleParse = {
     ok: true;

package/dist/hitl/localAllowRule.js

@@ -1,4 +1,4 @@
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { reasonOfThrownWithSink } from '../hostCallbackGuard.js';
 const BASH_TOOL_NAME_FOR_RULES = 'Bash';
 export function parseLocalAllowRule(rule, expectedToolName, deps) {
     if (typeof rule !== 'string' || rule === '') {
@@ -9,7 +9,7 @@ export function parseLocalAllowRule(rule, expectedToolName, deps) {
         value = deps.parseRule(rule);
     }
     catch (e) {
-        return { ok: false, error: `rule text did not parse (${wireFailureTextsOf(e).reason})` };
+        return { ok: false, error: `rule text did not parse (${reasonOfThrownWithSink(e, (log) => deps.onFailure?.(log))})` };
     }
     if (typeof value.toolName !== 'string' || value.toolName === '') {
         return { ok: false, error: 'rule text carries no tool name' };

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,8 @@
 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, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, isRefusedParkCode, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { RESUME_REFUSAL_CODES } from '../resumeRefusalCopy.js';
+import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -35,67 +35,25 @@ 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) ||
+        (typeof code === 'string' && RESUME_REOPEN_CODES.includes(code) && retriable === true) ||
         code === DECIDE_WORKFLOW_PARKS_UNREADABLE ||
         code === DECIDE_WORKFLOW_PARK_FORKED);
 }
 export function isCodeClassifiedGateFailure(code, retriable) {
-    return isGateStandingErrorCode(code, retriable) || code === PARKED_RESUME_STARTUP_FAILED;
+    return (isGateStandingErrorCode(code, retriable) ||
+        code === PARKED_RESUME_STARTUP_FAILED ||
+        (typeof code === 'string' && (RESUME_RETRY_LATER_CODES.includes(code) || RESUME_REFUSAL_CODES.includes(code))));
 }
 export function toAnsweredOutput(questions, answer) {
     const answers = {};
@@ -193,7 +151,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 +163,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 } : {}),
         };
     }
@@ -235,7 +193,7 @@ async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
             ...(onPresented ? { onPresented } : {}),
             ...(deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : {}),
             ...(decidedByReading !== undefined ? { approvalDecidedBy: decidedByReading } : {}),
-        }, taskId, argsByCallOf(led), ctx.signal, gatedCallId);
+        }, taskId, argsByCallOf(led), ctx.signal, gatedCallId, park.toolName);
         const outcomeDenied = 'denied' in outcome ? outcome.denied : undefined;
         if (outcome.kind === 'decided' && outcomeDenied === true && outcome.gatedCallId) {
             const denySettledBy = 'denySettledBy' in outcome ? outcome.denySettledBy : undefined;

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

@@ -1,4 +1,4 @@
-import { type ApprovalSettledHow } from './gateLedger.js';
+import { type ApprovalSettledHow } from './approvalHolds.js';
 import { type ApprovalsListEnvelope, type CrashConvergedRow } from './crashConverged.js';
 export type ReplayedApprovalDisposition = {
     readonly kind: 'live';
@@ -20,10 +20,10 @@ export interface ReplayPendingBasis {
     } | {
         readonly read: 'failed';
     };
-    readonly settled?: ReadonlyMap<string, ApprovalSettledHow>;
 }
-export declare function settledApprovalDisposition(frame: object, settled: ReplayPendingBasis['settled']): ReplayedApprovalDisposition | undefined;
+export declare function settledApprovalDisposition(frame: object): 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

@@ -1,7 +1,9 @@
-import { APPROVAL_SETTLED_HOWS, hasLedgerPositionKey } from './gateLedger.js';
+import { hasLedgerPositionKey } from './gateLedger.js';
+import { anyApprovalSettled, settledApprovalOf } from './approvalHolds.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
@@ -22,15 +24,12 @@ function crashConvergedFactsOf(body, approvalId) {
     }
     return undefined;
 }
-export function settledApprovalDisposition(frame, settled) {
+export function settledApprovalDisposition(frame) {
     try {
-        if (typeof settled !== 'object' || settled === null || typeof settled.get !== 'function')
+        if (!anyApprovalSettled())
             return undefined;
-        const id = approvalIdOf(frame);
-        if (id === undefined)
-            return undefined;
-        const how = settled.get(id);
-        return typeof how === 'string' && APPROVAL_SETTLED_HOWS.includes(how) ? decidedSettled(how) : undefined;
+        const entry = settledApprovalOf(approvalIdOf(frame));
+        return entry === undefined ? undefined : decidedSettled(entry.how);
     }
     catch {
         return undefined;
@@ -47,14 +46,7 @@ export function replayedApprovalDisposition(frame, basis) {
     catch {
         return unknown('unreadable_frame');
     }
-    let settledBasis;
-    try {
-        settledBasis = typeof basis === 'object' && basis !== null ? basis.settled : undefined;
-    }
-    catch {
-        settledBasis = undefined;
-    }
-    const early = settledApprovalDisposition(frame, settledBasis);
+    const early = settledApprovalDisposition(frame);
     if (early !== undefined)
         return early;
     try {
@@ -162,6 +154,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.d.ts

@@ -15,7 +15,6 @@ export interface SessionPolicyDeliverability {
 export interface SessionPolicyDeliverableOptions {
     readonly roster?: ToolRosterView;
 }
-export { isEngineRefusedToolName } from '../engineRefusedToolName.js';
 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;