@sema-agent/client-core 0.106.0 → 0.107.0

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -3,6 +3,7 @@ import type { ActiveRunBusySignal } from './runStream.js';
 import type { RejectedSubmissionOrigin } from '../request/submissionIdentity.js';
 import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
 import { type AskParkAutoReopenBlock } from '../hitl/askParkAutoReopenBlock.js';
+import { type CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 export declare const PLAN_REVIEW_GATE_KIND = "plan_review";
 export type DurableDecideLeg = 'approval' | 'plan_review' | 'other_gate' | 'unreadable';
@@ -44,6 +45,9 @@ export type ReopenCardVerdict = {
     _sema_errorCode?: string;
     _sema_reopenRefusal?: PlanReviewReopenRefusal;
     _sema_policyBlocked?: AskParkAutoReopenBlock;
+    _sema_rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 } | {
     reopened: true;
     firstSight: boolean;
@@ -147,6 +151,9 @@ export type SelfHealOutcome = {
     noPresentationSurface?: true;
     errorCode?: string;
     policyBlocked?: AskParkAutoReopenBlock;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 } | {
     kind: 'ask-decided-without-card';
     taskId: string;
@@ -162,6 +169,7 @@ export type SelfHealOutcome = {
     delivery: string | null;
     status: string | null;
     reopened: ReopenCardVerdict | null;
+    messageId?: string;
 } | {
     kind: 'running-steer-failed';
     taskId: string;

package/dist/adapter/activeRunSelfHeal.js

@@ -6,6 +6,7 @@ import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { ASK_PARK_AUTO_REOPEN_BLOCKS, askParkAutoReopenBlockedContent } from '../hitl/askParkAutoReopenBlock.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
 import { readThrownStatusSlot } from '../wireFailureShape.js';
+import { checkpointRowBarOf, checkpointRowBarSentence } from '../checkpointRowVerdict.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
@@ -145,6 +146,12 @@ function injectedCarrierVerdict(items, busyTaskId) {
         return null;
     return allNameBusyRun && present === length ? 'redundant' : 'deferred';
 }
+function injectedCarrierVerdictOf(deps, busyTaskId) {
+    return deps?.submissionOrigin === 'injected' ? injectedCarrierVerdict(guardedRead(() => deps?.injectedCarriers), busyTaskId) : null;
+}
+function runSettledOutcome(carrierVerdict, settled) {
+    return carrierVerdict === 'redundant' ? { kind: 'injected-redundant', taskId: settled.taskId } : settled;
+}
 function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
@@ -207,6 +214,7 @@ const REOPEN_VERDICT_KEYS = [
     '_sema_errorCode',
     '_sema_reopenRefusal',
     '_sema_policyBlocked',
+    '_sema_rowVerdict',
 ];
 function snapshotReopenVerdict(raw) {
     if (raw === null || raw === undefined)
@@ -320,6 +328,16 @@ function reopenPolicyBlockedOf(verdict) {
         return undefined;
     }
 }
+function reopenRowVerdictOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        return checkpointRowBarOf({ rowVerdict: verdict._sema_rowVerdict });
+    }
+    catch {
+        return undefined;
+    }
+}
 function reopenRefusalOf(verdict) {
     try {
         if (verdict.reopened !== false)
@@ -583,6 +601,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
             detail: 'the engine did not name the run that holds this session',
         };
     }
+    const carrierVerdict = injectedCarrierVerdictOf(deps, taskId);
     const gateKind = signal.pendingGate?.kind ?? null;
     const gateLeg = durableDecideLegOf({ gateKind });
     const pendingCp = signal.pendingGate?.checkpointId;
@@ -590,7 +609,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (gateLeg === 'plan_review')
         return planReviewArm(taskId, signal, deps, sameTaskCp);
     if (gateLeg === 'approval')
-        return askParkArm(taskId, signal, runs, deps);
+        return askParkArm(taskId, signal, runs, carrierVerdict, deps);
     let status = signal.activeTaskStatus;
     const statusFresh = status === null;
     if (status === null) {
@@ -610,16 +629,16 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         return { kind: 'state-unknown', taskId, detail: 'the engine reported no status for that run' };
     }
     if (isSdkRunTerminal(status))
-        return { kind: 'running-settled', taskId, status };
+        return runSettledOutcome(carrierVerdict, { kind: 'running-settled', taskId, status });
     const triageGate = signal.pendingGate && !statusFresh ? { pendingGateKind: signal.pendingGate.kind ?? null } : {};
     if (gateKind !== null)
         return { kind: 'not-parked', taskId, status, ...triageGate };
     if (PLAN_REVIEW_STATES.includes(status))
         return planReviewArm(taskId, signal, deps);
     if (ASK_PARK_STATES.includes(status))
-        return askParkArm(taskId, signal, runs, deps);
+        return askParkArm(taskId, signal, runs, carrierVerdict, deps);
     if (RUNNING_STATES.includes(status)) {
-        return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, deps);
+        return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, carrierVerdict, deps);
     }
     return { kind: 'not-parked', taskId, status, ...triageGate };
 }
