@sema-agent/client-core 0.78.2 → 0.79.0

package/dist/hitl/persistedRulesWire.d.ts

@@ -64,6 +64,12 @@ export type RulesFailure = {
 } | {
     kind: 'write-indeterminate';
     message: string;
+} | {
+    kind: 'write-not-committed';
+    message: string;
+} | {
+    kind: 'remove-indeterminate';
+    message: string;
 } | {
     kind: 'error';
     message: string;
@@ -93,7 +99,7 @@ export type PersistedRuleWriteBehavior = (typeof PERSISTED_RULE_WRITE_BEHAVIORS)
 export type PersistedRuleWriteRequest = RuleWriteRequest;
 export type PersistedRuleWriteWireResult = RuleWriteResult;
 export type PersistedRuleLiveness = RemovalLiveness;
-export declare const PERSISTED_RULE_WRITE_REFUSAL_CAUSES: readonly ["unwritable_behavior", "unreadable_identity", "unusable_principal", "client_too_old", "field_refused", "body_shape", "operator_only", "store_absent", "lane_too_old", "route_absent"];
+export declare const PERSISTED_RULE_WRITE_REFUSAL_CAUSES: readonly ["unwritable_behavior", "unreadable_identity", "unusable_principal", "client_too_old", "field_refused", "body_shape", "operator_only", "store_absent", "lane_too_old", "route_absent", "not_committed"];
 export type PersistedRuleWriteRefusalCause = (typeof PERSISTED_RULE_WRITE_REFUSAL_CAUSES)[number];
 export declare const PERSISTED_RULE_WRITE_UNKNOWN_REASONS: readonly ["indeterminate", "malformed_result", "identity_mismatch", "unattributed_method_refusal", "unclassified"];
 export type PersistedRuleWriteUnknownReason = (typeof PERSISTED_RULE_WRITE_UNKNOWN_REASONS)[number];
@@ -110,6 +116,11 @@ export type PersistedRuleWriteOutcome = {
     wrote: 'persisted' | 'no_op';
     rev: number;
     message: string;
+} | {
+    status: 'unverified';
+    wrote: 'persisted' | 'no_op';
+    rev: number;
+    message: string;
 } | {
     status: 'refused';
     cause: PersistedRuleWriteRefusalCause;

package/dist/hitl/persistedRulesWire.js

@@ -35,7 +35,7 @@ export function readCcImportRedeemCounts(result) {
     return null;
 }
 export function classifyRulesFailure(e) {
-    const { status, errorCode, message, retryAfterSec } = wireFailureShapeOf(e);
+    const { status, errorCode, message, retryAfterSec, committed } = wireFailureShapeOf(e);
     if (errorCode === 'capability.rule_store_required') {
         return { kind: 'lane-unavailable', message };
     }
@@ -50,10 +50,12 @@ export function classifyRulesFailure(e) {
         const sec = retryAfterSec;
         return { kind: 'retry-same-ticket', message, ...(sec !== undefined ? { retryAfterSec: sec } : {}) };
     }
-    if (errorCode === 'state.rule_remove_failed')
-        return { kind: 'retryable', message };
-    if (errorCode === 'state.rule_write_failed')
-        return { kind: 'write-indeterminate', message };
+    if (errorCode === 'state.rule_remove_failed') {
+        return committed === 'unknown' || committed === 'unreadable' ? { kind: 'remove-indeterminate', message } : { kind: 'retryable', message };
+    }
+    if (errorCode === 'state.rule_write_failed') {
+        return committed === 'no' ? { kind: 'write-not-committed', message } : { kind: 'write-indeterminate', message };
+    }
     if (status === 400 && errorCode === 'request.query_invalid')
         return { kind: 'cursor-stale', message };
     if (status === 400 && errorCode === 'request.field_invalid')
@@ -222,6 +224,7 @@ export const PERSISTED_RULE_WRITE_REFUSAL_CAUSES = Object.freeze([
     'store_absent',
     'lane_too_old',
     'route_absent',
+    'not_committed',
 ]);
 export const PERSISTED_RULE_WRITE_UNKNOWN_REASONS = Object.freeze([
     'indeterminate',
@@ -249,6 +252,8 @@ function writeOutcomeFromFailure(failure) {
             return { status: 'refused', cause: 'route_absent', message };
         case 'write-indeterminate':
             return { status: 'unknown', why: 'indeterminate', message };
+        case 'write-not-committed':
+            return { status: 'refused', cause: 'not_committed', message };
         default:
             return { status: 'unknown', why: 'unclassified', message };
     }
@@ -361,6 +366,16 @@ export async function writePersistedRule(facade, input, opts) {
                 message: 'the rule write landed (the revision is real) but a concurrent revoke arrived before it could be read back — the requested tightening is not standing; do not retry (that would re-create what was just revoked): list the rules to see the current state',
             };
         }
+        if (liveness === 'unknown') {
+            if (hasRow)
+                return malformed();
+            return {
+                status: 'unverified',
+                wrote,
+                rev,
+                message: 'the rule write landed (the revision is real) but the engine could not observe the rule liveness when reading it back — the requested tightening is not verified as standing; do not blindly retry: list the rules to see the current state',
+            };
+        }
         if (liveness !== 'yes')
             return malformed();
     }

package/dist/hitl/toolApprovalWire.d.ts

@@ -17,6 +17,8 @@ export type FsApprovalOutcome = {
     kind: 'decided';
     gatedCallId?: string | undefined;
     denied?: boolean | undefined;
+    denySettledBy?: ApprovalDenySettledBy | undefined;
+    denyReason?: string | undefined;
     receipt?: DecideReceiptView | undefined;
 } | {
     kind: 'aborted';
@@ -85,7 +87,11 @@ export interface ApprovalCardAllowDecision {
 export interface ApprovalCardDenyDecision {
     kind: 'deny';
     reason?: string;
+    settledBy?: ApprovalDenySettledBy;
 }
+export declare const APPROVAL_DENY_SETTLED_BY_WORDS: readonly ["human", "policy"];
+export type ApprovalDenySettledBy = (typeof APPROVAL_DENY_SETTLED_BY_WORDS)[number];
+export declare function readApprovalDenySettledBy(decision: unknown): ApprovalDenySettledBy | undefined;
 export type ApprovalCardDecision = ApprovalCardAllowDecision | ApprovalCardDenyDecision | {
     kind: 'aborted';
 } | {
@@ -124,6 +130,7 @@ export interface ApprovalCardRequest {
     serverNowMs?: number;
     receivedAtMs?: number;
     ruleOffersAbsence?: string;
+    mandated?: true;
     denialLimitFallback?: DenialLimitFallback;
     origin?: string;
     ruleStoreUnreadable?: RuleStoreUnreadableKind;
@@ -162,6 +169,7 @@ export interface ToolApprovalFrame {
     probeCause?: unknown;
     ruleEvidence?: unknown;
     requiresRealApproval?: true;
+    mandated?: true;
     origin?: string;
     inputHasBidi?: true;
     parked?: true;
@@ -180,7 +188,11 @@ export interface ToolApprovalDelegation {
     depth: number;
     agentName?: string;
 }
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleSuggestions", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "ruleStoreUnreadable", "readRootCandidate", "origin", "inputHasBidi", "parked", "persistedRuleShadowed", "probeCause", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome"];
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleSuggestions", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "ruleStoreUnreadable", "readRootCandidate", "mandated", "origin", "inputHasBidi", "parked", "persistedRuleShadowed", "probeCause", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome"];
+export declare function approvalIsMandated(v: {
+    mandated?: true;
+    ruleOffersAbsence?: string;
+} | undefined | null): boolean;
 export declare function isFromSubagent(frame: ToolApprovalFrame): boolean;
 export type ToolApprovalRespondDecision = 'allow' | 'allow_session' | 'deny';
 export interface RespondToolApprovalOpts {
@@ -201,6 +213,8 @@ export interface ToolApprovalFrameOutcome {
     respondRefusal?: ToolApprovalRespondRefusal;
     editRefused?: true;
     retracted?: true;
+    denySettledBy?: ApprovalDenySettledBy;
+    denyReason?: string;
 }
 interface ToolApprovalRespondRefusalFields {
     status?: number;

package/dist/hitl/toolApprovalWire.js

@@ -49,6 +49,24 @@ export function structurallyEqual(a, b) {
 }
 export { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS };
 export { RULE_OFFERS_ABSENCE_REASONS, DENIAL_LIMIT_KINDS };
+export const APPROVAL_DENY_SETTLED_BY_WORDS = Object.freeze(['human', 'policy']);
+export function readApprovalDenySettledBy(decision) {
+    if (decision === null || typeof decision !== 'object')
+        return undefined;
+    let d;
+    try {
+        d = Object.getOwnPropertyDescriptor(decision, 'settledBy');
+    }
+    catch {
+        return undefined;
+    }
+    if (d === undefined || !('value' in d))
+        return undefined;
+    const v = d.value;
+    return typeof v === 'string' && APPROVAL_DENY_SETTLED_BY_WORDS.includes(v)
+        ? v
+        : undefined;
+}
 export const RETRACTED_CARD_DECISION_KIND = 'retracted';
 const cardPortByKey = createSessionSlot();
 const cardPortMissesByKey = new Map();
@@ -191,7 +209,16 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
             try {
                 const raw = await bridge.decideTool({ decision: 'deny', reason: denyReasonForWire(card.reason, `task ${taskId}`) ?? DEFAULT_DENY_REASON }, gatedCallId, signal ? { signal } : undefined, pending);
                 const receipt = readDecideReceipt(raw);
-                return { kind: 'decided', gatedCallId, denied: true, ...(receipt !== undefined ? { receipt } : {}) };
+                const denySettledBy = readApprovalDenySettledBy(card);
+                const denyReason = typeof card.reason === 'string' && card.reason.trim() !== '' ? card.reason : undefined;
+                return {
+                    kind: 'decided',
+                    gatedCallId,
+                    denied: true,
+                    ...(denySettledBy !== undefined ? { denySettledBy } : {}),
+                    ...(denyReason !== undefined ? { denyReason } : {}),
+                    ...(receipt !== undefined ? { receipt } : {}),
+                };
             }
             catch (e) {
                 const currentPending = readDecideCurrentPending(e);
@@ -238,6 +265,7 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'denialLimitFallback',
     'ruleStoreUnreadable',
     'readRootCandidate',
+    'mandated',
     'origin',
     'inputHasBidi',
     'parked',
@@ -253,6 +281,14 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
 ];
 const _mirrorPin = [true, true];
 void _mirrorPin;
+const MANDATED_ABSENCE_WORD = 'mandated';
+export function approvalIsMandated(v) {
+    if (v === null || v === undefined)
+        return false;
+    if (v.mandated === true)
+        return true;
+    return v.ruleOffersAbsence === MANDATED_ABSENCE_WORD;
+}
 function isToolApprovalDelegation(v) {
     if (v === null || typeof v !== 'object')
         return false;
@@ -657,6 +693,7 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         ...(isWireRecordCarrier(frame.probeCause) ? { probeCause: frame.probeCause } : {}),
         ...(isWireRecordCarrier(frame.ruleEvidence) ? { ruleEvidence: frame.ruleEvidence } : {}),
         ...(frame.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
+        ...(frame.mandated === true ? { mandated: true } : {}),
         ...(() => { const rc = readReadRootCandidate(frame.readRootCandidate); return rc !== undefined ? { readRootCandidate: rc } : {}; })(),
         ...(frame.inputHasBidi === true ? { inputHasBidi: true } : {}),
         ...(typeof frame.ruleOffersAbsence === 'string' && frame.ruleOffersAbsence !== ''
@@ -834,7 +871,13 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             hostLog('debug', `liveToolApprovalWire: ${frame.approvalId} decision note was sent but not persisted ` +
                 `(ack.noteRecorded=${String(ack.noteRecorded)}) — decision stood; the audit note did not land on the ask row`);
         }
-        return ack !== undefined ? { decision, ack } : { decision };
+        const denyAttribution = card.kind === 'deny'
+            ? {
+                ...((o) => (o !== undefined ? { denySettledBy: o } : {}))(readApprovalDenySettledBy(card)),
+                ...(typeof card.reason === 'string' && card.reason.trim() !== '' ? { denyReason: card.reason } : {}),
+            }
+            : {};
+        return ack !== undefined ? { decision, ack, ...denyAttribution } : { decision, ...denyAttribution };
     }
     catch (e) {
         const respondRefusal = readToolApprovalRespondRefusal(e);

package/dist/index.d.ts

@@ -40,6 +40,8 @@ export * from './argvFlagValue.js';
 export * from './readFacePosture.js';
 export * from './mcpPanel.js';
 export * from './mcpLiveness.js';
+export * from './mcpProbeCapability.js';
+export * from './mcpProbeWire.js';
 export * from './effectiveFacts.js';
 export * from './gateOutcome.js';
 export * from './postureKnob.js';

package/dist/index.js

@@ -40,6 +40,8 @@ export * from './argvFlagValue.js';
 export * from './readFacePosture.js';
 export * from './mcpPanel.js';
 export * from './mcpLiveness.js';
+export * from './mcpProbeCapability.js';
+export * from './mcpProbeWire.js';
 export * from './effectiveFacts.js';
 export * from './gateOutcome.js';
 export * from './postureKnob.js';

package/dist/mcpLiveness.js

@@ -1,4 +1,7 @@
 export const MCP_LIVENESS_STATES = Object.freeze(['reachable', 'unreachable', 'unknown']);
+void MCP_LIVENESS_STATES;
+void true;
+void true;
 const isLivenessState = (v) => typeof v === 'string' && MCP_LIVENESS_STATES.includes(v);
 const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 export function readMcpLiveness(row) {

package/dist/mcpProbeCapability.d.ts

@@ -0,0 +1,18 @@
+export type McpProbeReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectMcpProbeCapability(caps: unknown): McpProbeReading | undefined;
+export declare function noteEngineCapsForMcpProbe(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedMcpProbe(baseUrl?: string | undefined): McpProbeReading;
+export declare function mcpProbeAvailable(reading: McpProbeReading): 'yes' | 'no' | 'unknown';
+export declare function mcpProbeDoctorDetail(reading: McpProbeReading): string;
+export declare function forgetMcpProbeReading(baseUrl: string | undefined): void;
+export declare function __resetMcpProbeReadingsForTests(): void;

package/dist/mcpProbeCapability.js

@@ -0,0 +1,55 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectMcpProbeCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'mcpProbe'))
+        return { kind: 'not_reported' };
+    const v = caps.mcpProbe;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'mcpProbe',
+    project: projectMcpProbeCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForMcpProbe(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedMcpProbe(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function mcpProbeAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent')
+        return 'no';
+    return 'unknown';
+}
+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)');
+        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); ' +
+                'prefer the session panel last-leg roster where that panel carries one, and otherwise show this reason rather than an entry that cannot answer');
+        case 'absent':
+            return ('per-server MCP status face reported off on this deployment — this engine answers no readings there; ' +
+                'this client does not guess why, and whether caller-supplied declarations are honored is a separate position with its own answer');
+        case 'present':
+            return ('per-server MCP status face on — this engine dials its own declared MCP servers on request, with no run, ' +
+                'and a probe of caller-supplied declarations answers with the very same body shape');
+    }
+}
+export function forgetMcpProbeReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetMcpProbeReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/mcpProbeWire.d.ts

@@ -0,0 +1,51 @@
+import type { McpProbeFace, McpServerSpec } from '@sema-agent/sdk';
+import { type WiringManifestMcpEntryView } from './adapter/downstream/eventToSdkMessage.js';
+import { type McpProbeReading } from './mcpProbeCapability.js';
+export interface McpProbeFacade {
+    mcpCapabilities(opts?: {
+        signal?: AbortSignal;
+    }): Promise<McpProbeFace>;
+    probeMcp(mcpServers: McpServerSpec[], opts?: {
+        signal?: AbortSignal;
+    }): Promise<McpProbeFace>;
+}
+export declare const MCP_PROBE_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "injection_not_honored", "body_shape", "field_invalid", "body_unparseable", "payload_too_large", "rate_limited", "unauthorized", "principal_required", "principal_unverified"];
+export type McpProbeRefusalCause = (typeof MCP_PROBE_REFUSAL_CAUSES)[number];
+export declare const MCP_PROBE_UNKNOWN_WHYS: readonly ["no_verdict", "probe_incomplete", "server_fault", "result_unreadable", "index_misaligned", "unclassified"];
+export type McpProbeUnknownWhy = (typeof MCP_PROBE_UNKNOWN_WHYS)[number];
+export type McpProbeRefused = {
+    status: 'refused';
+    cause: McpProbeRefusalCause;
+    message: string;
+    retryAfterSec?: number;
+};
+export type McpProbeUnknown = {
+    status: 'unknown';
+    why: McpProbeUnknownWhy;
+    message: string;
+    retryAfterSec?: number;
+};
+export type McpProbeFailure = McpProbeRefused | McpProbeUnknown;
+export interface McpProbeFaceView {
+    probedAt: string;
+    ttlSec: number;
+    servers: WiringManifestMcpEntryView[];
+}
+export type McpProbeOutcome = {
+    status: 'face';
+    face: McpProbeFaceView;
+} | McpProbeRefused | McpProbeUnknown;
+export declare function classifyMcpProbeFailure(e: unknown): McpProbeFailure;
+export interface McpCapabilitiesCall {
+    capability: McpProbeReading;
+}
+export declare function readMcpCapabilities(facade: McpProbeFacade, call: McpCapabilitiesCall, opts?: {
+    signal?: AbortSignal;
+}): Promise<McpProbeOutcome>;
+export interface McpProbeServersCall {
+    specs: McpServerSpec[];
+    capability: McpProbeReading;
+}
+export declare function probeMcpServers(facade: McpProbeFacade, call: McpProbeServersCall, opts?: {
+    signal?: AbortSignal;
+}): Promise<McpProbeOutcome>;

package/dist/mcpProbeWire.js

@@ -0,0 +1,217 @@
+import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
+import { wireFailureShapeOf } from './wireFailureShape.js';
+import { mcpProbeAvailable } from './mcpProbeCapability.js';
+export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
+    'face_absent',
+    'client_too_old',
+    'unreadable_request',
+    'injection_not_honored',
+    'body_shape',
+    'field_invalid',
+    'body_unparseable',
+    'payload_too_large',
+    'rate_limited',
+    'unauthorized',
+    'principal_required',
+    'principal_unverified',
+]);
+export const MCP_PROBE_UNKNOWN_WHYS = Object.freeze([
+    'no_verdict',
+    'probe_incomplete',
+    'server_fault',
+    'result_unreadable',
+    'index_misaligned',
+    'unclassified',
+]);
+const _mcpProbeFaceViewPin = true;
+void _mcpProbeFaceViewPin;
+function refusedBy(cause, message, retryAfterSec) {
+    return { status: 'refused', cause, message, ...(retryAfterSec !== undefined ? { retryAfterSec } : {}) };
+}
+function unknownBy(why, message, retryAfterSec) {
+    return { status: 'unknown', why, message, ...(retryAfterSec !== undefined ? { retryAfterSec } : {}) };
+}
+export function classifyMcpProbeFailure(e) {
+    const { status, errorCode, message, retryAfterSec } = wireFailureShapeOf(e);
+    if (errorCode === undefined || errorCode === '')
+        return unknownBy('no_verdict', message, retryAfterSec);
+    switch (errorCode) {
+        case 'not_found.route':
+            return refusedBy('face_absent', message);
+        case 'capability.mcp_injection_required':
+            return refusedBy('injection_not_honored', message);
+        case 'request.body_shape':
+            return refusedBy('body_shape', message);
+        case 'request.field_invalid':
+            return refusedBy('field_invalid', message);
+        case 'request.rejected':
+            return refusedBy('body_unparseable', message);
+        case 'request.payload_too_large':
+            return refusedBy('payload_too_large', message);
+        case 'limit.rate_exceeded':
+            return refusedBy('rate_limited', message, retryAfterSec);
+        case 'auth.unauthorized':
+            return refusedBy('unauthorized', message);
+        case 'auth.principal_required':
+            return refusedBy('principal_required', message);
+        case 'principal_unverified':
+            return refusedBy('principal_unverified', message);
+        case 'state.mcp_probe_incomplete':
+            return unknownBy('probe_incomplete', message, retryAfterSec);
+        default:
+            break;
+    }
+    if (errorCode.startsWith('auth.'))
+        return refusedBy('unauthorized', message);
+    if (status === undefined)
+        return unknownBy('no_verdict', message, retryAfterSec);
+    if (status >= 500)
+        return unknownBy('server_fault', message, retryAfterSec);
+    return unknownBy('unclassified', message, retryAfterSec);
+}
+function plainObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function nonEmptyString(v) {
+    return typeof v === 'string' && v !== '';
+}
+const MAX_ROWS = 10_000;
+function snapshotArray(v) {
+    try {
+        if (!Array.isArray(v))
+            return null;
+        const n = v.length;
+        if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0 || n > MAX_ROWS)
+            return null;
+        const out = [];
+        for (let i = 0; i < n; i++)
+            out.push(v[i]);
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+function snapshotSpecs(v) {
+    let ownSerializer;
+    try {
+        ownSerializer = v?.toJSON;
+    }
+    catch {
+        return null;
+    }
+    if (ownSerializer !== undefined)
+        return null;
+    const rows = snapshotArray(v);
+    return rows === null ? null : rows;
+}
+function narrowProbeFace(body) {
+    let probedAt;
+    let ttlSec;
+    let servers;
+    try {
+        if (!plainObject(body))
+            return { ok: false, why: 'result_unreadable' };
+        probedAt = body.probedAt;
+        ttlSec = body.ttlSec;
+        servers = body.servers;
+    }
+    catch {
+        return { ok: false, why: 'result_unreadable' };
+    }
+    if (!nonEmptyString(probedAt))
+        return { ok: false, why: 'result_unreadable' };
+    if (typeof ttlSec !== 'number' || !Number.isFinite(ttlSec) || ttlSec < 0)
+        return { ok: false, why: 'result_unreadable' };
+    const raw = snapshotArray(servers);
+    if (raw === null)
+        return { ok: false, why: 'result_unreadable' };
+    let rows;
+    try {
+        rows = projectMcpSection(raw);
+    }
+    catch {
+        return { ok: false, why: 'result_unreadable' };
+    }
+    if (rows === undefined)
+        return { ok: false, why: 'result_unreadable' };
+    if (rows.length !== raw.length)
+        return { ok: false, why: 'result_unreadable' };
+    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; ' +
+    'read the last leg roster from the session panel, or show the real cause, rather than an entry that cannot answer';
+function readCapabilityKind(capability) {
+    const kind = plainObject(capability) ? capability.kind : undefined;
+    if (!nonEmptyString(kind)) {
+        throw new TypeError('mcpProbeWire: `capability` (this call reading of the per-server MCP status face position) is required — ' +
+            'a default reading anchor would silently answer for whichever engine happens to be installed, ' +
+            'and this step decides whether a request goes on the wire at all');
+    }
+    return kind;
+}
+function faceGate(capability) {
+    const kind = readCapabilityKind(capability);
+    if (mcpProbeAvailable({ kind }) !== 'no')
+        return undefined;
+    return refusedBy('face_absent', FACE_ABSENT_MESSAGE);
+}
+export async function readMcpCapabilities(facade, call, opts) {
+    if (typeof facade?.mcpCapabilities !== 'function') {
+        return refusedBy('client_too_old', 'this client has no per-server MCP status read — nothing was sent; upgrade the client that builds this port');
+    }
+    const gate = faceGate(call?.capability);
+    if (gate !== undefined)
+        return gate;
+    let res;
+    try {
+        res = await facade.mcpCapabilities(opts);
+    }
+    catch (e) {
+        return classifyMcpProbeFailure(e);
+    }
+    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, ' +
+            'because a normal-looking empty list is exactly the false answer this face exists to remove');
+    }
+    return { status: 'face', face: narrowed.face };
+}
+export async function probeMcpServers(facade, call, opts) {
+    if (typeof facade?.probeMcp !== 'function') {
+        return refusedBy('client_too_old', 'this client has no MCP declaration probe — nothing was sent, so nothing was dialed; upgrade the client that builds this port');
+    }
+    const gate = faceGate(call?.capability);
+    if (gate !== undefined)
+        return gate;
+    let submitted;
+    try {
+        submitted = snapshotSpecs(call?.specs);
+    }
+    catch {
+        submitted = null;
+    }
+    if (submitted === null) {
+        return refusedBy('unreadable_request', 'a declaration probe needs a plain declaration list this client can count — the rows come back aligned by index with it, ' +
+            'so a list of unknown length, or one that serializes itself (its own toJSON can put a different set of servers on the wire ' +
+            'than the one that was counted), cannot be paired with anything; nothing was sent');
+    }
+    let res;
+    try {
+        res = await facade.probeMcp(submitted, opts);
+    }
+    catch (e) {
+        return classifyMcpProbeFailure(e);
+    }
+    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');
+    }
+    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) — ` +
+            'the rows are paired with the submitted list by index, so refusing to pair any of them');
+    }
+    return { status: 'face', face: narrowed.face };
+}

package/dist/printToolResultFrame.d.ts

@@ -12,6 +12,7 @@ export interface ToolEndResultArmLike {
     gate?: unknown;
     delivered?: unknown;
     gatedCallId?: unknown;
+    _sema_denial_kind?: unknown;
     parentToolCallId?: unknown;
     uuid?: unknown;
     session_id?: unknown;

package/dist/printToolResultFrame.js

@@ -1,3 +1,4 @@
+import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
 function bashExitCodeFailed(toolName, text, structured) {
@@ -30,6 +31,7 @@ export function toolEndResultToUserFrame(arm) {
             ],
         },
         parent_tool_use_id: typeof arm.parentToolCallId === 'string' ? arm.parentToolCallId : null,
+        ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
         uuid: arm.uuid,
         session_id: arm.session_id,
     };