@sema-agent/client-core 0.85.1 → 0.86.0

package/dist/adapt/arms.js

@@ -685,6 +685,9 @@ function prefixOf(whole, part) {
         return trimmed;
     return null;
 }
+const ERROR_SUBTYPE_PREFIX = 'error_';
+const _errorSubtypePrefixPin = true;
+void _errorSubtypePrefixPin;
 const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
     yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
     yield* panel.settle(null, false);
@@ -698,7 +701,8 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
     });
     yield* text.takeAnswerSegment();
     const salvaged = m._sema_salvaged_result;
-    const terminalText = typeof salvaged === 'string' ? salvaged : typeof m.result === 'string' ? m.result : '';
+    const errorEnvelope = typeof m.subtype === 'string' && m.subtype.startsWith(ERROR_SUBTYPE_PREFIX);
+    const terminalText = typeof salvaged === 'string' ? salvaged : !errorEnvelope && typeof m.result === 'string' ? m.result : '';
     const committed = text.lastCommittedAnswerText;
     const terminalIdentity = messageIdentityOf(m, ctx);
     const emitTerminal = function* (body, tag) {

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -36,6 +36,7 @@ export type ReopenCardVerdict = {
     _sema_decisionInFlight?: true;
     dismissedByUser?: true;
     _sema_noPresentationSurface?: true;
+    _sema_errorCode?: string;
 } | {
     reopened: true;
     firstSight: boolean;
@@ -88,6 +89,7 @@ export type SelfHealOutcome = {
     pendingRowGone?: true;
     dismissedByUser?: true;
     noPresentationSurface?: true;
+    errorCode?: string;
 } | {
     kind: 'not-parked';
     taskId: string;
@@ -111,6 +113,7 @@ export type SelfHealOutcome = {
     decisionInFlight?: true;
     pendingRowGone?: true;
     noPresentationSurface?: true;
+    errorCode?: string;
 } | {
     kind: 'ask-decided-without-card';
     taskId: string;

package/dist/adapter/activeRunSelfHeal.js

@@ -1,5 +1,5 @@
 import { abortableSleep } from '../abortableSleep.js';
-import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
+import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 export const PLAN_REVIEW_GATE_KINDS = Object.freeze([PLAN_REVIEW_GATE_KIND, 'dry_run_review']);
 export const ASK_PARK_GATE_KINDS = Object.freeze(['human', 'irreversible_ask', 'policy_ask', 'tool_approval']);
@@ -45,20 +45,42 @@ function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
 }
+function errorSlot(e, key) {
+    if (e === null || e === undefined)
+        return undefined;
+    try {
+        return e[key];
+    }
+    catch {
+        return undefined;
+    }
+}
 function describeFailure(e) {
     const where = corruptStoredRowWhere(e);
     const rowNote = where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`;
-    if (typeof e === 'object' && e !== null && 'message' in e) {
-        const m = e.message;
-        if (typeof m === 'string' && m.length > 0)
-            return `${m.length > 200 ? `${m.slice(0, 200)}…` : m}${rowNote}`;
+    let m;
+    try {
+        m = typeof e === 'object' && e !== null && 'message' in e ? e.message : undefined;
     }
+    catch {
+        m = undefined;
+    }
+    if (typeof m === 'string' && m.length > 0)
+        return `${m.length > 200 ? `${m.slice(0, 200)}…` : m}${rowNote}`;
     return `the engine gave no detail${rowNote}`;
 }
 function readStatus(record) {
     const st = record?.status;
     return typeof st === 'string' && st.length > 0 ? st : null;
 }
+function readStatusGuarded(record) {
+    try {
+        return readStatus(record);
+    }
+    catch {
+        return null;
+    }
+}
 function readClaimHolder(record) {
     if (record === null || typeof record !== 'object')
         return 'unknown';
@@ -88,6 +110,7 @@ const REOPEN_VERDICT_KEYS = [
     '_sema_decisionInFlight',
     'dismissedByUser',
     '_sema_noPresentationSurface',
+    '_sema_errorCode',
 ];
 function snapshotReopenVerdict(raw) {
     if (raw === null || raw === undefined)
@@ -179,6 +202,29 @@ function reopenRefusedForNoPresentationSurface(verdict) {
         return false;
     }
 }
+function reopenErrorCodeOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        const v = verdict._sema_errorCode;
+        return typeof v === 'string' && v.length > 0 ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function failureWireCode(e) {
+    try {
+        return effectiveWireErrorCode(e);
+    }
+    catch {
+        return undefined;
+    }
+}
+function thrownReopenVerdict(e) {
+    const code = failureWireCode(e);
+    return code !== undefined ? { reopened: false, _sema_errorCode: code } : { reopened: false };
+}
 function planReviewReopenTriggerFor(origin) {
     if (origin === 'user')
         return 'user';
@@ -214,20 +260,30 @@ function reopenedOfOutcome(outcome) {
     }
 }
 export function atMostOnceFailureClass(e) {
-    const status = e?.status;
+    const status = errorSlot(e, 'status');
     return typeof status === 'number' && status >= 400 && status < 500 ? 'rejected' : 'unknown';
 }
 export function readSteerDelivery(receipt) {
-    if (typeof receipt !== 'object' || receipt === null || !('delivery' in receipt))
+    try {
+        if (typeof receipt !== 'object' || receipt === null || !('delivery' in receipt))
+            return null;
+        const d = receipt.delivery;
+        return typeof d === 'string' && d.length > 0 ? d : null;
+    }
+    catch {
         return null;
-    const d = receipt.delivery;
-    return typeof d === 'string' && d.length > 0 ? d : null;
+    }
 }
 export function readSteerReceiptStatus(receipt) {
-    if (typeof receipt !== 'object' || receipt === null || !('status' in receipt))
+    try {
+        if (typeof receipt !== 'object' || receipt === null || !('status' in receipt))
+            return null;
+        const s = receipt.status;
+        return typeof s === 'string' && s.length > 0 ? s : null;
+    }
+    catch {
         return null;
-    const s = receipt.status;
-    return typeof s === 'string' && s.length > 0 ? s : null;
+    }
 }
 const CANCEL_RELEASE_WAIT_MS = 10_000;
 const RUNNING_LIVENESS_RECHECK_TIMEOUT_MS = 4_000;
@@ -345,11 +401,14 @@ async function readOwnedPendingCount(read, deps) {
             claimPollSleep(OWNED_PENDING_RECHECK_TIMEOUT_MS, recheckCtl.signal).then(() => null),
         ]);
         if (deps?.signal?.aborted === true)
-            return null;
-        return typeof count === 'number' ? count : null;
+            return { count: null };
+        return { count: typeof count === 'number' ? count : null };
     }
-    catch {
-        return null;
+    catch (e) {
+        if (deps?.signal?.aborted === true)
+            return { count: null };
+        const errorCode = failureWireCode(e);
+        return errorCode !== undefined ? { count: null, errorCode } : { count: null };
     }
     finally {
         deps?.signal?.removeEventListener('abort', onCallerAbort);
@@ -366,7 +425,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     }
     const callerAborted = () => deps?.signal?.aborted === true;
     if (pending && typeof deps?.listOwnedPendingApprovals === 'function' && !callerAborted()) {
-        const count = await readOwnedPendingCount(deps.listOwnedPendingApprovals, deps);
+        const { count } = await readOwnedPendingCount(deps.listOwnedPendingApprovals, deps);
         if (count === 0 && !callerAborted())
             pending = false;
     }
@@ -397,7 +456,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         catch (e) {
             return { kind: 'state-unknown', taskId, detail: describeFailure(e) };
         }
-        status = readStatus(record);
+        status = readStatusGuarded(record);
     }
     if (status === null) {
         return { kind: 'state-unknown', taskId, detail: 'the engine reported no status for that run' };
@@ -419,30 +478,39 @@ async function planVerdict(taskId, deps) {
         const verdict = trigger === undefined ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, { trigger });
         return snapshotReopenVerdict(await verdict);
     }
-    catch {
-        return { reopened: false };
+    catch (e) {
+        if (deps?.signal?.aborted === true)
+            return { reopened: false };
+        return thrownReopenVerdict(e);
     }
 }
 async function askVerdict(taskId, deps) {
     try {
         return snapshotReopenVerdict(await deps?.reopenAskPark?.(taskId));
     }
-    catch {
-        return { reopened: false };
+    catch (e) {
+        if (deps?.signal?.aborted === true)
+            return { reopened: false };
+        return thrownReopenVerdict(e);
     }
 }
 async function planReviewArm(taskId, signal, deps) {
     const verdict = await planVerdict(taskId, deps);
     if (reopenDelivered(verdict))
         return { kind: 'plan-review-reopened', taskId, firstSight: verdict.firstSight === true };
+    const inFlight = reopenRefusedForDecisionInFlight(verdict);
+    const dismissed = reopenRefusedForUserDismissal(verdict);
+    const noView = reopenRefusedForNoPresentationSurface(verdict);
+    const errorCode = inFlight || dismissed || noView ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'plan-review-reopen-failed',
         taskId,
         decidePath: signal.pendingGate?.decidePath ?? null,
-        ...(reopenRefusedForDecisionInFlight(verdict) ? { decisionInFlight: true } : {}),
+        ...(inFlight ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
-        ...(reopenRefusedForUserDismissal(verdict) ? { dismissedByUser: true } : {}),
-        ...(reopenRefusedForNoPresentationSurface(verdict) ? { noPresentationSurface: true } : {}),
+        ...(dismissed ? { dismissedByUser: true } : {}),
+        ...(noView ? { noPresentationSurface: true } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
     };
 }
 async function askParkArm(taskId, signal, runs, deps) {
@@ -477,30 +545,41 @@ async function askParkArm(taskId, signal, runs, deps) {
     if (verdict.reopened === false && verdict.decidedWithoutCard !== true && verdict.pendingRowGone === true && !inFlight) {
         return staleParkArm(taskId, signal, runs, deps);
     }
+    const noView = reopenRefusedForNoPresentationSurface(verdict);
+    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'ask-reopen-failed',
         taskId,
         decidePath: signal.pendingGate?.decidePath ?? null,
         ...(inFlight ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
-        ...(reopenRefusedForNoPresentationSurface(verdict) ? { noPresentationSurface: true } : {}),
+        ...(noView ? { noPresentationSurface: true } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
     let status = null;
     let ghost = false;
+    let errorCode;
+    let record = null;
+    let answered = false;
     const lease = claimProbeLease(deps?.signal, RUNNING_LIVENESS_RECHECK_TIMEOUT_MS);
     try {
-        status = readStatus(await durableGet.call(durable, taskId, { signal: lease.signal, ...sessionOpts(deps) }));
+        record = await durableGet.call(durable, taskId, { signal: lease.signal, ...sessionOpts(deps) });
+        answered = true;
     }
     catch (e) {
-        if (e?.status === 404)
+        if (errorSlot(e, 'status') === 404)
             ghost = true;
+        else
+            errorCode = failureWireCode(e);
     }
     finally {
         lease.release();
     }
-    return { status, ghost };
+    if (answered)
+        status = readStatusGuarded(record);
+    return errorCode !== undefined ? { status, ghost, errorCode } : { status, ghost };
 }
 async function staleParkArm(taskId, busy, runs, deps) {
     const reopenFailed = {
@@ -514,6 +593,7 @@ async function staleParkArm(taskId, busy, runs, deps) {
         taskId,
         decidePath: busy.pendingGate?.decidePath ?? null,
     };
+    const withFailureCode = (base, code) => code !== undefined ? { ...base, errorCode: code } : base;
     if (runs === undefined || typeof runs.get !== 'function')
         return reopenFailed;
     const durableGet = runs.get;
@@ -527,7 +607,7 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return reopenFailed;
     const fresh = first.status;
     if (fresh === null)
-        return reopenFailed;
+        return withFailureCode(reopenFailed, first.errorCode);
     if (RUNNING_STATES.includes(fresh))
         return runningChoiceArm(taskId, fresh, busy, false, runs, deps);
     if (PLAN_REVIEW_STATES.includes(fresh))
@@ -566,12 +646,14 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return { kind: 'ask-run-not-found', taskId };
     if (callerAborted())
         return reopenFailedAfterCard;
-    if (afterCard.status === null || !ASK_PARK_STATES.includes(afterCard.status)) {
-        return afterCard.status !== null && !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
-    }
-    const stillGone = await readOwnedPendingCount(recheckOwnedPending, deps);
-    if (stillGone !== 0)
-        return reopenFailedAfterCard;
+    if (afterCard.status === null)
+        return withFailureCode(reopenFailedAfterCard, afterCard.errorCode);
+    if (!ASK_PARK_STATES.includes(afterCard.status)) {
+        return !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
+    }
+    const recheck = await readOwnedPendingCount(recheckOwnedPending, deps);
+    if (recheck.count !== 0)
+        return withFailureCode(reopenFailedAfterCard, recheck.errorCode);
     const verdict = await cancelAndConfirmRelease(taskId, runs, durableGet, deps);
     if (verdict.outcome === 'released') {
         return { kind: 'stale-park-cancelled', taskId, ...(verdict.engineStatedRelease ? { releaseConfirmedByEngine: true } : {}) };
@@ -816,6 +898,14 @@ function injectedSubmissionRow(outcome, following = false) {
         return (`${lead} has not reached the model: the earlier reply${id} had already finished, so the message was set aside on it ` +
             `instead of starting a new reply, and sema did not retry it.`);
     }
+    if (outcome.kind === 'running-steered' && outcome.delivery !== 'applied') {
+        const unknown = `${lead} was accepted for the reply already in progress${id}, but how it will be delivered was not reported, ` +
+            `so sema cannot tell whether that reply will pick it up`;
+        return following
+            ? `${unknown}. sema is following that reply and will show whatever it asks for next; check what it does ` +
+                `before deciding whether anything needs to be sent again.`
+            : `${unknown} — watch that reply before deciding whether anything needs to be sent again.`;
+    }
     switch (selfHealSubmissionDisposition(outcome)) {
         case 'held-for-decision':
             return (`${lead} is on hold: this session is busy with an earlier reply${id} that is waiting on a decision. ` +

package/dist/adapter/downstream/terminalToSdkResult.d.ts

@@ -1,5 +1,5 @@
-import type { AgentEvent, DeniedBy, TaskStats } from '@sema-agent/sdk';
-import { type CcToolDenialKind } from '../../gateVocabulary.js';
+import type { AgentEvent, TaskStats } from '@sema-agent/sdk';
+import { type CcToolDenialKind, type GateDeniedByWord } from '../../gateVocabulary.js';
 import { type SDKMessage, type EmitContext } from '../types.js';
 import type { TerminalReason } from '@sema-agent/agent-types';
 import { type SemaModelUsage } from './turnUsageToModelUsage.js';
@@ -32,7 +32,7 @@ export interface SemaPermissionDenial {
     readonly _sema_tool_input_source?: 'tool_start';
     readonly _sema_tool_input_redacted?: true;
     readonly _sema_tool_arg?: string;
-    readonly deniedBy?: DeniedBy;
+    readonly deniedBy?: GateDeniedByWord;
     readonly _sema_denied_by_source?: 'tool_end';
     readonly toolDenialKind?: CcToolDenialKind;
 }

package/dist/agentSession/backgroundView.js

@@ -2,6 +2,7 @@ import { abortableSleep } from '../abortableSleep.js';
 import { errCodes } from '../controlRouter.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
+import { isReadCredentialRefusal } from '../readCredentialRefusal.js';
 export function backgroundStatusFromAssistant(s) {
     switch (s) {
         case 'running':
@@ -169,7 +170,12 @@ export function createBackgroundView(client, opts) {
         }
         catch (err) {
             debugLog(`fleet.snapshot degrade: ${String(err)}`);
-            return { health: isNotImplemented(err) ? 'not-configured' : 'unavailable', tasks: [] };
+            const health = isNotImplemented(err)
+                ? 'not-configured'
+                : isReadCredentialRefusal(err)
+                    ? 'unauthorized'
+                    : 'unavailable';
+            return { health, tasks: [] };
         }
     }
     async function pollOnce() {

package/dist/agentSession/contract.d.ts

@@ -47,7 +47,7 @@ export type AttachSeatSession = (seatApi: unknown) => AgentSession & {
     readonly supportedFields: readonly string[];
 };
 export type BackgroundSource = 'assistant' | 'fleet';
-export type BackgroundSourceHealth = 'ok' | 'unavailable' | 'not-configured';
+export type BackgroundSourceHealth = 'ok' | 'unavailable' | 'not-configured' | 'unauthorized';
 export type BackgroundStatus = 'running' | 'waiting-on-human' | 'queued' | 'stopping' | 'done' | 'failed' | 'stopped' | 'unknown';
 export interface BackgroundRow {
     readonly key: {

package/dist/centerWiringCapability.d.ts

@@ -0,0 +1,38 @@
+export interface CenterWiringRevisionView {
+    version: number;
+    updatedAt: string;
+}
+export interface CenterWiringCallerView {
+    lease: string;
+    retryAfterSec?: number;
+}
+export interface CenterWiringView {
+    effectivePull: boolean;
+    effectiveRevision: CenterWiringRevisionView | null;
+    lease: string;
+    leaseHealth?: string;
+    failMode?: string;
+    usageReport: boolean;
+    issuer: string;
+    caller?: CenterWiringCallerView;
+}
+export type CenterWiringReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'none';
+} | {
+    kind: 'present';
+    view: CenterWiringView;
+};
+export declare function projectCenterWiringCapability(caps: unknown): CenterWiringReading | undefined;
+export declare function noteEngineCapsForCenterWiring(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedCenterWiring(baseUrl?: string | undefined): CenterWiringReading;
+export type CallerQuotaLease = 'enforced' | 'not-enforced' | 'exhausted' | 'unobserved' | 'no-lease' | 'unknown';
+export declare function callerQuotaLease(reading: CenterWiringReading): CallerQuotaLease;
+export declare function centerWiringDoctorDetail(reading: CenterWiringReading): string;
+export declare function forgetCenterWiringReading(baseUrl: string | undefined): void;
+export declare function __resetCenterWiringReadingsForTests(): void;

package/dist/centerWiringCapability.js

@@ -0,0 +1,202 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+const nonEmpty = (v) => typeof v === 'string' && v !== '';
+const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function optionalSeat(o, key) {
+    if (!Object.hasOwn(o, key))
+        return { state: 'absent' };
+    const value = o[key];
+    return value === undefined ? { state: 'absent' } : { state: 'value', value };
+}
+export function projectCenterWiringCapability(caps) {
+    try {
+        return projectCenterWiringOf(caps);
+    }
+    catch {
+        return undefined;
+    }
+}
+function projectCenterWiringOf(caps) {
+    if (!isPlainObject(caps))
+        return undefined;
+    const cw = Object.hasOwn(caps, 'centerWiring') ? caps.centerWiring : undefined;
+    if (cw === undefined)
+        return capsGenerationOf(caps).generation === 'new' ? { kind: 'none' } : { kind: 'not_reported' };
+    if (!isPlainObject(cw))
+        return undefined;
+    const effectivePull = cw.effectivePull;
+    const revisionRaw = cw.effectiveRevision;
+    const lease = cw.lease;
+    const usageReport = cw.usageReport;
+    const issuer = cw.issuer;
+    if (typeof effectivePull !== 'boolean' || typeof usageReport !== 'boolean')
+        return undefined;
+    if (!nonEmpty(lease) || !nonEmpty(issuer))
+        return undefined;
+    let effectiveRevision;
+    if (revisionRaw === null) {
+        effectiveRevision = null;
+    }
+    else {
+        if (!isPlainObject(revisionRaw))
+            return undefined;
+        const version = revisionRaw.version;
+        const updatedAt = revisionRaw.updatedAt;
+        if (typeof version !== 'number' || !Number.isFinite(version) || !nonEmpty(updatedAt))
+            return undefined;
+        effectiveRevision = { version, updatedAt };
+    }
+    const health = optionalSeat(cw, 'leaseHealth');
+    if (health.state === 'value' && !nonEmpty(health.value))
+        return undefined;
+    const mode = optionalSeat(cw, 'failMode');
+    if (mode.state === 'value' && !nonEmpty(mode.value))
+        return undefined;
+    const callerSeat = optionalSeat(cw, 'caller');
+    let caller;
+    if (callerSeat.state === 'value') {
+        if (!isPlainObject(callerSeat.value))
+            return undefined;
+        const callerLease = callerSeat.value.lease;
+        if (!nonEmpty(callerLease))
+            return undefined;
+        const wait = optionalSeat(callerSeat.value, 'retryAfterSec');
+        if (wait.state === 'value' && (typeof wait.value !== 'number' || !Number.isFinite(wait.value) || wait.value < 0))
+            return undefined;
+        caller = { lease: callerLease, ...(wait.state === 'value' ? { retryAfterSec: wait.value } : {}) };
+    }
+    return {
+        kind: 'present',
+        view: {
+            effectivePull,
+            effectiveRevision,
+            lease,
+            ...(health.state === 'value' ? { leaseHealth: health.value } : {}),
+            ...(mode.state === 'value' ? { failMode: mode.value } : {}),
+            usageReport,
+            issuer,
+            ...(caller !== undefined ? { caller } : {}),
+        },
+    };
+}
+const reader = createEngineCapReader({
+    name: 'centerWiring',
+    project: projectCenterWiringCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForCenterWiring(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedCenterWiring(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+function guarded(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    try {
+        const kind = reading.kind;
+        if (kind === 'not_reported' || kind === 'unobserved' || kind === 'none')
+            return { kind };
+        if (kind !== 'present')
+            return undefined;
+        const view = reading.view;
+        return isPlainObject(view) ? { kind: 'present', view } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function callerQuotaLease(reading) {
+    const r = guarded(reading);
+    if (r === undefined)
+        return 'unknown';
+    if (r.kind === 'none')
+        return 'no-lease';
+    if (r.kind !== 'present')
+        return 'unknown';
+    try {
+        const lease = r.view.lease;
+        if (lease === 'absent')
+            return 'no-lease';
+        if (lease !== 'configured')
+            return 'unknown';
+        const caller = r.view.caller;
+        if (!isPlainObject(caller))
+            return 'unknown';
+        const callerLease = caller.lease;
+        return callerLease === 'enforced' || callerLease === 'not-enforced' || callerLease === 'exhausted' || callerLease === 'unobserved' ? callerLease : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const WORD_DETAIL_MAX = 40;
+const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
+function healthClause(v) {
+    if (v === undefined)
+        return 'lease health not reported';
+    if (v === 'ok')
+        return 'the quota service is answering';
+    if (v === 'auth-rejected')
+        return "the quota service rejected this engine's credentials";
+    if (v === 'unreachable')
+        return 'the quota service could not be reached';
+    if (v === 'unobserved')
+        return 'no lease negotiated yet';
+    return nonEmpty(v) ? `lease health reported as "${word(v)}"` : 'lease health not reported';
+}
+function failModeClause(v) {
+    if (v === undefined)
+        return 'failure posture not reported';
+    if (v === 'closed')
+        return 'billed requests are refused while a budget cannot be confirmed';
+    if (v === 'open')
+        return 'billed requests are let through while a budget cannot be confirmed';
+    return nonEmpty(v) ? `failure posture reported as "${word(v)}"` : 'failure posture not reported';
+}
+export function centerWiringDoctorDetail(reading) {
+    const unobserved = 'center wiring not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this engine is connected to a configuration center is unknown';
+    const r = guarded(reading);
+    if (r?.kind === 'not_reported') {
+        return 'center wiring not reported by this engine — only newer engines advertise it; this does not say whether the engine is connected to a configuration center';
+    }
+    if (r?.kind === 'none') {
+        return 'no configuration center on this deployment — the engine runs on its own local configuration; no quota lease or usage reporting goes through a center';
+    }
+    if (r?.kind !== 'present')
+        return unobserved;
+    try {
+        const v = r.view;
+        const pull = v.effectivePull === true ? 'configuration pulled from the center' : 'latest configuration pull did not succeed (running on what it already had)';
+        const rev = v.effectiveRevision;
+        const revision = isPlainObject(rev) && typeof rev.version === 'number' && Number.isFinite(rev.version) ? `revision ${String(rev.version)} in effect` : 'no revision in effect yet';
+        const lease = v.lease;
+        const leasePart = lease === 'absent'
+            ? 'quota lease not configured'
+            : lease === 'configured'
+                ? `quota lease configured (${healthClause(v.leaseHealth)}; ${failModeClause(v.failMode)})`
+                : nonEmpty(lease)
+                    ? `quota lease reported as "${word(lease)}"`
+                    : 'quota lease not reported';
+        const usage = v.usageReport === true ? 'usage reporting on' : 'usage reporting off';
+        const iss = v.issuer;
+        const issuer = iss === 'explicit'
+            ? 'token issuer set explicitly'
+            : iss === 'fallback'
+                ? 'token issuer defaults to the center'
+                : nonEmpty(iss)
+                    ? `token issuer reported as "${word(iss)}"`
+                    : 'token issuer not reported';
+        return `connected to a configuration center — ${pull}, ${revision} · ${leasePart} · ${usage} · ${issuer}`;
+    }
+    catch {
+        return unobserved;
+    }
+}
+export function forgetCenterWiringReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetCenterWiringReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/decideFailureNote.js

@@ -1,13 +1,16 @@
 import { corruptStoredRowContent, corruptStoredRowWhere } from './wireErrorTriage.js';
 import { parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
+import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
     const startup = parkedResumeStartupFromError(err, decision);
     const moved = decideParkMovedFromError(err);
+    const bucket = settingsPermissionBucketRefusalFromError(err);
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
+        (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`));
 }