@sema-agent/client-core 0.92.0 → 0.93.1

package/dist/goalStopHook.js

@@ -1,80 +1,24 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
-import { engineCapString } from './engineCapsCache.js';
 let wireSessionStopHookPrompt = null;
-let wireSessionStopHookCcSemantics = false;
 export const GOAL_STOP_HOOK_WIRE_ENV = 'SEMA_GOAL_STOP_HOOK_WIRE';
-export const CC_STOP_SEMANTICS_MIN_SERVER = '1.279.3';
-function parseSemverCore(v) {
-    const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(v.trim());
-    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
-}
-export function ccStopSemanticsFromVersion(version) {
-    if (typeof version !== 'string' || version.length === 0)
-        return false;
-    const got = parseSemverCore(version);
-    const min = parseSemverCore(CC_STOP_SEMANTICS_MIN_SERVER);
-    if (got === null || min === null)
-        return false;
-    const [gotMajor, gotMinor, gotPatch] = got;
-    const [minMajor, minMinor, minPatch] = min;
-    if (gotMajor !== minMajor)
-        return gotMajor > minMajor;
-    if (gotMinor !== minMinor)
-        return gotMinor > minMinor;
-    if (gotPatch !== minPatch)
-        return gotPatch > minPatch;
-    return true;
-}
-export function engineCcStopSemantics(env = hostEnv()) {
-    const base = env.SEMA_LIVE_BASEURL;
-    if (!base)
-        return false;
-    return ccStopSemanticsFromVersion(engineCapString(base, 'version'));
-}
 export function isGoalStopHookWireArmed(env = hostEnv()) {
     return !envFlagOff(env[GOAL_STOP_HOOK_WIRE_ENV]);
 }