@@ -668,7 +687,7 @@ async function planReviewArm(taskId, signal, deps, checkpointId) {
         ...(reopenRefusal !== undefined ? { reopenRefusal } : {}),
     };
 }
-async function askParkArm(taskId, signal, runs, deps) {
+async function askParkArm(taskId, signal, runs, carrierVerdict, deps) {
     const verdict = await askVerdict(taskId, deps);
     if (reopenDelivered(verdict))
         return { kind: 'ask-reopened', taskId, firstSight: verdict.firstSight === true };
@@ -692,17 +711,18 @@ async function askParkArm(taskId, signal, runs, deps) {
             };
         }
         if (release.lastStatus !== null && RUNNING_STATES.includes(release.lastStatus)) {
-            return runningChoiceArm(taskId, release.lastStatus, signal, false, runs, deps);
+            return runningChoiceArm(taskId, release.lastStatus, signal, false, runs, carrierVerdict, deps);
         }
         return { kind: 'ask-decided-release-unknown', taskId, lastStatus: release.lastStatus };
     }
     const inFlight = reopenRefusedForDecisionInFlight(verdict);
     if (verdict.reopened === false && verdict.decidedWithoutCard !== true && verdict.pendingRowGone === true && !inFlight) {
-        return staleParkArm(taskId, signal, runs, deps);
+        return staleParkArm(taskId, signal, runs, carrierVerdict, deps);
     }
     const noView = reopenRefusedForNoPresentationSurface(verdict);
     const policyBlocked = inFlight || noView ? undefined : reopenPolicyBlockedOf(verdict);
-    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) || policyBlocked !== undefined ? undefined : reopenErrorCodeOf(verdict);
+    const rowVerdict = inFlight ? undefined : reopenRowVerdictOf(verdict);
+    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) || policyBlocked !== undefined || rowVerdict !== undefined ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'ask-reopen-failed',
         taskId,
