@sema-agent/client-core 0.92.0 → 0.93.0

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/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

@@ -34,6 +34,7 @@ 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

@@ -91,11 +91,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';

package/dist/hitl/sessionPolicyWire.d.ts

@@ -115,6 +115,8 @@ export declare function sessionPolicyReadNotice(outcome: Exclude<SessionPolicyRe
     kind: 'present';
 }> | {
     kind: 'no_target';
+} | {
+    kind: 'not_started';
 }): string;
 export interface SessionPolicyRemovedEntry {
     readonly field: 'toolDeny' | 'toolAllow';

package/dist/hitl/sessionPolicyWire.js

@@ -328,7 +328,7 @@ export function sessionPolicyTightenNotice(outcome) {
                 case 'face_unavailable':
                     return 'This deployment does not keep per-session tool rules, so nothing was written.';
                 case 'session_not_found':
-                    return 'This session is not readable from here — it may not exist, or it may belong to someone else; nothing was written.';
+                    return 'This session is not readable from here — it may not exist, or it may belong to someone else (the engine answers both the same way, so this client cannot tell which); nothing was written.';
                 case 'session_ownerless':
                     return 'This session has no owner, so a rule written for it could never be read back; nothing was written. Attach an identity to the session and try again.';
                 case 'unauthorized':
@@ -354,6 +354,7 @@ export function sessionPolicyTightenNotice(outcome) {
 }
 const READ_NOTICE_GENERIC = 'This session’s rule record could not be shown, so what it holds is not known. Try reading it again.';
 const READ_NOTICE_NO_TARGET = 'There is no engine connection for this session, so its rule record cannot be read and what it holds is not known. Look again once it is connected.';
+const READ_NOTICE_NOT_STARTED = 'This session has not begun on the engine yet — nothing has been sent in it — so it has no rule record to read. Send a first message, then look again.';
 function readFailureSentence(kind) {
     switch (kind) {
         case 'face-unavailable':
@@ -367,7 +368,7 @@ function readFailureSentence(kind) {
         case 'session-ownerless':
             return 'This session has no owner, so it has no rule record to read.';
         case 'session-not-found':
-            return 'This session is not readable from here — it may not exist, or it may belong to someone else — so its rule record cannot be shown. Check that you are connected to the engine and the session you meant, or continue in a new session.';
+            return 'This session is not readable from here — it may not exist, or it may belong to someone else (the engine answers both the same way, so this client cannot tell which) — so its rule record cannot be shown. Check that you are connected to the engine and the session you meant, or continue in a new session.';
         case 'request-rejected':
             return 'The engine rejected the request to read this session’s rule record as malformed, so it could not be read. Sending the same request again will not change that; check which session was asked for.';
         case 'legacy-tool-name':
@@ -409,6 +410,8 @@ export function sessionPolicyReadNotice(outcome) {
             return readMalformedSentence(ownRead(outcome, 'why')) ?? READ_NOTICE_GENERIC;
         if (arm === 'no_target')
             return READ_NOTICE_NO_TARGET;
+        if (arm === 'not_started')
+            return READ_NOTICE_NOT_STARTED;
         return READ_NOTICE_GENERIC;
     }
     catch {
@@ -569,7 +572,7 @@ export function sessionPolicyRemovalNotice(outcome) {
                 case 'face_unavailable':
                     return 'This deployment does not keep per-session tool rules, so there is no session rule record to remove entries from — nothing was changed.';
                 case 'session_not_found':
-                    return 'This session is not readable from here — it may not exist, or it may belong to someone else; nothing was changed.';
+                    return 'This session is not readable from here — it may not exist, or it may belong to someone else (the engine answers both the same way, so this client cannot tell which); nothing was changed.';
                 case 'session_ownerless':
                     return 'This session has no owner, so it has no session rule record to change; nothing was changed.';
                 case 'unauthorized':
@@ -586,7 +589,7 @@ export function sessionPolicyRemovalNotice(outcome) {
                 case 'store_corrupt':
                     return 'The engine could not establish which version this session’s rules are at and refused to stamp a new one, so nothing was changed. This needs an operator to look at the rule store.';
                 case 'session_not_found':
-                    return 'This session is not writable from here — it may not exist, or it may belong to someone else; nothing was changed.';
+                    return 'This session is not writable from here — it may not exist, or it may belong to someone else (the engine answers both the same way, so this client cannot tell which); nothing was changed.';
                 case 'unauthorized':
                     return 'This call could not present a verifiable identity, so nothing was changed.';
                 default: