@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/adapter/runStream.js

@@ -5,7 +5,7 @@ import { terminalPartsOfObserved, readRunCostFacts, terminalToSdkResult, TOOL_IN
 import { terminalRunIdOf, terminalUuidOf } from '../engineRowRef.js';
 import { publishSubagentContentEvent, subagentContentEventOf } from '../subagentContentStore.js';
 import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
-import { doneResultView, isReplayedTerminal } from '../replayBody.js';
+import { doneResultView, isReplayedTerminal, terminalLayerOf } from '../replayBody.js';
 import { carriesAnswerText, guardedRead, readFrameStringKey } from '../ownKey.js';
 import { ccErrorOfProviderStatus } from '../providerRejection.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
@@ -206,8 +206,7 @@ function terminalOwnerOfStream(ctx, busy, busyHandle, runId) {
     };
 }
 function engineResultOf(result) {
-    const v = doneResultView(result);
-    return v.replay ? (v.engine ?? result) : result;
+    return doneResultView(result).body;
 }
 function engineSessionIdOf(result) {
     const v = result?.sessionId;
@@ -371,7 +370,7 @@ function apiErrorTerminalFromFacts(x, facts) {
             return none();
         if (type === 'failed')
             return { carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(x, 'errorCode')), undefined, nonEmptyStr(ownDataBit(x, 'errorMessage'))), detail: undefined };
-        const result = type === 'done' ? plainObjectOf(engineResultOf(ownDataBit(x, 'result'))) : x;
+        const result = type === 'done' ? plainObjectOf(terminalLayerOf(ownDataBit(x, 'result'))) : x;
         if (result === undefined)
             return none();
         const snap = ownTerminalSnapshot(result);

package/dist/approvalReachWire.d.ts

@@ -1,5 +1,6 @@
 import { CORE_APPROVAL_REACH } from './generated/engineFactTables.js';
 export type ApprovalReachWord = (typeof CORE_APPROVAL_REACH)[number];