@@ -712,6 +732,7 @@ async function askParkArm(taskId, signal, runs, deps) {
         ...(noView ? { noPresentationSurface: true } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
         ...(policyBlocked !== undefined ? { policyBlocked } : {}),
+        ...(rowVerdict !== undefined ? { rowVerdict } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
@@ -738,7 +759,7 @@ async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
         status = readStatusGuarded(record);
     return errorCode !== undefined ? { status, ghost, errorCode } : { status, ghost };
 }
-async function staleParkArm(taskId, busy, runs, deps) {
+async function staleParkArm(taskId, busy, runs, carrierVerdict, deps) {
     const reopenFailed = {
         kind: 'ask-reopen-failed',
         taskId,
@@ -766,11 +787,11 @@ async function staleParkArm(taskId, busy, runs, deps) {
     if (fresh === null)
         return withFailureCode(reopenFailed, first.errorCode);
     if (RUNNING_STATES.includes(fresh))
-        return runningChoiceArm(taskId, fresh, busy, false, runs, deps);
+        return runningChoiceArm(taskId, fresh, busy, false, runs, carrierVerdict, deps);
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
     if (isSdkRunTerminal(fresh))
-        return { kind: 'ask-run-settled', taskId, status: fresh };
+        return runSettledOutcome(carrierVerdict, { kind: 'ask-run-settled', taskId, status: fresh });
     if (!ASK_PARK_STATES.includes(fresh))
         return reopenFailed;
     const offer = deps?.offerStaleParkChoice;
@@ -809,7 +830,7 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return withFailureCode(reopenFailedAfterCard, afterCard.errorCode);
     if (!ASK_PARK_STATES.includes(afterCard.status)) {
         if (isSdkRunTerminal(afterCard.status))
-            return { kind: 'ask-run-settled', taskId, status: afterCard.status };
+            return runSettledOutcome(carrierVerdict, { kind: 'ask-run-settled', taskId, status: afterCard.status });
         if (RUNNING_STATES.includes(afterCard.status))
             return { kind: 'not-parked', taskId, status: afterCard.status };
         return !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
@@ -871,11 +892,10 @@ async function cancelAndConfirmRelease(taskId, durable, durableGet, deps) {
             (verdict.lastStatus !== null && CLAIM_HELD_STATES.includes(verdict.lastStatus)),
     };
 }
-async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps) {
+async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, carrierVerdict, deps) {
     const notParked = { kind: 'not-parked', taskId, status };
     const offer = deps?.offerRunningChoice;
     const injected = deps?.submissionOrigin === 'injected';
-    const carrierVerdict = injected ? injectedCarrierVerdict(guardedRead(() => deps?.injectedCarriers), taskId) : null;
     if (typeof offer !== 'function' && !injected)
         return notParked;
     const text = typeof deps?.deniedMessage === 'string' ? deps.deniedMessage : '';
@@ -895,7 +915,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         if (probeCallerAborted())
             return notParked;
         if (fresh !== null) {
-            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps);
+            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps, carrierVerdict);
             if (routed !== undefined)
                 return routed;
         }
@@ -936,16 +956,17 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     if (choice === 'steer' && canSteer && runs?.steer !== undefined) {
         try {
             const receipt = await runs.steer(taskId, steerBodyOf({ text }, UNOBSERVED_STEER_PRIORITY), sessionOpts(deps));
-            const { delivery, status: receiptStatus } = readSteerReceipt(receipt);
+            const { delivery, status: receiptStatus, messageId } = readSteerReceipt(receipt);
+            const handedId = messageId !== undefined ? { messageId } : {};
             if (delivery === 'queued') {
                 const verdict = receiptStatus !== null && PLAN_REVIEW_STATES.includes(receiptStatus)
                     ? await planVerdict(taskId, deps)
                     : receiptStatus !== null && ASK_PARK_STATES.includes(receiptStatus)
                         ? await askVerdict(taskId, deps)
                         : null;
-                return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: verdict };
+                return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: verdict, ...handedId };
             }
-            return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: null };
+            return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: null, ...handedId };
         }
         catch (e) {
             const delivery = atMostOnceFailureClass(e);
@@ -974,7 +995,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
             return { kind: 'running-not-found', taskId };
         if (probeCallerAborted() || preFire.status === null)
             return notParked;
-        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps);
+        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps, carrierVerdict);
         if (rerouted !== undefined)
             return rerouted;
         const verdict = await cancelAndConfirmRelease(taskId, runs, runs.get, deps);
@@ -996,15 +1017,15 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         return { kind: 'running-attach', taskId };
     return notParked;
 }
