@sema-agent/client-core 0.81.1 → 0.82.1

package/dist/fileHistoryCaptureCapability.d.ts

@@ -0,0 +1,18 @@
+export type FileHistoryCaptureReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    word: string;
+};
+export type FileHistoryCaptureMode = 'off' | 'on-always' | 'unknown';
+export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
+export declare function noteEngineCapsForFileHistoryCapture(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
+export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
+export declare function fileHistoryCaptureDoctorDetail(reading: FileHistoryCaptureReading): string;
+export declare function forgetFileHistoryCaptureReading(baseUrl: string | undefined): void;
+export declare function __resetFileHistoryCaptureReadingsForTests(): void;

package/dist/fileHistoryCaptureCapability.js

@@ -0,0 +1,58 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectFileHistoryCaptureCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'fileHistoryCapture'))
+        return { kind: 'not_reported' };
+    const v = caps.fileHistoryCapture;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'string' || v.length === 0)
+        return undefined;
+    return { kind: 'present', word: v };
+}
+const reader = createEngineCapReader({
+    name: 'fileHistoryCapture',
+    project: projectFileHistoryCaptureCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForFileHistoryCapture(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedFileHistoryCapture(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function fileHistoryCaptureMode(reading) {
+    if (reading.kind !== 'present')
+        return 'unknown';
+    if (reading.word === 'off')
+        return 'off';
+    if (reading.word === 'on-always')
+        return 'on-always';
+    return 'unknown';
+}
+const WORD_DETAIL_MAX = 40;
+export function fileHistoryCaptureDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';
+        case 'not_reported':
+            return 'file history capture not reported by this engine — only newer engines advertise it; this does not say whether file history is captured here';
+        case 'present':
+            if (reading.word === 'off') {
+                return 'file history capture off on this deployment — the engine takes no snapshots of the files it changes; whether code can be rewound here is answered separately by the rewind readings';
+            }
+            if (reading.word === 'on-always') {
+                return 'file history capture always on — the engine snapshots files before changing them in every session, and it cannot be turned off for a single session here';
+            }
+            return `file history capture reported as "${capForDisplay(reading.word, WORD_DETAIL_MAX)}" — a mode this client does not know yet, so whether it captures is shown as unknown`;
+    }
+}
+export function forgetFileHistoryCaptureReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetFileHistoryCaptureReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/gateOutcome.js

@@ -146,6 +146,8 @@ export function ccToolDenialKindForToolEnd(frame) {
     const stamped = frame._sema_denial_kind;
     if (isCcToolDenialKind(stamped))
         return stamped;
+    if (frame._sema_denial_unclassified === true)
+        return undefined;
     const outcome = gateOutcomeOf(frame);
     const kind = outcome?.settlement?.kind;
     if (kind === 'human_refused')
@@ -156,11 +158,29 @@ export function ccToolDenialKindForToolEnd(frame) {
     const settlementAbsent = typeof rawGate === 'object' && rawGate !== null && rawGate.settlement === undefined;
     if (outcome !== undefined && settlementAbsent && outcome.disposition.kind === 'denied') {
         const by = outcome.disposition.deniedBy;
-        if (by !== 'ask_resolution' && isGateDeniedByWord(by))
-            return ccToolDenialKindForSettledBy('policy');
+        if (by === 'ask_resolution' || !isGateDeniedByWord(by))
+            return undefined;
+        if (DENIED_BY_MAY_CARRY_CAUSE.has(by)) {
+            const rawDisposition = rawKeyOf(rawGate, 'disposition');
+            if (rawKeyOf(rawDisposition, 'cause') !== undefined) {
+                const cause = outcome.disposition.cause;
+                if (cause === 'unavailable')
+                    return 'automode-unavailable';
+                if (cause === 'parse_error')
+                    return 'automode-parsing-error';
+                return undefined;
+            }
+            if (by === 'classifier')
+                return 'automode-blocked';
+            if (rawKeyOf(rawDisposition, 'classifier') !== undefined)
+                return undefined;
+        }
+        return ccToolDenialKindForSettledBy('policy');
     }
     return undefined;
 }
+const rawKeyOf = (holder, key) => typeof holder === 'object' && holder !== null ? holder[key] : undefined;
+const DENIED_BY_MAY_CARRY_CAUSE = new Set(['classifier', 'policy']);
 const _gateOutcomeShapePin = (w) => w;
 void _gateOutcomeShapePin;
 const _settlementWordMirrorPin = SETTLEMENT_KIND_WORDS;

package/dist/hitl/askGateWire.d.ts

@@ -8,7 +8,7 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {

package/dist/hitl/askGateWire.js

@@ -6,7 +6,7 @@ export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
 export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();
     const taskId = { current: opts?.taskId };

package/dist/hitl/hitlHostSurface.js

@@ -1,6 +1,7 @@
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 import { HitlSafetyError } from './hitlBridge.js';
 const hostSurfaceByKey = createSessionSlot();
 const hostSurfaceMissesByKey = new Map();
@@ -38,8 +39,8 @@ export const CANCEL_DENY_BUDGET_MS = 2000;
 export const CANCEL_DENY_WARN_TEXT = 'could not cancel the pending question — the session may stay locked; the run may need engine-side recovery';
 const CANCEL_DENY_WARN_KEY = 'hitl-cancel-deny-warn';
 const CANCEL_DENY_WARN_TIMEOUT_MS = 10_000;
-function surfaceCancelDenyWarn() {
-    surfaceSelfClearingWarn(CANCEL_DENY_WARN_KEY, CANCEL_DENY_WARN_TEXT, CANCEL_DENY_WARN_TIMEOUT_MS);
+function surfaceCancelDenyWarn(text = CANCEL_DENY_WARN_TEXT) {
+    surfaceSelfClearingWarn(CANCEL_DENY_WARN_KEY, text, CANCEL_DENY_WARN_TIMEOUT_MS);
 }
 function surfaceSelfClearingWarn(key, text, timeoutMs) {
     try {
@@ -112,8 +113,9 @@ export function observeCancelByDeny(settle, taskId) {
             hostLog('debug', `[hitl-cancel-deny] cancel-by-deny no_pending for run ${taskId} (benign — already resolved)`);
             return;
         }
-        hostLog('error', `[hitl-cancel-deny] cancel-by-deny FAILED for run ${taskId}: ${String(e)}`);
-        surfaceCancelDenyWarn();
+        const rowNote = decideFailureNote(e);
+        hostLog('error', `[hitl-cancel-deny] cancel-by-deny FAILED for run ${taskId}: ${String(e)}${rowNote}`);
+        surfaceCancelDenyWarn(`${CANCEL_DENY_WARN_TEXT}${rowNote}`);
     })
         .finally(() => {
         if (timer !== undefined)

package/dist/hitl/parkResolver.d.ts

@@ -33,6 +33,7 @@ export type GateOutcome = {
     currentPending?: GateCurrentPending | undefined;
 };
 export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
+export declare function isGateStandingErrorCode(code: string | null | undefined): boolean;
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;
 export type ParkResolution = {
     kind: 'reattach';

package/dist/hitl/parkResolver.js

@@ -1,5 +1,6 @@
 import { putOwnKey } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
+import { RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -7,6 +8,7 @@ import { observeCancelByDeny } from './hitlHostSurface.js';
 import { flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
 import { readDecideReceipt } from '../decideReceipt.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 export const MAX_GATE_HOPS = 2;
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
@@ -40,7 +42,14 @@ function alreadyResolvedReasonToken(reason) {
 }
 function isAlreadyResolvedFailure(outcome) {
     const code = 'code' in outcome && isGateFailureCode(outcome.code) ? outcome.code : undefined;
-    return code !== undefined ? code === 'no_pending' : isAlreadyResolvedGateReason(outcome.reason);
+    if (code !== undefined)
+        return code === 'no_pending';
+    if ('errorCode' in outcome && isGateStandingErrorCode(outcome.errorCode))
+        return false;
+    return isAlreadyResolvedGateReason(outcome.reason);
+}
+export function isGateStandingErrorCode(code) {
+    return code === RESUME_POLICY_FOLD_CODE || code === 'corrupt';
 }
 export function toAnsweredOutput(questions, answer) {
     const answers = {};
@@ -140,7 +149,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
             kind: 'failed',
             stage: 'decide',
             gatedCallId,
-            reason: `decide failed: ${String(e)}`,
+            reason: `decide failed: ${String(e)}${decideFailureNote(e)}`,
             ...(code !== undefined ? { code } : {}),
             ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
             ...(currentPending !== undefined ? { currentPending } : {}),

package/dist/hitl/planReviewWire.js

@@ -3,6 +3,8 @@ import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
+import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 import { isPlanReviewModeAfter } from './hitlBridge.js';
 import { engineCapString } from '../engineCapsCache.js';
 import { planReviewQuestionId, REOPEN_ID_TAIL } from './gateIdentity.js';
@@ -326,11 +328,17 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                         `This ${decision} was not applied: the engine no longer has a pending plan review for this task — an earlier decision most likely already went through (or the review expired). ` +
                             'This is NOT a rejection of the plan and NOT a failure of the task; the answer just given simply had nothing left to act on.';
                 }
+                else if (typeof status === 'number' && corruptStoredRowWhere(e) !== undefined) {
+                    const where = corruptStoredRowWhere(e);
+                    hostLog('debug', `planReviewWire: ${decision} → ${String(status)} corrupt (stored resume context unreadable)`);
+                    effect = 'not_applied';
+                    outcome = `This ${decision} was not applied. ${corruptStoredRowContent(where)}`;
+                }
                 else if (typeof status === 'number') {
                     const msg = e instanceof Error ? e.message : String(e);
                     hostLog('debug', `planReviewWire: ${decision} → ${status} ${msg.slice(0, 200)}`);
                     effect = status >= 400 && status < 500 ? 'not_applied' : 'unconfirmed';
-                    outcome = `The plan_review decision failed: HTTP ${status} ${msg}`.trim();
+                    outcome = `${`The plan_review decision failed: HTTP ${status} ${msg}`.trim()}${decideFailureNote(e)}`;
                 }
                 else {
                     outcome = `The plan_review decision could not reach the engine: ${String(e)}`;
@@ -375,6 +383,11 @@ export function reopenPlanReviewCard(taskId, opts) {
         if (typeof taskId !== 'string' || taskId.length === 0) {
             return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
         }
+        if (decideInFlight.has(taskId)) {
+            hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — a decision for this task is in flight (its answer is still being delivered)`);
+            const refused = { reopened: false, _sema_decisionInFlight: true };
+            return receiptMs === undefined ? refused : Promise.resolve(refused);
+        }
         const sessionKey = opts?.sessionKey ?? DEFAULT_SESSION_KEY;
         if (!hasQuestionOverlayFor(sessionKey)) {
             return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });

package/dist/hitl/toolApprovalWire.js

@@ -7,6 +7,7 @@ import { observeCancelByDeny, surfaceRememberNotApplied, surfaceEditNotForwarded
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { isRuleStoreUnreadableKind } from '../gateVocabulary.js';
 import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, DENIAL_LIMIT_KINDS, } from '@sema-agent/sdk';
 export function isFsApprovalGate(gate) {
@@ -199,7 +200,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                     kind: 'failed',
                     stage: 'decide',
                     gatedCallId,
-                    reason: `decide(approve) failed: ${String(e)}`,
+                    reason: `decide(approve) failed: ${String(e)}${decideFailureNote(e)}`,
                     ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                     ...(currentPending !== undefined ? { currentPending } : {}),
                     ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
@@ -256,7 +257,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                     kind: 'failed',
                     stage: 'decide',
                     gatedCallId,
-                    reason: `decide(deny) failed: ${String(e)}`,
+                    reason: `decide(deny) failed: ${String(e)}${decideFailureNote(e)}`,
                     ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                     ...(currentPending !== undefined ? { currentPending } : {}),
                     ...(wireCode !== undefined ? { errorCode: wireCode } : {}),

package/dist/index.d.ts

@@ -77,6 +77,9 @@ export * from './promptProfileWireCaps.js';
 export * from './retainBackgroundWireCaps.js';
 export * from './oneShotWireCaps.js';
 export * from './rewindWireCaps.js';
+export * from './rewindArchiveCapability.js';
+export * from './fileHistoryCaptureCapability.js';
+export * from './registryQuotaUsage.js';
 export * from './selfOrchestrationWireCaps.js';
 export * from './skillsWireCaps.js';
 export * from './ultracodeWireCaps.js';
@@ -84,6 +87,7 @@ export * from './selfOrchestrationDenial.js';
 export * from './webSearchWireCaps.js';
 export * from './liveModelCatalog.js';
 export * from './modelBudgetRule.js';
+export * from './modelIdentityResolvability.js';
 export * from './sessionModelLatch.js';
 export * from './effortWire.js';
 export * from './adapter/types.js';

package/dist/index.js

@@ -76,6 +76,9 @@ export * from './promptProfileWireCaps.js';
 export * from './retainBackgroundWireCaps.js';
 export * from './oneShotWireCaps.js';
 export * from './rewindWireCaps.js';
+export * from './rewindArchiveCapability.js';
+export * from './fileHistoryCaptureCapability.js';
+export * from './registryQuotaUsage.js';
 export * from './selfOrchestrationWireCaps.js';
 export * from './skillsWireCaps.js';
 export * from './ultracodeWireCaps.js';
@@ -83,6 +86,7 @@ export * from './selfOrchestrationDenial.js';
 export * from './webSearchWireCaps.js';
 export * from './liveModelCatalog.js';
 export * from './modelBudgetRule.js';
+export * from './modelIdentityResolvability.js';
 export * from './sessionModelLatch.js';
 export * from './effortWire.js';
 export * from './adapter/types.js';

package/dist/modelIdentityResolvability.d.ts

@@ -0,0 +1,31 @@
+type ModelIdentityLaneTuple = readonly [
+    'processEnv',
+    'settingsEnv',
+    'modelCatalogFile',
+    'followedSettingsFile',
+    'followedProviderEnv'
+];
+export type ModelIdentityLane = ModelIdentityLaneTuple[number];
+export type ModelIdentityLaneReading = 'complete' | 'partial' | 'absent' | 'unreadable';
+export type ModelIdentityLanes = {
+    [L in ModelIdentityLane]: L extends 'modelCatalogFile' ? Exclude<ModelIdentityLaneReading, 'complete'> : ModelIdentityLaneReading;
+};
+export type EngineAnswerObservation = 'answered' | 'not_observed' | 'unreachable';
+export interface LocalEngineModelIdentityReading {
+    engine: 'local';
+    lanes: ModelIdentityLanes;
+    engineAnswer?: EngineAnswerObservation;
+}
+export interface RemoteEngineModelIdentityReading {
+    engine: 'remote';
+    engineAnswer: EngineAnswerObservation;
+}
+export type ModelIdentityReading = LocalEngineModelIdentityReading | RemoteEngineModelIdentityReading;
+export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unknown';
+export type ModelSetupDecision = 'offer_setup' | 'explain_unconfigured' | 'proceed';
+export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
+export declare function modelIdentityDetail(reading: ModelIdentityReading): string;
+export declare function modelSetupDecision(identity: ModelIdentityResolvability, hostCanConfigureModel: boolean): ModelSetupDecision;
+export declare function modelSetupNotice(decision: ModelSetupDecision): string | null;
+export declare function observedEngineAnswer(baseUrl?: string | undefined): EngineAnswerObservation;
+export {};

package/dist/modelIdentityResolvability.js

@@ -0,0 +1,145 @@
+import { engineCapValue } from './engineCapsCache.js';
+import { engineWireTarget } from './engineWireTarget.js';
+function laneOrder() {
+    return ['processEnv', 'settingsEnv', 'modelCatalogFile', 'followedSettingsFile', 'followedProviderEnv'];
+}
+function malformed() {
+    return { verdict: 'unknown', why: 'malformed' };
+}
+function own(o, key) {
+    if (!Object.hasOwn(o, key))
+        return undefined;
+    return { v: o[key] };
+}
+function isPlainObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function laneState(lanes, lane) {
+    const hit = own(lanes, lane);
+    if (hit === undefined)
+        return 'not_reported';
+    const v = hit.v;
+    const _catalogPin = true;
+    void _catalogPin;
+    if (v === 'complete')
+        return lane === 'modelCatalogFile' ? 'unusable' : v;
+    return v === 'partial' || v === 'absent' || v === 'unreadable' ? v : 'unusable';
+}
+function analyse(reading) {
+    try {
+        if (!isPlainObject(reading))
+            return malformed();
+        const answer = own(reading, 'engineAnswer')?.v;
+        if (answer === 'answered')
+            return { verdict: 'resolvable', why: 'engine_answered' };
+        const engine = own(reading, 'engine')?.v;
+        if (engine === 'remote') {
+            return { verdict: 'unknown', why: 'remote', answer: answer === 'unreachable' ? 'unreachable' : 'not_observed' };
+        }
+        if (engine !== 'local')
+            return malformed();
+        const lanesHit = own(reading, 'lanes')?.v;
+        const order = laneOrder();
+        if (!isPlainObject(lanesHit))
+            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [] };
+        const partial = [];
+        const unreadable = [];
+        const unreported = [];
+        const unusable = [];
+        for (const lane of order) {
+            const s = laneState(lanesHit, lane);
+            if (s === 'complete')
+                return { verdict: 'resolvable', why: 'lane', lane };
+            if (s === 'partial')
+                partial.push(lane);
+            else if (s === 'unreadable')
+                unreadable.push(lane);
+            else if (s === 'not_reported')
+                unreported.push(lane);
+            else if (s === 'unusable')
+                unusable.push(lane);
+        }
+        if (unreadable.length > 0 || unreported.length > 0 || unusable.length > 0) {
+            return { verdict: 'unknown', why: 'lanes', unreadable, unreported, unusable };
+        }
+        return { verdict: 'not_resolvable', partial };
+    }
+    catch {
+        return malformed();
+    }
+}
+export function modelIdentityResolvability(reading) {
+    return analyse(reading).verdict;
+}
+function laneLabel(lane) {
+    switch (lane) {
+        case 'processEnv':
+            return 'the environment this client was started with';
+        case 'settingsEnv':
+            return "this client's settings file";
+        case 'modelCatalogFile':
+            return 'the local model catalog file';
+        case 'followedSettingsFile':
+            return "another tool's settings file that this client follows";
+        case 'followedProviderEnv':
+            return 'the provider environment variables this client follows';
+    }
+}
+function joinPhrases(xs) {
+    if (xs.length <= 1)
+        return xs.join('');
+    return `${xs.slice(0, -1).join(', ')} and ${xs[xs.length - 1]}`;
+}
+export function modelIdentityDetail(reading) {
+    const a = analyse(reading);
+    switch (a.verdict) {
+        case 'resolvable':
+            if (a.why === 'engine_answered') {
+                return 'the engine is up and answering, and it does not start without a model name, so it has one — whether its gateway accepts that name is a separate check';
+            }
+            return `${laneLabel(a.lane)} supplies a model name, so the local engine can start with it — whether its gateway accepts that name is a separate check`;
+        case 'not_resolvable':
+            if (a.partial.length > 0) {
+                const labels = joinPhrases(a.partial.map(laneLabel));
+                return `no model name is configured for the local engine — ${labels} ${a.partial.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name, and the engine does not start without one`;
+            }
+            return 'no model name is configured for the local engine — none of the places this client reads supplies one, and the engine does not start without it';
+        case 'unknown':
+            if (a.why === 'remote') {
+                return a.answer === 'unreachable'
+                    ? 'the engine runs elsewhere and did not answer — it may be unreachable or may have failed to start; its model configuration lives with that deployment, so whether it has a model name is unknown'
+                    : 'the engine runs elsewhere and has not been seen answering yet — its model configuration lives with that deployment, so whether it has a model name is unknown';
+            }
+            if (a.why === 'lanes') {
+                const parts = [
+                    ...a.unreadable.map((l) => `${laneLabel(l)} could not be read`),
+                    ...a.unreported.map((l) => `${laneLabel(l)} was not reported`),
+                    ...a.unusable.map((l) => `${laneLabel(l)} gave no usable reading`),
+                ];
+                return `whether the local engine has a model name is unknown — ${joinPhrases(parts)}, and no other place this client reads provides one`;
+            }
+            return "this reading of the engine's model configuration could not be interpreted, so whether the engine has a model name is unknown";
+    }
+}
+export function modelSetupDecision(identity, hostCanConfigureModel) {
+    if (identity !== 'not_resolvable')
+        return 'proceed';
+    if (hostCanConfigureModel === true)
+        return 'offer_setup';
+    if (hostCanConfigureModel === false)
+        return 'explain_unconfigured';
+    return 'proceed';
+}
+export function modelSetupNotice(decision) {
+    switch (decision) {
+        case 'offer_setup':
+            return 'no model name is configured for the engine, and it does not start without one — opening model setup';
+        case 'explain_unconfigured':
+            return 'this engine has no model configured, and it cannot be configured from this client — ask whoever runs the engine to set one up';
+        default:
+            return null;
+    }
+}
+export function observedEngineAnswer(baseUrl = engineWireTarget()?.baseUrl) {
+    return engineCapValue(baseUrl, 'version').kind === 'unobserved' ? 'not_observed' : 'answered';
+}

package/dist/printToolResultFrame.js

@@ -1,6 +1,8 @@
 import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
+import { parseModelFacingBash } from './toolResult.js';
+import { toolResultEnvelopeParts, toolResultOutcomeOf } from './adapt/toolCards.js';
 function bashExitCodeFailed(toolName, text, structured) {
     if (typeof toolName !== 'string' || toolName.toLowerCase() !== 'bash')
         return false;
@@ -10,6 +12,8 @@ function bashExitCodeFailed(toolName, text, structured) {
     const ec = st?.exitCode;
     if (typeof ec === 'number')
         return ec !== 0;
+    if (parseModelFacingBash(text)?.note !== undefined)
+        return false;
     const m = /^exit code: (\d+)\b/.exec(text);
     return m !== null && m[1] !== '0';
 }
@@ -17,6 +21,14 @@ export function toolEndResultToUserFrame(arm) {
     if (typeof arm.toolCallId !== 'string' || arm.toolCallId.length === 0)
         return null;
     const text = flattenWireOutput(arm.output);
+    const parent = typeof arm.parentToolCallId === 'string' ? arm.parentToolCallId : null;
+    const outcome = toolResultOutcomeOf(typeof arm.toolName === 'string' ? arm.toolName : '', {
+        output: arm.output,
+        structured: arm.structured,
+        truncated: arm.truncated === true,
+        isError: arm.isError === true,
+    }, undefined, parent === null ? 'leader' : 'subagent');
+    const envelope = toolResultEnvelopeParts(outcome);
     return {
         type: 'user',
         message: {
@@ -30,8 +42,10 @@ export function toolEndResultToUserFrame(arm) {
                 },
             ],
         },
-        parent_tool_use_id: typeof arm.parentToolCallId === 'string' ? arm.parentToolCallId : null,
+        parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
+        ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
+        ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: arm.uuid,
         session_id: arm.session_id,
     };

package/dist/registryQuotaUsage.d.ts

@@ -0,0 +1,44 @@
+export type QuotaAmount = {
+    kind: 'value';
+    value: number;
+} | {
+    kind: 'unlimited';
+} | {
+    kind: 'unknown';
+};
+export type QuotaResetAt = {
+    kind: 'at';
+    iso: string;
+} | {
+    kind: 'not-exhausted';
+} | {
+    kind: 'unknown';
+};
+export interface QuotaWindowReading {
+    readonly window: 'fiveHour' | 'weekly';
+    readonly limit: QuotaAmount;
+    readonly used: QuotaAmount;
+    readonly remaining: QuotaAmount;
+    readonly exhausted: boolean | undefined;
+    readonly resetAt: QuotaResetAt;
+    readonly isEstimate: boolean | undefined;
+}
+export type QuotaConfigured = 'configured' | 'not-configured' | 'unknown';
+export interface QuotaUsageReading {
+    readonly principal: string | undefined;
+    readonly configured: QuotaConfigured;
+    readonly source: string | undefined;
+    readonly fiveHour: QuotaWindowReading;
+    readonly weekly: QuotaWindowReading;
+    readonly lastResetAt: {
+        kind: 'at';
+        iso: string;
+    } | {
+        kind: 'never';
+    } | {
+        kind: 'unknown';
+    };
+}
+export declare function projectRegistryQuotaUsage(body: unknown): QuotaUsageReading | undefined;
+export declare function quotaAmountText(amount: QuotaAmount): string;
+export declare function registryQuotaDoctorDetail(reading: QuotaUsageReading | undefined): string;