+export declare function isApprovalReachWord(v: {} | null | undefined): v is ApprovalReachWord;
 export declare function refuseBadApprovalReach(v: unknown, who: string): void;
 export type ApprovalReachWithheldCause = 'not_reported' | 'unsupported' | 'unprobed' | 'unreadable';
 export type ApprovalReachDeclaration = {

package/dist/approvalReachWire.js

@@ -3,6 +3,9 @@ import { engineCapState, engineCapsSettled } from './engineCapsCache.js';
 const KEY = 'approvalReach';
 const APPROVAL_REACH_NONE = 'none';
 const WORDS = new Set(CORE_APPROVAL_REACH);
+export function isApprovalReachWord(v) {
+    return typeof v === 'string' && WORDS.has(v);
+}
 const shapeOf = (v) => {
     try {
         return v === null ? 'null' : Array.isArray(v) ? 'typeof=object / array' : typeof v === 'string' ? `typeof=string(长 ${v.length})` : `typeof=${typeof v}`;
@@ -14,7 +17,7 @@ const shapeOf = (v) => {
 export function refuseBadApprovalReach(v, who) {
     if (v === undefined || v === null)
         return;
-    if (typeof v === 'string' && WORDS.has(v))
+    if (isApprovalReachWord(v))
         return;
     throw new TypeError(`${who}: approvalReach 只接受引擎闭集里的词(${[...CORE_APPROVAL_REACH].join(' / ')})或缺席(undefined/null)—— 收到 ${shapeOf(v)}。` +
         '这一位是「这条运行上没有人能答审批」的声明,值只经片段口 approvalReachDeclaration 铸;本层若把坏值折成缺席,这一发会照常发审批卡而声明方不会知道。' +

package/dist/approvalSeat.d.ts

@@ -0,0 +1,21 @@
+import { type ApprovalReachWord } from './approvalReachWire.js';
+import { type SubmissionIdentity } from './request/submissionIdentity.js';
+export declare const APPROVAL_SEAT_STATES: readonly ["seated", "unseated", "unknown"];
+export type ApprovalSeatState = (typeof APPROVAL_SEAT_STATES)[number];
+export declare const APPROVAL_SEAT_BASES: Readonly<{
+    seated: readonly ["interactive_lane", "host_seat"];
+    unseated: readonly ["engine_declared_none", "host_declined"];
+    unknown: readonly ["identity_unreadable", "word_unreadable", "fact_unreadable", "word_unmapped", "lane_without_approvals", "seat_unstated"];
+}>;
+export type ApprovalSeatReading = {
+    readonly [S in ApprovalSeatState]: {
+        readonly state: S;
+        readonly basis: (typeof APPROVAL_SEAT_BASES)[S][number];
+    };
+}[ApprovalSeatState];
+export interface ApprovalSeatInput {
+    readonly identity: SubmissionIdentity;
+    readonly approvalReach?: ApprovalReachWord | null | undefined;
+    readonly approverReachable?: boolean | null | undefined;
+}
+export declare function approvalSeatOf(input: ApprovalSeatInput): ApprovalSeatReading;

package/dist/approvalSeat.js

@@ -0,0 +1,73 @@
+import { isApprovalReachWord } from './approvalReachWire.js';
+import { requestLaneOf } from './request/submissionIdentity.js';
+import { ownDataField } from './ownKey.js';
+export const APPROVAL_SEAT_STATES = Object.freeze(['seated', 'unseated', 'unknown']);
+export const APPROVAL_SEAT_BASES = Object.freeze({
+    seated: Object.freeze(['interactive_lane', 'host_seat']),
+    unseated: Object.freeze(['engine_declared_none', 'host_declined']),
+    unknown: Object.freeze(['identity_unreadable', 'word_unreadable', 'fact_unreadable', 'word_unmapped', 'lane_without_approvals', 'seat_unstated']),
+});
+const mint = (state, basis) => Object.freeze({ state, basis });
+const READINGS = Object.freeze({
+    seated: Object.freeze({ interactive_lane: mint('seated', 'interactive_lane'), host_seat: mint('seated', 'host_seat') }),
+    unseated: Object.freeze({ engine_declared_none: mint('unseated', 'engine_declared_none'), host_declined: mint('unseated', 'host_declined') }),
+    unknown: Object.freeze({
+        identity_unreadable: mint('unknown', 'identity_unreadable'),
+        word_unreadable: mint('unknown', 'word_unreadable'),
+        fact_unreadable: mint('unknown', 'fact_unreadable'),
+        word_unmapped: mint('unknown', 'word_unmapped'),
+        lane_without_approvals: mint('unknown', 'lane_without_approvals'),
+        seat_unstated: mint('unknown', 'seat_unstated'),
+    }),
+});
+const SEAT_OF_WORD = Object.freeze({
+    none: READINGS.unseated.engine_declared_none,
+});
+const ABSENT = Symbol('absent');
+const UNREADABLE = Symbol('unreadable');
+const slotOf = (carrier, key) => {
+    try {
+        const v = ownDataField(carrier, key);
+        return v === undefined ? ABSENT : v;
+    }
+    catch {
+        return UNREADABLE;
+    }
+};
+const isCarrier = (x) => {
+    try {
+        return typeof x === 'object' && x !== null && !Array.isArray(x);
+    }
+    catch {
+        return false;
+    }
+};
+export function approvalSeatOf(input) {
+    const R = READINGS.unknown;
+    if (!isCarrier(input))
+        return R.identity_unreadable;
+    const identity = slotOf(input, 'identity');
+    const word = slotOf(input, 'approvalReach');
+    const declared = slotOf(input, 'approverReachable');
+    const lane = identity === ABSENT || identity === UNREADABLE || !isCarrier(identity) ? undefined : requestLaneOf(identity);
+    if (lane === undefined)
+        return R.identity_unreadable;
+    const wordIn = word === ABSENT || word === null ? undefined : word;
+    if (word === UNREADABLE || (wordIn !== undefined && !isApprovalReachWord(wordIn)))
+        return R.word_unreadable;
+    const reachable = declared === ABSENT || declared === null ? undefined : declared;
+    if (declared === UNREADABLE || (reachable !== undefined && reachable !== true && reachable !== false))
+        return R.fact_unreadable;
+    if (wordIn !== undefined && !Object.hasOwn(SEAT_OF_WORD, wordIn))
+        return R.word_unmapped;
+    switch (lane) {
+        case 'interactive':
+            return READINGS.seated.interactive_lane;
+        case 'utility':
+            return R.lane_without_approvals;
+        case 'print':
+            if (wordIn !== undefined)
+                return SEAT_OF_WORD[wordIn];
+            return reachable === true ? READINGS.seated.host_seat : reachable === false ? READINGS.unseated.host_declined : R.seat_unstated;
+    }
+}

package/dist/assistantInbox.d.ts

@@ -1,4 +1,5 @@
 import type { AgentClient } from '@sema-agent/sdk';
+import { type CheckpointRowVerdictReading } from './checkpointRowVerdict.js';
 export type AssistantInboxVerb = Pick<AgentClient['assistant'], 'inbox'>;
 export interface AssistantInboxEntry {
     readonly sessionId: string;
@@ -13,6 +14,7 @@ export interface AssistantInboxEntry {
     readonly requiresRealApproval?: true;
     readonly mandated?: true;
     readonly hasBidiControls?: true;
+    readonly rowVerdict?: CheckpointRowVerdictReading;
 }
 export type AssistantInboxUnavailableReason = 'unauthorized' | 'unreadable' | 'failed';
 export type AssistantInboxReading = {

package/dist/assistantInbox.js

@@ -1,3 +1,4 @@
+import { checkpointRowVerdictOf } from './checkpointRowVerdict.js';
 import { errCodes } from './controlRouter.js';
 import { readOwnDataValue } from './ownKey.js';
 import { isReadCredentialRefusal } from './readCredentialRefusal.js';
@@ -41,6 +42,7 @@ function entryOf(raw) {
     const objective = nonEmptyString(own(raw, 'objective'));
     const input = own(raw, 'input');
     const inputPreview = typeof input === 'string' && input !== '' ? input : undefined;
+    const rowVerdict = checkpointRowVerdictOf(raw);
     return Object.freeze({
         sessionId,
         ...(scope !== undefined ? { scope } : {}),
@@ -54,6 +56,7 @@ function entryOf(raw) {
         ...(own(raw, 'requiresRealApproval') === true ? { requiresRealApproval: true } : {}),
         ...(own(raw, 'mandated') === true ? { mandated: true } : {}),
         ...(own(raw, 'hasBidiControls') === true ? { hasBidiControls: true } : {}),
+        ...(rowVerdict !== undefined ? { rowVerdict } : {}),
     });
 }
 function isArraySafely(v) {

package/dist/checkpointRowVerdict.d.ts

@@ -0,0 +1,29 @@
+export type CheckpointRowVerdictReading = {
+    readonly kind: 'ok';
+} | {
+    readonly kind: 'lacking' | 'damaged';
+    readonly code: string;
+    readonly reason?: string;
+    readonly requires?: readonly string[];
+    readonly sentence: string;
+} | {
+    readonly kind: 'unknown';
+    readonly word: string;
+    readonly sentence?: string;
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function checkpointRowVerdictOf(row: object | null | undefined): CheckpointRowVerdictReading | undefined;
+export type CheckpointRequirementsDamagedReading = {
+    readonly kind: 'judge_tripped';
+    readonly thrownName: string;
+} | {
+    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

@@ -0,0 +1,98 @@
+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) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+}
+function ownWordList(o, key) {
+    const r = slotReadOf(o, key);
+    if (r.presence !== 'present')
+        return undefined;
+    const v = r.value;
+    try {
+        if (typeof v !== 'object' || v === null || !Array.isArray(v))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const len = slotReadOf(v, 'length');
+    if (len.presence !== 'present' || typeof len.value !== 'number' || !Number.isSafeInteger(len.value) || len.value < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < len.value; i++) {
+        const w = ownNonEmptyString(v, String(i));
+        if (w === undefined)
+            return undefined;
+        out.push(w);
+    }
+    return Object.freeze(out);
+}
+export function checkpointRowVerdictOf(row) {
+    try {
+        if (typeof row !== 'object' || row === null)
+            return undefined;
+        const slot = slotReadOf(row, 'rowVerdict');
+        if (slot.presence === 'absent')
+            return undefined;
+        if (slot.presence !== 'present')
+            return UNREADABLE;
+        const v = slot.value;
+        if (v === undefined)
+            return undefined;
+        if (typeof v !== 'object' || v === null)
+            return UNREADABLE;
+        if (Array.isArray(v))
+            return UNREADABLE;
+        const kind = slotReadOf(v, 'kind');
+        if (kind.presence !== 'present' || typeof kind.value !== 'string' || kind.value === '')
+            return UNREADABLE;
+        const word = kind.value;
+        if (word === 'ok')
+            return OK;
+        const sentence = ownNonEmptyString(v, 'sentence');
+        if (word === 'lacking' || word === 'damaged') {
+            const code = ownNonEmptyString(v, 'code');
+            if (code === undefined || sentence === undefined)
+                return UNREADABLE;
+            const reason = ownNonEmptyString(v, 'reason');
+            const requires = ownWordList(v, 'requires');
+            return Object.freeze({
+                kind: word,
+                code,
+                ...(reason !== undefined ? { reason } : {}),
+                ...(requires !== undefined ? { requires } : {}),
+                sentence,
+            });
+        }
+        return Object.freeze({ kind: 'unknown', word, ...(sentence !== undefined ? { sentence } : {}) });
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+const ROW_MISMATCH = Object.freeze({ kind: 'row_mismatch' });
+const REQUIREMENTS_DAMAGED = 'requirements_damaged';
+export function checkpointRequirementsDamagedOf(failure) {
+    try {
+        if ((typeof failure !== 'object' && typeof failure !== 'function') || failure === null)
+            return undefined;
+        if (readErrorString(failure, 'reason') !== REQUIREMENTS_DAMAGED)
+            return undefined;
+        const thrownName = readErrorString(failure, 'thrownName');
+        return thrownName !== undefined && thrownName !== '' ? Object.freeze({ kind: 'judge_tripped', thrownName }) : ROW_MISMATCH;
+    }
+    catch {
+        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/coreValuePorts.d.ts

@@ -151,8 +151,17 @@ export interface CoreValuePorts {
     readToolFaces(declared: {} | null | undefined): McpToolFacesReadView;
     ruleNameCovers: (ruleName: string, toolName: string) => boolean;
     IMPORTED_SETTINGS_LAYERS: readonly ['userSettings', 'projectSettings', 'localSettings'];
+    runParkedOf(run: WorkflowRunParkedInputView): boolean;
+    parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[];
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers", "IMPORTED_SETTINGS_LAYERS"];
+export interface WorkflowAgentStatusView {
+    readonly status: string;
+}
+export interface WorkflowRunParkedInputView {
+    readonly status: string;
+    readonly agents: ReadonlyArray<WorkflowAgentStatusView>;
+}
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers", "IMPORTED_SETTINGS_LAYERS", "runParkedOf", "parkedAgentsOf"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -184,3 +193,5 @@ export declare function anthropicDefaultBaseUrl(): string | undefined;
 export declare function readToolFaces(declared: {} | null | undefined): McpToolFacesReadView | undefined;
 export declare function ruleNameCovers(ruleName: string, toolName: string): boolean | undefined;
 export declare function importedSettingsLayers(): CoreValuePorts['IMPORTED_SETTINGS_LAYERS'] | undefined;
+export declare function runParkedOf(run: WorkflowRunParkedInputView): boolean | undefined;
+export declare function parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[] | undefined;

package/dist/coreValuePorts.js

@@ -21,6 +21,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'readToolFaces',
     'ruleNameCovers',
     'IMPORTED_SETTINGS_LAYERS',
+    'runParkedOf',
+    'parkedAgentsOf',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -127,3 +129,11 @@ export function ruleNameCovers(ruleName, toolName) {
 export function importedSettingsLayers() {
     return port('IMPORTED_SETTINGS_LAYERS');
 }
+export function runParkedOf(run) {
+    const fn = port('runParkedOf');
+    return fn === undefined ? undefined : fn(run);
+}
+export function parkedAgentsOf(agents) {
+    const fn = port('parkedAgentsOf');
+    return fn === undefined ? undefined : fn(agents);
+}

package/dist/decideFailureNote.js

@@ -1,6 +1,6 @@
 import { corruptStoredRowContent, corruptStoredRowWhere, scenarioDenyFromError, scenarioNotAllowedContent } from './wireErrorTriage.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
-import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
+import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError, decideRequiresBindingContent, decideRequiresBindingFromError } from './decideReceipt.js';
 import { fieldLimitRefusalContent, fieldLimitRefusalFromError } from './wireRefusalCopy.js';
 import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf, decisionGrantChangedContent } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
@@ -12,6 +12,7 @@ export function decideFailureNote(err, decision) {
     const scenario = scenarioDenyFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
+    const missingBinding = decideRequiresBindingFromError(err);
     const conflict = decisionConflictOf(err);
     const answerInvalid = conflict === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
@@ -22,6 +23,7 @@ export function decideFailureNote(err, decision) {
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +
         (unsupported === null ? '' : ` — ${checkpointUnsupportedVersionContent(unsupported)}`) +
         (gone === null ? '' : ` — ${askGoneContent(gone)}`) +
+        (missingBinding === null ? '' : ` — ${decideRequiresBindingContent(missingBinding)}`) +
         (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : '') +
         (conflict === 'grant_changed' ? ` — ${decisionGrantChangedContent()}` : ''));
 }

package/dist/decideReceipt.d.ts

@@ -2,6 +2,8 @@ import { type GateOutcomeView } from './gateOutcome.js';
 import { type ResumeReopenDetail } from './hitl/suspendedReopen.js';
 import { type CrashConvergedRowReading } from './hitl/crashConverged.js';
 import type { AskRowEndingCause } from '@sema-agent/sdk';
+import { SDK_DECIDE_BINDING_KEYS } from './generated/sdkFactTables.js';
+import { type UiLanguage } from './env/uiLanguage.js';
 export interface DecideReceiptView {
     status?: string;
     taskId?: string;
@@ -31,6 +33,13 @@ export interface DecideParkMovedDetail {
 }
 export declare function decideParkMovedFromError(e: unknown): DecideParkMovedDetail | null;
 export declare function decideParkMovedContent(detail: Pick<DecideParkMovedDetail, 'code'>): string;
+export type DecideBindingKey = (typeof SDK_DECIDE_BINDING_KEYS)[number];
+export interface DecideRequiresBindingDetail {
+    readonly code: string;
+    readonly missingKeys?: readonly DecideBindingKey[];
+}
+export declare function decideRequiresBindingFromError(e: {} | null | undefined): DecideRequiresBindingDetail | null;
+export declare function decideRequiresBindingContent(_detail?: DecideRequiresBindingDetail, lang?: UiLanguage | (string & {})): string;
 export interface AskGoneDetail {
     code: 'gone.ask';
     state?: 'VOID' | 'DENIED';

package/dist/decideReceipt.js

@@ -1,11 +1,14 @@
 import { gateOutcomeOf } from './gateOutcome.js';
 import { readOwnDataValue } from './ownKey.js';
 import { resumeReopenFromError } from './hitl/suspendedReopen.js';
-import { ASK_GONE, DECIDE_CLAIM_LOST, CONFLICT_NOT_RESUMABLE, GATE_NOT_TOOL_APPROVAL, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
+import { ASK_GONE, DECIDE_CLAIM_LOST, CONFLICT_NOT_RESUMABLE, GATE_NOT_TOOL_APPROVAL, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_REQUIRES_BINDING, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { isSlotCarrier, readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
 import { isCrashConvergedCause } from './hitl/crashConverged.js';
 import { askRowEndingCauseFor } from './hitl/approvalEndingCause.js';
+import { SDK_DECIDE_BINDING_KEYS } from './generated/sdkFactTables.js';
+import { isUiLanguage } from './env/uiLanguage.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const STATUS_RESUMING = 'resuming';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -136,6 +139,31 @@ export function decideParkMovedContent(detail) {
     const extra = code === DECIDE_CLAIM_LOST ? '; if this approval is still listed, wait a little before deciding it again' : '';
     return `${what} · This decision was not applied — fetch the pending approvals again and decide from what is pending now${extra}`;
 }
+const isDecideBindingKey = (v) => SDK_DECIDE_BINDING_KEYS.includes(v);
+export function decideRequiresBindingFromError(e) {
+    try {
+        if (effectiveWireErrorCode(e) !== DECIDE_REQUIRES_BINDING)
+            return null;
+        const raw = readErrorStrictStringList(e, 'missingKeys');
+        const keys = [];
+        if (raw !== undefined) {
+            for (const k of raw) {
+                if (!isDecideBindingKey(k) || keys.includes(k)) {
+                    keys.length = 0;
+                    break;
+                }
+                keys.push(k);
+            }
+        }
+        return Object.freeze({ code: DECIDE_REQUIRES_BINDING, ...(keys.length > 0 ? { missingKeys: Object.freeze(keys) } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+export function decideRequiresBindingContent(_detail, lang) {
+    return renderMessage(msg('approval.decide.requiresBinding', { wayOut: msg('approval.decide.unboundWayOut') }), isUiLanguage(lang) ? lang : undefined);
+}
 function askGoneRawCause(e) {
     let top;
     try {

package/dist/declared/supportFloorDeclared.js

@@ -1,5 +1,5 @@
 export const DECLARED_SUPPORT_FLOOR = Object.freeze({
-    server: "7.129.1",
-    core: "7.51.2",
+    server: "7.139.0",
+    core: "7.60.0",
     sdk: "23.1.0",
 });

package/dist/deviceRebind.d.ts

@@ -95,6 +95,13 @@ export declare function listDevices(devices: DeviceListVerb | null | undefined,
 export declare function readSessionBinding(sessions: SessionExecutionPlacementVerb | null | undefined, rootSessionId: string, opts?: {
     readonly signal?: AbortSignal | undefined;
 }): Promise<DeviceSessionBindingOutcome>;
+export interface SessionPlacementView {
+    readonly sessionId: string;
+    readonly executionLane?: string;
+    readonly onDevice: boolean;
+    readonly rev?: number;
+}
+export declare function foldSessionPlacement(held: SessionPlacementView | undefined, sessionId: string, body: {} | null | undefined): SessionPlacementView | undefined;
 export declare function rebindSession(devices: DeviceRebindVerb | null | undefined, req: DeviceRebindInput, opts?: {
     readonly signal?: AbortSignal | undefined;
 }): Promise<DeviceRebindOutcome>;

package/dist/deviceRebind.js

@@ -140,6 +140,17 @@ function placementReadFailureOf(e) {
     return v.status !== undefined ? refusedOf(v.status, v.code, e) : transportOf(v);
 }
 const isPlacementRole = (v) => typeof v === 'string' && EXECUTION_PLACEMENT_ROLES.includes(v);
+function placementBodyOf(body) {
+    const role = own(body, 'role');
+    if (!isPlacementRole(role))
+        return { role: undefined, lane: undefined, device: null };
+    if (role !== 'writer')
+        return { role, lane: undefined, device: null };
+    const lane = own(body, 'lane');
+    if (typeof lane !== 'string' || lane === '')
+        return { role, lane: undefined, device: null };
+    return { role, lane, device: lane === EXECUTION_PLACEMENT_DEVICE_LANE ? bindingOf(own(body, 'device')) : null };
+}
 export async function readSessionBinding(sessions, rootSessionId, opts) {
     if (typeof rootSessionId !== 'string' || rootSessionId === '') {
         return { kind: 'refused', status: 0, errorCode: 'request.id_invalid', message: 'the session id to read the execution placement of must be a non-empty string — nothing was sent' };
@@ -154,24 +165,47 @@ export async function readSessionBinding(sessions, rootSessionId, opts) {
     catch (e) {
         return placementReadFailureOf(e);
     }
-    const role = own(body, 'role');
-    if (!isPlacementRole(role)) {
+    const { role, lane, device: bound } = placementBodyOf(body);
+    if (role === undefined) {
         return { kind: 'unreadable', why: 'the execution placement it returned names no role this client knows (absent / writer / mirror / forking) — refusing to read it as "not bound"' };
     }
     if (role !== 'writer')
         return { kind: 'unbound', role };
-    const lane = own(body, 'lane');
-    if (typeof lane !== 'string' || lane === '') {
+    if (lane === undefined) {
         return { kind: 'unreadable', why: "the writer's execution lane in the execution placement is missing or not a word — refusing to guess whether a device is bound" };
     }
     if (lane !== EXECUTION_PLACEMENT_DEVICE_LANE)
         return { kind: 'unbound', role };
-    const bound = bindingOf(own(body, 'device'));
     if (bound === null) {
         return { kind: 'unreadable', why: 'the session is written on the device lane but the execution placement names no readable device (deviceId + rev) — the device is unknown, not unbound' };
     }
     return { kind: 'ok', rootSessionId, boundDevice: bound };
 }
+export function foldSessionPlacement(held, sessionId, body) {
+    try {
+        if (typeof sessionId !== 'string' || sessionId === '')
+            return held;
+        const heldOk = held !== null && typeof held === 'object';
+        if (heldOk && own(held, 'sessionId') !== sessionId)
+            return held;
+        const { role, lane, device } = placementBodyOf(body);
+        if (role === undefined)
+            return held;
+        const heldRev = heldOk ? nonNegInt(own(held, 'rev')) : undefined;
+        const rev = device?.rev;
+        if (heldRev !== undefined && (rev === undefined || rev < heldRev))
+            return held;
+        return Object.freeze({
+            sessionId,
+            ...(lane !== undefined ? { executionLane: lane } : {}),
+            onDevice: device !== null,
+            ...(rev !== undefined ? { rev } : {}),
+        });
+    }
+    catch {
+        return held;
+    }
+}
 function rebindFailureOf(e) {
     const v = atMostOnceVerdictOf(e);
     const { status, code } = v;

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;