-async function routeFreshNonRunning(fresh, taskId, busy, runs, deps) {
+async function routeFreshNonRunning(fresh, taskId, busy, runs, deps, carrierVerdict) {
     if (RUNNING_STATES.includes(fresh))
         return undefined;
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
     if (ASK_PARK_STATES.includes(fresh))
-        return askParkArm(taskId, busy, runs, deps);
+        return askParkArm(taskId, busy, runs, carrierVerdict, deps);
     if (isSdkRunTerminal(fresh))
-        return { kind: 'running-settled', taskId, status: fresh };
+        return runSettledOutcome(carrierVerdict, { kind: 'running-settled', taskId, status: fresh });
     return { kind: 'not-parked', taskId, status: fresh };
 }
 export const INTERACTIVE_WAY_OUT = EN_MESSAGES['session.selfHeal.wayOut.interactive'];
@@ -1190,6 +1211,13 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
         case 'ask-reopen-failed': {
             if (outcome.decisionInFlight === true)
                 return decisionInFlightRow('ask', outcome.taskId, lang);
+            if (outcome.rowVerdict !== undefined) {
+                return say(lang, 'session.selfHeal.row.askReopenFailed.rowUnresumable', {
+                    taskId: outcome.taskId,
+                    sentence: checkpointRowBarSentence(outcome.rowVerdict),
+                    unbound: msg('approval.decide.unboundWayOut'),
+                });
+            }
             if (outcome.policyBlocked !== undefined)
                 return askParkAutoReopenBlockedContent(outcome.policyBlocked, outcome.taskId, 'interactive', lang);
             const viaEngine = engineDecide && outcome.decidePath ? msg('session.selfHeal.viaEngine', { decidePath: outcome.decidePath }) : '';

package/dist/checkpointRowVerdict.d.ts

@@ -21,3 +21,9 @@ export type CheckpointRequirementsDamagedReading = {
     readonly kind: 'row_mismatch';
 };
 export declare function checkpointRequirementsDamagedOf(failure: object | null | undefined): CheckpointRequirementsDamagedReading | undefined;
+export type CheckpointRowBar = Exclude<CheckpointRowVerdictReading, {
+    readonly kind: 'ok';
+}>;
+export declare function checkpointRowBarOf(row: object | null | undefined): CheckpointRowBar | undefined;
+export declare const CHECKPOINT_ROW_BAR_SENTENCE: string;
+export declare function checkpointRowBarSentence(bar: CheckpointRowBar): string;

package/dist/checkpointRowVerdict.js

@@ -1,4 +1,5 @@
 import { readErrorString, slotReadOf } from './wireFailureShape.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const UNREADABLE = Object.freeze({ kind: 'unreadable' });
 const OK = Object.freeze({ kind: 'ok' });
 function ownNonEmptyString(o, key) {
@@ -87,3 +88,11 @@ export function checkpointRequirementsDamagedOf(failure) {
         return undefined;
     }
 }
+export function checkpointRowBarOf(row) {
+    const v = checkpointRowVerdictOf(row);
+    return v === undefined || v.kind === 'ok' ? undefined : v;
+}
+export const CHECKPOINT_ROW_BAR_SENTENCE = renderMessage(msg('approval.rowUnresumable.fallback'));
+export function checkpointRowBarSentence(bar) {
+    return bar.kind !== 'unreadable' && typeof bar.sentence === 'string' && bar.sentence !== '' ? bar.sentence : CHECKPOINT_ROW_BAR_SENTENCE;
+}

package/dist/decideReceipt.js

@@ -162,7 +162,7 @@ export function decideRequiresBindingFromError(e) {
     }
 }
 export function decideRequiresBindingContent(_detail, lang) {
-    return renderMessage(msg('approval.decide.requiresBinding'), isUiLanguage(lang) ? lang : undefined);
+    return renderMessage(msg('approval.decide.requiresBinding', { wayOut: msg('approval.decide.unboundWayOut') }), isUiLanguage(lang) ? lang : undefined);
 }
 function askGoneRawCause(e) {
     let top;

package/dist/displayUntrusted.d.ts

@@ -2,6 +2,7 @@ export declare const REDACTION_MARKER_PREFIX = "\u00ABredacted";
 export declare function looksLikeKnownSecret(s: string): boolean;
 export declare function isDiagnosticValueWord(value: string): boolean;
 export declare function percentBoundaryReadingOf(text: string): string;
+type BlankNet = 0 | 1 | 2;
 interface WashStats {
     passes: number;
     capped: boolean;
@@ -13,7 +14,7 @@ export interface DisplayFace {
     readonly unsafe: RegExp | null;
     readonly fold: boolean;
     readonly mark: DisplayMark;
-    readonly keepBlanks?: boolean;
+    readonly blanks?: BlankNet;
     readonly keepCrlf?: boolean;
 }
 export declare function applyDisplayFace(text: string, face: DisplayFace): string;
@@ -26,8 +27,8 @@ export interface DisplayUntrustedOptions {
     readonly keepLayout?: boolean | 'crlf';
     readonly mark?: DisplayMark;
     readonly max?: number;
-    readonly escapeBackslashes?: boolean;
-    readonly blanks?: boolean | 'fillers';
+    readonly escapeBackslashes?: boolean | 'auto';
+    readonly blanks?: boolean | 'except-ideographic';
 }
 export interface DisplayMarkSpan {
     readonly start: number;
@@ -37,6 +38,7 @@ export interface DisplayMarkSpan {
 export interface DisplayUntrustedMarked {
     readonly text: string;
     readonly marks: readonly DisplayMarkSpan[];
+    readonly exact: boolean;
 }
 export declare const DISPLAY_DECISION_BODY: Readonly<DisplayUntrustedOptions>;
 export declare const ESCAPE_FACE: DisplayFace;

package/dist/displayUntrusted.js

@@ -957,13 +957,14 @@ function hiddenHostEnd(text, from, unitAt) {
     const c = text.charCodeAt(k);
     return endsSchemelessHost(c) || c === 0x40 ? k : -1;
 }
+const IDEOGRAPHIC_SPACE = 0x3000;
 const NAME_BLANK_RANGES = [
     [0x00a0, 0x00a0],
     [0x1680, 0x1680],
     [0x2000, 0x200a],
     [0x202f, 0x202f],
     [0x205f, 0x205f],
-    [0x3000, 0x3000],
+    [IDEOGRAPHIC_SPACE, IDEOGRAPHIC_SPACE],
     [0x115f, 0x1160],
     [0x3164, 0x3164],
     [0xffa0, 0xffa0],
@@ -3593,7 +3594,7 @@ const FACE_MARKED_CHAR = new RegExp(`^(?:[${C0_ALL}${DEL_C1}${LONE_SURROGATE}${L
 const isStrippableControl = (c) => (c <= 0x1f && (c < 0x09 || c > 0x0d)) || (c >= 0x7f && c <= 0x9f);
 class SequenceReader {
     text;
-    atomicBlanks;
+    blanks;
     foldBlanks;
     terminator;
     lineBreak;
@@ -3602,9 +3603,9 @@ class SequenceReader {
     breakFrom = -1;
     breakAt = -1;
     foldSpaces;
-    constructor(text, atomicBlanks, foldBlanks = false, foldSpaces = false) {
+    constructor(text, blanks, foldBlanks = false, foldSpaces = false) {
         this.text = text;
-        this.atomicBlanks = atomicBlanks;
+        this.blanks = blanks;
         this.foldBlanks = foldBlanks;
         this.foldSpaces = foldSpaces;
         this.terminator = /[\u0007\u009c]|\u001b\\|\\u(?:0007|009[cC]|001[bB]\\)/g;
@@ -3615,12 +3616,7 @@ class SequenceReader {
             return false;
         if (escapeTokenAt(this.text, at) !== null)
             return true;
-        if (this.atomicBlanks === 'none')
-            return false;
-        const cp = nameBlankTokenAt(this.text, at);
-        if (this.atomicBlanks === 'fillers')
-            return cp !== -1 && !isFoldedBlank(cp);
-        return this.atomicBlanks === 'all' ? cp !== -1 : isFoldedBlank(cp);
+        return isMarkedNameBlank(this.blanks, nameBlankTokenAt(this.text, at));
     }
     intermediateAt(at) {
         const c = this.text.charCodeAt(at);
@@ -3628,11 +3624,12 @@ class SequenceReader {
             return 1;
         if (this.foldSpaces && ((c >= 0x09 && c <= 0x0d) || c === 0x2028 || c === 0x2029))
             return 1;
-        if (!this.foldBlanks)
-            return 0;
-        if (isFoldedBlank(c))
+        if (this.blankAsSpace(c))
             return 1;
-        return c === 0x5c && isFoldedBlank(nameBlankTokenAt(this.text, at)) ? 6 : 0;
+        return c === 0x5c && this.blankAsSpace(nameBlankTokenAt(this.text, at)) ? 6 : 0;
+    }
+    blankAsSpace(cp) {
+        return isFoldedBlank(cp) && (this.foldBlanks || isMarkedNameBlank(this.blanks, cp));
     }
     interruptsAt(at) {
         if (at >= this.text.length)
@@ -3738,7 +3735,7 @@ function nameBlankTokenAt(text, at) {
     return isNameBlank(cp) ? cp : -1;
 }
 function isMarkedNameBlank(net, c) {
-    return net === 1 ? isNameBlank(c) : net === 2 ? isNameBlank(c) && !isRegexSpace(c) : false;
+    return net === 1 ? isNameBlank(c) : net === 2 ? isNameBlank(c) && c !== IDEOGRAPHIC_SPACE : false;
 }
 function buildScanView(text, o) {
     const chars = [];
@@ -3748,7 +3745,7 @@ function buildScanView(text, o) {
     const dropped = [];
     const spaceUnits = [];
     const contents = [];
-    const seq = new SequenceReader(text, o.blanks === 1 ? 'all' : o.blanks === 2 ? 'fillers' : 'none', o.blanks === 1 || o.fold, o.fold);
+    const seq = new SequenceReader(text, o.blanks, o.fold, o.fold);
     const keep = (ch, s, e, unit = UNIT_NONE) => {
         chars.push(ch);
         starts.push(s);
@@ -3945,7 +3942,7 @@ function screenSurfaces(text, o) {
     if (face === null)
         return { surfaces: [], rawSoft: null, rawPlain: null, contents: [] };
     const unsafe = face.unsafe === null ? null : new RegExp(face.unsafe.source, 'u');
-    const keepBlanks = face.keepBlanks === true;
+    const blankNet = face.blanks ?? 0;
     const chars = [];
     const ps = [];
     const pe = [];
@@ -3955,7 +3952,7 @@ function screenSurfaces(text, o) {
     let changed = false;
     const foldable = (at) => {
         const c = text.codePointAt(at) ?? 0;
-        return isRegexSpace(c) && !(keepBlanks && isNameBlank(c));
+        return isRegexSpace(c) && !isMarkedNameBlank(blankNet, c);
     };
     let lo = 0;
     let hi = text.length;
@@ -4648,7 +4645,7 @@ export function washCredentials(text) {
     return scanAndMask(text, WASH_OPTIONS, false).text;
 }
 const NAME_BLANKS = NAME_BLANK_RANGES.map(([a, b]) => (a === b ? classEscape(a) : `${classEscape(a)}-${classEscape(b)}`)).join('');
-const NAME_FILLERS = NAME_BLANK_RANGES.filter(([a, b]) => !isRegexSpace(a) && !isRegexSpace(b))
+const NAME_BLANKS_EXCEPT_IDEOGRAPHIC = NAME_BLANK_RANGES.filter(([a, b]) => !(a <= IDEOGRAPHIC_SPACE && IDEOGRAPHIC_SPACE <= b))
     .map(([a, b]) => (a === b ? classEscape(a) : `${classEscape(a)}-${classEscape(b)}`))
     .join('');
 function classEscape(cp) {
@@ -4777,17 +4774,17 @@ function markOf(ch, mark) {
     return code > 0xffff ? `\\u{${hex}}` : `\\u${hex.padStart(4, '0')}`;
 }
 const FOLD_RUN = /\s+/g;
-const FOLD_RUN_KEEPING_BLANKS = new RegExp(`[^\\S${NAME_BLANKS}]+`, 'g');
+const FOLD_RUN_BY_NET = [FOLD_RUN, new RegExp(`[^\\S${NAME_BLANKS}]+`, 'g'), new RegExp(`[^\\S${NAME_BLANKS_EXCEPT_IDEOGRAPHIC}]+`, 'g')];
 const EDGE_SPACE = /^ | $/g;
-const foldWhitespace = (s, keepBlanks = false) => keepBlanks ? s.replace(FOLD_RUN_KEEPING_BLANKS, ' ').replace(EDGE_SPACE, '') : s.replace(FOLD_RUN, ' ').trim();
+const foldWhitespace = (s, net = 0) => net !== 0 ? s.replace(FOLD_RUN_BY_NET[net] ?? FOLD_RUN, ' ').replace(EDGE_SPACE, '') : s.replace(FOLD_RUN, ' ').trim();
 export function applyDisplayFace(text, face) {
     const markAll = (s) => face.unsafe === null ? s : s.replace(face.unsafe, (ch, at, whole) => (faceHitKept(ch, at, whole, face.keepCrlf === true) ? ch : markOf(ch, face.mark)));
-    const keepBlanks = face.keepBlanks === true;
+    const net = face.blanks ?? 0;
     if (face.mark === 'space') {
         const marked = markAll(text);
-        return face.fold ? foldWhitespace(marked, keepBlanks) : marked;
+        return face.fold ? foldWhitespace(marked, net) : marked;
     }
-    return markAll(face.fold ? foldWhitespace(text, keepBlanks) : text);
+    return markAll(face.fold ? foldWhitespace(text, net) : text);
 }
 function markTracked(t, re, mark, ledger, crlf = false) {
     const parts = [];
@@ -4820,11 +4817,11 @@ function markTracked(t, re, mark, ledger, crlf = false) {
     keep(cursor, t.text.length);
     return { text: parts.join(''), ids: Int32Array.from(ids) };
 }
-function foldTracked(t, keepBlanks) {
+function foldTracked(t, net) {
     const parts = [];
     const ids = [];
     let cursor = 0;
-    for (const run of t.text.matchAll(keepBlanks ? FOLD_RUN_KEEPING_BLANKS : FOLD_RUN)) {
+    for (const run of t.text.matchAll(FOLD_RUN_BY_NET[net] ?? FOLD_RUN)) {
         const at = run.index ?? 0;
         parts.push(t.text.slice(cursor, at));
         for (let k = cursor; k < at; k++)
@@ -4849,14 +4846,14 @@ function foldTracked(t, keepBlanks) {
     return { text: folded.slice(from, to), ids: Int32Array.from(ids.slice(from, to)) };
 }
 function faceTracked(t, face, ledger) {
-    const keepBlanks = face.keepBlanks === true;
+    const net = face.blanks ?? 0;
     const unsafe = face.unsafe;
     const markAll = (x) => (unsafe === null ? x : markTracked(x, unsafe, face.mark, ledger, face.keepCrlf === true));
     if (face.mark === 'space') {
         const marked = markAll(t);
-        return face.fold ? foldTracked(marked, keepBlanks) : marked;
+        return face.fold ? foldTracked(marked, net) : marked;
     }
-    return markAll(face.fold ? foldTracked(t, keepBlanks) : t);
+    return markAll(face.fold ? foldTracked(t, net) : t);
 }
 function carryIds(ids, origin) {
     if (origin === undefined)
@@ -4933,7 +4930,7 @@ function collectMarks(t, ledger) {
 export const DISPLAY_DECISION_BODY = Object.freeze({
     foldLines: false,
     keepLayout: 'crlf',
-    blanks: 'fillers',
+    blanks: 'except-ideographic',
     mark: 'escape',
 });
 const PUBLIC_UNSAFE_BY_NETS = Object.freeze(Array.from({ length: 24 }, (_, i) => {
@@ -4942,12 +4939,12 @@ const PUBLIC_UNSAFE_BY_NETS = Object.freeze(Array.from({ length: 24 }, (_, i) =>
     const controls = (rest & 4) !== 0;
     const bidi = (rest & 2) !== 0;
     const keep = (rest & 1) !== 0;
-    const blanks = net === 1 ? NAME_BLANKS : net === 2 ? NAME_FILLERS : '';
+    const blanks = net === 1 ? NAME_BLANKS : net === 2 ? NAME_BLANKS_EXCEPT_IDEOGRAPHIC : '';
     const members = `${controls ? `${keep ? C0_KEEP_LAYOUT : C0_ALL}${DEL_C1}${LONE_SURROGATE}` : ''}${bidi ? LINE_SEPARATORS : ''}${blanks}`;
     return unsafeClass(members, bidi);
 }));
 function blankNetOf(opts) {
-    return opts.blanks === true ? 1 : opts.blanks === 'fillers' ? 2 : 0;
+    return opts.blanks === true ? 1 : opts.blanks === 'except-ideographic' ? 2 : 0;
 }
 const keepsLayout = (opts) => opts.keepLayout === true || opts.keepLayout === 'crlf';
 function publicFace(opts) {
@@ -4955,7 +4952,7 @@ function publicFace(opts) {
     const keep = !fold && keepsLayout(opts);
     const net = blankNetOf(opts);
     const index = ((opts.controls !== false ? 4 : 0) + (opts.bidi !== false ? 2 : 0) + (keep ? 1 : 0)) * 3 + net;
-    const face = { unsafe: PUBLIC_UNSAFE_BY_NETS[index] ?? null, fold, mark: opts.mark ?? 'escape', keepBlanks: net === 1 };
+    const face = { unsafe: PUBLIC_UNSAFE_BY_NETS[index] ?? null, fold, mark: opts.mark ?? 'escape', blanks: net };
     return keep && opts.keepLayout === 'crlf' && opts.controls !== false ? { ...face, keepCrlf: true } : face;
 }
 export const ESCAPE_FACE = Object.freeze({ ...publicFace({ foldLines: false }) });
@@ -5074,13 +5071,22 @@ function displayInputText(text) {
             return text === null ? '' : REDACTED_SECRET;
     }
 }
+const ENCODED_FORM = /\\\\|\\u(?:[0-9A-Fa-f]{4}|\{[0-9A-Fa-f]{1,6}\})/;
+function pairsByItself(form) {
+    return ENCODED_FORM.test(form.text);
+}
+function pairModeOf(o, face) {
+    if (face.mark === 'dot' || face.mark === 'space')
+        return 'off';
+    return o.escapeBackslashes === true ? 'on' : o.escapeBackslashes === 'auto' ? 'auto' : 'off';
+}
 function renderUntrusted(text, opts, ledger, queryByShape = false, wholeAddress = false) {
     const input = displayInputText(text);
     const o = opts ?? {};
     const face = publicFace(o);
     const scan = scanOptionsOf(o, face, queryByShape, wholeAddress);
-    const pairBackslashes = o.escapeBackslashes === true && face.mark !== 'dot' && face.mark !== 'space';
-    const book = ledger ?? (pairBackslashes ? { cps: [], lens: [] } : null);
+    const mode = pairModeOf(o, face);
+    const book = ledger ?? (mode !== 'off' ? { cps: [], lens: [] } : null);
     if (book === null) {
         return runDisplaySteps(input, {
             wash: (s) => scanAndMask(s, scan, false).text,
@@ -5089,6 +5095,7 @@ function renderUntrusted(text, opts, ledger, queryByShape = false, wholeAddress
             text: (s) => s,
         });
     }
+    let paired = mode === 'on';
     const out = runDisplaySteps({ text: input, ids: new Int32Array(input.length).fill(-1) }, {
         wash: (t) => {
             const r = scanAndMask(t.text, scan, true);
@@ -5096,18 +5103,20 @@ function renderUntrusted(text, opts, ledger, queryByShape = false, wholeAddress
         },
         paint: (t) => faceTracked(t, face, book),
         cap: (t) => {
-            if (pairBackslashes)
+            if (mode === 'auto' && !paired)
+                paired = pairsByItself(t);
+            if (paired)
                 return capPaired(t, o.max);
             const cut = capDisplay(t.text, o.max, face.mark);
             return cut === t.text ? t : { text: cut, ids: t.ids.slice(0, cut.length) };
         },
         text: (t) => t.text,
     });
-    return pairBackslashes ? pairLiteralBackslashes(out) : out;
+    return { tracked: paired ? pairLiteralBackslashes(out) : out, exact: paired };
 }
 export function displayUntrusted(text, opts = {}) {
     const out = renderUntrusted(text, opts, null);
-    return typeof out === 'string' ? out : out.text;
+    return typeof out === 'string' ? out : out.tracked.text;
 }
 export function cleanUntrustedScalar(v) {
     return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false });
@@ -5354,7 +5363,7 @@ export function queryCarriesCredential(query) {
 export function displayConfiguredUrl(url, opts = {}) {
     const reading = typeof url === 'string' ? configuredAddressReading(url) : null;
     const out = renderUntrusted(reading === null ? url : reading.withheld ? REDACTED_SECRET : reading.text, opts, null, 'relaxed', true);
-    return typeof out === 'string' ? out : out.text;
+    return typeof out === 'string' ? out : out.tracked.text;
 }
 function parserViewOf(url) {
     return url.replace(/[\t\n\r]/g, '').replace(/^[\u0000-\u0020]+/, '');
@@ -5773,7 +5782,7 @@ export function displayUntrustedMarks(text, opts = {}) {
     const ledger = { cps: [], lens: [] };
     const out = renderUntrusted(text, opts, ledger);
     if (typeof out === 'string')
-        return { text: out, marks: [] };
-    return { text: out.text, marks: collectMarks(out, ledger) };
+        return { text: out, marks: [], exact: false };
+    return { text: out.tracked.text, marks: collectMarks(out.tracked, ledger), exact: out.exact };
 }
 const isQuoteChar = (c) => c.charCodeAt(0) === 0x22 || c.charCodeAt(0) === 0x27;

package/dist/engineNoticeCodes.d.ts

@@ -197,8 +197,19 @@ export interface UserInputUndrainedFactsView {
     sessionId?: string;
     runId?: string;
     childSessionId?: string;
+    inputIds?: readonly string[];
 }
 export declare function readUserInputUndrained(notice: unknown): UserInputUndrainedFactsView | undefined;
+export interface UndrainedInputsLedger {
+    readonly handed?: readonly string[];
+    readonly redelivered?: readonly string[];
+}
+export interface UndrainedInputsVerdict {
+    readonly redeliver: readonly string[];
+    readonly askUser: readonly string[];
+    readonly unattributed: number;
+}
+export declare function undrainedInputsVerdict(facts: Pick<UserInputUndrainedFactsView, 'count' | 'cause' | 'inputIds' | 'childSessionId'> | null | undefined, ledger: UndrainedInputsLedger | null | undefined): UndrainedInputsVerdict | undefined;
 export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause' | 'childSessionId'>): string | undefined;
 export interface TurnInterruptedFactsView {
     lane: 'input_now' | 'user_halt' | 'unrecognized';
@@ -285,6 +296,7 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'route.stream_end_ignored': typeof readStreamEndIgnored;
     readonly 'mcp.authorization_required': typeof readMcpAuthorizationRequired;
     readonly 'context.media_removed': typeof readContextMediaRemoved;
+    readonly 'context.image_removed': typeof readContextMediaRemoved;
     readonly 'session.lineage_rerooted': typeof readSessionLineageRerooted;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;