-export function setWireSessionStopHook(prompt, opts) {
+export function setWireSessionStopHook(prompt) {
     wireSessionStopHookPrompt = prompt && prompt.length > 0 ? prompt : null;
-    wireSessionStopHookCcSemantics = wireSessionStopHookPrompt === null ? false : opts?.ccSemantics === true;
 }
 export function getWireSessionStopHook() {
     return wireSessionStopHookPrompt;
 }
-export function getWireSessionStopHookCcSemantics() {
-    return wireSessionStopHookCcSemantics;
-}
-export function buildGoalStopHookPrompt(condition) {
-    const reason = `[session goal] Before you stop: verify that this goal actually holds — ${condition}. ` +
-        `If it does hold, say so plainly and finish. If it does not, keep working toward it and do not ` +
-        `pause to ask the user what to do.`;
-    return ('You are the Stop gate for an autonomous coding agent session. The user set this session goal, ' +
-        'which the agent is supposed to satisfy before it stops:\n' +
-        `<goal>\n${condition}\n</goal>\n` +
-        'Stop-hook input JSON: $ARGUMENTS\n' +
-        'Reply with RAW JSON only — no prose, no explanation, no code fences.\n' +
-        'If the input JSON has "stop_hook_active" set to true, this gate already fired once for this turn: ' +
-        'reply with exactly {"continue":true} so the agent may stop.\n' +
-        'Otherwise reply with exactly:\n' +
-        JSON.stringify({ decision: 'block', reason }));
-}
 export function goalStopHookMatcher(managedOnly) {
     if (wireSessionStopHookPrompt === null || managedOnly || !isGoalStopHookWireArmed())
         return null;
     return {
         matcher: '',
-        hooks: [
-            {
-                type: 'prompt',
-                prompt: wireSessionStopHookCcSemantics
-                    ? wireSessionStopHookPrompt
-                    : buildGoalStopHookPrompt(wireSessionStopHookPrompt),
-            },
-        ],
+        hooks: [{ type: 'prompt', prompt: wireSessionStopHookPrompt }],
     };
 }
 export function __resetGoalStopHookForTests() {
     wireSessionStopHookPrompt = null;
-    wireSessionStopHookCcSemantics = false;
 }

package/dist/headlessPermissionModeWire.d.ts

@@ -1,13 +1,14 @@
 import { type PermissionMode, type PermissionModeField } from './permissionWireCaps.js';
+import { type PermissionModesReading } from './permissionModesCapability.js';
 import { type EnvLike } from './hostEnv.js';
 export declare const HEADLESS_PERMISSION_MODE_ENV = "SEMA_HEADLESS_PERMISSION_MODE";
 export declare const HEADLESS_PERMISSION_WIRE_MODES: readonly PermissionMode[];
-export declare function normalizeShellPermissionModeForWire(mode: string | undefined): string | undefined;
+export declare function normalizeShellPermissionModeForWire(mode: string | undefined, permissionModes?: PermissionModesReading): string | undefined;
 export type HeadlessPermissionResolution = {
     fields: PermissionModeField;
     source: 'flag' | 'env' | 'default' | 'absent';
     warning?: string;
 };
 export declare function permissionModeFromArgv(argv: readonly string[]): string | undefined;
-export declare function resolveHeadlessPermissionMode(argv: readonly string[], env?: EnvLike): HeadlessPermissionResolution;
+export declare function resolveHeadlessPermissionMode(argv: readonly string[], env?: EnvLike, permissionModes?: PermissionModesReading): HeadlessPermissionResolution;
 export declare function _resetHeadlessPermissionModeWireForTest(): void;

package/dist/headlessPermissionModeWire.js

@@ -1,16 +1,20 @@
 import { permissionModeField } from './permissionWireCaps.js';
+import { permissionModeAdmitted } from './permissionModesCapability.js';
 import { hostEnv } from './hostEnv.js';
 import { lastFlagValue } from './argvFlagValue.js';
 import { PERMISSION_MODE_WORDS } from './taskRequestWords.js';
+import { readOwnDataValue } from './ownKey.js';
 export const HEADLESS_PERMISSION_MODE_ENV = 'SEMA_HEADLESS_PERMISSION_MODE';
 export const HEADLESS_PERMISSION_WIRE_MODES = [...PERMISSION_MODE_WORDS];
 const SHELL_INTERNAL_MODE_TO_WIRE = new Map([
     ['manual', 'default'],
     ['dontAsk', 'default'],
 ]);
-export function normalizeShellPermissionModeForWire(mode) {
+export function normalizeShellPermissionModeForWire(mode, permissionModes) {
     if (mode === undefined)
         return undefined;
+    if (mode === 'dontAsk' && permissionModeAdmitted(permissionModes, mode))
+        return mode;
     return SHELL_INTERNAL_MODE_TO_WIRE.get(mode) ?? mode;
 }
 export function permissionModeFromArgv(argv) {
@@ -27,19 +31,32 @@ export function permissionModeFromArgv(argv) {
     return undefined;
 }
 let warnedInvalidEnv = false;
-export function resolveHeadlessPermissionMode(argv, env = hostEnv()) {
+export function resolveHeadlessPermissionMode(argv, env = hostEnv(), permissionModes) {
     const flagMode = permissionModeFromArgv(argv);
     if (flagMode !== undefined) {
-        const normalized = normalizeShellPermissionModeForWire(flagMode);
-        return { fields: permissionModeField(normalized, { stampDefault: true }), source: 'flag' };
+        const snap = flagMode === 'dontAsk' ? dontAskSnapshot(permissionModes) : undefined;
+        const normalized = normalizeShellPermissionModeForWire(flagMode, snap);
+        return { fields: permissionModeField(normalized, { stampDefault: true, permissionModes: snap }), source: 'flag' };
     }
     const raw = env[HEADLESS_PERMISSION_MODE_ENV]?.trim();
     if (raw === undefined || raw === '') {
         return { fields: permissionModeField('default', { stampDefault: true }), source: 'default' };
     }
     if (HEADLESS_PERMISSION_WIRE_MODES.includes(raw)) {
+        const snap = raw === 'dontAsk' ? dontAskSnapshot(permissionModes) : undefined;
+        if (raw === 'dontAsk' && snap === undefined) {
+            const downgraded = {
+                fields: permissionModeField('default', { stampDefault: true }),
+                source: 'env',
+            };
+            if (!warnedInvalidEnv) {
+                warnedInvalidEnv = true;
+                downgraded.warning = `sema: ${HEADLESS_PERMISSION_MODE_ENV}="dontAsk" is only sent once this client knows the engine accepts that mode, and ${dontAskWithheldClause(permissionModes)} — this run uses "default"`;
+            }
+            return downgraded;
+        }
         return {
-            fields: permissionModeField(raw, { stampDefault: true }),
+            fields: permissionModeField(raw, { stampDefault: true, permissionModes: snap }),
             source: 'env',
         };
     }
@@ -53,6 +70,30 @@ export function resolveHeadlessPermissionMode(argv, env = hostEnv()) {
     }
     return resolution;
 }
+function dontAskSnapshot(reading) {
+    return permissionModeAdmitted(reading, 'dontAsk') ? { kind: 'present', modes: Object.freeze(['dontAsk']) } : undefined;
+}
+function dontAskWithheldClause(reading) {
+    if (reading === undefined)
+        return 'no such reading was supplied for this run';
+    let kind;
+    try {
+        kind = typeof reading === 'object' && reading !== null ? readOwnDataValue(reading, 'kind') : undefined;
+    }
+    catch {
+        kind = undefined;
+    }
+    switch (kind) {
+        case 'unobserved':
+            return "this engine's capabilities have not been read yet (wait for them before the first request)";
+        case 'not_reported':
+            return 'this engine does not report which modes it accepts';
+        case 'present':
+            return "this engine's list of accepted modes does not include it";
+        default:
+            return 'the reading supplied for it could not be read';
+    }
+}
 export function _resetHeadlessPermissionModeWireForTest() {
     warnedInvalidEnv = false;
 }

package/dist/hitl/approvalResolution.d.ts

@@ -1,9 +1,9 @@
 import type { DecideReceiptView } from '../decideReceipt.js';
 import type { HitlSafetyCode } from './hitlBridge.js';
-import type { FsApprovalOutcome, ToolApprovalFrameOutcome, ToolApprovalRespondAckView, ToolApprovalRespondDecision } from './toolApprovalWire.js';
+import type { FsApprovalOutcome, ToolApprovalFrameOutcome, ToolApprovalRespondAckView, ToolApprovalRespondDecision, ToolApprovalRespondParkingView } from './toolApprovalWire.js';
 export declare const APPROVAL_NOT_SENT_CAUSES: readonly ["retracted", "edit_refused", "no_pending", "fetch_failed", "no_input", "card_unavailable"];
 export type ApprovalNotSentCause = (typeof APPROVAL_NOT_SENT_CAUSES)[number];
-export declare const APPROVAL_UNSETTLED_CAUSES: readonly ["engine_refused", "decide_failed", "transport_exhausted", "safety_stop", "respond_failed", "interrupted", "orchestration", "unreadable"];
+export declare const APPROVAL_UNSETTLED_CAUSES: readonly ["engine_refused", "decide_failed", "transport_exhausted", "safety_stop", "respond_failed", "parking_in_progress", "interrupted", "orchestration", "unreadable"];
 export type ApprovalUnsettledCause = (typeof APPROVAL_UNSETTLED_CAUSES)[number];
 export interface ApprovalResolutionDecided {
     kind: 'decided';
@@ -26,6 +26,7 @@ export interface ApprovalResolutionUnsettled {
     errorCode?: string;
     status?: number;
     detail?: string;
+    parking?: ToolApprovalRespondParkingView;
 }
 export type ApprovalResolution = ApprovalResolutionDecided | ApprovalResolutionNotSent | ApprovalResolutionUnsettled;
 export type ApprovalLegOutcome = FsApprovalOutcome | ToolApprovalFrameOutcome;

package/dist/hitl/approvalResolution.js

@@ -12,6 +12,7 @@ export const APPROVAL_UNSETTLED_CAUSES = Object.freeze([
     'transport_exhausted',
     'safety_stop',
     'respond_failed',
+    'parking_in_progress',
     'interrupted',
     'orchestration',
     'unreadable',
@@ -98,11 +99,23 @@ function fsLegResolution(outcome, kind) {
         return { kind: 'unsettled', cause: 'orchestration', ...call, ...detail };
     return { kind: 'unsettled', cause: 'unreadable', ...call, ...detail };
 }
+function parkingViewOf(v) {
+    const approvalId = str(pick(v, 'approvalId'));
+    if (approvalId === undefined)
+        return undefined;
+    const hint = pick(v, 'retryAfterMs');
+    const retryAfterMs = typeof hint === 'number' && Number.isFinite(hint) && hint >= 0 ? hint : undefined;
+    const decidePath = str(pick(v, 'decidePath'));
+    return { approvalId, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), ...(decidePath !== undefined ? { decidePath } : {}) };
+}
 function frameLegResolution(outcome) {
     if (pick(outcome, 'retracted') === true)
         return { kind: 'not_sent', cause: 'retracted' };
     if (pick(outcome, 'editRefused') === true)
         return { kind: 'not_sent', cause: 'edit_refused' };
+    const parking = parkingViewOf(pick(outcome, 'parking'));
+    if (parking !== undefined)
+        return { kind: 'unsettled', cause: 'parking_in_progress', parking };
     if (pick(outcome, 'decision') === 'unresolved') {
         const refusal = pick(outcome, 'respondRefusal');
         return {

package/dist/hitl/askParkRowRouting.js

@@ -15,9 +15,9 @@ export function classifyAskParkRows(rows, taskId, deps) {
             kind: 'unborn',
             reason: rows.length === 0
                 ?
-                    `no pending row at all for task ${taskId} — either an orphan park (a seat held with no decision outstanding) or the next gate's row is not minted yet`
+                    `no pending row at all for task ${taskId} — either an orphan park (a seat held with no decision outstanding) or the next gate's row is not minted yet; this client cannot tell which`
                 : soleUnowned
-                    ? `the only pending row (task ${String(sole?.taskId)} / session ${String(sole?.sessionId)}) could not be proven to belong to this client (not in its own-run ledger, session id absent or different) — refusing to surface an approval that may be another session's`
+                    ? `the only pending row (task ${String(sole?.taskId)} / session ${String(sole?.sessionId)}) could not be proven to belong to this client (not in its own-run ledger, session id absent or different; this client cannot tell which) — refusing to surface an approval that may be another session's`
                     : `${String(rows.length)} pending rows but none for task ${taskId} — ambiguous queue, refusing to surface an unrelated row`,
         };
     }

package/dist/hitl/frameRouter.js

@@ -66,6 +66,11 @@ function isGatedToolName(name) {
 function isFsOrShellToolName(name) {
     return typeof name === 'string' && (toolNameIsFsWrite(name) || toolNameIsShellExec(name));
 }
+function parkFamilyEvidence(led, gateToolName, gatedCallId) {
+    if (!isFsOrShellToolName(gateToolName))
+        return false;
+    return gatedCallId === undefined || led.isFsOrShellGatedCall(gatedCallId);
+}
 const ENGINE_GATE_PARKED_ERROR_CODE = GATE_PARKED_ERROR_CODE;
 function isEngineAbortToolEnd(ev) {
     if (ev.errorCode === ENGINE_GATE_PARKED_ERROR_CODE)
@@ -353,7 +358,7 @@ function routeSuspended(ev, ctx) {
     if (ev.gate &&
         isToolApprovalGate(ev.gate) &&
         ctx.taskId.current) {
-        ctx.led.noteParkGate({ fsOrShellFamily: isFsOrShellToolName(ev.gate.toolName) });
+        ctx.led.noteParkGate({ fsOrShellFamily: parkFamilyEvidence(ctx.led, ev.gate.toolName, gatedCallId) });
         return { kind: 'park', gate: 'fs', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     return { kind: 'yield', events: [ev] };
@@ -364,7 +369,7 @@ function routeDone(ev, ctx) {
     const park = parkGateOf(ev.result);
     if (park !== null) {
         ctx.taskId.current = ctx.taskId.current ?? park.taskId;
-        led.noteParkGate({ fsOrShellFamily: park.gate === 'fs' && isFsOrShellToolName(park.toolName) });
+        led.noteParkGate({ fsOrShellFamily: park.gate === 'fs' && parkFamilyEvidence(led, park.toolName, gatedCallId) });
         return { kind: 'park', gate: park.gate, pendingDone: ev, ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     const events = [...flushHeldWithInterruptRewrite(led, { terminal: ev, signal: ctx.signal })];

package/dist/hitl/gateLedger.d.ts

@@ -46,6 +46,7 @@ export interface GateLedger {
     lastPendingFsCall(): string | undefined;
     noteFsOrShellGate(callId: string): void;
     lastFsOrShellGatedCallId(): string | undefined;
+    isFsOrShellGatedCall(callId: string): boolean;
     noteParkGate(evidence: {
         fsOrShellFamily: boolean;
     }): void;

package/dist/hitl/gateLedger.js

@@ -235,6 +235,9 @@ export function createGateLedger() {
         lastFsOrShellGatedCallId() {
             return lastFsOrShellGatedCall;
         },
+        isFsOrShellGatedCall(callId) {
+            return fsOrShellGatedCalls.has(callId);
+        },
         noteParkGate(evidence) {
             if (batchParkCount > 0 && !heldSinceLastPark)
                 return;

package/dist/hitl/hitlBridge.d.ts

@@ -56,6 +56,7 @@ export interface HitlDecideDenyOutcome {
     decision: 'deny';
     reason?: string | undefined;
     settledBy?: 'policy' | undefined;
+    decidedBy?: 'policy' | undefined;
 }
 export declare class HitlSafetyError extends Error {
     readonly code: HitlSafetyCode;

package/dist/hitl/hitlBridge.js

@@ -2,6 +2,7 @@ import { askParkForeignGateKind } from '../adapter/activeRunSelfHeal.js';
 import { eventSeq } from '../adapter/types.js';
 import { hostLog } from '../host.js';
 import { abortableSleep } from '../abortableSleep.js';
+import { readOwnDataValue } from '../ownKey.js';
 import { suspendedReopenOf } from './suspendedReopen.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 const MAX_DENY_REASON_CHARS = 4096;
@@ -291,7 +292,11 @@ export class HitlBridge {
                 decision: 'deny',
                 ...this.bindingOf(pending),
                 ...(outcome.reason !== undefined ? { reason: outcome.reason } : {}),
-                ...(outcome.settledBy === 'policy' ? { settledBy: 'policy' } : {}),
+                ...(readOwnDataValue(outcome, 'decidedBy') === 'policy'
+                    ? { decidedBy: 'policy' }
+                    : readOwnDataValue(outcome, 'settledBy') === 'policy'
+                        ? { settledBy: 'policy' }
+                        : {}),
             };
         return this.decideRaw(pending.sessionId, decision, opts);
     }

package/dist/hitl/hitlHostSurface.d.ts

@@ -28,12 +28,16 @@ export declare const REMEMBER_NOT_APPLIED_WARN_TEXT = "this session-wide allow w
 export declare const EDIT_NOT_FORWARDED_WARN_TEXT = "your edited tool input was NOT forwarded \u2014 the tool is running with the ORIGINAL input you saw before editing";
 export declare function surfaceRememberNotApplied(): void;
 export declare function surfaceEditNotForwarded(): void;
+export declare const APPROVAL_PARKING_WARN_TEXT = "This approval is being parked; answer it again on the parked card when it appears.";
+export declare function approvalParkingNoticeText(retryAfterMs?: number): string;
+export declare function surfaceApprovalParking(retryAfterMs?: number): void;
 export declare const REPLAYED_APPROVAL_LIST_UNREADABLE_WARN_TEXT: string;
 export declare function surfaceReplayedApprovalListUnreadable(): void;
 export declare const EDIT_REFUSED_ON_BLIND_ASK_WARN_TEXT: string;
 export declare function surfaceEditRefusedOnBlindAsk(): void;
 export declare const RULE_NOT_SENT_WARN_TEXT = "your \"don't ask again\" choice was NOT sent to this engine \u2014 support for that rule form could not be confirmed. The approval itself went through, but you will be asked again";
 export declare function surfaceRuleArmNotSent(): void;
-export declare const RULE_NOT_SENT_REJECTED_WARN_TEXT = "your \"don't ask again\" choice was NOT sent \u2014 it did not pass the client-side check (the card returned a rule the engine never offered, an index that is not a batch offer, or two conflicting choices at once). The approval itself went through, but you will be asked again";
-export declare function surfaceRuleArmRejected(): void;
+export type RuleArmRejectedWhy = 'both_arms' | 'index_not_a_batch_offer' | 'text_not_offered';
+export declare const RULE_NOT_SENT_REJECTED_WARN_TEXT: string;
+export declare function surfaceRuleArmRejected(why?: RuleArmRejectedWhy): void;
 export declare function observeCancelByDeny(settle: Promise<unknown>, taskId: string): void;

package/dist/hitl/hitlHostSurface.js

@@ -72,6 +72,17 @@ export function surfaceRememberNotApplied() {
 export function surfaceEditNotForwarded() {
     surfaceSelfClearingWarn(EDIT_NOT_FORWARDED_KEY, EDIT_NOT_FORWARDED_WARN_TEXT, EDIT_NOT_FORWARDED_TIMEOUT_MS);
 }
+export const APPROVAL_PARKING_WARN_TEXT = 'This approval is being parked; answer it again on the parked card when it appears.';
+const APPROVAL_PARKING_KEY = 'hitl-approval-parking';
+const APPROVAL_PARKING_TIMEOUT_MS = 15_000;
+export function approvalParkingNoticeText(retryAfterMs) {
+    if (retryAfterMs === undefined)
+        return APPROVAL_PARKING_WARN_TEXT;
+    return `${APPROVAL_PARKING_WARN_TEXT} (the engine suggested waiting about ${Math.ceil(retryAfterMs / 100) / 10} s)`;
+}
+export function surfaceApprovalParking(retryAfterMs) {
+    surfaceSelfClearingWarn(APPROVAL_PARKING_KEY, approvalParkingNoticeText(retryAfterMs), APPROVAL_PARKING_TIMEOUT_MS);
+}
 export const REPLAYED_APPROVAL_LIST_UNREADABLE_WARN_TEXT = "Could not read the pending-approval list, so an approval request read back from this run's event log was not raised as a question, " +
     'and no decision was sent for it.';
 const REPLAYED_APPROVAL_LIST_UNREADABLE_KEY = 'hitl-replayed-approval-list-unreadable';
@@ -91,11 +102,26 @@ const RULE_NOT_SENT_TIMEOUT_MS = 10_000;
 export function surfaceRuleArmNotSent() {
     surfaceSelfClearingWarn(RULE_NOT_SENT_KEY, RULE_NOT_SENT_WARN_TEXT, RULE_NOT_SENT_TIMEOUT_MS);
 }
-export const RULE_NOT_SENT_REJECTED_WARN_TEXT = 'your "don\'t ask again" choice was NOT sent — it did not pass the client-side check (the card returned a rule the engine never offered, an index that is not a batch offer, or two conflicting choices at once). The approval itself went through, but you will be asked again';
+function ruleNotSentRejectedReason(why) {
+    switch (why) {
+        case 'both_arms':
+            return 'the card returned two conflicting choices at once, a rule text and a batch index';
+        case 'index_not_a_batch_offer':
+            return 'the card returned an index that is not a batch offer';
+        case 'text_not_offered':
+            return 'the card returned a rule text that is not one of the single rules the engine offered';
+        default:
+            return 'the card returned a rule text that is not one of the single rules the engine offered, an index that is not a batch offer, or two conflicting choices at once; this client cannot tell which';
+    }
+}
+function ruleNotSentRejectedText(why) {
+    return `your "don't ask again" choice was NOT sent — it did not pass the client-side check (${ruleNotSentRejectedReason(why)}). The approval itself went through, but you will be asked again`;
+}
+export const RULE_NOT_SENT_REJECTED_WARN_TEXT = ruleNotSentRejectedText();
 const RULE_NOT_SENT_REJECTED_KEY = 'hitl-rule-arm-rejected';
 const RULE_NOT_SENT_REJECTED_TIMEOUT_MS = 10_000;
-export function surfaceRuleArmRejected() {
-    surfaceSelfClearingWarn(RULE_NOT_SENT_REJECTED_KEY, RULE_NOT_SENT_REJECTED_WARN_TEXT, RULE_NOT_SENT_REJECTED_TIMEOUT_MS);
+export function surfaceRuleArmRejected(why) {
+    surfaceSelfClearingWarn(RULE_NOT_SENT_REJECTED_KEY, ruleNotSentRejectedText(why), RULE_NOT_SENT_REJECTED_TIMEOUT_MS);
 }
 function isNoPendingError(e) {
     if (e instanceof HitlSafetyError)

package/dist/hitl/parkResolver.js

@@ -1,6 +1,6 @@
-import { putOwnKey } from '../ownKey.js';
+import { putOwnKey, readOwnDataValue } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, NO_QUESTION_OVERLAY_REASON, findPendingForTask, isNoDecisionSurfaceReason, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
-import { ASK_GONE, CHECKPOINT_UNSUPPORTED_VERSION, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isDecideParkMovedCode, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { ASK_GONE, CHECKPOINT_UNSUPPORTED_VERSION, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isDecideParkMovedCode, refusalSaysStillPending } from '../engineErrorCodes.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -63,7 +63,11 @@ function alreadyResolvedFailureVerdict(outcome) {
     return isAlreadyResolvedGateReason(outcome.reason);
 }
 export function isGateStandingErrorCode(code, retriable) {
-    return code === RESUME_POLICY_FOLD_CODE || code === 'corrupt' || (code === CHECKPOINT_UNSUPPORTED_VERSION && retriable === true);
+    return (code === RESUME_POLICY_FOLD_CODE ||
+        code === 'corrupt' ||
+        (code === CHECKPOINT_UNSUPPORTED_VERSION && 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;
@@ -192,10 +196,18 @@ function isFetchStepNoPending(outcome) {
 async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
     const { deps, led, taskId } = ctx;
     if (park.gate === 'fs') {
+        let decidedByReading;
+        try {
+            decidedByReading = readOwnDataValue(deps.approvalLane, 'approvalDecidedBy');
+        }
+        catch {
+            decidedByReading = undefined;
+        }
         const outcome = await surfaceFsApprovalAndDecide({
             client: deps.client,
             ...(onPresented ? { onPresented } : {}),
             ...(deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : {}),
+            ...(decidedByReading !== undefined ? { approvalDecidedBy: decidedByReading } : {}),
         }, taskId, argsByCallOf(led), ctx.signal, gatedCallId);
         const outcomeDenied = 'denied' in outcome ? outcome.denied : undefined;
         if (outcome.kind === 'decided' && outcomeDenied === true && outcome.gatedCallId) {
@@ -210,6 +222,12 @@ async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
     }
     return surfaceGateAndDecide(deps, taskId, argsByCallOf(led), ctx.signal, gatedCallId, onPresented);
 }
+function decidedIdentityCandidate(led, park) {
+    const id = park.gatedCallId;
+    if (id !== undefined)
+        return id;
+    return led.lastFsOrShellGatedCallId();
+}
 export async function resolvePark(park, ctx) {
     const { led, taskId } = ctx;
     let outcome;
@@ -245,7 +263,7 @@ export async function resolvePark(park, ctx) {
     }
     else {
         if (park.gate === 'fs')
-            candidateGatedCallId = led.lastFsOrShellGatedCallId();
+            candidateGatedCallId = decidedIdentityCandidate(led, park);
         outcome = await surfaceParkGate(park, ctx, park.gatedCallId, witness);
     }
     const alreadyDecidedById = outcome.kind === 'failed' &&

package/dist/hitl/persistedRulesWire.js

@@ -88,6 +88,10 @@ function rowStr(row, key) {
 function persistedRuleIdentityRowReadable(row) {
     return rowStr(row, 'rule') !== undefined && rowStr(row, 'scope') !== undefined;
 }
+function persistedRuleIdentityRowWhy(row) {
+    const bad = ['rule', 'scope'].filter((k) => rowStr(row, k) === undefined);
+    return `${bad.join(' and ')} ${bad.length === 1 ? 'is' : 'are'} missing or not a non-empty string`;
+}
 export function persistedRuleBehaviorOf(rule) {
     const b = rowStr(rule, 'behavior');
     return b !== undefined && BEHAVIOR_SET.has(b) ? b : undefined;
@@ -148,16 +152,22 @@ export async function listAllPersistedRules(facade, params = {}, opts) {
                 }
                 return { ok: false, failure };
             }
-            if (typeof res !== 'object' ||
-                res === null ||
-                !Array.isArray(res.rules) ||
-                typeof res.rev !== 'number' ||
-                !Number.isFinite(res.rev)) {
+            const pageProblems = [];
+            if (typeof res !== 'object' || res === null) {
+                pageProblems.push('the page is not an object');
+            }
+            else {
+                if (!Array.isArray(res.rules))
+                    pageProblems.push('rules is missing or not an array');
+                if (typeof res.rev !== 'number' || !Number.isFinite(res.rev))
+                    pageProblems.push('rev is missing or not a finite number');
+            }
+            if (pageProblems.length > 0) {
                 return {
                     ok: false,
                     failure: {
                         kind: 'error',
-                        message: 'rule list page was malformed (missing/ill-typed rules array or rev on a 2xx) — refusing to certify it as a complete governance list',
+                        message: `rule list page was malformed (${pageProblems.join('; ')}) on a 2xx — refusing to certify it as a complete governance list`,
                     },
                 };
             }
@@ -176,7 +186,7 @@ export async function listAllPersistedRules(facade, params = {}, opts) {
                         ok: false,
                         failure: {
                             kind: 'error',
-                            message: 'rule list page carried a malformed rule row (missing/ill-typed rule or scope) — refusing to present a list that hides or garbles live rules',
+                            message: `rule list page carried a malformed rule row (${persistedRuleIdentityRowWhy(r)}) — refusing to present a list that hides or garbles live rules`,
                         },
                     };
                 }
@@ -348,24 +358,26 @@ export async function writePersistedRule(facade, input, opts) {
     catch (e) {
         return writeOutcomeFromFailure(classifyRulesFailure(e));
     }
-    const malformed = () => ({
+    const malformed = (what) => ({
         status: 'unknown',
         why: 'malformed_result',
-        message: 'the rule write answered 2xx with a body this client cannot read (status, rev, liveness or the written row) — refusing to certify it as a standing rule; re-list the rules to reconcile',
+        message: `the rule write answered 2xx with a body this client cannot read (${what}) — refusing to certify it as a standing rule; re-list the rules to reconcile`,
     });
     if (res === null || typeof res !== 'object' || Array.isArray(res))
-        return malformed();
+        return malformed('the body is not an object');
     const snap = certificationSnapshot(res);
     if (snap === null)
-        return malformed();
+        return malformed('a field of the body is an inherited or accessor property, or threw when read');
     const { status, rev, hasLiveness, liveness, hasRow, row } = snap;
-    if ((status !== 'persisted' && status !== 'no-op') || typeof rev !== 'number' || !Number.isFinite(rev))
-        return malformed();
+    const statusOk = status === 'persisted' || status === 'no-op';
+    const revOk = typeof rev === 'number' && Number.isFinite(rev);
+    if (!statusOk || !revOk)
+        return malformed([...(statusOk ? [] : ['status is not persisted or no-op']), ...(revOk ? [] : ['rev is not a finite number'])].join('; '));
     const wrote = status === 'persisted' ? 'persisted' : 'no_op';
     if (hasLiveness) {
         if (liveness === 'no') {
             if (hasRow)
-                return malformed();
+                return malformed('liveness and the written row contradict each other');
             return {
                 status: 'revoked',
                 wrote,
@@ -375,7 +387,7 @@ export async function writePersistedRule(facade, input, opts) {
         }
         if (liveness === 'unknown') {
             if (hasRow)
-                return malformed();
+                return malformed('liveness and the written row contradict each other');
             return {
                 status: 'unverified',
                 wrote,
@@ -384,10 +396,10 @@ export async function writePersistedRule(facade, input, opts) {
             };
         }
         if (liveness !== 'yes')
-            return malformed();
+            return malformed('liveness is not one of yes, no or unknown');
     }
     if (!persistedRuleIdentityRowReadable(row))
-        return malformed();
+        return malformed(`the written row is unreadable (${persistedRuleIdentityRowWhy(row)})`);
     const landed = row;
     if (landed.behavior !== behavior || landed.rule !== rule || landed.scope !== scope) {
         return {

package/dist/hitl/planReviewWire.d.ts

@@ -6,8 +6,6 @@ export declare const PLAN_REVIEW_APPROVE_LABEL = "Yes, approve and run the plan"
 export declare const PLAN_REVIEW_REJECT_LABEL = "No, reject it (keep planning)";
 export declare const PLAN_REVIEW_APPROVE_AUTO_LABEL = "Yes, and auto-accept edits";
 export declare const PLAN_REVIEW_APPROVE_MANUAL_LABEL = "Yes, and manually approve edits";
-export declare const PLAN_REVIEW_MODE_AFTER_MIN_ENGINE: readonly [number, number, number];
-export declare function versionSupportsPlanReviewModeAfter(v: string | undefined): 'supported' | 'unsupported' | 'unknown';
 export declare function planReviewDecisionFromAnswer(answer: QuestionAnswer | null | undefined, shownLabels?: readonly string[]): 'approve' | 'reject' | 'dismissed';
 export type PlanReviewChoice = {
     decision: 'approve';

package/dist/hitl/planReviewWire.js

@@ -9,7 +9,6 @@ import { decideFailureNote } from '../decideFailureNote.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError } from '../resumeRefusalCopy.js';
 import { REQUEST_FIELD_CONFLICT, isUnavailableFaceCode } from '../engineErrorCodes.js';
 import { denyReasonForWire, isPlanReviewModeAfter } from './hitlBridge.js';
-import { engineCapString } from '../engineCapsCache.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';
@@ -20,20 +19,6 @@ export const PLAN_REVIEW_APPROVE_LABEL = 'Yes, approve and run the plan';
 export const PLAN_REVIEW_REJECT_LABEL = 'No, reject it (keep planning)';
 export const PLAN_REVIEW_APPROVE_AUTO_LABEL = 'Yes, and auto-accept edits';
 export const PLAN_REVIEW_APPROVE_MANUAL_LABEL = 'Yes, and manually approve edits';
-export const PLAN_REVIEW_MODE_AFTER_MIN_ENGINE = Object.freeze([7, 86, 0]);
-export function versionSupportsPlanReviewModeAfter(v) {
-    const mm = v ? /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(v) : null;
-    if (!mm)
-        return 'unknown';
-    const got = [Number(mm[1]), Number(mm[2]), Number(mm[3])];
-    for (let i = 0; i < 3; i++) {
-        const g = got[i];
-        const need = PLAN_REVIEW_MODE_AFTER_MIN_ENGINE[i];
-        if (g !== need)
-            return g > need ? 'supported' : 'unsupported';
-    }
-    return 'supported';
-}
 const APPROVE_LABEL = PLAN_REVIEW_APPROVE_LABEL;
 const REJECT_LABEL = PLAN_REVIEW_REJECT_LABEL;
 const LEGACY_TWO_CHOICE_LABELS = Object.freeze([PLAN_REVIEW_APPROVE_LABEL, PLAN_REVIEW_REJECT_LABEL]);
@@ -266,9 +251,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
         }
         armedPlanReviewTaskIds.add(taskId);
         armedTaskId = taskId;
-        const capsBaseUrl = wire !== undefined ? wire.capsBaseUrl : engineWireTarget()?.baseUrl;
-        const offerModeAfter = opts?.submittedInPlanMode === true &&
-            versionSupportsPlanReviewModeAfter(engineCapString(capsBaseUrl, 'version')) === 'supported';
+        const offerModeAfter = opts?.submittedInPlanMode === true;
         if (offerModeAfter)
             offerModeAfterByTask.set(taskId, true);
         else

package/dist/hitl/sessionPolicyDeliverable.js

@@ -109,10 +109,10 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
         }
         if (why === undefined && COVERING_NAMESPACE_PREFIXES.some((p) => r.startsWith(p))) {
             const segment = protocolSegmentOf(r);
-            if (segment.kind === 'unknown')
-                return unreadable();
-            if (segment.kind === 'unminted')
+            if (segment.kind === 'empty' || segment.kind === 'unminted')
                 why = 'not_a_tool_name';
+            else if (segment.kind === 'unknown')
+                return unreadable();
         }
         if (why === undefined && mounted !== undefined && !mounted.has(r))
             why = 'not_in_roster';