@sema-agent/client-core 0.97.1 → 0.98.0

package/dist/hitl/persistedRulesWire.js

@@ -1,10 +1,12 @@
+import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { CORE_RULE_BEHAVIORS } from '../generated/engineFactTables.js';
 import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED } from '../engineErrorCodes.js';
 import { hostLog } from '../host.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 import { observedPermissionRulesWrite, permissionRulesWriteAvailable } from '../permissionRulesWriteCapability.js';
-import { readToolApprovalRespondAck } from './toolApprovalWire.js';
+import { isToolApprovalRespondReplayed, readToolApprovalRespondAck } from './toolApprovalWire.js';
 export function persistedRulesLaneAvailable(baseUrl) {
     return engineCapTrue(baseUrl, 'permissionRules');
 }
@@ -112,6 +114,124 @@ export const PERSISTED_RULE_BEHAVIOR_UNKNOWN = '(unknown)';
 export function persistedRuleBehaviorLabel(rule) {
     return rowStr(rule, 'behavior') ?? PERSISTED_RULE_BEHAVIOR_UNKNOWN;
 }
+const PERSISTED_RULE_ORIGIN_PHRASES = Object.freeze({
+    user: 'added by you',
+    'imported-cc': 'imported',
+    starter: 'preset',
+});
+const UNKNOWN_ORIGIN_PHRASE = 'an origin this build does not know';
+const NO_ORIGIN_PHRASE = 'unknown origin';
+function ownSlot(o, key) {
+    if (typeof o !== 'object' || o === null)
+        return undefined;
+    return guardedRead(() => readOwnDataValue(o, key));
+}
+const ORIGINS_READ_MAX = 256;
+export function persistedRuleAddOriginLabel(origin) {
+    return typeof origin === 'string' && Object.hasOwn(PERSISTED_RULE_ORIGIN_PHRASES, origin)
+        ? PERSISTED_RULE_ORIGIN_PHRASES[origin]
+        : UNKNOWN_ORIGIN_PHRASE;
+}
+export function persistedRuleOriginsLabel(rule) {
+    const adds = ownSlot(rule, 'adds');
+    const isArr = guardedRead(() => (Array.isArray(adds) ? true : undefined));
+    if (isArr !== true)
+        return NO_ORIGIN_PHRASE;
+    const lenRaw = ownSlot(adds, 'length');
+    const len = typeof lenRaw === 'number' && Number.isSafeInteger(lenRaw) && lenRaw > 0 ? Math.min(lenRaw, ORIGINS_READ_MAX) : 0;
+    const seen = [];
+    for (let i = 0; i < len; i++) {
+        const origin = ownSlot(ownSlot(adds, String(i)), 'origin');
+        const phrase = persistedRuleAddOriginLabel(typeof origin === 'string' ? origin : undefined);
+        if (!seen.includes(phrase))
+            seen.push(phrase);
+    }
+    return seen.length === 0 ? NO_ORIGIN_PHRASE : seen.join(' + ');
+}
+const UNKNOWN_SCOPE_PHRASE = 'a scope this build does not know';
+export function persistedRuleScopeLabel(scope) {
+    if (scope === 'global')
+        return 'all projects';
+    if (typeof scope === 'string' && scope.startsWith('project:') && scope.length > 'project:'.length) {
+        const shown = displayUntrusted(scope.slice('project:'.length), { max: 400, blanks: true });
+        return shown === '' ? UNKNOWN_SCOPE_PHRASE : shown;
+    }
+    return UNKNOWN_SCOPE_PHRASE;
+}
+const PERSISTED_RULE_REVOKE_LINES = Object.freeze({
+    removed: {
+        yes: {
+            notice: '{rule}: a tombstone was written, but the rule is still live — it was approved again during the call.',
+            change: 'Revoked saved rule {rule} (still live — approved again meanwhile)',
+        },
+        unknown: {
+            notice: '{rule}: a tombstone was written, but whether the rule is still live could not be confirmed — treat it as still in effect and check the list.',
+            change: 'Revoked saved rule {rule} (liveness could not be confirmed — treated as still in effect)',
+        },
+        no: { notice: 'Removed {rule}.', change: 'Revoked saved rule {rule}' },
+    },
+    'nothing-written': {
+        yes: {
+            notice: '{rule}: nothing was written, and the rule is still live — it was not removed; check the list.',
+            change: 'Removing saved rule {rule} wrote nothing — the rule is still live',
+        },
+        unknown: {
+            notice: '{rule}: nothing was written, and whether the rule is still live could not be confirmed — treat it as still in effect and check the list.',
+            change: 'Removing saved rule {rule} wrote nothing — liveness could not be confirmed',
+        },
+        no: { notice: '{rule}: nothing to remove.', change: 'Removing saved rule {rule} wrote nothing (nothing to remove)' },
+    },
+});
+const REVOKE_UNKNOWN_STATUS = Object.freeze({
+    absent: {
+        notice: '{rule}: the engine did not say what this removal did, so whether anything was removed is unclear — check the list.',
+        change: 'Removing saved rule {rule} came back without saying what it did',
+    },
+    unrecognised: {
+        notice: '{rule}: the engine answered with a status this build does not know, so whether anything was removed is unclear — check the list.',
+        change: 'Removing saved rule {rule} returned a status this build does not know',
+    },
+    liveness: { yes: ' It also reports the rule is still live.', unknown: ' Whether the rule is still live could not be confirmed either.', no: '' },
+});
+const fillRule = (template, rule) => template.split('{rule}').join(rule);
+export function persistedRuleRevokeOutcome(ruleText, result) {
+    const quoted = typeof ruleText === 'string' ? quoteUntrustedForSentence(ruleText, 120) : undefined;
+    const rule = quoted ?? 'this rule';
+    const status = ownSlot(result, 'status');
+    const rawLive = ownSlot(result, 'stillLive');
+    const liveness = rawLive === 'yes' || rawLive === 'no' || rawLive === 'unknown' ? rawLive : 'unknown';
+    if (status === 'removed' || status === 'no-op') {
+        const outcome = status === 'removed' ? 'removed' : 'nothing-written';
+        const line = PERSISTED_RULE_REVOKE_LINES[outcome][liveness];
+        return Object.freeze({ outcome, liveness, notice: fillRule(line.notice, rule), change: fillRule(line.change, rule) });
+    }
+    const head = typeof status === 'string' && status !== '' ? REVOKE_UNKNOWN_STATUS.unrecognised : REVOKE_UNKNOWN_STATUS.absent;
+    return Object.freeze({
+        outcome: 'unknown-status',
+        liveness,
+        notice: `${fillRule(head.notice, rule)}${REVOKE_UNKNOWN_STATUS.liveness[liveness]}`,
+        change: fillRule(head.change, rule),
+    });
+}
+const PERSISTED_RULE_MATCH_LABELS = Object.freeze({
+    exact: 'exact match',
+    prefix: 'prefix match',
+    wildcard: 'wildcard match',
+    subpath: 'subpath match',
+    path: 'path match',
+    name: 'skill name match',
+    name_prefix: 'skill name prefix match',
+    host: 'web domain match (one host)',
+    subdomain: 'web domain match (every host under the domain)',
+});
+export function persistedRuleMatchLabel(ruleOrMatch) {
+    const word = typeof ruleOrMatch === 'string' ? ruleOrMatch : ownSlot(ruleOrMatch, 'match');
+    if (typeof word !== 'string' || word === '')
+        return 'an unreported match form';
+    return Object.hasOwn(PERSISTED_RULE_MATCH_LABELS, word)
+        ? PERSISTED_RULE_MATCH_LABELS[word]
+        : 'a match form this build does not know';
+}
 export function revokeTargetFromPersistedRule(rule, opts) {
     const behavior = persistedRuleBehaviorOf(rule);
     if (behavior === undefined)
@@ -434,7 +554,7 @@ export function classifySkippedReason(reason) {
 }
 export function readRulePersistOutcome(ack) {
     const parsed = readToolApprovalRespondAck(ack);
-    if (parsed === undefined)
+    if (parsed === undefined || isToolApprovalRespondReplayed(parsed))
         return { state: 'unknown' };
     if (parsed.rulePersisted === true)
         return { state: 'persisted' };

package/dist/hitl/planReviewWire.d.ts

@@ -28,6 +28,16 @@ export declare function _resetArmedPlanReviewsForTest(): void;
 export type PlanReviewReopenTrigger = 'user' | 'automatic';
 export type PlanReviewGateInstanceReader = (taskId: string) => Promise<ReadonlySet<string> | null>;
 export declare function clearPlanReviewUserDismissals(sessionKey?: string): void;
+export type PlanReviewOfferedMode = 'three_choice' | 'two_choice' | 'unknown';
+export interface PlanReviewCardLike {
+    readonly questionId?: string;
+    readonly questions?: ReadonlyArray<{
+        readonly options?: ReadonlyArray<{
+            readonly label?: string;
+        }>;
+    }>;
+}
+export declare function planReviewOfferedModeOf(card: string | PlanReviewCardLike): PlanReviewOfferedMode;
 export interface ArmPlanReviewOptions {
     submittedInPlanMode?: boolean;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
@@ -76,22 +86,25 @@ export declare function notePlanReviewGateLeft(taskId: string): void;
 export declare function latestPlanReviewDecisionMark(taskId: string): number | null;
 export declare function __resetPlanReviewDecisionLatchForTests(): void;
 export declare function decidePlanReview(taskId: string, decision: 'approve' | 'reject', permissionModeAfter?: string, opts?: DecidePlanReviewOptions): Promise<void>;
-export interface ReopenPlanReviewOpts {
-    mintFreshQuestionId?: boolean;
-    deliverDecision?: (taskId: string, decision: 'approve' | 'reject', reason?: string) => void | Promise<void>;
+export interface ReopenPlanReviewSharedOpts {
     sessionKey?: string;
-    wire?: PlanReviewWire;
-    onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
-    presentationReceiptMs?: number;
+    presentationReceiptMs: number;
     trigger?: PlanReviewReopenTrigger;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
     pendingReadStartedAt?: number;
 }
+export interface ReopenPlanReviewFreshOpts extends ReopenPlanReviewSharedOpts {
+    mintFreshQuestionId?: true;
+    deliverDecision?: (taskId: string, decision: 'approve' | 'reject', reason?: string) => void | Promise<void>;
+    wire?: PlanReviewWire;
+    onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
+}
+export interface ReopenPlanReviewReuseOpts extends ReopenPlanReviewSharedOpts {
+    mintFreshQuestionId: false;
+    deliverDecision?: never;
+    wire?: never;
+    onOutcome?: never;
+}
+export type ReopenPlanReviewOpts = ReopenPlanReviewFreshOpts | ReopenPlanReviewReuseOpts;
 export declare function _resetActiveReopenRespondersForTest(): void;
-export declare function reopenPlanReviewCard(taskId: string, opts: ReopenPlanReviewOpts & {
-    presentationReceiptMs: number;
-}): Promise<ReopenCardVerdict>;
-export declare function reopenPlanReviewCard(taskId: string, opts?: ReopenPlanReviewOpts & {
-    presentationReceiptMs?: undefined;
-}): ReopenCardVerdict;
-export declare function reopenPlanReviewCard(taskId: string, opts?: ReopenPlanReviewOpts): ReopenCardVerdict | Promise<ReopenCardVerdict>;
+export declare function reopenPlanReviewCard(taskId: string, opts: ReopenPlanReviewOpts): Promise<ReopenCardVerdict>;

package/dist/hitl/planReviewWire.js

@@ -7,11 +7,13 @@ import { enqueuePlanReviewOutcome } from '../notifications.js';
 import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, resumeContextUnavailableContent, resumeContextUnavailableFromError } from '../resumeRefusalCopy.js';
-import { REQUEST_FIELD_CONFLICT, isUnavailableFaceCode } from '../engineErrorCodes.js';
+import { REQUEST_FIELD_CONFLICT } from '../engineErrorCodes.js';
+import { refusalDeliveryOf } from './decisionRefusal.js';
 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 { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { PLAN_REVIEW_GATE_KIND, durableDecideLegOf } from '../adapter/activeRunSelfHeal.js';
 import { readRunTerminal, runTerminalGateKind } from '../runTerminal.js';
@@ -144,9 +146,12 @@ function pausedGateKindOf(carrier) {
 }
 const armedPlanReviewTaskIds = new Set();
 const offerModeAfterByTask = new Map();
+const offeredModeByQuestionId = new Map();
+const OFFERED_MODE_LEDGER_MAX = 64;
 export function _resetArmedPlanReviewsForTest() {
     armedPlanReviewTaskIds.clear();
     offerModeAfterByTask.clear();
+    offeredModeByQuestionId.clear();
     planReviewDismissalsByKey.clear();
 }
 const ON_SCREEN = Promise.resolve(true);
@@ -247,12 +252,77 @@ function planReviewQuestions(question, offerModeAfter = false) {
         },
     ];
 }
+function planReviewQuestionFrame(questionId, question, offerModeAfter, reopened = false) {
+    if (!reopened) {
+        offeredModeByQuestionId.delete(questionId);
+        offeredModeByQuestionId.set(questionId, offerModeAfter);
+        while (offeredModeByQuestionId.size > OFFERED_MODE_LEDGER_MAX) {
+            const oldest = offeredModeByQuestionId.keys().next();
+            if (oldest.done === true)
+                break;
+            offeredModeByQuestionId.delete(oldest.value);
+        }
+    }
+    return { type: 'question', questionId, questions: planReviewQuestions(question, offerModeAfter) };
+}
 function publishPlanReviewCard(taskId) {
-    publishQuestionFrame({
-        type: 'question',
-        questionId: planReviewQuestionId(taskId),
-        questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
-    });
+    publishQuestionFrame(planReviewQuestionFrame(planReviewQuestionId(taskId), ARM_QUESTION, offerModeAfterByTask.get(taskId) === true));
+}
+const OFFERED_MODE_SCAN_MAX = 32;
+function ownElementsOf(v, max) {
+    if (!Array.isArray(v))
+        return [];
+    const n = Math.min(v.length, max);
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push(readOwnDataValue(v, String(i)));
+    return out;
+}
+function offeredModeFromLabels(card) {
+    let modeAfter = false;
+    let plain = false;
+    for (const q of ownElementsOf(readOwnDataValue(card, 'questions'), OFFERED_MODE_SCAN_MAX)) {
+        if (typeof q !== 'object' || q === null)
+            continue;
+        for (const o of ownElementsOf(readOwnDataValue(q, 'options'), OFFERED_MODE_SCAN_MAX)) {
+            if (typeof o !== 'object' || o === null)
+                continue;
+            const label = readOwnDataNonEmptyString(o, 'label');
+            if (label === PLAN_REVIEW_APPROVE_AUTO_LABEL || label === PLAN_REVIEW_APPROVE_MANUAL_LABEL)
+                modeAfter = true;
+            else if (label === APPROVE_LABEL)
+                plain = true;
+        }
+    }
+    if (modeAfter && !plain)
+        return 'three_choice';
+    if (plain && !modeAfter)
+        return 'two_choice';
+    return undefined;
+}
+function offeredModeFromQuestionId(questionId) {
+    if (taskIdFromPlanReviewQuestionId(questionId) === undefined)
+        return 'unknown';
+    const recorded = offeredModeByQuestionId.get(questionId);
+    if (recorded !== undefined)
+        return recorded ? 'three_choice' : 'two_choice';
+    return questionId.includes(REOPEN_ID_TAIL) ? 'two_choice' : 'unknown';
+}
+export function planReviewOfferedModeOf(card) {
+    try {
+        if (typeof card === 'string')
+            return offeredModeFromQuestionId(card);
+        if (typeof card !== 'object' || card === null)
+            return 'unknown';
+        const fromLabels = offeredModeFromLabels(card);
+        if (fromLabels !== undefined)
+            return fromLabels;
+        const questionId = readOwnDataNonEmptyString(card, 'questionId');
+        return questionId === undefined ? 'unknown' : offeredModeFromQuestionId(questionId);
+    }
+    catch {
+        return 'unknown';
+    }
 }
 export function armPlanReviewApproval(result, sessionKey, opts) {
     let armedTaskId;
@@ -752,13 +822,13 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 else if (typeof status === 'number' && corruptStoredRowWhere(e) !== undefined) {
                     const where = corruptStoredRowWhere(e);
                     hostLog('debug', `planReviewWire: ${decision} → ${String(status)} corrupt (stored resume context unreadable)`);
-                    effect = 'not_applied';
+                    effect = refusalDeliveryOf(e, { route: 'plan_review' }).delivery === 'refused' ? 'not_applied' : 'unconfirmed';
                     outcome = `This ${decision} was not applied. ${corruptStoredRowContent(where)}`;
                 }
                 else if (typeof status === 'number') {
                     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';
+                    effect = refusalDeliveryOf(e, { route: 'plan_review' }).delivery === 'refused' ? 'not_applied' : 'unconfirmed';
                     outcome = `${`The plan_review decision failed: HTTP ${status} ${failureTexts.reason}`.trim()}${decideFailureNote(e)}`;
                 }
                 else if (noAnswer === 'time-limit' || noAnswer === 'deadline') {
@@ -828,8 +898,6 @@ export function _resetActiveReopenRespondersForTest() {
 const reopenFlights = new Map();
 function joinReopenFlight(flight, taskId, receiptMs) {
     hostLog('debug', `planReviewWire: reopen for task ${taskId} joined the card already on its way (no second card, its answer path kept)`);
-    if (receiptMs === undefined)
-        return { reopened: true, firstSight: false };
     const ac = new AbortController();
     return Promise.race([
         flight.presented.then((v) => v === true, () => false),
@@ -867,17 +935,13 @@ function mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs) {
         settle(false);
         throw e;
     }
-    if (verdict instanceof Promise) {
-        return verdict.then((v) => {
-            settle(v.reopened === true);
-            return v;
-        }, (e) => {
-            settle(false);
-            throw e;
-        });
-    }
-    settle(verdict.reopened === true);
-    return verdict;
+    return verdict.then((v) => {
+        settle(v.reopened === true);
+        return v;
+    }, (e) => {
+        settle(false);
+        throw e;
+    });
 }
 function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
     const markBefore = dismissalEntryFor(sessionKey, taskId);
@@ -893,30 +957,10 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
     const mintFresh = opts?.mintFreshQuestionId !== false;
     if (!mintFresh && hasLocalQuestionResponder(canonicalId)) {
         hostLog('debug', `planReviewWire: reopen for task ${taskId} reusing the canonical responder (path=reopen-canonical)`);
-        if (opts?.deliverDecision !== undefined) {
-            hostLog('debug', `planReviewWire: reopen canonical-reuse branch for task ${taskId} ignores opts.deliverDecision (answers route through the existing arm responder — documented exception)`);
-        }
-        if (opts?.wire !== undefined || opts?.onOutcome !== undefined) {
-            hostLog('debug', `planReviewWire: reopen canonical-reuse branch for task ${taskId} ignores opts.wire / opts.onOutcome (answers route through the existing arm responder and the wire it was armed with — documented exception)`);
-        }
         retireActiveReopen(sessionKey, canonicalId);
-        if (receiptMs !== undefined) {
-            const receipt = waitForGateArmedFor(sessionKey, [canonicalId], receiptMs);
-            publishQuestionFrameFor(sessionKey, {
-                type: 'question',
-                questionId: canonicalId,
-                questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
-            });
-            return settleOnReceipt(receipt, firstSight);
-        }
-        publishQuestionFrameFor(sessionKey, {
-            type: 'question',
-            questionId: canonicalId,
-            questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
-        });
-        registerArmedGateFor(sessionKey, armedKey);
-        revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
-        return { reopened: true, firstSight };
+        const receipt = waitForGateArmedFor(sessionKey, [canonicalId], receiptMs);
+        publishQuestionFrameFor(sessionKey, planReviewQuestionFrame(canonicalId, ARM_QUESTION, offerModeAfterByTask.get(taskId) === true));
+        return settleOnReceipt(receipt, firstSight);
     }
     retireActiveReopen(sessionKey, canonicalId);
     if (unregisterLocalQuestionResponder(canonicalId)) {
@@ -961,23 +1005,9 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
         return { ok: true };
     });
     activeReopenResponders.set(activeKey, { questionId, unregister });
-    if (receiptMs !== undefined) {
-        const receipt = waitForGateArmedFor(sessionKey, [questionId], receiptMs);
-        publishQuestionFrameFor(sessionKey, {
-            type: 'question',
-            questionId,
-            questions: planReviewQuestions(REOPEN_QUESTION),
-        });
-        return settleOnReceipt(receipt, firstSight);
-    }
-    registerArmedGateFor(sessionKey, armedKey);
-    publishQuestionFrameFor(sessionKey, {
-        type: 'question',
-        questionId,
-        questions: planReviewQuestions(REOPEN_QUESTION),
-    });
-    revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
-    return { reopened: true, firstSight };
+    const receipt = waitForGateArmedFor(sessionKey, [questionId], receiptMs);
+    publishQuestionFrameFor(sessionKey, planReviewQuestionFrame(questionId, REOPEN_QUESTION, false, true));
+    return settleOnReceipt(receipt, firstSight);
 }
 function noPresentationSurfaceVerdict(taskId, sessionKey) {
     const verdict = { reopened: false, _sema_noPresentationSurface: true };
@@ -1075,44 +1105,48 @@ async function staleDismissalVerdict(current, sessionKey, taskId, receiptMs) {
 }
 export function reopenPlanReviewCard(taskId, opts) {
     const receiptMs = opts?.presentationReceiptMs;
+    if (typeof receiptMs !== 'number' || Number.isNaN(receiptMs)) {
+        hostLog('debug', `planReviewWire: reopen for task ${String(taskId)} refused — presentationReceiptMs is required (a number of milliseconds); the synchronous form was retired in 0.98.0`);
+        return Promise.resolve({ reopened: false });
+    }
     try {
         if (typeof taskId !== 'string' || taskId.length === 0) {
-            return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
+            return Promise.resolve({ reopened: false });
+        }
+        const injected = opts;
+        if (opts?.mintFreshQuestionId === false && (injected?.deliverDecision !== undefined || injected?.wire !== undefined || injected?.onOutcome !== undefined)) {
+            hostLog('error', `planReviewWire: plan_review reopen for task ${taskId} refused — mintFreshQuestionId:false reuses the armed card's responder and its delivery, ` +
+                'so deliverDecision / wire / onOutcome cannot be given with it; drop mintFreshQuestionId:false to deliver through the injected path');
+            return Promise.resolve({ reopened: false });
         }
-        const readStart = typeof opts?.pendingReadStartedAt === 'number' && Number.isFinite(opts.pendingReadStartedAt) ? opts.pendingReadStartedAt : undefined;
+        const readStart = typeof opts.pendingReadStartedAt === 'number' && Number.isFinite(opts.pendingReadStartedAt) ? opts.pendingReadStartedAt : undefined;
         if (planReviewDecisionInFlight(taskId, readStart)) {
             hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — a decision for this task is in flight (its answer is still being delivered)`);
             const refused = { reopened: false, _sema_decisionInFlight: true };
-            return receiptMs === undefined ? refused : Promise.resolve(refused);
+            return Promise.resolve(refused);
         }
         const guardStartedAt = planReviewPendingReadMark();
         const recheckReadStart = readStart === undefined ? guardStartedAt : Math.min(readStart, guardStartedAt);
-        const sessionKey = opts?.sessionKey ?? DEFAULT_SESSION_KEY;
+        const sessionKey = opts.sessionKey ?? DEFAULT_SESSION_KEY;
         if (!hasQuestionOverlayFor(sessionKey)) {
-            const noSurface = noPresentationSurfaceVerdict(taskId, sessionKey);
-            return receiptMs === undefined ? noSurface : Promise.resolve(noSurface);
+            return Promise.resolve(noPresentationSurfaceVerdict(taskId, sessionKey));
         }
-        if (sessionKey !== DEFAULT_SESSION_KEY && opts?.deliverDecision === undefined && opts?.wire === undefined) {
+        if (sessionKey !== DEFAULT_SESSION_KEY && opts.deliverDecision === undefined && opts.wire === undefined) {
             hostLog('error', `planReviewWire: plan_review 卡未重开 —— sessionKey=${JSON.stringify(sessionKey)} 是非默认槽,` +
                 '而缺省决断投递口(decidePlanReview)今天固定打默认槽的 baseUrl/token/principal。' +
                 '整条链转 keyed 之前,非默认槽要重开请自带 deliverDecision(按本槽投递);' +
                 '此处拒绝而不是照发 —— 照发会把这条会话的决断发到另一个槽上。');
-            return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
+            return Promise.resolve({ reopened: false });
         }
-        const trigger = opts?.trigger === undefined ? undefined : opts.trigger === 'user' ? 'user' : 'automatic';
+        const trigger = opts.trigger === undefined ? undefined : opts.trigger === 'user' ? 'user' : 'automatic';
         if (trigger === 'automatic') {
             const mark = planReviewUserDismissalMarkFor(sessionKey, taskId);
-            if (mark !== undefined) {
-                if (receiptMs === undefined || opts === undefined) {
-                    hostLog('debug', `planReviewWire: automatic reopen for task ${taskId} refused — the user closed this gate's card`);
-                    return { reopened: false, dismissedByUser: true };
-                }
+            if (mark !== undefined)
                 return reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark, recheckReadStart);
-            }
         }
         return mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
     }
     catch {
-        return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
+        return Promise.resolve({ reopened: false });
     }
 }

package/dist/hitl/refusedToolNameProse.d.ts

@@ -1,4 +1,3 @@
 export declare const PREFIXES_IN_PROSE: string;
 export declare const REFUSED_NAME_CLASSES: string;
 export declare const REFUSED_NAME_FIX: string;
-export declare const RULES_LEGACY_TOOL_NAME_WRITE_NOTE: string;

package/dist/hitl/refusedToolNameProse.js

@@ -2,6 +2,3 @@ import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
 export const PREFIXES_IN_PROSE = CORE_PROTOCOL_PREFIXES.map((prefix) => `"${prefix}"`).join(' or ');
 export const REFUSED_NAME_CLASSES = `a retired tool name, or a name that contains "__" but does not start with ${PREFIXES_IN_PROSE}`;
 export const REFUSED_NAME_FIX = `If the tool still exists, use its current name; a server or agent-peer tool name starts with ${PREFIXES_IN_PROSE}.`;
-export const RULES_LEGACY_TOOL_NAME_WRITE_NOTE = `The engine refused to write these session rules, and the stored record was not changed at all: they name a tool the engine refuses — ${REFUSED_NAME_CLASSES} (the engine's own error text names the entry). ` +
-    `${REFUSED_NAME_FIX} Then write the rules again. ` +
-    'If that entry was already in this session’s rule record, it has to be removed from the record before the record can be written again.';

package/dist/hitl/replayedApproval.d.ts

@@ -1,13 +1,14 @@
 import { type ApprovalSettledHow } from './approvalHolds.js';
-import { type ApprovalsListEnvelope, type CrashConvergedRow } from './crashConverged.js';
+import { type ApprovalsListEnvelope, type CrashConvergedRowReading } from './crashConverged.js';
 export type ReplayedApprovalDisposition = {
     readonly kind: 'live';
     readonly basis: 'live_leg' | 'preamble' | 'pending_list';
 } | {
     readonly kind: 'decided';
-    readonly cause?: CrashConvergedRow['cause'];
-    readonly needsHumanReason?: NonNullable<CrashConvergedRow['needsHumanReason']>;
+    readonly cause?: CrashConvergedRowReading['cause'];
+    readonly needsHumanReason?: NonNullable<CrashConvergedRowReading['needsHumanReason']>;
     readonly settled?: ApprovalSettledHow;
+    readonly parked?: true;
 } | {
     readonly kind: 'unknown';
     readonly why: 'unreadable_frame' | 'no_approval_id' | 'not_read' | 'list_unreadable' | 'list_not_reported' | 'list_incomplete';

package/dist/hitl/replayedApproval.js

@@ -1,5 +1,5 @@
 import { hasLedgerPositionKey } from './gateLedger.js';
-import { anyApprovalSettled, settledApprovalOf } from './approvalHolds.js';
+import { anyApprovalSettled, APPROVAL_SETTLED_HOWS, settledApprovalOf } from './approvalHolds.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { projectCrashConverged } from './crashConverged.js';
 import { quoteUntrustedForSentence } from '../displayUntrusted.js';
@@ -9,7 +9,7 @@ const unknown = (why) => Object.freeze({ kind: 'unknown', why });
 const decided = (row) => Object.freeze(row === undefined
     ? { kind: 'decided' }
     : { kind: 'decided', cause: row.cause, ...(row.needsHumanReason !== undefined ? { needsHumanReason: row.needsHumanReason } : {}) });
-const decidedSettled = (how) => Object.freeze({ kind: 'decided', settled: how });
+const decidedSettled = (how, parked) => Object.freeze(parked && how === 'closed_by_engine' ? { kind: 'decided', settled: how, parked: true } : { kind: 'decided', settled: how });
 function approvalIdOf(frame) {
     const v = frame.approvalId;
     return typeof v === 'string' && v !== '' ? v : undefined;
@@ -29,7 +29,7 @@ export function settledApprovalDisposition(frame) {
         if (!anyApprovalSettled())
             return undefined;
         const entry = settledApprovalOf(approvalIdOf(frame));
-        return entry === undefined ? undefined : decidedSettled(entry.how);
+        return entry === undefined ? undefined : decidedSettled(entry.how, entry.parked);
     }
     catch {
         return undefined;
@@ -161,7 +161,10 @@ export function replayedApprovalClosesCardFrame(disposition) {
         if (readOwnDataValue(disposition, 'kind') !== 'decided')
             return false;
         const cause = readOwnDataValue(disposition, 'cause');
-        return typeof cause === 'string' && Object.hasOwn(STOPPED_BY_CAUSE, cause);
+        if (typeof cause === 'string' && Object.hasOwn(STOPPED_BY_CAUSE, cause))
+            return true;
+        const settled = readOwnDataValue(disposition, 'settled');
+        return typeof settled === 'string' && APPROVAL_SETTLED_HOWS.includes(settled) && !('parked' in disposition);
     }
     catch {
         return false;

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,8 +1,8 @@
-import { CONFIG_LEGACY_TOOL_NAME, RULES_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
+import { CONFIG_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
 import { ruleCompileVerdict } from '../ruleCompileVerdict.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 { PREFIXES_IN_PROSE, REFUSED_NAME_CLASSES, REFUSED_NAME_FIX } from './refusedToolNameProse.js';
 import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
 const COVERING_NAMESPACE_PREFIXES = CORE_PROTOCOL_PREFIXES;
 const WITHHELD_NOTICE = {
@@ -132,7 +132,5 @@ const LEGACY_TOOL_NAME_FAILURE_NOTE = `This run did not start: a tool rule appli
 export function legacyToolNameFailureNoteOf(code) {
     if (code === CONFIG_LEGACY_TOOL_NAME)
         return LEGACY_TOOL_NAME_FAILURE_NOTE;
-    if (code === RULES_LEGACY_TOOL_NAME)
-        return RULES_LEGACY_TOOL_NAME_WRITE_NOTE;
     return undefined;
 }