@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/hitl/toolApprovalWire.js

@@ -1,22 +1,22 @@
-import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, NO_APPROVAL_CARD_PORT_REASON, HitlSafetyError, denyReasonForWire, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
+import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, NO_APPROVAL_CARD_PORT_REASON, denyReasonForWire, findPendingForTask, hitlSafetyCodeOf, readDecideCurrentPending, readWireErrorCode, readWireErrorCodeReading, } from './hitlBridge.js';
 import { askParkRowArm } from './askParkRowRouting.js';
 import { hostLog } from '../host.js';
-import { readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
+import { readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPair } from './askClassPair.js';
-import { legacyShadowedRuleTextOf, readAllowRuleShadowFromWire } from './allowRuleShadow.js';
+import { readAllowRuleShadowFromWire } from './allowRuleShadow.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
 import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted } from '../displayUntrusted.js';
-import { approvalDecisionHolds, holdLiveCard, joinLiveCard, liveCardHoldOf } from './approvalHolds.js';
+import { approvalDecisionHolds, awaitLiveCardHolder, holdLiveCard, joinLiveCard, liveCardHoldFor, liveCardHoldOf } from './approvalHolds.js';
 import { approvalResolutionOf } from './approvalResolution.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
 import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
-import { wireFailureTextsOf } from '../wireFailureShape.js';
-import { refusalSaysStillPending } from '../engineErrorCodes.js';
+import { thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, refusalSaysStillPending } from '../engineErrorCodes.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, PERSISTED_RULE_MANDATES, } from '@sema-agent/sdk';
 export function isFsApprovalGate(gate) {
@@ -132,17 +132,26 @@ function cardPortMissReason() {
         return APPROVAL_CARD_PORT_KEY_MISMATCH_REASON;
     return NO_APPROVAL_CARD_PORT_REASON;
 }
-function rememberRefusedByServer(e) {
-    switch (readWireErrorCode(e)) {
-        case 'remember_not_in_proof':
-        case 'remember_requires_binding':
-        case 'capability.store_required':
-        case 'decide.workflow_remember_unsupported':
-        case 'decide.parked_remember_unsupported':
-            return true;
-        default:
-            return false;
-    }
+const REMEMBER_REFUSAL_CODES = Object.freeze([
+    'remember_not_in_proof',
+    'remember_requires_binding',
+    'capability.store_required',
+    DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
+    'decide.parked_remember_unsupported',
+]);
+export function rememberRefusalOf(error) {
+    return rememberRefusalIn(readWireErrorCodeReading(error));
+}
+function rememberRefusalIn(reading) {
+    return reading.state === 'code' ? REMEMBER_REFUSAL_CODES.find((c) => c === reading.code) : undefined;
+}
+function rememberFallbackKind(e) {
+    const reading = readWireErrorCodeReading(e);
+    if (rememberRefusalIn(reading) !== undefined)
+        return 'refused';
+    if (reading.state !== 'absent')
+        return undefined;
+    return readToolApprovalRespondRefusal(e)?.status === 400 ? 'legacy' : undefined;
 }
 function logAfterDecided(msg) {
     try {
@@ -281,6 +290,13 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         return { kind: 'failed', stage: 'fetch', reason: found.reason, ...(found.code !== undefined ? { code: found.code } : {}) };
     if (held !== undefined)
         return joinDurableDecision(held, deps, signal);
+    const liveHolder = liveCardHoldFor(parkRowHolderIdentity(found.pending, found.gatedCallId));
+    if (liveHolder !== undefined) {
+        const joined = await awaitLiveCardHolder(liveHolder, signal);
+        if (joined !== undefined)
+            return fsOutcomeOfJoinedLiveCard(joined, found.gatedCallId);
+        return surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signal, parkGatedCallId);
+    }
     const callKey = approvalCallKey(found.gatedCallId, taskId);
     const fetched = found;
     return holdDurableDecision(durableHoldKey(fetched.pending, callKey), signal, async (hold) => {
@@ -290,6 +306,33 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         return out;
     });
 }
+function parkRowHolderIdentity(row, gatedCallId) {
+    return {
+        ...(typeof row.taskId === 'string' && row.taskId !== '' ? { taskId: row.taskId } : {}),
+        ...(gatedCallId !== undefined && gatedCallId !== '' ? { toolCallId: gatedCallId } : {}),
+        ...(typeof row.sessionId === 'string' && row.sessionId !== '' ? { sessionId: row.sessionId } : {}),
+    };
+}
+function fsOutcomeOfJoinedLiveCard(o, gatedCallId) {
+    if (o.aborted === true)
+        return { kind: 'aborted', gatedCallId, joinedInFlight: true };
+    if (o.decision === 'unresolved')
+        return { kind: 'retracted', gatedCallId, joinedInFlight: true };
+    return {
+        kind: 'decided',
+        gatedCallId,
+        ...(o.decision === 'deny'
+            ? {
+                denied: true,
+                ...(o.denySettledBy !== undefined ? { denySettledBy: o.denySettledBy } : {}),
+                ...(o.denyReason !== undefined ? { denyReason: o.denyReason } : {}),
+            }
+            : {}),
+        ...(o.denyAttributionDropped === true ? { denyAttributionDropped: true } : {}),
+        ...(o.denyAttributionRenamed === true ? { denyAttributionRenamed: true } : {}),
+        joinedInFlight: true,
+    };
+}
 async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, found, decidedByReading, callKey, hold, ledgerSlot) {
     const { pending, gatedCallId } = found;
     const toolName = typeof pending.toolName === 'string' ? pending.toolName : '';
@@ -329,16 +372,15 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
         ...(pending.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
         ...(hasOwnStrictTrue(pending, 'mandated') ? { mandated: true } : {}),
         ...((w) => (w !== undefined ? { mandate: w } : {}))(readApprovalMandate(pending)),
-        ...((o) => (o !== undefined ? { origin: o } : {}))(readOwnNonEmptyString(pending, 'origin')),
+        ...((o) => (o !== undefined ? { origin: o } : {}))(readAskOrigin(pending)),
         ...(readAskClassPair(pending) ?? {}),
         ...(pending.gateKind === 'irreversible_ask' ? { irreversibleParkGate: true } : {}),
         ...(pending.hasBidiControls === true ? { hasBidiControls: true } : {}),
         ...(ruleOffersReadOnly !== undefined ? { ruleOffersReadOnly } : {}),
         ...(isWireRecordCarrier(durableProbeCause) ? { probeCause: durableProbeCause } : {}),
         ...(durableProbeReason !== undefined ? { probeReason: durableProbeReason } : {}),
-        ...(readRememberRefused(pending) ? { rememberRefused: true } : {}),
+        ...(readApprovalRememberRefused(pending) ? { rememberRefused: true } : {}),
         ...(durableShadow !== undefined ? { allowRuleShadow: durableShadow } : {}),
-        ...((t) => (t !== undefined ? { persistedRuleShadowed: t } : {}))(legacyShadowedRuleTextOf(durableShadow)),
         ...(typeof durableRuleOffersAbsence === 'string' && durableRuleOffersAbsence !== ''
             ? { ruleOffersAbsence: durableRuleOffersAbsence }
             : {}),
@@ -379,12 +421,11 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                             sessionDecided = true;
                         }
                         catch (e) {
-                            if (e instanceof HitlSafetyError || e instanceof DecideTransportRetryExhaustedError)
-                                throw e;
-                            if (readDecideCurrentPending(e) !== undefined)
+                            const fallbackKind = rememberFallbackKind(e);
+                            if (fallbackKind === undefined)
                                 throw e;
-                            rememberRefused = rememberRefusedByServer(e);
-                            logAfterDecided(`liveToolApprovalWire: decide(approve+remember) failed (${String(e)}) — falling back to plain approve`);
+                            rememberRefused = fallbackKind === 'refused';
+                            logAfterDecided(`liveToolApprovalWire: decide(approve+remember) refused the remember part (${String(e)}) — falling back to plain approve`);
                         }
                         if (sessionDecided) {
                             if (sessionReceipt?.rememberApplied === false)
@@ -402,7 +443,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     const currentPending = readDecideCurrentPending(e);
                     const wireCode = readWireErrorCode(e);
                     const wireRetriable = typeof e === 'object' && e !== null && refusalSaysStillPending(e);
-                    const safetyCode = e instanceof HitlSafetyError ? e.code : undefined;
+                    const safetyCode = hitlSafetyCodeOf(e);
                     const failureTexts = wireFailureTextsOf(e);
                     hostLog('debug', `liveToolApprovalWire: decide(approve) failed: ${failureTexts.log}`);
                     return {
@@ -410,7 +451,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                         stage: 'decide',
                         gatedCallId,
                         reason: `decide(approve) failed: ${failureTexts.reason}${decideFailureNote(e, 'approve')}`,
-                        ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                        ...(thrownIsInstanceOf(e, DecideTransportRetryExhaustedError) ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
                         ...(wireRetriable ? { retriable: true } : {}),
@@ -488,7 +529,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     const currentPending = readDecideCurrentPending(e);
                     const wireCode = readWireErrorCode(e);
                     const wireRetriable = typeof e === 'object' && e !== null && refusalSaysStillPending(e);
-                    const safetyCode = e instanceof HitlSafetyError ? e.code : undefined;
+                    const safetyCode = hitlSafetyCodeOf(e);
                     const attributionRefusal = denyAttributionRefusalFromError(e, lastSendCarriedAttribution);
                     const failureTexts = wireFailureTextsOf(e);
                     hostLog('debug', `liveToolApprovalWire: decide(deny) failed: ${failureTexts.log}`);
@@ -497,7 +538,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                         stage: 'decide',
                         gatedCallId,
                         reason: `decide(deny) failed: ${failureTexts.reason}${decideFailureNote(e, 'deny')}`,
-                        ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                        ...(thrownIsInstanceOf(e, DecideTransportRetryExhaustedError) ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
                         ...(wireRetriable ? { retriable: true } : {}),
@@ -562,6 +603,7 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'serverNowMs',
     'delegation',
     'outcome',
+    'cause',
 ];
 const _mirrorPin = [true, true];
 void _mirrorPin;
@@ -588,7 +630,7 @@ export function toolPermissionRequestAskBits(card) {
         return {};
     const mandated = hasOwnStrictTrue(card, 'mandated');
     const mandate = readApprovalMandate(card);
-    const origin = readOwnNonEmptyString(card, 'origin');
+    const origin = readAskOrigin(card);
     const ruleOffersAbsence = readOwnNonEmptyString(card, 'ruleOffersAbsence');
     const askClassPair = readAskClassPair(card);
     return {
@@ -874,7 +916,7 @@ export function askProbeReasonDetail(card) {
     const head = 'An automatic check could not clear this call, so it is asking you; the engine did not say the specific reason';
     return typeof code === 'string' && PROBE_CAUSE_CODE_WORD.test(code) ? `${head} (check code: ${code}).` : `${head}.`;
 }
-function readRememberRefused(v) {
+export function readApprovalRememberRefused(v) {
     try {
         return typeof v === 'object' && v !== null && Object.hasOwn(v, 'rememberRefused') && v.rememberRefused === true;
     }
@@ -1208,19 +1250,55 @@ function subagentBadgeFor(frame) {
     return { name, color: 'cyan' };
 }
 const MAX_RESPOND_NOTE_CHARS = 2048;
-export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamArgs, signal, lane) {
+export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamArgs, signal, lane, run) {
     const approvalId = frame.approvalId;
-    const key = liveFrameCallKey(approvalId);
-    const held = liveCardHoldOf(key);
+    const held = liveCardHoldOf(liveFrameCallKey(approvalId));
     if (held !== undefined)
         return joinLiveCard(held, signal);
-    return holdLiveCard(key, signal, async (hold) => {
+    return holdLiveCard(liveCardIdentityOf(approvalId, frame, run), signal, async (hold) => {
         const slot = {};
         const out = await presentToolApprovalFrameAndRespond(frame, approvalId, respond, streamArgs, signal, lane, hold, slot);
         noteCallOutcome(slot, out);
         return out;
     });
 }
+function liveCardIdentityOf(approvalId, frame, run) {
+    const toolCallId = typeof frame.toolCallId === 'string' && frame.toolCallId !== '' ? frame.toolCallId : undefined;
+    const fromSubagent = isFromSubagent(frame);
+    const ownRun = fromSubagent ? frame.sourceTaskId : run?.taskId;
+    const taskId = typeof ownRun === 'string' && ownRun !== '' ? ownRun : undefined;
+    const sessionId = !fromSubagent && typeof run?.sessionId === 'string' && run.sessionId !== '' ? run.sessionId : undefined;
+    return {
+        approvalId,
+        ...(toolCallId !== undefined ? { toolCallId } : {}),
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(sessionId !== undefined ? { sessionId } : {}),
+    };
+}
+function readApprovalHolderIdentity(v) {
+    if (typeof v !== 'object' || v === null)
+        return {};
+    const out = {};
+    try {
+        for (const k of ['approvalId', 'taskId', 'toolCallId', 'sessionId']) {
+            const d = Object.getOwnPropertyDescriptor(v, k);
+            const x = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+            if (typeof x === 'string' && x !== '')
+                out[k] = x;
+        }
+    }
+    catch {
+        return {};
+    }
+    return out;
+}
+export async function joinApprovalHolder(identity, signal) {
+    const hold = liveCardHoldFor(readApprovalHolderIdentity(identity));
+    if (hold === undefined)
+        return { kind: 'free' };
+    const joined = await awaitLiveCardHolder(hold, signal);
+    return joined !== undefined ? { kind: 'joined', outcome: joined } : { kind: 'free' };
+}
 async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, streamArgs, signal, lane, hold, ledgerSlot) {
     const frameToolCallId = typeof frame.toolCallId === 'string' && frame.toolCallId !== '' ? frame.toolCallId : undefined;
     const decidedByReading = decidedByReadingSnapshotOf(lane);
@@ -1278,10 +1356,9 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
             : {}),
         ...(ruleOffers !== undefined ? { ruleOffers } : {}),
         ...((sh) => (sh !== undefined ? { allowRuleShadow: sh } : {}))(frameShadow),
-        ...((t) => (t !== undefined ? { persistedRuleShadowed: t } : {}))(legacyShadowedRuleTextOf(frameShadow)),
         ...(isWireRecordCarrier(frame.probeCause) ? { probeCause: frame.probeCause } : {}),
         ...((r) => (r !== undefined ? { probeReason: r } : {}))(readProbeReason(frame)),
-        ...(readRememberRefused(frame) ? { rememberRefused: true } : {}),
+        ...(readApprovalRememberRefused(frame) ? { rememberRefused: true } : {}),
         ...(isWireRecordCarrier(frame.ruleEvidence) ? { ruleEvidence: frame.ruleEvidence } : {}),
         ...(frame.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
         ...(hasOwnStrictTrue(frame, 'mandated') ? { mandated: true } : {}),
@@ -1292,7 +1369,7 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
             ? { ruleOffersAbsence: frame.ruleOffersAbsence }
             : {}),
         ...(denialLimitFallback !== undefined ? { denialLimitFallback } : {}),
-        ...((o) => (o !== undefined ? { origin: o } : {}))(readOwnNonEmptyString(frame, 'origin')),
+        ...((o) => (o !== undefined ? { origin: o } : {}))(readAskOrigin(frame)),
         ...(readAskClassPair(frame) ?? {}),
         ...((g) => (g !== undefined ? { boundGrants: g } : {}))(readApprovalBoundGrants(frame)),
         ...((w) => (w !== undefined ? { classifierNoRuling: w } : {}))(readApprovalClassifierNoRuling(frame)),

package/dist/hooksWireCaps.js

@@ -71,6 +71,35 @@ function startupModeWord(settings) {
     hostLog('debug', `hooksWireCaps: hooksStartupMode() returned ${describeStartupModeValue(v)}, which is neither 'safe' nor 'bare' — treated as neither mode (settings hooks not narrowed)`);
     return undefined;
 }
+const MANAGED_POLICY_STATES = ['absent', 'in-effect', 'unreadable'];
+const _managedPolicyStatesPin = [true, true];
+void _managedPolicyStatesPin;
+function managedPolicyUnreadable(settings) {
+    try {
+        const member = settings.managedPolicyReading;
+        if (member === undefined)
+            return false;
+        if (typeof member !== 'function') {
+            hostLog('debug', `hooksWireCaps: managedPolicyReading is ${describeStartupModeValue(member)}, not a method — fail-closed (no hooks projected to the engine)`);
+            return true;
+        }
+        const r = member.call(settings);
+        const state = typeof r === 'object' && r !== null && !Array.isArray(r) ? r.state : undefined;
+        const word = MANAGED_POLICY_STATES.find((w) => w === state);
+        if (word === 'absent' || word === 'in-effect')
+            return false;
+        if (word === 'unreadable') {
+            hostLog('debug', 'hooksWireCaps: managed policy layer reported unreadable — fail-closed (no hooks projected to the engine)');
+            return true;
+        }
+        hostLog('debug', `hooksWireCaps: managedPolicyReading() returned ${describeStartupModeValue(state)} as its state, which is none of 'absent' / 'in-effect' / 'unreadable' — fail-closed (no hooks projected to the engine)`);
+        return true;
+    }
+    catch (err) {
+        hostLog('debug', `hooksWireCaps: managedPolicyReading() threw — fail-closed (no hooks projected to the engine): ${String(err)}`);
+        return true;
+    }
+}
 function hooksOfSource(source) {
     try {
         const s = hostSettings()?.getSettingsForSource(source);
@@ -183,11 +212,12 @@ export function hooksWirePlan(opts = {}) {
     const shellRuns = (event, type) => {
         if (!shellEvents.has(event))
             return false;
-        const types = typesByEvent?.get(event);
+        if (typesByEvent === undefined)
+            return type !== 'prompt' && type !== 'agent';
+        const types = typesByEvent.get(event);
         return types === undefined || (typeof type === 'string' && types.has(type));
     };
-    const settingsShellRuns = typesByEvent !== undefined ? shellRuns : (event, type) => type !== 'prompt' && type !== 'agent' && shellRuns(event, type);
-    return buildHooksWirePlan(engine, shellRuns, true, promptAuthoredByUserOf(o), settingsShellRuns);
+    return buildHooksWirePlan(engine, shellRuns, true, promptAuthoredByUserOf(o));
 }
 function taskHooksCapability(baseUrl) {
     const v = engineCapValue(baseUrl, 'taskSettings');
@@ -218,7 +248,7 @@ function shellHookTypesOf(o) {
         return out;
     }
     catch (err) {
-        hostLog('debug', `hooksWirePlan: shellHookTypesByEvent is malformed — treated as absent (command and http hooks count as running on every reported event; prompt and agent hooks from settings stay with the engine): ${String(err)}`);
+        hostLog('debug', `hooksWirePlan: shellHookTypesByEvent is malformed — treated as absent (command and http hooks count as running on every reported event; prompt and agent hooks are not counted as running locally): ${String(err)}`);
         return undefined;
     }
 }
@@ -238,11 +268,11 @@ function promptAuthoredByUserOf(o) {
     }
     return true;
 }
-function buildHooksWirePlan(engine, shellRuns, withPlugins, promptAuthoredByUser, settingsShellRuns = shellRuns) {
+function buildHooksWirePlan(engine, shellRuns, withPlugins, promptAuthoredByUser) {
     const settingsDropped = [];
     const settingsVerdicts = [];
     const settingsExcluded = [];
-    const judge = withPlugins ? createSettingsHookJudge(engine, settingsShellRuns, promptAuthoredByUser) : undefined;
+    const judge = withPlugins ? createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser) : undefined;
     let settingsStripped = 0;
     const planOf = (pluginReader, wire, verdicts = [], excluded = []) => ({ engine, pluginReader, verdicts, excluded, settingsDropped, settingsVerdicts, settingsExcluded, wire });
     const closedPlan = (settings, reason) => {
@@ -278,6 +308,8 @@ function buildHooksWirePlan(engine, shellRuns, withPlugins, promptAuthoredByUser
         hostLog('debug', `hooksWireCaps: workspace trust check threw — fail-closed (no hooks projected to the engine): ${String(err)}`);
         return closedPlan(settings, 'governance_unreadable');
     }
+    if (managedPolicyUnreadable(settings))
+        return closedPlan(settings, 'governance_unreadable');
     let policy = null;
     try {
         policy = settings.getSettingsForSource('policySettings');

package/dist/host.d.ts

@@ -8,6 +8,11 @@ export interface SettingsPort {
     mergedDisableAllHooks?(): boolean | undefined;
     enabledPluginHooks?(): PluginHooksReading;
     hooksStartupMode?(): HooksStartupMode | undefined;
+    managedPolicyReading?(): ManagedPolicyReading;
+}
+export type ManagedPolicyState = 'absent' | 'in-effect' | 'unreadable';
+export interface ManagedPolicyReading {
+    readonly state: ManagedPolicyState;
 }
 export type HooksStartupMode = 'safe' | 'bare';
 export type PluginHookOptionValue = string | number | boolean;

package/dist/host.js

@@ -48,7 +48,9 @@ export function installHostFor(sessionKey, ports) {
 }
 function callDiagnosticPort(call) {
     try {
-        call();
+        const out = call();
+        if (out !== undefined && out !== null)
+            void Promise.resolve(out).then(undefined, () => undefined);
         return true;
     }
     catch {

package/dist/hostCallbackGuard.d.ts

@@ -0,0 +1 @@
+export declare function invokeHostCallbackIsolated(label: string, call: () => void): void;

package/dist/hostCallbackGuard.js

@@ -0,0 +1,25 @@
+import { hostLog } from './host.js';
+function faultText(e) {
+    try {
+        return String(e).slice(0, 160);
+    }
+    catch {
+        return '(unprintable)';
+    }
+}
+function reportHostCallbackFault(label, what, e) {
+    hostLog('debug', `${label} ${what}: ${faultText(e)}`);
+}
+export function invokeHostCallbackIsolated(label, call) {
+    try {
+        const out = call();
+        if (out && typeof out.then === 'function') {
+            void Promise.resolve(out).then(undefined, (e) => {
+                reportHostCallbackFault(label, 'rejected', e);
+            });
+        }
+    }
+    catch (e) {
+        reportHostCallbackFault(label, 'threw', e);
+    }
+}

package/dist/index.d.ts

@@ -18,6 +18,8 @@ export type { BgTerminalFacts, SubagentContentEvent, SubagentContentItem, Subage
 export * from './engineAgentPanelStore.js';
 export * from './engineAgentAbsence.js';
 export * from './fleetAgentPanelProjection.js';
+export { reducePanelFrame, createPanelReduceState, PANEL_DELTA_OPS } from './panelReduce.js';
+export type { PanelFrame, PanelDelta, PanelRowFields, PanelReduceState } from './panelReduce.js';
 export { _resetLiveQuestionStore, hasLocalQuestionResponder, hasQuestionOverlay, hasQuestionOverlayFor, onQuestionFrame, onQuestionFrameFor, publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionResponder, respondToQuestion, setQuestionRespond, } from './liveQuestionStore.js';
 export type { AskQuestion, AskQuestionOption, QuestionAnswer, QuestionFrame, } from './liveQuestionStore.js';
 export * from './engineInlineTaskStats.js';
@@ -31,7 +33,7 @@ export * from './executionLaneCapability.js';
 export * from './approvalsStreamLiveCapability.js';
 export * from './peerLaneCapability.js';
 export * from './permissionRulesWriteCapability.js';
-export { __resetPermissionsAllowGrantReadingsForTests, forgetPermissionsAllowGrantReading, noteEngineCapsForPermissionsAllowGrant, observedPermissionsAllowGrant, permissionsAllowGrantAvailable, permissionsAllowGrantDoctorDetail, projectPermissionsAllowGrantCapability, } from './permissionsAllowGrantCapability.js';
+export { __resetPermissionsAllowGrantReadingsForTests, noteEngineCapsForPermissionsAllowGrant, observedPermissionsAllowGrant, permissionsAllowGrantAvailable, permissionsAllowGrantDoctorDetail, projectPermissionsAllowGrantCapability, } from './permissionsAllowGrantCapability.js';
 export type { PermissionsAllowGrantReading } from './permissionsAllowGrantCapability.js';
 export * from './sessionPolicyCapability.js';
 export * from './memoryComplianceCapability.js';
@@ -40,9 +42,13 @@ export * from './memoryEntriesWire.js';
 export * from './memoryVerbsWire.js';
 export * from './deviceExecutorManagementCapability.js';
 export * from './mcpReconnect.js';
+export * from './hitl/parkExpiryJudgements.js';
+export * from './usageAnalytics.js';
 export * from './leaderConflict.js';
 export * from './runTerminal.js';
-export { providerRejectionResend, type ProviderRejectionResend } from './providerRejection.js';
+export { CORE_SEMA_TASK_TERMINAL_STATUSES, CORE_TASK_NOTIFICATION_TERMINAL_STATUSES, CORE_TERMINAL_CAUSE_KINDS, SDK_FLEET_TASK_TERMINAL_STATUSES, SDK_RUN_TERMINAL_STATUSES, ccTaskTerminalStatusOf, isCoreSemaTaskTerminal, isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTerminalCauseKind, isSdkFleetTaskTerminal, isSdkFleetTaskTerminalNotSuccess, isSdkRunTerminal, isSdkRunTerminalNotSuccess, } from './terminalStatuses.js';
+export type { CcTaskTerminalStatus, CoreSemaTaskTerminalStatus, CoreTaskNotificationTerminalStatus, CoreTerminalCauseKind, SdkFleetTaskTerminalStatus, SdkRunTerminalStatus, } from './terminalStatuses.js';
+export type { ProviderRejectionResend } from './providerRejection.js';
 export * from './runCancelContext.js';
 export * from './argvFlagValue.js';
 export * from './readFacePosture.js';
@@ -104,6 +110,7 @@ export * from './retainBackgroundWireCaps.js';
 export * from './oneShotWireCaps.js';
 export * from './rewindWireCaps.js';
 export * from './rewindArchiveCapability.js';
+export * from './rewindEngineAction.js';
 export * from './fileHistoryCaptureCapability.js';
 export { FILE_HISTORY_LEG_VERDICTS, fileHistoryLegNoticeVerdict, fileHistoryLegNoticeSentence, fileHistoryDeclarationOfBody, createFileHistoryDeclarationLedger, } from './fileHistoryLegNotice.js';
 export type { FileHistoryDeclarationFact, FileHistoryLegNoticeVerdict, FileHistoryLegNoticeInput, FileHistoryDeclarationLedger } from './fileHistoryLegNotice.js';
@@ -123,6 +130,7 @@ export * from './liveModelCatalog.js';
 export * from './modelBudgetRule.js';
 export * from './modelIdentityResolvability.js';
 export * from './sessionModelLatch.js';
+export * from './modelSwitchFallback.js';
 export * from './effortWire.js';
 export * from './adapter/types.js';
 export * from './adapter/downstream/turnUsageToModelUsage.js';
@@ -137,8 +145,8 @@ export { disableSkillsDeclaration, disableSkillsDeclarationSettled } from './dis
 export { approvalReachDeclaration, approvalReachDeclarationSettled } from './approvalReachWire.js';
 export type { ApprovalReachDeclaration, ApprovalReachWithheldCause, ApprovalReachWord } from './approvalReachWire.js';
 export type { DisableSkillsDeclaration } from './disableSkillsWire.js';
-export { PERMISSIONS_KEPT_REASONS, WIRE_RULE_TRUST_ORDER, permissionsDeclaration, permissionsDeclarationReport } from './permissionsDeclaration.js';
-export type { PermissionsClientOwnedStatement, PermissionsDeclaration, PermissionsDeclarationBuckets, PermissionsDeclarationInput, PermissionsDeclarationReport, PermissionsKeptReason, PermissionsKeptRule, PermissionsRewrittenRule, PermissionsUncheckedRule, PermissionsUnreachableRule, WireRuleOrigin, WireRuleOrigins, } from './permissionsDeclaration.js';
+export { PERMISSIONS_KEPT_REASONS, WIRE_RULE_TRUST_ORDER, permissionsAllowKeptNotice, permissionsDeclaration, permissionsDeclarationReport } from './permissionsDeclaration.js';
+export type { PermissionsAllowKeptFacts, PermissionsClientOwnedStatement, PermissionsDeclaration, PermissionsDeclarationBuckets, PermissionsDeclarationInput, PermissionsDeclarationReport, PermissionsKeptReason, PermissionsKeptRule, PermissionsRewrittenRule, PermissionsUncheckedRule, PermissionsUnreachableRule, WireRuleOrigin, WireRuleOrigins, } from './permissionsDeclaration.js';
 export * from './clientSlice.js';
 export * from './host.js';
 export { abortableSleep } from './abortableSleep.js';
@@ -153,7 +161,7 @@ export * from './limitsWire.js';
 export * from './interactiveToolsWire.js';
 export * from './headlessPermissionModeWire.js';
 export * from './headlessReconnectWire.js';
-export { coerceTaskStatus, coerceWorkflowStatus, CONTROL_TOOL_VERBS, FLEET_TASK_ROW_KEYS_NOT_PROJECTED, FLEET_TASK_ROW_WIRE_KEYS, FLEET_TASK_VIEW_KEYS, FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED, FLEET_WORKFLOW_ROW_WIRE_KEYS, FLEET_WORKFLOW_VIEW_KEYS, projectDescription, projectTasks, projectWorkflows, TERMINAL_FLEET_TASK_STATUSES, wireResumable, wireRowUsage, } from './fleet/fleetProjection.js';
+export { coerceTaskStatus, coerceWorkflowStatus, CONTROL_TOOL_VERBS, FLEET_TASK_ROW_KEYS_NOT_PROJECTED, FLEET_TASK_ROW_WIRE_KEYS, FLEET_TASK_VIEW_KEYS, FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED, FLEET_WORKFLOW_ROW_WIRE_KEYS, FLEET_WORKFLOW_VIEW_KEYS, projectDescription, projectTasks, projectWorkflows, wireResumable, wireRowUsage, } from './fleet/fleetProjection.js';
 export type { FleetRowUsage, FleetTaskStatus, FleetTaskView, FleetWorkflowView, NotProjectedEntry, ProjectTasksOptions, } from './fleet/fleetProjection.js';
 export * from './fleet/fleetLedger.js';
 export * from './fleet/workflowSizeWarning.js';
@@ -178,8 +186,6 @@ export * from './corruptSessionCopy.js';
 export { classifyToolHistoryMismatch, readToolHistoryMismatchKey, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
 export type { ToolHistoryMismatchRowKey } from './toolHistoryMismatch.js';
 export { toolHistoryBadTurnSentence } from './toolHistoryBadTurn.js';
-export { classifyRegistryConflict, isScopeGoneError } from './registryConflict.js';
-export type { RegistryConflictClass } from './registryConflict.js';
 export { deviceFlowPollingPlan } from './deviceFlowPolling.js';
 export type { DeviceFlowPollingPlan } from './deviceFlowPolling.js';
 export { createPromptDeliveryLedger, promptKnownUndelivered, withoutUndeliveredPrompts } from './promptDelivery.js';
@@ -188,7 +194,7 @@ export { mintUserAttachmentEnvelope } from './userAttachmentEnvelope.js';
 export type { UserAttachmentDescriptor, UserAttachmentNotebookCell } from './userAttachmentEnvelope.js';
 export { encodeHumanTurn, deliveredUuidsOf } from './humanTurn.js';
 export type { HumanTurnInput, HumanTurnItem, HumanTurnAttachment, HumanTurnRider, HumanTurnMissing, HumanTurnCaps, HumanTurnEncoding, HumanTurnShare, HumanTurnSharePart, HumanTurnDegraded, HumanTurnDelivered, } from './humanTurn.js';
-export { noteEngineCapsForAttachmentSeat, observedAttachmentSeat, forgetAttachmentSeatReading, __resetAttachmentSeatReadingsForTests, } from './attachmentSeatCapability.js';
+export { noteEngineCapsForAttachmentSeat, observedAttachmentSeat, __resetAttachmentSeatReadingsForTests, } from './attachmentSeatCapability.js';
 export type { AttachmentSeatReading } from './attachmentSeatCapability.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
@@ -236,17 +242,27 @@ export * from './hitl/sessionPolicyWire.js';
 export * from './hitl/sessionPolicyDeliverable.js';
 export * from './hitl/approvalsFeed.js';
 export * from './hitl/livePendingAsk.js';
-export { replayedApprovalDisposition } from './hitl/replayedApproval.js';
+export { replayedApprovalDisposition, replayedApprovalSentence } from './hitl/replayedApproval.js';
 export type { ReplayedApprovalDisposition, ReplayPendingBasis } from './hitl/replayedApproval.js';
+export { hasLedgerPositionKey } from './hitl/gateLedger.js';
 export { MODE_ARBITRATION, automaticAnswerVerdict, mandatedApprovalDetailOf, permissionRequestHookScope, type AutomaticAnswerLane, type AutomaticAnswerAskFace, type AutomaticAnswerFacts, type AutomaticAnswerRoad, type AutomaticAnswerUnknownWhy, type AutomaticAnswerVerdict, type PermissionRequestHookScope, } from './hitl/automaticAnswerVerdict.js';
-export { classifyDecisionRefusal, liveAskPendingReading, decisionRefusalClosesOut, undeliverableDecisionContent, type DecisionRefusalStanding, type DecisionRefusalClassified, type LiveAskPendingReading, type UndeliverableDecisionEnd, type UndeliverableDecisionFacts, } from './hitl/decisionRefusal.js';
+export { classifyDecisionRefusal, liveAskPendingReading, decisionRefusalClosesOut, undeliverableDecisionContent, type DecisionRefusalStanding, type DecisionRefusalClassified, type DecisionRefusalConflict, type LiveAskPendingReading, type UndeliverableDecisionEnd, type UndeliverableDecisionFacts, } from './hitl/decisionRefusal.js';
 export { noAllowCauseOf, type NoAllowCause, type RuleLadderNoAllowFacts } from './hitl/noAllowCause.js';
 export { policyDenyReason, type PolicyDenyLane, type PolicyDenyReasonFacts } from './hitl/frameRouter.js';
-export { readApprovalAllowRuleShadow, approvalAllowRuleShadowed, type ApprovalAllowRuleShadow, type ApprovalAllowRuleShadowMember, type AllowRuleShadowedWireMember, } from './hitl/allowRuleShadow.js';
+export { readApprovalAllowRuleShadow, approvalAllowRuleShadowed, allowRuleShadowSentence, type ApprovalAllowRuleShadow, type ApprovalAllowRuleShadowMember, type AllowRuleShadowedWireMember, } from './hitl/allowRuleShadow.js';
 export { projectCrashConverged } from './hitl/crashConverged.js';
 export type { ApprovalsListEnvelope, CrashConvergedOrphanState, CrashConvergedProjection, CrashConvergedRow } from './hitl/crashConverged.js';
 export * from './hitl/crashConvergedNotice.js';
+export { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
+export { approvalCompleteCauseOf } from './hitl/approvalEndingCause.js';
 export * from './interactiveHalt.js';
+export { fireInteractiveInterrupt } from './interactiveInterrupt.js';
+export type { InteractiveInterruptRuns, InteractiveInterruptOptions } from './interactiveInterrupt.js';
+export { listDevices, readSessionBinding, rebindSession, reconcileRebindOutcome, rebindProvesRequestNotApplied } from './deviceRebind.js';
+export type { DeviceSummary, DeviceListResult, DeviceBinding, DeviceSessionBinding, DeviceRebindRequest, DeviceRevokeRequest, DeviceRebindResult, DeviceEnrollToken, DeviceEnrollRequest, DeviceEnrollResult, DeviceRevokeResult, } from '@sema-agent/sdk';
+export type { DeviceListVerb, DeviceSessionBindingVerb, DeviceRebindVerb, DeviceRosterRow, DeviceBindingReading, DeviceRefused, DeviceLaneAbsent, DeviceTransport, DeviceUnreadable, DeviceUnarmed, DeviceListOutcome, DeviceSessionBindingOutcome, DeviceRebindInput, DeviceRebindUnconfirmed, DeviceRebindOutcome, DeviceRebindReconcileVerdict, } from './deviceRebind.js';
+export { resolveEngineEnvSourcing, engineEnvView } from './engineEnvSourcing.js';
+export type { EngineEnvView, EngineEnvGroupDecl, EngineEnvSourcingInput, EngineEnvTouchedKey, EngineEnvGroupReading, EngineEnvKeyReason, EngineEnvSourcingVerdict, } from './engineEnvSourcing.js';
 export * from './compensations.js';
 export * from './request/printNotification.js';
 export * from './seatContract.js';
@@ -271,3 +287,6 @@ export * from './env/localeTag.js';
 export * from './env/uiLanguage.js';
 export type { PendingCheckpoint, RuleSuggestion } from '@sema-agent/sdk';
 export * from './ruleRemovalConsequence.js';
+export { engineCredentialRequirementOf } from './engineCredentialRequirement.js';
+export type { EngineProbeAnswer, EngineCredentialNeed } from './engineCredentialRequirement.js';
+export { isSessionIdPathSegment } from './sessionIdSegment.js';