@sema-agent/client-core 0.92.0 → 0.93.0

package/dist/limitsWire.d.ts

@@ -8,7 +8,6 @@ export declare const MAX_TURNS_MIN = 1;
 export declare const MAX_TURNS_MAX: number;
 export declare const MAX_TOKENS_MIN = 1;
 export declare const MAX_TOKENS_MAX: number;
-export declare const LIMITS_WIRE_MIN_ENGINE: readonly [number, number, number];
 export interface HeadlessLimits {
     maxWalltimeMs?: number;
     maxTurns?: number;
@@ -32,8 +31,3 @@ export type HeadlessEnvLimitsResult = {
 };
 export declare function headlessLimitsFromEnv(env?: EnvLike): HeadlessEnvLimitsResult;
 export declare function limitsForPrint(argv: string[], env?: EnvLike): LimitsParseResult;
-export declare function versionSupportsLimits(v: string | undefined): boolean;
-export declare function engineLimitsSupportWarning(baseUrl: string, flaggedFlags: string[], opts?: {
-    fetchImpl?: typeof fetch;
-    timeoutMs?: number;
-}): Promise<string | undefined>;

package/dist/limitsWire.js

@@ -10,7 +10,6 @@ export const MAX_TURNS_MAX = Number.MAX_SAFE_INTEGER;
 export const MAX_TOKENS_MIN = 1;
 export const MAX_TOKENS_MAX = Number.MAX_SAFE_INTEGER;
 const SEC_TO_MS = 1_000;
-export const LIMITS_WIRE_MIN_ENGINE = [1, 196, 0];
 const DEADLINE_USAGE = `sema: --deadline expects a whole number of seconds between ${DEADLINE_SEC_MIN} and ${DEADLINE_SEC_MAX}.\n` +
     '  --deadline <sec>     wall-clock budget for this run (sema superset — no upstream equivalent):\n' +
     '                       reaching it ends the run LOUDLY (failed / limits.max_walltime_exceeded)\n' +
@@ -112,40 +111,3 @@ export function limitsForPrint(argv, env = hostEnv()) {
     const merged = { ...(fromEnv.limits ?? {}), ...(parsed.limits ?? {}) };
     return { ok: true, ...(hasAnyLimit(merged) ? { limits: merged } : {}), flaggedFlags: parsed.flaggedFlags };
 }
-export function versionSupportsLimits(v) {
-    const m = v ? /^(\d+)\.(\d+)\.(\d+)/.exec(v) : null;
-    if (!m)
-        return false;
-    const [a, b, c] = [Number(m[1]), Number(m[2]), Number(m[3])];
-    const [ma, mb, mc] = LIMITS_WIRE_MIN_ENGINE;
-    if (a !== ma)
-        return a > ma;
-    if (b !== mb)
-        return b > mb;
-    return c >= mc;
-}
-export async function engineLimitsSupportWarning(baseUrl, flaggedFlags, opts) {
-    const fetchImpl = opts?.fetchImpl ?? fetch;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? 1500);
-    try {
-        const res = await fetchImpl(`${baseUrl.replace(/\/+$/, '')}/health`, {
-            method: 'GET',
-            signal: controller.signal,
-        });
-        if (!res.ok)
-            return undefined;
-        const body = (await res.json());
-        const version = typeof body?.version === 'string' ? body.version : undefined;
-        if (versionSupportsLimits(version))
-            return undefined;
-        const flags = flaggedFlags.length > 0 ? flaggedFlags.join('/') : '--deadline/--max-turns/--max-tokens';
-        return `[sema] engine ${version ?? '(unversioned, pre-1.96)'} does not support ${flags} (needs ≥1.196.0); the flag will be ignored by the engine`;
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}

package/dist/mcpProbeCapability.js

@@ -34,7 +34,7 @@ export function mcpProbeDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('per-server MCP status face not observed — the engine reports whether it has one on /v1/capabilities; ' +
-                'this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)');
+                'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
         case 'not_reported':
             return ('per-server MCP status face not reported by this engine — this binary predates the face, so that path is not expected to exist here ' +
                 '(asking it usually answers with a machine-readable route-not-found, though a timeout or an uncoded gateway answer still says nothing either way); ' +

package/dist/mcpProbeWire.js

@@ -111,32 +111,32 @@ function narrowProbeFace(body) {
     let servers;
     try {
         if (!plainObject(body))
-            return { ok: false, why: 'result_unreadable' };
+            return { ok: false, why: 'result_unreadable', what: 'the body is not a plain object' };
         probedAt = body.probedAt;
         ttlSec = body.ttlSec;
         servers = body.servers;
     }
     catch {
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the body threw when read' };
     }
     if (!nonEmptyString(probedAt))
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the reading time is missing or empty' };
     if (typeof ttlSec !== 'number' || !Number.isFinite(ttlSec) || ttlSec < 0)
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the reuse window is not a non-negative number' };
     const raw = snapshotArray(servers);
     if (raw === null)
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the per-server rows are not a readable list' };
     let rows;
     try {
         rows = projectMcpSection(raw);
     }
     catch {
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the per-server rows could not be read' };
     }
     if (rows === undefined)
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'none of the per-server rows could be read' };
     if (rows.length !== raw.length)
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'some of the per-server rows could not be read' };
     return { ok: true, face: { probedAt, ttlSec, servers: rows } };
 }
 const FACE_ABSENT_MESSAGE = 'this engine reports no per-server MCP status face on this deployment, so nothing was sent; ' +
