@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/hitl/planReviewWire.js

@@ -11,6 +11,7 @@ import { readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, resumeContextUnavailableContent, resumeContextUnavailableFromError } from '../resumeRefusalCopy.js';
 import { REQUEST_FIELD_CONFLICT } from '../engineErrorCodes.js';
 import { refusalDeliveryOf } from './decisionRefusal.js';
+import { __resetDecisionLedgerForTests, decisionInFlightOf, decisionKeyInFlight, decisionLedgerKeysOf, decisionOpsWithKey, decisionReadMark, dropDecisionOp, latestDecisionHandedMark, markLatestDecisionNotApplied, openDecisionOp, planDecisionKey, readMarkOf, settleDecisionOp, settleDecisionOpsOnGateLeft, } from './decisionLedger.js';
 import { denyReasonForWire, isPlanReviewModeAfter } from './hitlBridge.js';
 import { planReviewQuestionId, REOPEN_ID_TAIL, taskIdFromPlanReviewQuestionId } from './gateIdentity.js';
 import { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
@@ -457,42 +458,21 @@ function usablePlanReviewWireClient(client) {
     return clientHasVerbs(client, [['assistant', 'planReview'], ['runs', 'get']]);
 }
 const PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS = 15_000;
-const planReviewDecisionOps = [];
-const MAX_PLAN_REVIEW_DECISION_OPS = 32;
-let planReviewLedgerClock = 0;
-let decideDispatchSeq = 0;
-function planReviewOpsOf(taskId) {
-    return planReviewDecisionOps.filter((op) => op.taskId === taskId);
-}
-function settlePlanReviewDecisionOp(op, by) {
-    if (op.settledAt !== null)
-        return;
-    op.settledAt = ++planReviewLedgerClock;
-    op.settler = by;
-}
-function pushPlanReviewDecisionOp(op) {
-    planReviewDecisionOps.push(op);
-    while (planReviewDecisionOps.length > MAX_PLAN_REVIEW_DECISION_OPS) {
-        let victim = planReviewDecisionOps.findIndex((o) => o.settledAt !== null && !o.ownCallOpen);
-        if (victim < 0)
-            victim = planReviewDecisionOps.findIndex((o) => o !== op && o.phase === 'handed');
-        if (victim < 0)
-            break;
-        planReviewDecisionOps.splice(victim, 1);
-    }
+function planReviewLedgerKeys(taskId) {
+    return taskId === '' ? [planDecisionKey('')] : decisionLedgerKeysOf({ taskId, planTaskId: taskId });
 }
-function dropPlanReviewDecisionOp(op) {
-    const i = planReviewDecisionOps.indexOf(op);
-    if (i >= 0)
-        planReviewDecisionOps.splice(i, 1);
+function planReviewOpsOf(taskId) {
+    return decisionOpsWithKey('plan_review', planDecisionKey(taskId));
 }
+let decideDispatchSeq = 0;
 function claimablePlanReviewDecisionOp(taskId) {
-    const open = planReviewDecisionOps.find((o) => o.taskId === taskId && o.phase === 'handed' && o.settledAt === null);
+    const ops = planReviewOpsOf(taskId);
+    const open = ops.find((o) => o.phase === 'handed' && o.settledAt === null);
     if (open !== undefined)
         return open;
     let leftBehind;
-    for (const o of planReviewDecisionOps) {
-        if (o.taskId !== taskId || o.phase !== 'handed' || o.settler !== 'gate_left')
+    for (const o of ops) {
+        if (o.phase !== 'handed' || o.settler !== 'gate_left')
             continue;
         if (leftBehind === undefined || o.handedAt > leftBehind.handedAt)
             leftBehind = o;
@@ -502,62 +482,47 @@ function claimablePlanReviewDecisionOp(taskId) {
 export function notePlanReviewDecisionHandedOver(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return null;
-    if (planReviewDecisionOps.some((op) => op.taskId === taskId && op.settledAt === null))
+    if (planReviewOpsOf(taskId).some((op) => op.settledAt === null))
         return null;
-    const op = { taskId, handedAt: ++planReviewLedgerClock, settledAt: null, settler: null, phase: 'handed', notApplied: false, ownCallOpen: false };
-    pushPlanReviewDecisionOp(op);
+    const op = openDecisionOp('plan_review', planReviewLedgerKeys(taskId), 'handed', false);
     return {
         settle: () => {
             if (op.phase !== 'handed')
                 return;
-            settlePlanReviewDecisionOp(op, 'host');
+            settleDecisionOp(op, 'host');
         },
         revoke: () => {
             if (op.phase !== 'handed' || op.settledAt !== null)
                 return;
-            dropPlanReviewDecisionOp(op);
+            dropDecisionOp(op);
         },
     };
 }
 export function planReviewPendingReadMark() {
-    return ++planReviewLedgerClock;
+    return decisionReadMark();
 }
 export function planReviewDecisionInFlight(taskId, pendingReadStartedAt) {
     if (typeof taskId !== 'string' || taskId === '')
         return false;
-    const mark = typeof pendingReadStartedAt === 'number' && Number.isFinite(pendingReadStartedAt) ? pendingReadStartedAt : undefined;
-    return planReviewDecisionOps.some((op) => op.taskId === taskId && (op.settledAt === null || (mark !== undefined && op.settledAt > mark && !op.notApplied)));
+    return decisionKeyInFlight(planDecisionKey(taskId), readMarkOf(pendingReadStartedAt));
 }
 export function notePlanReviewDecisionNotApplied(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return;
-    const ops = planReviewOpsOf(taskId);
-    if (ops.some((op) => op.settledAt === null))
-        return;
-    let latest;
-    for (const op of ops)
-        if (latest === undefined || op.handedAt > latest.handedAt)
-            latest = op;
-    if (latest !== undefined)
-        latest.notApplied = true;
+    markLatestDecisionNotApplied('plan_review', planDecisionKey(taskId));
 }
 export function notePlanReviewGateLeft(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return;
-    for (const op of planReviewOpsOf(taskId))
-        settlePlanReviewDecisionOp(op, 'gate_left');
+    settleDecisionOpsOnGateLeft('plan_review', planDecisionKey(taskId));
 }
 export function latestPlanReviewDecisionMark(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return null;
-    let mark = null;
-    for (const op of planReviewOpsOf(taskId))
-        if (mark === null || op.handedAt > mark)
-            mark = op.handedAt;
-    return mark;
+    return latestDecisionHandedMark('plan_review', planDecisionKey(taskId));
 }
 export function __resetPlanReviewDecisionLatchForTests() {
-    planReviewDecisionOps.length = 0;
+    __resetDecisionLedgerForTests('plan_review');
 }
 export async function decidePlanReview(taskId, decision, permissionModeAfter, opts) {
     return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, parkedGateIdentityOf(opts));
@@ -609,14 +574,13 @@ function bodySaysReparked(body) {
     }
 }
 async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, gateBefore) {
-    if (typeof taskId === 'string' && planReviewDecisionOps.some((op) => op.taskId === taskId && op.phase === 'posting')) {
+    if (typeof taskId === 'string' && planReviewOpsOf(taskId).some((op) => op.phase === 'posting')) {
         hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
     }
-    let op = claimablePlanReviewDecisionOp(taskId);
+    let op = typeof taskId === 'string' ? claimablePlanReviewDecisionOp(taskId) : undefined;
     if (op === undefined) {
-        op = { taskId: typeof taskId === 'string' ? taskId : String(taskId), handedAt: ++planReviewLedgerClock, settledAt: null, settler: null, phase: 'posting', notApplied: false, ownCallOpen: true };
-        pushPlanReviewDecisionOp(op);
+        op = openDecisionOp('plan_review', planReviewLedgerKeys(typeof taskId === 'string' ? taskId : String(taskId)), 'posting', true);
     }
     else {
         if (op.settler === 'gate_left') {
@@ -635,7 +599,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     const settle = (notApplied) => {
         if (notApplied)
             mine.notApplied = true;
-        settlePlanReviewDecisionOp(mine, 'package');
+        settleDecisionOp(mine, 'package');
     };
     const dispatchNo = ++decideDispatchSeq;
     hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${decision} mode=${permissionModeAfter ?? '-'}`);
@@ -644,7 +608,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     }
     finally {
         releaseLatch();
-        settlePlanReviewDecisionOp(mine, 'package');
+        settleDecisionOp(mine, 'package');
         mine.ownCallOpen = false;
     }
 }
@@ -912,10 +876,10 @@ function joinReopenFlight(flight, taskId, receiptMs) {
         abortableSleep(Math.max(0, receiptMs), ac.signal).then(() => false),
     ]).then((presented) => {
         ac.abort();
-        return presented ? { reopened: true, firstSight: false } : { reopened: false };
+        return presented ? { reopened: true, firstSight: false } : refusedReopen('not_presented');
     }, () => {
         ac.abort();
-        return { reopened: false };
+        return refusedReopen('not_presented');
     });
 }
 function mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs) {
@@ -955,10 +919,10 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
     const markBefore = dismissalEntryFor(sessionKey, taskId);
     const settleOnReceipt = (receipt, firstSight) => receipt.then((presented) => {
         if (!presented)
-            return { reopened: false };
+            return refusedReopen('not_presented');
         revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
         return { reopened: true, firstSight };
-    }, () => ({ reopened: false }));
+    }, () => refusedReopen('not_presented'));
     const canonicalId = planReviewQuestionId(taskId);
     const armedKey = planReviewArmedKeyFor(sessionKey, taskId);
     const firstSight = !wasGateArmedFor(sessionKey, armedKey);
@@ -1017,6 +981,9 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
     publishQuestionFrameFor(sessionKey, planReviewQuestionFrame(questionId, REOPEN_QUESTION, false, true));
     return settleOnReceipt(receipt, firstSight);
 }
+function refusedReopen(cause) {
+    return { reopened: false, _sema_reopenRefusal: cause };
+}
 function noPresentationSurfaceVerdict(taskId, sessionKey) {
     const verdict = { reopened: false, _sema_noPresentationSurface: true };
     hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — nothing is subscribed to question frames for session ` +
@@ -1039,7 +1006,7 @@ async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, ma
                 }
             }
         }
-        const ledgerSaysInFlight = planReviewDecisionInFlight(taskId, recheckReadStart);
+        const ledgerSaysInFlight = decisionInFlightOf({ gate: 'plan_review', taskId }, recheckReadStart);
         if (ledgerSaysInFlight) {
             hostLog('debug', `planReviewWire: reopen for task ${taskId} refused after the dismissal check — a decision for this task went out while the check was reading`);
             return { reopened: false, _sema_decisionInFlight: true };
@@ -1088,24 +1055,26 @@ async function staleDismissalVerdict(current, sessionKey, taskId, receiptMs) {
     const windowEnd = abortableSleep(Math.max(0, receiptMs), ac.signal).then(() => false);
     try {
         let entry = current;
+        let lastWaitPresented;
         for (let round = 0; round < 8; round++) {
             if (entry?.kind === 'decided')
                 return { reopened: false, _sema_decisionInFlight: true };
             if (entry?.kind === 'dismissed')
                 return { reopened: false, dismissedByUser: true };
             if (entry?.kind !== 'reopened' || entry.onScreen === undefined)
-                return { reopened: false };
+                return refusedReopen(entry === undefined && lastWaitPresented === false ? 'not_presented' : 'gate_record_gone');
             const onScreen = await Promise.race([
                 entry.onScreen.then((v) => v === true, () => false),
                 windowEnd,
             ]);
             const now = dismissalEntryFor(sessionKey, taskId);
             if (now === entry) {
-                return onScreen ? { reopened: true, firstSight: !wasGateArmedFor(sessionKey, planReviewArmedKeyFor(sessionKey, taskId)) } : { reopened: false };
+                return onScreen ? { reopened: true, firstSight: !wasGateArmedFor(sessionKey, planReviewArmedKeyFor(sessionKey, taskId)) } : refusedReopen('not_presented');
             }
+            lastWaitPresented = onScreen;
             entry = now;
         }
-        return { reopened: false };
+        return refusedReopen('gate_record_gone');
     }
     finally {
         ac.abort();
@@ -1115,25 +1084,25 @@ export function reopenPlanReviewCard(taskId, opts) {
     const receiptMs = opts?.presentationReceiptMs;
     if (typeof receiptMs !== 'number' || Number.isNaN(receiptMs)) {
         hostLog('debug', `planReviewWire: reopen for task ${String(taskId)} refused — presentationReceiptMs is required (a number of milliseconds); the synchronous form was retired in 0.98.0`);
-        return Promise.resolve({ reopened: false });
+        return Promise.resolve(refusedReopen('invalid_call'));
     }
     try {
         if (typeof taskId !== 'string' || taskId.length === 0) {
-            return Promise.resolve({ reopened: false });
+            return Promise.resolve(refusedReopen('invalid_call'));
         }
         const injected = opts;
         if (opts?.mintFreshQuestionId === false && (injected?.deliverDecision !== undefined || injected?.wire !== undefined || injected?.onOutcome !== undefined)) {
             hostLog('error', `planReviewWire: plan_review reopen for task ${taskId} refused — mintFreshQuestionId:false reuses the armed card's responder and its delivery, ` +
                 'so deliverDecision / wire / onOutcome cannot be given with it; drop mintFreshQuestionId:false to deliver through the injected path');
-            return Promise.resolve({ reopened: false });
+            return Promise.resolve(refusedReopen('invalid_call'));
         }
         const readStart = typeof opts.pendingReadStartedAt === 'number' && Number.isFinite(opts.pendingReadStartedAt) ? opts.pendingReadStartedAt : undefined;
-        if (planReviewDecisionInFlight(taskId, readStart)) {
+        if (decisionInFlightOf({ gate: 'plan_review', taskId }, readStart)) {
             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 Promise.resolve(refused);
         }
-        const guardStartedAt = planReviewPendingReadMark();
+        const guardStartedAt = decisionReadMark();
         const recheckReadStart = readStart === undefined ? guardStartedAt : Math.min(readStart, guardStartedAt);
         const sessionKey = opts.sessionKey ?? DEFAULT_SESSION_KEY;
         if (!hasQuestionOverlayFor(sessionKey)) {
@@ -1144,7 +1113,7 @@ export function reopenPlanReviewCard(taskId, opts) {
                 '而缺省决断投递口(decidePlanReview)今天固定打默认槽的 baseUrl/token/principal。' +
                 '整条链转 keyed 之前,非默认槽要重开请自带 deliverDecision(按本槽投递);' +
                 '此处拒绝而不是照发 —— 照发会把这条会话的决断发到另一个槽上。');
-            return Promise.resolve({ reopened: false });
+            return Promise.resolve(refusedReopen('no_delivery_path'));
         }
         const trigger = opts.trigger === undefined ? undefined : opts.trigger === 'user' ? 'user' : 'automatic';
         if (trigger === 'automatic') {
@@ -1155,6 +1124,6 @@ export function reopenPlanReviewCard(taskId, opts) {
         return mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
     }
     catch {
-        return Promise.resolve({ reopened: false });
+        return Promise.resolve(refusedReopen('internal_error'));
     }
 }

package/dist/hitl/sessionPolicyDeliverable.js

@@ -4,7 +4,8 @@ import { ruleCompileVerdict } from '../ruleCompileVerdict.js';
 import { readRuleEntry } from '../coreValuePorts.js';
 import { readOwnDataValue } from '../ownKey.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.js';
-import { PREFIXES_IN_PROSE, REFUSED_NAME_CLASSES, REFUSED_NAME_FIX } from './refusedToolNameProse.js';
+import { PREFIXES_IN_PROSE, REFUSED_NAME_FIX } from './refusedToolNameProse.js';
+import { prepareRefusalNoteOf } from '../prepareRefusal.js';
 import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
 const COVERING_NAMESPACE_PREFIXES = CORE_PROTOCOL_PREFIXES;
 const WITHHELD_NOTICE = {
@@ -170,10 +171,6 @@ export function sessionPolicyWithheldNotice(why) {
         ? WITHHELD_NOTICE[why]
         : 'Not written to this session’s rule record.';
 }
-const LEGACY_TOOL_NAME_FAILURE_NOTE = `This run did not start: a tool rule applied to it names a tool the engine refuses — ${REFUSED_NAME_CLASSES} (the engine's own error text names the entry). ` +
-    'Every later run fails the same way until that entry is removed from wherever it is set: this session’s rule record, the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules.';
 export function legacyToolNameFailureNoteOf(code) {
-    if (code === CONFIG_LEGACY_TOOL_NAME)
-        return LEGACY_TOOL_NAME_FAILURE_NOTE;
-    return undefined;
+    return code === CONFIG_LEGACY_TOOL_NAME ? prepareRefusalNoteOf(code) : undefined;
 }

package/dist/hitl/toolApprovalWire.js

@@ -17,11 +17,11 @@ import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, sur
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { frameBindingOf } from '../frameBinding.js';
-import { approvalDecisionHolds, approvalHoldFor, awaitApprovalHolder, claimApprovalCardFor, holdLiveCard, joinLiveCard, liveCardHoldOf, clearSettledApprovals, noteHolderSettledApproval, settledApprovalOf, settledForDurableLane, settledLiveCardOutcome } from './approvalHolds.js';
+import { carriesAttributionKey, deliverWithAttributionLadder } from './attributionLadder.js';
+import { approvalDecisionHolds, approvalHoldFor, awaitApprovalHolder, claimApprovalCardFor, enterLiveRespondPhase, holdLiveCard, joinLiveCard, liveCardHoldOf, clearSettledApprovals, noteHolderSettledApproval, settledApprovalOf, settledForDurableLane, settledLiveCardOutcome } from './approvalHolds.js';
 import { joinedResolution, resolutionOfDecisionFailure } from './approvalResolution.js';
 import { parkRowDeadlineState } from './parkExpiryJudgements.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';
@@ -462,49 +462,30 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 try {
                     const denyPayload = { decision: 'deny', reason: answerPayloadFor({ kind: 'deny', ...(denyReasonSnapshot !== undefined ? { reason: denyReasonSnapshot } : {}) }, 'decide').reason };
                     const denyBody = { ...denyPayload, ...attributionKeys };
-                    let attributionDropped = false;
-                    let attributionRenamed = false;
+                    const ladder = { lastCarried: carriesAttributionKey(attributionKeys), dropped: false, renamed: false };
                     let raw;
-                    lastSendCarriedAttribution = carriesAttributionKey(attributionKeys);
+                    lastSendCarriedAttribution = ladder.lastCarried;
                     emitAnswerCommitted(callKey, 'decide', card, denyPayload);
                     try {
-                        raw = await bridge.decideTool(denyBody, gatedCallId, decideOpts, pending);
+                        raw = await deliverWithAttributionLadder(denyBody, (b) => bridge.decideTool(b, gatedCallId, decideOpts, pending), signal, ladder, (step) => {
+                            hostLog('debug', step === 'renamed'
+                                ? `liveToolApprovalWire: decide(deny) for task ${taskId} was refused because the settlement note was sent under a name ` +
+                                    'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
+                                    '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)'
+                                : step === 'dropped'
+                                    ? `liveToolApprovalWire: decide(deny) for task ${taskId} was refused because the settlement note is not part of ` +
+                                        'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
+                                        '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)'
+                                    : `liveToolApprovalWire: decide(deny) for task ${taskId} was refused again because the settlement note is not part of ` +
+                                        'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
+                                        '(still before the approval was judged)');
+                        });
                     }
-                    catch (first) {
-                        if (shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal)) {
-                            const withoutAttribution = withoutAttributionKey(denyBody);
-                            lastSendCarriedAttribution = false;
-                            hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} was refused because the settlement note is not part of ` +
-                                'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
-                                '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
-                            raw = await bridge.decideTool(withoutAttribution, gatedCallId, decideOpts, pending);
-                            attributionDropped = true;
-                        }
-                        else if (shouldResendUnderSuccessorKey(first, Object.hasOwn(denyBody, 'settledBy'), signal)) {
-                            const renamed = withAttributionKeyRenamed(denyBody);
-                            hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} was refused because the settlement note was sent under a name ` +
-                                'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
-                                '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
-                            try {
-                                raw = await bridge.decideTool(renamed, gatedCallId, decideOpts, pending);
-                                attributionRenamed = true;
-                            }
-                            catch (second) {
-                                if (!shouldResendWithoutAttribution(second, true, signal))
-                                    throw second;
-                                const renamedWithoutAttribution = withoutAttributionKey(renamed);
-                                lastSendCarriedAttribution = false;
-                                hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} was refused again because the settlement note is not part of ` +
-                                    'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
-                                    '(still before the approval was judged)');
-                                raw = await bridge.decideTool(renamedWithoutAttribution, gatedCallId, decideOpts, pending);
-                                attributionDropped = true;
-                            }
-                        }
-                        else {
-                            throw first;
-                        }
+                    finally {
+                        lastSendCarriedAttribution = ladder.lastCarried;
                     }
+                    const attributionDropped = ladder.dropped;
+                    const attributionRenamed = ladder.renamed;
                     const receipt = readDecideReceipt(raw);
                     const deny = denyFactsOf(denySettledByForWire, denyReasonSnapshot, attributionDropped, attributionRenamed);
                     return {
@@ -872,39 +853,11 @@ function readPersistedRuleAnchors(v) {
 function isNonNegativeSafeInt(v) {
     return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
 }
-function shouldResendWithoutAttribution(e, sentAttributionKey, signal) {
-    if (!sentAttributionKey)
-        return false;
-    if (signal?.aborted === true)
-        return false;
-    return denyAttributionRefusalFromError(e, true)?.kind === 'not_in_proof';
-}
-function shouldResendUnderSuccessorKey(e, lastSendCarriedRetiredKey, signal) {
-    if (!lastSendCarriedRetiredKey)
-        return false;
-    if (signal?.aborted === true)
-        return false;
-    return denyAttributionRefusalFromError(e, true)?.kind === 'retired_key';
-}
 export function decisionAttributionKeyOf(reading, denySettledBy) {
     if (denySettledBy !== 'policy')
         return {};
     return approvalDecidedByAdmitted(reading) ? { decidedBy: 'policy' } : { settledBy: 'policy' };
 }
-function carriesAttributionKey(body) {
-    return Object.hasOwn(body, 'settledBy') || Object.hasOwn(body, 'decidedBy');
-}
-function withoutAttributionKey(body) {
-    const { settledBy: _droppedSettledBy, decidedBy: _droppedDecidedBy, ...rest } = body;
-    void _droppedSettledBy;
-    void _droppedDecidedBy;
-    return rest;
-}
-function withAttributionKeyRenamed(body) {
-    const { settledBy, decidedBy: _replaced, ...rest } = body;
-    void _replaced;
-    return settledBy === undefined ? rest : { ...rest, decidedBy: settledBy };
-}
 function readDecidedByReadingOf(holder) {
     try {
         return readOwnDataValue(holder, 'approvalDecidedBy');
@@ -986,7 +939,7 @@ function probeCauseSentence(cause, withProse, lang) {
         const key = withProse
             ? withCode ? 'approval.probe.withProseCode' : 'approval.probe.withProse'
             : withCode ? 'approval.probe.noProseCode' : 'approval.probe.noProse';
-        return renderMessage(withCode ? msg(key, { code }) : msg(key), lang);
+        return renderMessage(withCode ? msg(key, { code: displayUntrusted(code) }) : msg(key), lang);
     }
     catch {
         return undefined;
@@ -1190,7 +1143,7 @@ export function classifierNoRulingDetail(word, lang) {
         return renderMessage(msg(CLASSIFIER_NO_RULING_REASONS[word]), lang);
     }
     if (typeof word === 'string' && CAUSE_WORD.test(word))
-        return renderMessage(msg('approval.classifier.noRulingOther', { reason: word }), lang);
+        return renderMessage(msg('approval.classifier.noRulingOther', { reason: displayUntrusted(word) }), lang);
     return renderMessage(msg('approval.classifier.noRulingBare'), lang);
 }
 export function approvalBoundGrantsDetail(grants, lang) {
@@ -1863,7 +1816,7 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
         return { kind: 'not_sent', lane: 'respond', cause: 'retracted' };
     }
     if (card.kind === 'aborted') {
-        hold.phase = 'respond';
+        enterLiveRespondPhase(hold);
         const interruptOpts = lane?.approvalDecisionNoteCapable === true ? { note: INTERRUPT_DENY_REASON } : {};
         let interruptDeny;
         try {
@@ -1877,7 +1830,7 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
         hostLog('debug', `liveToolApprovalWire: ${approvalId} card aborted — one tool-level deny issued to settle the pending ask`);
         return { kind: 'unsettled', lane: 'respond', cause: 'interrupted' };
     }
-    hold.phase = 'respond';
+    enterLiveRespondPhase(hold);
     const noteCapable = lane?.approvalDecisionNoteCapable === true;
     const denyReasonRead = card.kind === 'deny' ? ((r) => (typeof r === 'string' ? r : undefined))(card.reason) : undefined;
     const answerSnapshot = card.kind === 'deny'
@@ -1982,49 +1935,30 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
             ...(note !== undefined ? { note } : {}),
             ...attributionKeys,
         };
-        let attributionDropped = false;
-        let attributionRenamed = false;
+        const ladder = { lastCarried: lastSendCarriedAttribution, dropped: false, renamed: false };
         let raw;
         if (basePayload !== undefined)
             emitAnswerCommitted(liveFrameCallKey(approvalId), 'respond', answerSnapshot, basePayload);
         try {
-            raw = await respond(approvalId, decision, respondOpts);
+            raw = await deliverWithAttributionLadder(respondOpts, (o) => respond(approvalId, decision, o), signal, ladder, (step) => {
+                hostLog('debug', step === 'renamed'
+                    ? `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note was sent under a name ` +
+                        'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
+                        '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)'
+                    : step === 'dropped'
+                        ? `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note is not part of ` +
+                            'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
+                            '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)'
+                        : `liveToolApprovalWire: respond(deny) for ${approvalId} was refused again because the settlement note is not part of ` +
+                            'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
+                            '(still before the approval was judged)');
+            });
         }
-        catch (first) {
-            if (shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal)) {
-                const withoutAttribution = withoutAttributionKey(respondOpts);
-                lastSendCarriedAttribution = false;
-                hostLog('debug', `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note is not part of ` +
-                    'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
-                    '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
-                raw = await respond(approvalId, decision, withoutAttribution);
-                attributionDropped = true;
-            }
-            else if (shouldResendUnderSuccessorKey(first, Object.hasOwn(respondOpts, 'settledBy'), signal)) {
-                const renamed = withAttributionKeyRenamed(respondOpts);
-                hostLog('debug', `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note was sent under a name ` +
-                    'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
-                    '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
-                try {
-                    raw = await respond(approvalId, decision, renamed);
-                    attributionRenamed = true;
-                }
-                catch (second) {
-                    if (!shouldResendWithoutAttribution(second, true, signal))
-                        throw second;
-                    const renamedWithoutAttribution = withoutAttributionKey(renamed);
-                    lastSendCarriedAttribution = false;
-                    hostLog('debug', `liveToolApprovalWire: respond(deny) for ${approvalId} was refused again because the settlement note is not part of ` +
-                        'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
-                        '(still before the approval was judged)');
-                    raw = await respond(approvalId, decision, renamedWithoutAttribution);
-                    attributionDropped = true;
-                }
-            }
-            else {
-                throw first;
-            }
+        finally {
+            lastSendCarriedAttribution = ladder.lastCarried;
         }
+        const attributionDropped = ladder.dropped;
+        const attributionRenamed = ladder.renamed;
         const parkingBody = readToolApprovalRespondParking(raw);
         if (parkingBody !== undefined) {
             const parking = parkingBody.kind === 'parking' && parkingBody.view.approvalId === approvalId ? parkingBody.view : undefined;

package/dist/hostTurnSettings.d.ts

@@ -1,14 +1,19 @@
+import type { TaskRequest } from '@sema-agent/sdk';
 import type { WireHooksConfig } from './finalVerifyWire.js';
+import type { memoryOffDeclared as MemoryOffDeclared } from './request/taskRequest.js';
+import type { EnvLike } from './hostEnv.js';
 import type { SettingsDocument } from './host.js';
 import { type HookSettingsSource, type HooksWirePlan } from './pluginHooksWire.js';
-export declare const HOST_SUPPLIED_KEYS: readonly ["settings.hooks", "settings.resolved", "settings.webSearch", "settings.outputStyle"];
+import { type WebSearchApiKeyFor } from './webSearchWireCaps.js';
+import { type FileHistoryCaptureReading } from './fileHistoryCaptureCapability.js';
+export declare const HOST_SUPPLIED_KEYS: readonly ["settings.hooks", "settings.resolved", "settings.webSearch", "settings.outputStyle", "memory", "fileHistory"];
 export type HostSuppliedKey = (typeof HOST_SUPPLIED_KEYS)[number];
-export declare const HOST_SETTING_CAUSES: readonly ["carried", "entries_dropped", "source_rejected", "projection_failed", "source_unreadable", "empty", "no_source", "host_port_missing"];
+export declare const HOST_SETTING_CAUSES: readonly ["carried", "entries_dropped", "source_rejected", "projection_failed", "source_unreadable", "empty", "no_source", "host_port_missing", "value_malformed"];
 export type HostSettingCause = (typeof HOST_SETTING_CAUSES)[number];
 export declare const HOST_SETTING_DISPOSITIONS: readonly ["carry", "carry_partial", "withhold_notice", "refuse_turn", "unwired", "nothing_to_carry"];
 export type HostSettingDisposition = (typeof HOST_SETTING_DISPOSITIONS)[number];
 export type HostSettingPlane = 'turn' | 'session' | 'diagnostic';
-export type HostSettingNoticeId = 'HS-UNWIRED' | 'HS-MANAGED-REJECTED' | 'HS-PROJECTION' | 'HS-SOURCE-UNREADABLE';
+export type HostSettingNoticeId = 'HS-UNWIRED' | 'HS-MANAGED-REJECTED' | 'HS-PROJECTION' | 'HS-SOURCE-UNREADABLE' | 'HS-WEBSEARCH-MALFORMED' | 'HS-SWITCH-MALFORMED' | 'HS-FILEHISTORY-UNJUDGED';
 export interface HostSettingRow {
     readonly key: HostSuppliedKey;
     readonly cause: HostSettingCause;
@@ -33,12 +38,24 @@ export interface HostTurnSettingsSources {
     readonly resolved: {
         readonly snapshot: SettingsDocument;
     } | 'none';
-    readonly webSearch: {
-        readonly settings: SettingsDocument;
-    } | 'none';
+    readonly webSearch: HostWebSearchSource | 'none';
     readonly outputStyle: {
         readonly name: string;
     } | 'none';
+    readonly memory: HostMemorySource | 'none';
+    readonly fileHistory: {
+        readonly reading: FileHistoryCaptureReading;
+        readonly captureOff: boolean;
+    } | 'none';
+}
+export interface HostWebSearchSource {
+    readonly section?: SettingsDocument;
+    readonly env: EnvLike;
+    readonly apiKeyFor?: WebSearchApiKeyFor;
+}
+export interface HostMemorySource {
+    readonly flag?: string;
+    readonly settingsMemory?: SettingsDocument;
 }
 export interface HostTurnSettingsInput {
     readonly sources: HostTurnSettingsSources;
@@ -48,6 +65,8 @@ export interface HostSettingsCarried {
     readonly resolved?: SettingsDocument;
     readonly webSearch?: SettingsDocument;
     readonly outputStyle?: string;
+    readonly memory?: TaskRequest['memory'];
+    readonly fileHistory?: TaskRequest['fileHistory'];
 }
 declare const hostTurnSettingsBrand: unique symbol;
 export interface HostTurnSettings {
@@ -58,14 +77,34 @@ export interface HostTurnSettings {
     readonly hooks: HooksWirePlan | undefined;
     readonly carried: HostSettingsCarried;
 }
+export interface HostTurnSettingsJudges {
+    readonly materialize: HostResolvedMaterializer;
+    readonly memoryOffDeclared: typeof MemoryOffDeclared;
+}
 export declare function rethrowHostResolvedDeferred(product: HostTurnSettings): void;
 export type HostResolvedMaterializer = (snapshot: SettingsDocument) => SettingsDocument;
-export declare function buildHostTurnSettings(input: HostTurnSettingsInput, materialize: HostResolvedMaterializer): HostTurnSettings;
+export declare function buildHostTurnSettings(input: HostTurnSettingsInput, judges: HostTurnSettingsJudges): HostTurnSettings;
 export declare function hostSettingsSelfCheck(product: HostTurnSettings): readonly HostSuppliedKey[];
+export declare const hostProjectionNotice: () => HostSettingNotice;
 export declare class HostSettingsRefused extends Error {
     readonly notice: HostSettingNotice;
     constructor(n: HostSettingNotice);
 }
 export declare function hostTurnSettingsOf(v: unknown, depth?: 'shape' | 'full'): HostTurnSettings | undefined;
+export interface HostHooksIntersection {
+    readonly hooks: WireHooksConfig | undefined;
+    readonly dropped: number;
+    readonly judged: boolean;
+}
+export declare function intersectHostHooks(sent: WireHooksConfig, now: WireHooksConfig | undefined): HostHooksIntersection;
+export interface HostIntakeSnapshot {
+    readonly carried: HostSettingsCarried;
+    readonly refuses: boolean;
+    readonly dispositions: Readonly<Record<HostSuppliedKey, HostSettingDisposition>>;
+    readonly refusingKeys: readonly HostSuppliedKey[];
+    readonly turnNotices: readonly HostSettingNotice[] | undefined;
+    readonly notice: HostSettingNotice | undefined;
+}
+export declare function hostIntakeSnapshotOf(product: HostTurnSettings, onResolved?: (resolved: HostSettingsCarried['resolved']) => void): HostIntakeSnapshot | undefined;
 export declare const UNWIRED_HOST_TURN_SETTINGS: HostTurnSettings;
 export {};