@sema-agent/client-core 0.108.0 → 0.109.0

package/dist/hitl/parkOwnership.js

@@ -3,31 +3,71 @@ import { rowIdTail } from '../workflow.js';
 import { hostSessionFor } from '../host.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { pendingRowIsOfSession } from './parkRowDelegation.js';
+import { slotReadOf } from '../wireFailureShape.js';
 export function pendingRowIsOwnedByThisSession(row, deps) {
+    return ownershipVerdictOf(row, deps) === 'owned';
+}
+export function pendingRowOwnershipOf(row, deps) {
+    try {
+        return ownershipVerdictOf(row, deps);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function ownershipVerdictOf(row, deps) {
     const sessionKey = deps?.sessionKey ?? DEFAULT_SESSION_KEY;
     const rowTaskId = typeof row.taskId === 'string' ? row.taskId : '';
     if (rowTaskId.length > 0) {
         const tail = rowIdTail(rowTaskId);
         if (deps?.isOwnRun !== undefined && deps.isOwnRun(tail))
-            return true;
+            return 'owned';
         if (sessionKey === DEFAULT_SESSION_KEY && isOwnEngineRun(tail))
-            return true;
+            return 'owned';
     }
     const currentSessionId = deps?.currentSessionId ?? (() => hostSessionFor(sessionKey)?.currentSessionId());
     const sessionId = currentSessionId();
     if (typeof sessionId !== 'string' || sessionId.length === 0)
+        return 'unknown';
+    if (pendingRowIsOfSession(row, sessionId))
+        return 'owned';
+    return rowIsProvablyForeign(row, sessionId) ? 'foreign' : 'unknown';
+}
+function rowIsProvablyForeign(row, selfSessionId) {
+    const own = slotReadOf(row, 'sessionId');
+    if (own.presence !== 'present' || typeof own.value !== 'string' || own.value === '' || own.value === selfSessionId)
+        return false;
+    const agent = slotReadOf(row, 'agent');
+    if (agent.presence === 'absent')
+        return true;
+    if (agent.presence !== 'present' || typeof agent.value !== 'object' || agent.value === null)
         return false;
-    return pendingRowIsOfSession(row, sessionId);
+    for (const key of ['parentSessionId', 'rootSessionId']) {
+        const link = slotReadOf(agent.value, key);
+        if (link.presence === 'absent')
+            continue;
+        if (link.presence !== 'present' || typeof link.value !== 'string' || link.value === selfSessionId)
+            return false;
+    }
+    return true;
+}
+export function usableAskQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return null;
+    for (let i = 0; i < value.length; i++) {
+        if (!Object.hasOwn(value, i))
+            return null;
+        const q = value[i];
+        if (typeof q !== 'object' || q === null || typeof q.question !== 'string')
+            return null;
+    }
+    return value;
 }
 export function askQuestionsFromPending(pending) {
     const input = pending.input;
     if (typeof input !== 'object' || input === null)
         return null;
-    const qs = input.questions;
-    if (!Array.isArray(qs) || qs.length === 0)
-        return null;
-    const ok = qs.every(q => typeof q === 'object' && q !== null && typeof q.question === 'string');
-    return ok ? qs : null;
+    return usableAskQuestions(input.questions);
 }
 export function isHitlSafetyErrorLike(e) {
     return typeof e === 'object' && e !== null && e.name === 'HitlSafetyError';

package/dist/hitl/parkResolver.js

@@ -10,6 +10,7 @@ import { denyAttributionOf, flushHeldWithInterruptRewrite, isAskTool } from './f
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
+import { usableAskQuestions } from './parkOwnership.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
@@ -69,12 +70,11 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         return { kind: 'not_sent', lane: 'ask', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}), ...(found.rowVerdict !== undefined ? { rowVerdict: found.rowVerdict } : {}) };
     const { pending, gatedCallId } = found;
     const at = { lane: 'ask', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
-    const fromArgs = gatedCallId
-        ? askArgsByCall.get(gatedCallId)?.questions
-        : undefined;
-    const fromPending = pending.input?.questions;
-    const questions = Array.isArray(fromArgs) && fromArgs.length > 0 ? fromArgs : fromPending;
-    if (!Array.isArray(questions) || questions.length === 0) {
+    const rowQuestions = usableAskQuestions(pending.input?.questions);
+    const streamQuestions = usableAskQuestions(gatedCallId ? askArgsByCall.get(gatedCallId)?.questions : undefined);
+    const questionsFromModelCall = rowQuestions === null && streamQuestions !== null;
+    const questions = rowQuestions ?? streamQuestions;
+    if (questions === null) {
         const truncated = pending.input?.truncated === true;
         return {
             kind: 'not_sent',
@@ -107,7 +107,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         }
         signal?.addEventListener('abort', onAbort, { once: true });
         onPresented?.();
-        publishQuestionFrame({ type: 'question', questionId, questions });
+        publishQuestionFrame({ type: 'question', questionId, questions, ...(questionsFromModelCall ? { _sema_questionsFromModelCall: true } : {}) });
     });
     const bridge = new HitlBridge(deps.client, taskId, deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : undefined);
     if (answer === null) {

package/dist/hitl/parkedUnresumable.d.ts

@@ -0,0 +1,13 @@
+import { type CheckpointRowBar } from '../checkpointRowVerdict.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+import type { OwnedPendingListView } from './askParkRowRouting.js';
+import { type ParkOwnershipDeps } from './parkOwnership.js';
+export interface ParkedUnresumableRow {
+    readonly rowVerdict: CheckpointRowBar;
+    readonly rowKey?: string;
+    readonly taskId?: string;
+    readonly toolName?: string;
+    readonly rowDeadline?: 'armed' | 'none';
+}
+export declare function parkedUnresumableRowsOf(listed: OwnedPendingListView | null | undefined, deps?: ParkOwnershipDeps): readonly ParkedUnresumableRow[];
+export declare function parkedUnresumableLine(row: ParkedUnresumableRow, lang?: UiLanguage | (string & {})): string;

package/dist/hitl/parkedUnresumable.js

@@ -0,0 +1,80 @@
+import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, rowBarWayOutContent, } from '../checkpointRowVerdict.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
+import { approvalCallKey } from './gateIdentity.js';
+import { checkpointQueueReadingOf } from './hitlBridge.js';
+import { pendingRowIsOwnedByThisSession } from './parkOwnership.js';
+function ownNonEmpty(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+}
+function memberOf(row, rowVerdict) {
+    const taskId = ownNonEmpty(row, 'taskId');
+    const callId = ownNonEmpty(row, 'toolCallId') ?? ownNonEmpty(row, 'boundCallId');
+    const rowKey = callId !== undefined || taskId !== undefined ? approvalCallKey(callId, taskId ?? '') : undefined;
+    const toolName = ownNonEmpty(row, 'toolName');
+    const deadline = checkpointDeadlineStateOf(row);
+    return Object.freeze({
+        rowVerdict,
+        ...(rowKey !== undefined ? { rowKey } : {}),
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(toolName !== undefined ? { toolName } : {}),
+        ...(deadline !== 'unknown' ? { rowDeadline: deadline } : {}),
+    });
+}
+export function parkedUnresumableRowsOf(listed, deps) {
+    if (typeof listed !== 'object' || listed === null || Array.isArray(listed)) {
+        throw new Error('approvals.list answered without a readable body — the rows this engine cannot continue are unknown');
+    }
+    const pending = listed.pending;
+    if (!Array.isArray(pending)) {
+        throw new Error('approvals.list answered without a readable `pending` array — the rows this engine cannot continue are unknown');
+    }
+    const out = [];
+    for (const row of pending) {
+        const member = parkedMemberOf(row, deps);
+        if (member !== undefined)
+            out.push(member);
+    }
+    return Object.freeze(out);
+}
+function parkedMemberOf(row, deps) {
+    try {
+        if (typeof row !== 'object' || row === null)
+            return undefined;
+        const reading = checkpointQueueReadingOf(row);
+        if (reading === undefined)
+            return undefined;
+        if (reading.foreign !== null && reading.foreign !== QUEUE_ROW_FAMILY_UNREADABLE_GATE)
+            return undefined;
+        const bar = checkpointRowBarOf(reading.r);
+        if (bar === undefined)
+            return undefined;
+        if (!pendingRowIsOwnedByThisSession(reading.r, deps))
+            return undefined;
+        return memberOf(reading.r, bar);
+    }
+    catch {
+        return undefined;
+    }
+}
+const UNREADABLE_BAR = Object.freeze({ kind: 'unreadable' });
+export function parkedUnresumableLine(row, lang) {
+    let bar = UNREADABLE_BAR;
+    let state = 'unknown';
+    try {
+        if (typeof row === 'object' && row !== null) {
+            const v = slotReadOf(row, 'rowVerdict');
+            if (v.presence === 'present')
+                bar = checkpointRowBarOf({ rowVerdict: v.value }) ?? UNREADABLE_BAR;
+            const d = slotReadOf(row, 'rowDeadline');
+            if (d.presence === 'present' && (d.value === 'armed' || d.value === 'none'))
+                state = d.value;
+        }
+    }
+    catch {
+        bar = UNREADABLE_BAR;
+        state = 'unknown';
+    }
+    return `${checkpointRowBarSentence(bar, lang)} · ${rowBarWayOutContent(bar, state, lang)}`;
+}

package/dist/hitl/permissionRuleScope.d.ts

@@ -0,0 +1,4 @@
+import type { PermissionRuleValue } from '@sema-agent/agent-types';
+export declare function isWholeToolRuleValue(value: PermissionRuleValue): boolean;
+export type AllowRuleScope = 'whole_tool' | 'content' | 'unreadable';
+export declare function allowRuleScopeOf(value: object | null | undefined): AllowRuleScope;

package/dist/hitl/permissionRuleScope.js

@@ -0,0 +1,31 @@
+import { readOwnDataValue } from '../ownKey.js';
+import { inSlotReadOf } from '../wireFailureShape.js';
+export function isWholeToolRuleValue(value) {
+    return value.ruleContent === undefined || value.ruleContent === '';
+}
+export function allowRuleScopeOf(value) {
+    try {
+        if (typeof value !== 'object' || value === null)
+            return 'unreadable';
+        const toolName = readOwnDataValue(value, 'toolName');
+        if (typeof toolName !== 'string' || toolName === '')
+            return 'unreadable';
+        let ruleContent;
+        const slot = inSlotReadOf(value, 'ruleContent');
+        if (slot.state === 'present') {
+            const raw = slot.value;
+            if (raw !== undefined) {
+                if (typeof raw !== 'string' || raw === '')
+                    return 'unreadable';
+                ruleContent = raw;
+            }
+        }
+        else if (slot.state !== 'absent')
+            return 'unreadable';
+        const snapshot = Object.freeze(Object.assign(Object.create(null), ruleContent !== undefined ? { toolName, ruleContent } : { toolName }));
+        return isWholeToolRuleValue(snapshot) ? 'whole_tool' : 'content';
+    }
+    catch {
+        return 'unreadable';
+    }
+}

package/dist/hitl/persistedRulesWire.d.ts

@@ -33,6 +33,8 @@ export interface CcImportRedeemRuleKey {
 }
 export interface CcImportRedeemRefused {
     readonly key?: CcImportRedeemRuleKey;
+    readonly reason?: string;
+    readonly detail?: string;
 }
 export interface CcImportRedeemCounts {
     persisted: number;

package/dist/hitl/persistedRulesWire.js

@@ -1,7 +1,7 @@
 import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { CORE_RULE_BEHAVIORS } from '../generated/engineFactTables.js';
-import { slotReadOf, wireFailureShapeOf } from '../wireFailureShape.js';
+import { inValueOf, slotReadOf, wireFailureShapeOf } from '../wireFailureShape.js';
 import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED } from '../engineErrorCodes.js';
 import { hostLog } from '../host.js';
 import { msg, renderMessage } from '../i18n/translate.js';
@@ -51,7 +51,7 @@ function ruleKeyOfRow(row) {
     const scope = keyObj === undefined ? undefined : ownNonEmpty(keyObj, 'scope');
     return behavior !== undefined && rule !== undefined && scope !== undefined ? Object.freeze({ behavior, rule, scope }) : undefined;
 }
-function indeterminateRowOf(row) {
+function unsettledRowOf(row) {
     const key = ruleKeyOfRow(row);
     const reason = ownNonEmpty(row, 'reason');
     const d = slotReadOf(row, 'detail');
@@ -62,10 +62,6 @@ function indeterminateRowOf(row) {
         ...(shown !== undefined && shown.trim() !== '' ? { detail: shown } : {}),
     });
 }
-function refusedRowOf(row) {
-    const key = ruleKeyOfRow(row);
-    return Object.freeze(key !== undefined ? { key } : {});
-}
 const RECEIPT_ROW_ARMS = {
     persisted: (acc) => {
         acc.persisted += 1;
@@ -74,10 +70,10 @@ const RECEIPT_ROW_ARMS = {
         acc.deduped += 1;
     },
     refused: (acc, row) => {
-        appendOwnElement(acc.refused, refusedRowOf(row));
+        appendOwnElement(acc.refused, unsettledRowOf(row));
     },
     indeterminate: (acc, row) => {
-        appendOwnElement(acc.indeterminate, indeterminateRowOf(row));
+        appendOwnElement(acc.indeterminate, unsettledRowOf(row));
     },
 };
 function receiptCountsOf(rows) {
@@ -333,9 +329,14 @@ export function revokeTargetFromPersistedRule(rule, opts) {
     };
 }
 function readPrincipalOverride(carrier) {
-    if (carrier === null || typeof carrier !== 'object' || !('principal' in carrier))
+    if (carrier === null || typeof carrier !== 'object')
         return { ok: true };
-    const raw = carrier.principal;
+    const slot = inValueOf(carrier, 'principal');
+    if (slot.state === 'absent')
+        return { ok: true };
+    if (slot.state === 'unproven')
+        return { ok: false };
+    const raw = slot.value;
     if (typeof raw !== 'string' || raw.trim().length === 0)
         return { ok: false };
     return { ok: true, principal: raw };

package/dist/hitl/sessionAllowRoute.js

@@ -1,3 +1,4 @@
+import { inSlotReadOf } from '../wireFailureShape.js';
 export function sessionAllowCarried(leg, approvalId) {
     if (leg === 'frame')
         return true;
@@ -7,10 +8,10 @@ export function sessionAllowCarried(leg, approvalId) {
 }
 export function readCardUnreadableEvidence(card) {
     try {
-        if (!('unreadableEvidence' in card))
+        const slot = inSlotReadOf(card, 'unreadableEvidence');
+        if (slot.state === 'absent')
             return 'absent';
-        const d = Object.getOwnPropertyDescriptor(card, 'unreadableEvidence');
-        const list = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+        const list = slot.state === 'present' ? slot.value : undefined;
         return Array.isArray(list) && list.every((k) => typeof k === 'string') ? list : 'unreadable';
     }
     catch {
@@ -21,7 +22,7 @@ export function sessionAllowCardReadable(card) {
     if (typeof card !== 'object' || card === null)
         return 'card_unreadable';
     try {
-        if ('cardPayloadUnreadable' in card)
+        if (inSlotReadOf(card, 'cardPayloadUnreadable').state !== 'absent')
             return 'card_unreadable';
     }
     catch {

package/dist/hitl/standingRows.d.ts

@@ -25,13 +25,9 @@ export interface RememberOfferable {
     readonly deploymentList: RememberOffer;
 }
 export declare function rememberOfferable(card: object | null | undefined, host?: StandingRowsHostFacts | null): RememberOfferable;
-export interface LocalAllowRuleHostFacts {
-    readonly hostLadderEnforces?: boolean;
-}
 export interface LocalAllowRuleEnforcement {
     readonly enforceable: boolean;
-    readonly by?: 'host_ladder' | 'engine_grant';
     readonly engine: 'sent' | 'kept' | 'unreadable';
     readonly keptReason?: PermissionsKeptReason;
 }
-export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading, host?: LocalAllowRuleHostFacts | null): LocalAllowRuleEnforcement;
+export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading): LocalAllowRuleEnforcement;

package/dist/hitl/standingRows.js

@@ -1,7 +1,8 @@
 import { DEPLOYMENT_LIST_ASK_CLASSES, readAskClassPairState } from './askClassPair.js';
-import { automaticAnswerVerdict } from './automaticAnswerVerdict.js';
+import { askLevelVerdict } from './automaticAnswerVerdict.js';
 import { readApprovalCardWord, readRuleOffers } from './toolApprovalWire.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
+import { inSlotReadOf, inValueOf } from '../wireFailureShape.js';
 import { toolPermissionRequestIdDomain } from '../seatContract.js';
 import { permissionsDeclarationReport } from '../permissionsDeclaration.js';
 import { readCardUnreadableEvidence, sessionAllowCardReadable, sessionAllowEligible } from './sessionAllowRoute.js';
@@ -15,9 +16,10 @@ function ownData(v, key) {
         return undefined;
     }
 }
-function hasKey(v, key) {
+function candidateSlot(v, key) {
     try {
-        return { inCard: key in v };
+        const s = inSlotReadOf(v, key);
+        return s.state === 'unproven' ? UNREADABLE : s;
     }
     catch {
         return UNREADABLE;
@@ -25,8 +27,10 @@ function hasKey(v, key) {
 }
 function present(v, key) {
     try {
-        const inCard = key in v;
-        return { inCard, value: inCard ? v[key] : undefined };
+        const s = inValueOf(v, key);
+        if (s.state === 'unproven')
+            return UNREADABLE;
+        return s.state === 'present' ? { inCard: true, value: s.value } : { inCard: false, value: undefined };
     }
     catch {
         return UNREADABLE;
@@ -42,12 +46,12 @@ function persistentRowOf(card, host, evidenceUnreadable) {
     if (evidenceUnreadable)
         return { row: 'none', why: 'evidence_unreadable' };
     for (const key of ['ruleOffers', 'ruleOffersReadOnly']) {
-        const p = hasKey(card, key);
+        const p = candidateSlot(card, key);
         if (p === UNREADABLE)
             return UNREADABLE;
-        if (!p.inCard)
+        if (p.state === 'absent')
             continue;
-        const offers = readRuleOffers(ownData(card, key));
+        const offers = readRuleOffers(p.state === 'present' ? p.value : undefined);
         if (offers === undefined || offers.length === 0)
             return { row: 'none', why: 'offers_unreadable' };
         return { row: 'engine_offer', why: 'given' };
@@ -69,7 +73,7 @@ function persistentRowOf(card, host, evidenceUnreadable) {
         return { row: 'none', why: 'tool_name_unreadable' };
     if (tool === CORE_SKILL_TOOL_NAME)
         return { row: 'none', why: 'grant_binding' };
-    if (automaticAnswerVerdict(card, 'standing_rule').kind !== 'may_answer')
+    if (askLevelVerdict(card, 'standing_rule').kind !== 'may_answer')
         return { row: 'none', why: 'rule_cannot_clear' };
     const face = readApprovalCardWord(card);
     if (face === undefined)
@@ -178,8 +182,7 @@ export function rememberOfferable(card, host) {
         deploymentList: SESSION_OFFER[rows.why.deploymentList],
     });
 }
-export function localAllowRuleEnforceable(rule, caps, host) {
-    const ladder = typeof host === 'object' && host !== null && ownData(host, 'hostLadderEnforces') === true;
+export function localAllowRuleEnforceable(rule, caps) {
     let engine = 'unreadable';
     let keptReason;
     if (typeof rule === 'string' && rule.trim() !== '') {
@@ -199,10 +202,8 @@ export function localAllowRuleEnforceable(rule, caps, host) {
             engine = 'unreadable';
         }
     }
-    const by = ladder ? 'host_ladder' : engine === 'sent' ? 'engine_grant' : undefined;
     return Object.freeze({
-        enforceable: by !== undefined,
-        ...(by !== undefined ? { by } : {}),
+        enforceable: engine === 'sent',
         engine,
         ...(keptReason !== undefined ? { keptReason } : {}),
     });

package/dist/hitl/toolApprovalWire.d.ts

@@ -12,6 +12,7 @@ import { type ApprovalMandateWord } from '../gateVocabulary.js';
 import type { ToolPermissionRequest } from '../seatContract.js';
 import { type ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type PolicyDenyCause } from './policyDenyCause.js';
+import { type ApprovalRequestFrameReading, type ApprovalRequestFrameUnreadableWhy } from './approvalRequestFrameReading.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS } from '@sema-agent/sdk';
 import type { ApprovalDecidedBy, ApprovalCardDelegation, ToolApprovalDecision as SdkToolApprovalDecision, ToolApprovalRespondAck, ToolApprovalRespondReplayed, PersistedRuleAnchor, RuleOfferMatch, RuleOfferBatchMember, RuleOfferUncoveredDetail, RuleOfferUncoveredReason, AskOrigin, RuleOffersAbsence, DenialLimitKind, DenialLimitFallback, ToolApprovalFrame, ApprovalRequestFrame, RuleOffer as SdkRuleOffer } from '@sema-agent/sdk';
 export declare function toolNameIsFsWrite(name: string): boolean;
@@ -138,6 +139,7 @@ export interface ApprovalCardRequest {
     priorCardsForCall?: readonly ApprovalPriorCard[];
     message?: string;
     cardPayloadUnreadable?: true;
+    cardPayloadUnreadableWhy?: ApprovalRequestFrameUnreadableWhy;
     supersedes?: ApprovalCardSupersedes;
     parkRow?: ApprovalCardParkRow;
 }
@@ -283,7 +285,7 @@ export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback
 export declare function readRuleOffers(v: unknown): RuleOfferReading[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOfferReading[] | undefined;
 export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'agentId' | 'askReasons' | 'grantBinding' | 'unreadableEvidence' | 'message' | 'approvalCard'>;
-export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'argsRewritten' | 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable'>;
+export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'argsRewritten' | 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable' | 'cardPayloadUnreadableWhy'>;
 export interface ApprovalCardFrameFactsOptions {
     readonly streamArgs?: object;
     readonly argsUnavailable?: true;
@@ -291,7 +293,7 @@ export interface ApprovalCardFrameFactsOptions {
 export declare function approvalCardFactsOfV1(card: object | null | undefined): Readonly<ApprovalCardV1Facts> | undefined;
 export declare function approvalCardFactsOfV1Frame(frame: object | null | undefined): Readonly<ApprovalCardFacts> | undefined;
 export declare function approvalCardFactsOfFrame(frame: object | null | undefined, opts?: ApprovalCardFrameFactsOptions | null): Readonly<ApprovalCardFacts> | undefined;
-export declare function approvalCardFactsOfGeneric(card: object | null | undefined): Readonly<ApprovalCardFacts> | undefined;
+export declare function approvalCardFactsOfGeneric(card: object | null | undefined, reading?: ApprovalRequestFrameReading | null): Readonly<ApprovalCardFacts> | undefined;
 export interface ToolApprovalFrameLaneOpts {
     approvalDecisionNoteCapable?: boolean;
     respondFreeFormRulesCapable?: boolean;
@@ -304,6 +306,10 @@ export declare function surfaceToolApprovalFrameAndRespond(frame: ToolApprovalFr
     readonly taskId?: string;
     readonly sessionId?: string;
 }): Promise<ApprovalResolution>;
+export declare function surfaceApprovalFrameWithId(frame: ToolApprovalFrame | ApprovalRequestFrame, approvalId: string, respond: RespondToolApprovalFn, streamArgs: Parameters<typeof surfaceToolApprovalFrameAndRespond>[2], signal: AbortSignal | undefined, lane: ToolApprovalFrameLaneOpts | undefined, run: {
+    readonly taskId?: string;
+    readonly sessionId?: string;
+} | undefined): Promise<ApprovalResolution>;
 export interface ApprovalHolderIdentity {
     readonly approvalId?: string;
     readonly taskId?: string;

package/dist/hitl/toolApprovalWire.js

@@ -30,13 +30,14 @@ import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { readPolicyDenyCause } from './policyDenyCause.js';
-import { slotPresenceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { inValueOf, slotPresenceOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { APPROVAL_LIVE_FACE_KEYS, approvalLiveFaceOf, hasOwnStrictTrue } from './approvalLiveFace.js';
+import { approvalFrameUnreadableWhyOf, approvalRequestFrameReadingThrowing, } from './approvalRequestFrameReading.js';
 import { subagentSourceSessionOf } from './subagentSource.js';
 import { isPlainRecord } from '../jsonFaithful.js';
 import { DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED } 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, isApprovalRequestFrameV1, } from '@sema-agent/sdk';
+import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, } from '@sema-agent/sdk';
 export function toolNameIsFsWrite(name) {
     const n = name.replace(/[\s_-]+/g, '').toLowerCase();
     return (n === 'write' || n === 'filewrite' || n === 'edit' || n === 'fileedit' || n === 'multiedit' || n === 'notebookedit');
@@ -493,6 +494,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     const rowArgsGap = reading.from !== 'none' ? undefined : reading.shape === 'absent' ? 'absent' : reading.shape === 'size_marker' ? 'truncated' : undefined;
     const args = reading.from !== 'none' ? reading.args : rowArgsGap !== undefined ? {} : reading.recorded;
     const argsRewritten = reading.from === 'recorded' && reading.rewritten;
+    const argsFromModelCall = reading.from === 'stream';
     if (typeof args !== 'object' || args === null) {
         return { kind: 'not_sent', ...at, cause: 'no_input', detail: 'gate has no tool input payload' };
     }
@@ -516,6 +518,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
             }
             : {}),
         ...(argsRewritten ? { argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE } : {}),
+        ...(argsFromModelCall ? { argsUnavailable: true, wireNote: renderMessage(msg('approval.park.argsFromModelCall')) } : {}),
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(pending) ? { requiresRealApproval: true } : {}),
         ...approvalLiveFaceOf(pending).facts,
@@ -541,8 +544,8 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     });
     const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, cardRequest);
     hold.phase = 'respond';
-    if (rowArgsGap !== undefined && card.kind === 'allow' && card.updatedInput !== undefined) {
-        hostLog('error', `liveToolApprovalWire: approval card for ${gatedCallId ?? `task ${taskId}`} returned an edited approval, but the tool input is ${rowArgsGap === 'truncated' ? 'a size marker on the pending row' : 'missing from both the stream and the pending row'} — nothing sent (the park stays pending)`);
+    if ((rowArgsGap !== undefined || argsFromModelCall) && card.kind === 'allow' && card.updatedInput !== undefined) {
+        hostLog('error', `liveToolApprovalWire: approval card for ${gatedCallId ?? `task ${taskId}`} returned an edited approval, but the tool input is ${rowArgsGap === 'truncated' ? 'a size marker on the pending row' : rowArgsGap === 'absent' ? 'missing from both the stream and the pending row' : 'not recorded on the pending row'} — nothing sent (the park stays pending)`);
         surfaceEditRefusedOnBlindAsk();
         return { kind: 'not_sent', ...at, cause: 'edit_refused', detail: PARK_EDIT_REFUSED_REASON };
     }
@@ -685,8 +688,11 @@ function readReadRootCandidate(v) {
     const o = v;
     if (typeof o.dir !== 'string' || o.dir.length === 0 || o.clearsThisAsk !== true)
         return undefined;
-    if ('covers' in o)
-        return o.covers === 'exact' ? { dir: o.dir, clearsThisAsk: true, covers: 'exact' } : undefined;
+    const covers = inValueOf(o, 'covers');
+    if (covers.state === 'unproven')
+        return undefined;
+    if (covers.state === 'present')
+        return covers.value === 'exact' ? { dir: o.dir, clearsThisAsk: true, covers: 'exact' } : undefined;
     return { dir: o.dir, clearsThisAsk: true };
 }
 export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
@@ -1679,7 +1685,7 @@ function v1Bit(stamp) {
 const SUSPENDED_ASK_ARGS_NOTE = "this request's tool arguments are not available on this surface — it was raised while no client was connected, " +
     'so you are deciding without seeing them; deny it if you are not sure what it will do. ' +
     'Edits are not accepted on this card: there is no original input to edit';
-function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
+function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
     const c = carrier;
     const full = leg !== 'generic';
     const live = leg === 'frame' ? carrier : leg === 'v1' ? liveFacts : undefined;
@@ -1865,8 +1871,11 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
         if (typeof msg === 'string' && msg.trim() !== '')
             out.message = msg;
     });
-    if (leg === 'generic')
+    if (leg === 'generic') {
         out.cardPayloadUnreadable = true;
+        if (payloadWhy !== undefined)
+            out.cardPayloadUnreadableWhy = payloadWhy;
+    }
     if (sessionAllowCarried(leg, approvalId))
         out.allowSessionCarried = true;
     out.grantBinding = readApprovalGrantBinding(carrier);
@@ -1898,15 +1907,26 @@ export function approvalCardFactsOfFrame(frame, opts) {
         return undefined;
     return Object.freeze(cardFactsOf(frame, 'frame', opts));
 }
-export function approvalCardFactsOfGeneric(card) {
+export function approvalCardFactsOfGeneric(card, reading) {
     if (typeof card !== 'object' || card === null)
         return undefined;
-    return Object.freeze(cardFactsOf(card, 'generic'));
+    return Object.freeze(cardFactsOf(card, 'generic', null, undefined, undefined, approvalFrameUnreadableWhyOf(reading)));
 }
 const MAX_RESPOND_NOTE_CHARS = 2048;
 export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamArgs, signal, lane, run) {
+    const approvalId = readOwnDataNonEmptyString(frame, 'approvalId');
+    if (approvalId === undefined)
+        return approvalIdUnreadableRefusal();
+    return surfaceApprovalFrameWithId(frame, approvalId, respond, streamArgs, signal, lane, run);
+}
+function approvalIdUnreadableRefusal() {
+    hostLog('debug', 'liveToolApprovalWire: refused (approvalId_unreadable)');
+    return { kind: 'not_sent', lane: 'respond', cause: 'card_unavailable' };
+}
+export async function surfaceApprovalFrameWithId(frame, approvalId, respond, streamArgs, signal, lane, run) {
     const receivedAtMs = Date.now();
-    const approvalId = frame.approvalId;
+    if (typeof approvalId !== 'string' || approvalId === '')
+        return approvalIdUnreadableRefusal();
     const carriers = openingFrameCarriersOf(frame);
     const entry = { frame, carriers, approvalId, identity: liveCardIdentityOf(approvalId, frame, carriers, run), respond, streamArgs, signal, lane, receivedAtMs };
     return enterLiveCard(entry);
@@ -1916,9 +1936,10 @@ function openingFrameCarriersOf(frame) {
         return { body: frame, live: frame, leg: 'frame' };
     const card = frame.card;
     const pinned = Object.create(frame, { card: { value: card, enumerable: true } });
-    if (isApprovalRequestFrameV1(pinned))
+    const reading = approvalRequestFrameReadingThrowing(pinned);
+    if (reading.v1)
         return { body: pinned.card, live: frame, leg: 'v1' };
-    return { body: typeof card === 'object' && card !== null ? card : {}, live: undefined, leg: 'generic' };
+    return { body: typeof card === 'object' && card !== null ? card : {}, live: undefined, leg: 'generic', why: reading.why };
 }
 function enterLiveCard(e) {
     const { approvalId, signal } = e;
@@ -2016,7 +2037,7 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
     const bodyToolCallId = carriers.body.toolCallId;
     const frameToolCallId = typeof bodyToolCallId === 'string' && bodyToolCallId !== '' ? bodyToolCallId : undefined;
     const decidedByReading = decidedByReadingSnapshotOf(lane);
-    const facts = cardFactsOf(carriers.body, carriers.leg, { streamArgs, ...(lane?.argsUnavailable === true ? { argsUnavailable: true } : {}) }, carriers.live, approvalId);
+    const facts = cardFactsOf(carriers.body, carriers.leg, { streamArgs, ...(lane?.argsUnavailable === true ? { argsUnavailable: true } : {}) }, carriers.live, approvalId, carriers.why);
     const argsNotRealInput = facts.argsUnavailable === true;
     const ruleOffers = facts.ruleOffers;
     if (argsNotRealInput && lane?.argsUnavailable !== true && facts.wireNote !== undefined) {

package/dist/hooksWireCaps.js

@@ -1,7 +1,7 @@
 import { engineCapNestedTrue, engineCapState, engineCapString, engineCapValue } from './engineCapsCache.js';
 import { hooksReaderNotReadKeys } from './hooksReaderGenerations.js';
 import { msg, renderMessage } from './i18n/translate.js';
-import { capForDisplay, collapseLabel } from './fleetTaskDesc.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 import { hostLog } from './host.js';
 import { faultText } from './hostCallbackGuard.js';
 import { HostSettingsSourceShapeError, MANAGED_READING_DISPOSITIONS, mergedBooleanOf, nonManagedLayerDown, readHostSettingsOnce } from './hostSettingsSource.js';
@@ -555,8 +555,9 @@ export function fleetHookFailureNoticeCapable(baseUrl) {
 export const HOOK_FAILURE_WARN_PREFIX = 'Hook error';
 export function hookFailureNoticeText(n) {
     const code = n.exitCode !== undefined ? `exit ${n.exitCode}` : n.reason;
-    const name = collapseLabel(n.hookName);
-    const tail = n.stderr !== undefined ? `: ${collapseLabel(n.stderr)}` : '';
+    const fold = (s) => s.replace(/\s+/g, ' ').trim();
+    const name = fold(n.hookName);
+    const tail = n.stderr !== undefined ? `: ${fold(n.stderr)}` : '';
     const line = `${HOOK_FAILURE_WARN_PREFIX}: ${name} (${code})${tail}`;
     return capForDisplay(line, MAX_HOOK_NOTICE_TEXT_CHARS);
 }