@@ -172,8 +172,7 @@ export async function readMcpCapabilities(facade, call, opts) {
     }
     const narrowed = narrowProbeFace(res);
     if (!narrowed.ok) {
-        return unknownBy(narrowed.why, 'the per-server MCP status call answered 2xx with a body this client cannot stand behind ' +
-            '(the reading time, the reuse window, or the per-server rows) — refusing to present it as a reading, ' +
+        return unknownBy(narrowed.why, `the per-server MCP status call answered 2xx with a body this client cannot stand behind (${narrowed.what}) — refusing to present it as a reading, ` +
             'because a normal-looking empty list is exactly the false answer this face exists to remove');
     }
     return { status: 'face', face: narrowed.face };
@@ -206,8 +205,7 @@ export async function probeMcpServers(facade, call, opts) {
     }
     const narrowed = narrowProbeFace(res);
     if (!narrowed.ok) {
-        return unknownBy(narrowed.why, 'the declaration probe answered 2xx with a body this client cannot stand behind ' +
-            '(the reading time, the reuse window, or the per-server rows) — refusing to present it as a reading');
+        return unknownBy(narrowed.why, `the declaration probe answered 2xx with a body this client cannot stand behind (${narrowed.what}) — refusing to present it as a reading`);
     }
     if (narrowed.face.servers.length !== submitted.length) {
         return unknownBy('index_misaligned', `the declaration probe answered with ${narrowed.face.servers.length} row(s) for ${submitted.length} declaration(s) — ` +

package/dist/mcpReconnect.d.ts

@@ -1,5 +1,6 @@
 export declare const MCP_RECONNECT_OUTCOMES: readonly string[];
 export declare const MCP_RECONNECT_TRANSACTION_NOTICE: string;
+export declare const MCP_RECONNECT_UNSETTLED_NOTICE: string;
 export interface McpReconnectStatusView {
     name: string;
     status: string;
@@ -51,6 +52,10 @@ export type McpReconnectVerdict = {
     readonly reason: 'capability' | 'route' | 'feature';
 } | {
     readonly kind: 'not_found';
+} | {
+    readonly kind: 'unsettled';
+    readonly errorCode: 'state.mcp_reconnect_unsettled';
+    readonly error?: string;
 } | {
     readonly kind: 'failed';
     readonly error: unknown;

package/dist/mcpReconnect.js

@@ -2,6 +2,9 @@ import { capForDisplay } from './fleetTaskDesc.js';
 export const MCP_RECONNECT_OUTCOMES = Object.freeze(['accepted', 'refused', 'unsupported']);
 export const MCP_RECONNECT_TRANSACTION_NOTICE = 'Reconnecting closes the current connection before dialing again. On a healthy server this is a transaction, ' +
     'not a refresh: a failed re-dial leaves the server down and withdraws its tools from the model until a later re-dial succeeds.';
+export const MCP_RECONNECT_UNSETTLED_NOTICE = 'The MCP re-dial did not settle within the time this request waits, so there is no result yet: the re-dial was not cancelled and may still be running. ' +
+    "Check the server's state before re-dialing it again — a second request that arrives after the dial has settled closes the connection and dials once more.";
+const UNSETTLED_CODE = 'state.mcp_reconnect_unsettled';
 const RECONNECT_TEXT_MAX = 200;
 const RECONNECT_WORD_MAX = 40;
 const SERVER_NAME_MAX = 190;
@@ -88,6 +91,27 @@ export function projectMcpReconnectResult(body) {
     }
     return view;
 }
+function unsettledVerdict(carrier) {
+    let text;
+    try {
+        const r = carrier;
+        text = nonEmpty(r.error) ? r.error : r.message;
+    }
+    catch {
+        text = undefined;
+    }
+    return nonEmpty(text)
+        ? { kind: 'unsettled', errorCode: UNSETTLED_CODE, error: capForDisplay(text, RECONNECT_TEXT_MAX) }
+        : { kind: 'unsettled', errorCode: UNSETTLED_CODE };
+}
+function isUnsettledBody(raw) {
+    try {
+        return isRecord(raw) && !('outcome' in raw) && raw.errorCode === UNSETTLED_CODE;
+    }
+    catch {
+        return false;
+    }
+}
 export function classifyMcpReconnectFailure(e) {
     let code;
     try {
@@ -96,6 +120,8 @@ export function classifyMcpReconnectFailure(e) {
     catch {
         return { kind: 'failed', error: e };
     }
+    if (code === UNSETTLED_CODE)
+        return unsettledVerdict(e);
     if (code === 'steering.invalid_content')
         return { kind: 'invalid' };
     if (code === 'steering.not_running')
@@ -123,6 +149,8 @@ export async function reconnectMcpServer(client, sessionId, server, opts) {
             return { kind: 'failed', error: opts.signal.reason ?? new Error('mcpReconnect: aborted before the verb was called') };
         }
         const raw = await client.sessions.mcpReconnect(sessionId, { server }, opts?.signal ? { signal: opts.signal } : undefined);
+        if (isUnsettledBody(raw))
+            return unsettledVerdict(raw);
         const view = projectMcpReconnectResult(raw);
         if (view === undefined)
             return { kind: 'failed', error: new Error('mcpReconnect: malformed body') };

package/dist/memoryComplianceCapability.js

@@ -35,9 +35,9 @@ export function memoryComplianceVerbsAvailable(reading) {
 export function memoryComplianceDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'memory compliance face not observed — the engine reports it on /v1/capabilities (memoryCompliance); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'memory compliance face not observed — the engine reports it on /v1/capabilities (memoryCompliance); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
-            return 'memory compliance face not reported by this engine — only newer engines advertise it; this does not say whether the provenance and erasure endpoints exist, probe them directly';
+            return 'memory compliance face not reported by this engine; this does not say whether the provenance and erasure endpoints exist, probe them directly';
         case 'absent':
             return `memory compliance face off on this deployment — the entry-provenance and erasure endpoints are unavailable (${MEMORY_ENGINE_REQUIRED_CODE}); the engine does not say which half is missing (a memory backend that does not own the engine control plane, or an empty operator roster), so do not guess`;
         case 'present':

package/dist/memoryOriginCapability.js

@@ -35,9 +35,9 @@ export function memoryOriginVerbsAvailable(reading) {
 export function memoryOriginDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'external-origin face not observed — the engine reports it on /v1/capabilities (memoryOrigin); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'external-origin face not observed — the engine reports it on /v1/capabilities (memoryOrigin); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
-            return 'external-origin face not reported by this engine — only newer engines advertise it; this does not say whether the origin listing and clearance endpoints exist, probe them directly';
+            return 'external-origin face not reported by this engine; this does not say whether the origin listing and clearance endpoints exist, probe them directly';
         case 'absent':
             return `external-origin face off on this deployment — the origin listing and clearance endpoints are unavailable (${MEMORY_ENGINE_REQUIRED_CODE}); the engine does not say which half is missing (a memory backend that does not own the engine control plane, or an empty operator roster), so do not guess`;
         case 'present':

package/dist/memoryVerbsWire.js

@@ -176,7 +176,7 @@ function narrowProvenanceAccount(body, entryId) {
     let exclusionCode;
     try {
         if (!plainObject(body))
-            return { ok: false, why: 'result_unreadable' };
+            return { ok: false, why: 'result_unreadable', what: 'the body is not a plain object' };
         v = body.v;
         id = body.id;
         binding = body.binding;
@@ -191,27 +191,28 @@ function narrowProvenanceAccount(body, entryId) {
         exclusionCode = plainObject(exclusion) ? exclusion.code : undefined;
     }
     catch {
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the body threw when read' };
     }
     if (typeof v !== 'number' || !Number.isFinite(v))
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the envelope version is missing or not a number' };
     if (v !== PROVENANCE_ACCOUNT_VERSION)
-        return { ok: false, why: 'unsupported_version' };
+        return { ok: false, why: 'unsupported_version', what: 'the envelope version is newer than this client knows' };
     if (!nonEmptyString(id))
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the entry id is missing or empty' };
     if (!plainObject(binding) || !nonEmptyString(bindingState))
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the binding is missing or has no usable state' };
     if (!plainObject(custody) || !nonEmptyString(custodyState) || !Array.isArray(custodyEvents)) {
-        return { ok: false, why: 'result_unreadable' };
-    }
-    if (!Array.isArray(contributors) || !nonEmptyString(contentState)) {
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the custody chain is missing or has no usable state or event list' };
     }
+    if (!Array.isArray(contributors))
+        return { ok: false, why: 'result_unreadable', what: 'the contributor list is missing or not a list' };
+    if (!nonEmptyString(contentState))
+        return { ok: false, why: 'result_unreadable', what: 'the content state is missing or empty' };
     if (hasExclusion && !(plainObject(exclusion) && nonEmptyString(exclusionCode))) {
-        return { ok: false, why: 'result_unreadable' };
+        return { ok: false, why: 'result_unreadable', what: 'the exclusion record is present but unreadable' };
     }
     if (id !== entryId)
-        return { ok: false, why: 'identity_mismatch' };
+        return { ok: false, why: 'identity_mismatch', what: 'the account is for a different entry id' };
     return { ok: true, account: body };
 }
 export async function readEntryProvenance(facade, call, opts) {
@@ -238,7 +239,7 @@ export async function readEntryProvenance(facade, call, opts) {
             ? 'the provenance account came back stamped with a newer envelope version than this client knows — refusing to reinterpret it; upgrade the client'
             : narrowed.why === 'identity_mismatch'
                 ? 'the provenance account came back for a different entry id than the one that was asked about — refusing to present it as this entry account'
-                : 'the provenance call answered 2xx with a body this client cannot branch on (envelope, entry id, binding or custody) — refusing to present it as an account');
+                : `the provenance call answered 2xx with a body this client cannot branch on (${narrowed.what}) — refusing to present it as an account`);
     }
     return { status: 'account', account: narrowed.account };
 }

package/dist/ownKey.d.ts

@@ -1,2 +1,4 @@
 export declare function putOwnKey<T>(table: Record<string, T>, key: string, value: T): void;
 export declare function readOwnNonEmptyString(v: object | null | undefined, key: string): string | undefined;
+export declare function readOwnDataNonEmptyString(v: object | null | undefined, key: string): string | undefined;
+export declare function readOwnDataValue<T>(v: object | null | undefined, key: string): T | undefined;

package/dist/ownKey.js

@@ -7,3 +7,18 @@ export function readOwnNonEmptyString(v, key) {
     const raw = v[key];
     return typeof raw === 'string' && raw !== '' ? raw : undefined;
 }
+export function readOwnDataNonEmptyString(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    const d = Object.getOwnPropertyDescriptor(v, key);
+    if (d === undefined || !Object.hasOwn(d, 'value'))
+        return undefined;
+    const raw = d.value;
+    return typeof raw === 'string' && raw !== '' ? raw : undefined;
+}
+export function readOwnDataValue(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    const d = Object.getOwnPropertyDescriptor(v, key);
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+}

package/dist/peerLaneCapability.js

@@ -35,9 +35,9 @@ export function peerLaneAvailable(reading) {
 export function peerLaneDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'cross-session lane not observed — the engine reports it on /v1/capabilities (peerLane); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'cross-session lane not observed — the engine reports it on /v1/capabilities (peerLane); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
-            return 'cross-session lane not reported by this engine — the engine predates the lane, so this deployment has no cross-session discovery or delivery (the key itself is the version signal; addressing another session by id is refused as unknown)';
+            return 'cross-session lane not reported by this engine — its capabilities reading carries no entry for the lane, so whether this deployment has cross-session discovery or delivery is unknown to this client';
         case 'absent':
             return 'no cross-session lane on this deployment — cross-session discovery and delivery (listing other sessions, addressing one by id) are unavailable';
         case 'present':

package/dist/permissionModesCapability.d.ts

@@ -0,0 +1,16 @@
+export type PermissionModesReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    modes: readonly string[];
+};
+export declare function projectPermissionModesCapability(caps: unknown): PermissionModesReading | undefined;
+export declare function noteEngineCapsForPermissionModes(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedPermissionModes(baseUrl?: string | undefined): PermissionModesReading;
+export declare function permissionModeAdmitted(reading: PermissionModesReading | undefined, mode: string): boolean;
+export declare function forgetPermissionModesReading(baseUrl: string | undefined): void;
+export declare function __resetPermissionModesReadingsForTests(): void;

package/dist/permissionModesCapability.js

@@ -0,0 +1,71 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { readOwnDataValue } from './ownKey.js';
+function readModesStrict(v) {
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+        const length = v.length;
+        if (length === 0)
+            return undefined;
+        const modes = [];
+        for (let i = 0; i < length; i++) {
+            const item = readOwnDataValue(v, String(i));
+            if (typeof item !== 'string' || item.length === 0)
+                return undefined;
+            modes.push(item);
+        }
+        return modes;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectPermissionModesCapability(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'permissionModes'))
+            return { kind: 'not_reported' };
+        const v = caps.permissionModes;
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        const modes = readModesStrict(v);
+        return modes === undefined ? undefined : { kind: 'present', modes };
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({
+    name: 'permissionModes',
+    project: projectPermissionModesCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForPermissionModes(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedPermissionModes(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function permissionModeAdmitted(reading, mode) {
+    try {
+        if (typeof mode !== 'string' || mode.length === 0)
+            return false;
+        if (reading === null || reading === undefined || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        if (readOwnDataValue(reading, 'kind') !== 'present')
+            return false;
+        const modes = readModesStrict(readOwnDataValue(reading, 'modes'));
+        return modes !== undefined && modes.includes(mode);
+    }
+    catch {
+        return false;
+    }
+}
+export function forgetPermissionModesReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetPermissionModesReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/permissionRuleIssue.js

@@ -23,7 +23,7 @@ const ISSUE_SENTENCES = Object.freeze({
     'invalid.paren': 'this rule is invalid: its parentheses do not parse (escape a literal one as \\( or \\))',
     'invalid.param_split': 'this rule is invalid: its parentheses do not hold a parameter rule written name:pattern',
     'invalid.primary_field': "this rule is invalid: it patterns the tool's primary field, which matches the whole trimmed string rather than a prefix",
-    'invalid.cap_exceeded': 'this rule set is invalid: it is over one of the deployment caps (rule count, rule length, pattern length, or star count)',
+    'invalid.cap_exceeded': 'this rule set is invalid: it is over one of the deployment caps (rule count, rule length, pattern length, or star count); this client cannot tell which from the code alone',
     'invalid.behavior': 'this rule is invalid: its behavior is neither deny nor ask, so it would never fire',
     'invalid.command_rule': 'this rule is invalid: the command pattern was rejected by the command-rule validator',
     'invalid.entry_type': 'this allow list is invalid: it must be a list of rule strings, and it or one of its entries is not a string',

package/dist/permissionRulesWriteCapability.js

@@ -31,11 +31,11 @@ export function permissionRulesWriteAvailable(reading) {
 export function permissionRulesWriteDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'permission-rule write entry not observed — the engine reports it on /v1/capabilities (permissionRulesWrite); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'permission-rule write entry not observed — the engine reports it on /v1/capabilities (permissionRulesWrite); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
             return 'permission-rule write entry not reported by this engine — this binary predates the entry itself; hide it rather than calling it';
         case 'absent':
-            return 'permission-rule write entry unreachable for this call — either the rules lane is not open on this deployment, or this call cannot bring a verifiable identity';
+            return 'permission-rule write entry unreachable for this call — either the rules lane is not open on this deployment, or this call cannot bring a verifiable identity; the engine reports one bit for both, so this client cannot tell which';
         case 'present':
             return 'permission-rule write entry reachable for this call — a per-call attempt still answers for itself whether the direction, text, and scope are accepted';
     }

package/dist/permissionWireCaps.d.ts

@@ -1,8 +1,10 @@
 import { type TaskRequestPermissionMode } from './taskRequestWords.js';
+import { type PermissionModesReading } from './permissionModesCapability.js';
 export type PermissionMode = TaskRequestPermissionMode;
 export interface PermissionModeField {
     permissionMode?: PermissionMode;
 }
 export declare function permissionModeField(mode: string | undefined, opts?: {
     stampDefault?: boolean;
+    permissionModes?: PermissionModesReading | undefined;
 }): PermissionModeField;

package/dist/permissionWireCaps.js

@@ -1,9 +1,16 @@
 import { PERMISSION_MODE_WORDS } from './taskRequestWords.js';
-const KNOWN = new Set(PERMISSION_MODE_WORDS);
+import { permissionModeAdmitted } from './permissionModesCapability.js';
+const BIT_GATED_MODE = 'dontAsk';
+const KNOWN = new Set(PERMISSION_MODE_WORDS.filter((w) => w !== BIT_GATED_MODE));
 export function permissionModeField(mode, opts) {
     if (typeof mode === 'string' && mode !== 'default' && KNOWN.has(mode)) {
         return { permissionMode: mode };
     }
+    if (mode === BIT_GATED_MODE) {
+        if (permissionModeAdmitted(opts?.permissionModes, mode))
+            return { permissionMode: mode };
+        return opts?.stampDefault === true ? { permissionMode: 'default' } : {};
+    }
     if (opts?.stampDefault === true && (mode === undefined || mode === 'default')) {
         return { permissionMode: 'default' };
     }

package/dist/permissionsAllowGrantCapability.js

@@ -65,7 +65,12 @@ export function permissionsAllowGrantDoctorDetail(reading, settingsRead) {
         return 'allow rules sent to the engine — it reads them as rules, not as an exclusive list: a matching call counts as answered for, and the engine still raises its own prompts where it requires them';
     }
     if (gate === 'settings_read_not_clean') {
-        return 'allow rules from settings files kept on this side — this engine reads allow rules as rules, but the settings read that produced them was not reported clean (a settings file was unreadable or had a problem, or no read health was given), so they are not sent; command-line and session allow rules are still sent, and matching approvals are still answered here';
+        const why = settingsRead === 'partial'
+            ? 'was reported partial (at least one settings file carried a bad field)'
+            : settingsRead === 'unreadable'
+                ? 'was reported unreadable (at least one settings file could not be read)'
+                : 'came with no recognized read health';
+        return `allow rules from settings files kept on this side — this engine reads allow rules as rules, but the settings read that produced them ${why}, so they are not sent; command-line and session allow rules are still sent, and matching approvals are still answered here`;
     }
     const kind = ownReadingField(reading, 'kind');
     if (kind === 'present' && ownReadingField(reading, 'grants') === false) {
@@ -74,7 +79,7 @@ export function permissionsAllowGrantDoctorDetail(reading, settingsRead) {
     if (kind === 'not_reported') {
         return 'allow rules kept on this side — this engine does not say how it reads allow rules; sending them to an engine that reads them as an exclusive list would block every tool not on it, so they are not sent and matching approvals are still answered here';
     }
-    return 'allow rules kept on this side — no usable capabilities reading is cached for this engine (none received, or the last one was unreadable), so allow rules are not sent and matching approvals are still answered here';
+    return 'allow rules kept on this side — no usable capabilities reading is cached for this engine (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which), so allow rules are not sent and matching approvals are still answered here';
 }
 export function forgetPermissionsAllowGrantReading(baseUrl) {
     reader.forget(baseUrl);

package/dist/postureKnob.js

@@ -87,7 +87,7 @@ export function postureKnobDetail(knob, opts) {
             ? `${label} ${word} (source: ${source} — ${note})`
             : `${label} ${word} (source: ${source})`;
     }
-    return `${label} not reported by this engine (an engine below 7.67.0, or a response this end could not parse)`;
+    return `${label} not reported by this engine (this end found no usable reading for it: the engine does not send one, or what it sent could not be parsed here; this end cannot tell which)`;
 }
 const _postureKnobShapePin = (w) => w;
 void _postureKnobShapePin;

package/dist/protocolSegment.d.ts

@@ -1,5 +1,7 @@
 export type ProtocolSegment = {
     readonly kind: 'ok';
+} | {
+    readonly kind: 'empty';
 } | {
     readonly kind: 'unminted';
     readonly minted?: string;

package/dist/protocolSegment.js

@@ -1,5 +1,8 @@
 import { hasCoreValuePort, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
+import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
 export function protocolSegmentOf(name) {
+    if (CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix) && name.slice(prefix.length).split('__')[0] === ''))
+        return { kind: 'empty' };
     const ns = protocolOf(name);
     if (ns === undefined)
         return hasCoreValuePort('protocolOf') ? { kind: 'ok' } : { kind: 'unknown' };

package/dist/readFacePosture.js

@@ -30,7 +30,7 @@ export function readFacePostureDetail(view, opts) {
     if (!opts.reachable) {
         return "read face not observed (this end could not read the engine's diagnostics)";
     }
-    return 'read face not reported by this engine (an engine below 7.65.0, or a response this end could not parse)';
+    return 'read face not reported by this engine (this end found no usable reading for it: the engine does not send one, or what it sent could not be parsed here; this end cannot tell which)';
 }
 export function readFaceDisagreement(capFace, posture) {
     if (posture === undefined)

package/dist/resumeRefusalCopy.d.ts

@@ -41,6 +41,7 @@ export interface ParkedResumeStartupDetail {
     code: string;
     cause: ParkedResumeStartupCause;
     taskId?: string;
+    startupCause?: string;
     resendable: false;
     denyStaysOpen: true;
 }

package/dist/resumeRefusalCopy.js

@@ -1,4 +1,5 @@
 import { readErrorNumber, readErrorString } from './wireFailureShape.js';
+import { readOwnDataNonEmptyString } from './ownKey.js';
 import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, refusalSaysStillPending, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
@@ -115,7 +116,7 @@ export function requireExistingSessionRefusalFromError(err) {
     }
 }
 const REQUIRE_EXISTING_SESSION_SENTENCES = Object.freeze({
-    session_not_found: 'The engine did not continue this conversation: the conversation it was asked to continue does not exist there (it may have expired, been removed, or never been created on that engine), and this request asked to continue only an existing one, so no new conversation was started · Start a new conversation, or pick another one to continue',
+    session_not_found: 'The engine did not continue this conversation: the conversation it was asked to continue does not exist there (it may have expired, been removed, or never been created on that engine; this client cannot tell which), and this request asked to continue only an existing one, so no new conversation was started · Start a new conversation, or pick another one to continue',
     session_id_missing: 'The engine did not continue this conversation: this request asked to continue only an existing conversation but named none, so there was nothing to continue and no new conversation was started · Name the conversation to continue, or start a new one',
 });
 const REQUIRE_EXISTING_SESSION_GENERIC = 'The engine did not continue this conversation: this request asked to continue only an existing conversation and there was none it could continue, so no new conversation was started · Start a new conversation, or pick another one to continue';
@@ -158,6 +159,26 @@ export function resumeContextUnavailableContent(d) {
         third,
     ].join(' · ');
 }
+function parkedResumeStartupCauseWord(err) {
+    let named;
+    try {
+        named = readOwnDataNonEmptyString(err, 'startupCause');
+    }
+    catch {
+        named = undefined;
+    }
+    if (named !== undefined)
+        return named;
+    try {
+        const extra = err.extra;
+        if (typeof extra !== 'object' || extra === null || Array.isArray(extra))
+            return undefined;
+        return readOwnDataNonEmptyString(extra, 'cause');
+    }
+    catch {
+        return undefined;
+    }
+}
 export function parkedResumeStartupFromError(err, decision) {
     if (typeof err !== 'object' || err === null)
         return null;
@@ -172,10 +193,12 @@ export function parkedResumeStartupFromError(err, decision) {
         return null;
     const rawTaskId = readErrorString(err, 'taskId');
     const taskId = rawTaskId !== undefined && rawTaskId.length > 0 ? rawTaskId : undefined;
+    const startupCause = parkedResumeStartupCauseWord(err);
     return {
         code: PARKED_RESUME_STARTUP_FAILED,
         cause: decision === 'deny' ? 'resume_rejected' : 'undetermined',
         ...(taskId !== undefined ? { taskId } : {}),
+        ...(startupCause !== undefined ? { startupCause } : {}),
         resendable: false,
         denyStaysOpen: true,
     };
@@ -183,7 +206,7 @@ export function parkedResumeStartupFromError(err, decision) {
 const PARKED_RESUME_STARTUP_STATE = 'This refusal does not say whether the card is still waiting — re-fetch the pending approvals';
 const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
     resume_rejected: [
-        'The engine could not start the parked work to apply this decision (its session may be gone, or the engine rejected the decision itself)',
+        'The engine could not start the parked work to apply this decision (its session may be gone, or the engine rejected the decision itself; this client cannot tell which)',
         PARKED_RESUME_STARTUP_STATE,
         'If the card is still there, decide it again from the fresh list',
     ].join(' · '),
@@ -249,7 +272,7 @@ export function checkpointUnsupportedVersionContent(detail, ctx) {
     }
     else {
         outlet =
-            'If it was parked before this server was upgraded, submit the work again as a new task: when it still has a run waiting on it (a tool approval, a plan review or a paused resource), cancel that run first; when it was waiting to be woken up, or was a workflow step continuing its host conversation, there is no run to cancel, so start a new task in that conversation';
+            'If it was parked before this server was upgraded, submit the work again as a new task (this client cannot tell which kind of parked work this is, so both ways out are given): when it still has a run waiting on it (a tool approval, a plan review or a paused resource), cancel that run first; when it was waiting to be woken up, or was a workflow step continuing its host conversation, there is no run to cancel, so start a new task in that conversation';
     }
     return [CHECKPOINT_UNSUPPORTED_WHAT, CHECKPOINT_UNSUPPORTED_STILL_WAITING, outlet + CHECKPOINT_UNSUPPORTED_DRAIN].join(' · ');
 }