@sema-agent/client-core 0.105.0 → 0.106.0

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 { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
@@ -28,7 +29,7 @@ function gateKindReadingOf(row) {
         return { leg: 'unreadable', kind: null };
     }
     if (typeof kind !== 'string' || kind === '')
-        return { leg: 'absent', kind: null };
+        return { leg: 'unreadable', kind: null };
     if (APPROVAL_LEG_GATE_KINDS.includes(kind))
         return { leg: 'approval', kind };
     if (PLAN_LEG_GATE_KINDS.includes(kind))
@@ -42,7 +43,7 @@ export function durableDecideLegOf(row) {
 }
 export function askParkForeignGateKind(row) {
     const r = gateKindReadingOf(row);
-    return r.leg === 'approval' || r.leg === 'absent' ? null : (r.kind ?? '(unreadable)');
+    return r.leg === 'approval' ? null : (r.kind ?? '(unreadable)');
 }
 export const PLAN_REVIEW_STATES = Object.freeze(['needs_review']);
 export const ASK_PARK_STATES = Object.freeze(['suspended']);
@@ -70,12 +71,20 @@ export function selfHealSubmissionDisposition(outcome) {
             return 'not-delivered';
         case 'running-attach':
             return 'not-delivered';
+        case 'injected-redundant':
+            return 'superseded';
+        case 'injected-deferred':
+            return 'deferred';
         default:
             return 'not-delivered';
     }
 }
 export function steerFollowIntent(outcome) {
-    if (typeof outcome !== 'object' || outcome === null || outcome.kind !== 'running-steered')
+    if (typeof outcome !== 'object' || outcome === null)
+        return null;
+    if (outcome.kind === 'injected-redundant')
+        return { kind: 'follow-resumed', taskId: outcome.taskId };
+    if (outcome.kind !== 'running-steered')
         return null;
     const taskId = outcome.taskId;
     if (outcome.delivery === 'queued')
@@ -84,6 +93,58 @@ export function steerFollowIntent(outcome) {
         return { kind: 'after-wake', taskId };
     return { kind: 'tail', taskId };
 }
+const injectedResubmitReleased = new WeakSet();
+export function injectedResubmitAfter(outcome, runStatus) {
+    try {
+        if (typeof outcome !== 'object' || outcome === null || outcome.kind !== 'injected-deferred')
+            return false;
+        if (!isSdkRunTerminal(runStatus) && !isSdkRunParked(runStatus))
+            return false;
+        if (injectedResubmitReleased.has(outcome))
+            return false;
+        injectedResubmitReleased.add(outcome);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const PLAN_REVIEW_CARRIER_KEY = '_sema_planReviewOutcome';
+function planReviewCarrierOf(item) {
+    const meta = guardedRead(() => (typeof item === 'object' && item !== null && !Array.isArray(item) ? readOwnDataValue(item, PLAN_REVIEW_CARRIER_KEY) : undefined));
+    if (guardedRead(() => typeof meta === 'object' && meta !== null && !Array.isArray(meta)) !== true)
+        return null;
+    return { run: guardedRead(() => readOwnDataNonEmptyString(meta, 'taskId')) };
+}
+function injectedCarrierVerdict(items, busyTaskId) {
+    const length = guardedRead(() => (Array.isArray(items) ? readOwnDataValue(items, 'length') : undefined));
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length <= 0)
+        return null;
+    const keys = guardedRead(() => Object.keys(items));
+    if (!Array.isArray(keys))
+        return null;
+    let present = 0;
+    let carriers = 0;
+    let allNameBusyRun = true;
+    for (let k = 0; k < keys.length; k++) {
+        const key = keys[k];
+        const index = Number(key);
+        if (typeof key !== 'string' || !Number.isSafeInteger(index) || index < 0 || index >= length || String(index) !== key)
+            continue;
+        present++;
+        const carrier = planReviewCarrierOf(guardedRead(() => readOwnDataValue(items, key)));
+        if (carrier === null) {
+            allNameBusyRun = false;
+            continue;
+        }
+        carriers++;
+        if (carrier.run === undefined || carrier.run !== busyTaskId)
+            allNameBusyRun = false;
+    }
+    if (carriers === 0)
+        return null;
+    return allNameBusyRun && present === length ? 'redundant' : 'deferred';
+}
 function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
@@ -523,7 +584,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         };
     }
     const gateKind = signal.pendingGate?.kind ?? null;
-    const gateLeg = gateKind !== null ? durableDecideLegOf({ gateKind }) : 'absent';
+    const gateLeg = durableDecideLegOf({ gateKind });
     const pendingCp = signal.pendingGate?.checkpointId;
     const sameTaskCp = pendingCp !== undefined && registeredPlanReviewCardFacts(DEFAULT_SESSION_KEY, taskId, pendingCp) !== undefined ? pendingCp : undefined;
     if (gateLeg === 'plan_review')
@@ -814,15 +875,16 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, 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 : '';
     const canSteer = typeof runs?.steer === 'function' && text.length > 0;
     const canCancel = typeof runs?.cancel === 'function' && typeof runs?.get === 'function';
     const canAttach = runningAttachOffered(deps?.canAttachRunning);
-    if (!canSteer && !canCancel && !canAttach)
+    if (!canSteer && !canCancel && !canAttach && carrierVerdict === null)
         return notParked;
-    if (injected && !canSteer)
+    if (injected && !canSteer && carrierVerdict === null)
         return notParked;
     const probeCallerAborted = () => deps?.signal?.aborted === true;
     if (statusFromWire && typeof runs?.get === 'function' && !probeCallerAborted()) {
@@ -847,6 +909,10 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     if (injected) {
         if (probeCallerAborted())
             return notParked;
+        if (carrierVerdict === 'redundant')
+            return { kind: 'injected-redundant', taskId };
+        if (carrierVerdict === 'deferred')
+            return { kind: 'injected-deferred', taskId };
         choice = 'steer';
     }
     else if (typeof offer === 'function') {
@@ -998,7 +1064,7 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow, lang
     if (typeof override === 'string')
         return override;
     const following = follow?.following === true && steerFollowIntent(outcome)?.kind === 'tail';
-    if (origin === 'injected')
+    if (origin === 'injected' || outcome.kind === 'injected-redundant' || outcome.kind === 'injected-deferred')
         return injectedSubmissionRow(outcome, following, lang);
     const engineDecide = copy?.engineDecidePath !== false;
     const keep = (outcome.kind === 'plan-review-reopen-failed' || outcome.kind === 'ask-reopen-failed') &&
@@ -1071,6 +1137,10 @@ function injectedSubmissionRow(outcome, following = false, lang) {
             return following
                 ? say(lang, 'session.selfHeal.injected.handedOffFollowing', { lead, id })
                 : say(lang, 'session.selfHeal.injected.handedOffWatch', { lead, id });
+        case 'superseded':
+            return say(lang, 'session.selfHeal.injected.redundant', { lead, id });
+        case 'deferred':
+            return say(lang, 'session.selfHeal.injected.deferred', { lead, id });
         case 'not-delivered': {
             const noView = (outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.noPresentationSurface === true
                 ? msg('session.selfHeal.noCardView.inParens')
@@ -1182,6 +1252,9 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             return outcome.delivery === 'rejected'
                 ? say(lang, 'session.selfHeal.row.steerFailed.rejected', { taskId: outcome.taskId, detail: outcome.detail })
                 : say(lang, 'session.selfHeal.row.steerFailed.unknown', { taskId: outcome.taskId, detail: outcome.detail });
+        case 'injected-redundant':
+        case 'injected-deferred':
+            return injectedSubmissionRow(outcome, following, lang);
         case 'running-attach':
             return say(lang, 'session.selfHeal.row.attach', { disclosure: resumeAttachReplayDisclosure(outcome.taskId) });
         case 'running-cancelled':

package/dist/adapter/downstream/eventToSdkMessage.d.ts

@@ -60,11 +60,6 @@ export interface WiringManifestAutoConsolidationView {
 export interface WiringManifestReadDenyView {
     builtinTiers: readonly string[];
 }
-export interface WiringManifestHookEntryView {
-    family: string;
-    owner: string;
-    observational?: true;
-}
 export interface WiringManifestLspSeamView {
     mounted: boolean;
     lane?: string;

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -42,7 +42,9 @@ export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'wiring_manifest',
     'approval_request',
     'approval_revoke',
+    'approval_complete',
     'message_committed',
+    'session_titled',
 ]);
 function assistantArm(ctx, content, eventId, parentToolCallId, recovered) {
     const id = typeof eventId === 'string' && eventId.length > 0 ? eventId : undefined;
@@ -113,7 +115,14 @@ function projectEvent(ev, ctx) {
         return compactionStartedProjection(ev, ctx);
     if (isBeyondFloorArm(ev)) {
         const word = ev.type;
-        return word === 'cross_boundary_taint' ? nothing('not_in_slice') : dropped('unsupported_arm', word);
+        if (word === 'cross_boundary_taint')
+            return nothing('not_in_slice');
+        if (word === 'session_titled')
+            return sessionTitledProjection(ev, ctx);
+        const body = approvalFrameBody(ev);
+        if (body === undefined)
+            return dropped('malformed', 'approval_complete');
+        return projected(internalArmExit(stamp(ctx, armBody({ type: 'approval_complete', ...body }))));
     }
     switch (ev.type) {
         case 'task_started':
@@ -632,7 +641,6 @@ function wiringManifestSupersetBody(ev) {
     const autoMode = projectAutoModeSection(ev.autoMode);
     const mcp = projectMcpSection(ev.mcp);
     const tools = projectToolRoster(ev);
-    const hooks = projectHooksSection(ev.hooks);
     const lsp = projectLspSection(ev.lsp);
     const writeProtection = projectWriteProtectionSection(ev.writeProtection);
     const autoConsolidation = projectAutoConsolidationSection(ev.autoConsolidation);
@@ -642,14 +650,13 @@ function wiringManifestSupersetBody(ev) {
     const instructions = readInstructionsSegment(ev, 'instructions');
     const fleet = readFleetSegment(ev, 'fleet');
     const mods = projectModsSection(ev);
-    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined && fleet === undefined && mods === undefined)
+    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined && fleet === undefined && mods === undefined)
         return undefined;
     return {
         ...(modelGate !== undefined ? { _sema_modelGate: modelGate } : {}),
         ...(autoMode !== undefined ? { _sema_autoMode: autoMode } : {}),
         ...(mcp !== undefined ? { _sema_mcp: mcp } : {}),
         ...(tools !== undefined ? { _sema_tools: tools } : {}),
-        ...(hooks !== undefined ? { _sema_hooks: hooks } : {}),
         ...(lsp !== undefined ? { _sema_lsp: lsp } : {}),
         ...(writeProtection !== undefined ? { _sema_writeProtection: writeProtection } : {}),
         ...(autoConsolidation !== undefined ? { _sema_autoConsolidation: autoConsolidation } : {}),
@@ -710,20 +717,6 @@ function projectModsSection(holder) {
         return undefined;
     }
 }
-function projectHooksSection(raw) {
-    if (!Array.isArray(raw))
-        return undefined;
-    const rows = [];
-    for (const r of raw) {
-        if (typeof r !== 'object' || r === null || Array.isArray(r))
-            continue;
-        const o = r;
-        if (typeof o.family !== 'string' || o.family.length === 0 || typeof o.owner !== 'string' || o.owner.length === 0)
-            continue;
-        rows.push({ family: o.family, owner: o.owner, ...(o.observational === true ? { observational: true } : {}) });
-    }
-    return rows.length > 0 ? rows : undefined;
-}
 function projectLspSection(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return undefined;
@@ -809,6 +802,13 @@ function compactionOutcomeProjection(frame, ctx) {
         ...identity,
     }))));
 }
+function sessionTitledProjection(frame, ctx) {
+    const sessionId = guardedRead(() => readOwnDataNonEmptyString(frame, 'sessionId'));
+    const title = guardedRead(() => readOwnDataNonEmptyString(frame, 'title'));
+    if (sessionId === undefined || title === undefined)
+        return dropped('malformed', 'session_titled');
+    return projected(internalArmExit(stamp(ctx, armBody({ type: 'session_titled', sessionId, title }))));
+}
 function compactionStartedProjection(frame, ctx) {
     const ev = frame;
     const { identity, bad } = identityOrMalformed(ev, 'compaction_started');
@@ -917,7 +917,8 @@ function engineNoticeProjection(ev, ctx) {
         ...(seq !== undefined ? { eventSeq: seq } : {}),
     })));
 }
-function approvalFrameBody(ev) {
+function approvalFrameBody(frame) {
+    const ev = frame;
     const schemaVersion = typeof ev.schemaVersion === 'number' && Number.isFinite(ev.schemaVersion)
         ? ev.schemaVersion
         : undefined;

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -702,12 +702,11 @@ export function doneToSdkResult(ev, ctx, observed) {
 }
 function doneToSdkResultBody(ev, ctx, observed) {
     const view = doneResultView(ev.result);
-    const rRaw = view.engine;
+    const rRaw = view.body;
     const rec = typeof rRaw === 'object' && rRaw !== null ? rRaw : {};
     const r = rec;
     const stats = r.stats;
-    const nestedSid = r.sessionId;
-    const echoedSid = typeof nestedSid === 'string' && nestedSid.length > 0 ? nestedSid : view.row?.sessionId;
+    const echoedSid = r.sessionId;
     if (typeof echoedSid === 'string' && echoedSid.length > 0)
         ctx.sessionId = echoedSid;
     const terminal = readRunTerminal(ev.result);

package/dist/adapter/downstream/wiringManifestView.d.ts

@@ -1,11 +1,10 @@
-import type { WiringManifestModelGate, WiringManifestAutoMode, WiringManifestMcpEntryView, WiringManifestHookEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, WiringManifestModView } from './eventToSdkMessage.js';
+import type { WiringManifestModelGate, WiringManifestAutoMode, WiringManifestMcpEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, WiringManifestModView } from './eventToSdkMessage.js';
 import type { ToolRosterView, WiringManifestHandsView } from '../../toolRoster.js';
 export type WiringManifestSections = {
     _sema_modelGate?: WiringManifestModelGate;
     _sema_autoMode?: WiringManifestAutoMode;
     _sema_mcp?: WiringManifestMcpEntryView[];
     _sema_tools?: ToolRosterView;
-    _sema_hooks?: WiringManifestHookEntryView[];
     _sema_lsp?: WiringManifestLspSeamView;
     _sema_writeProtection?: WiringManifestWriteProtectionView;
     _sema_autoConsolidation?: WiringManifestAutoConsolidationView;
@@ -27,7 +26,6 @@ export interface WiringManifestView {
     autoMode?: WiringManifestAutoMode;
     mcp?: readonly WiringManifestMcpEntryView[];
     tools?: ToolRosterView;
-    hooks?: readonly WiringManifestHookEntryView[];
     lsp?: WiringManifestLspSeamView;
     writeProtection?: WiringManifestWriteProtectionView;
     autoConsolidation?: WiringManifestAutoConsolidationView;

package/dist/adapter/downstream/wiringManifestView.js

@@ -51,7 +51,6 @@ export function wiringManifestViewOf(s) {
         ...(isObj(s._sema_autoMode) ? { autoMode: s._sema_autoMode } : {}),
         ...(Array.isArray(s._sema_mcp) ? { mcp: s._sema_mcp } : {}),
         ...(isObj(s._sema_tools) ? { tools: s._sema_tools } : {}),
-        ...(Array.isArray(s._sema_hooks) ? { hooks: s._sema_hooks } : {}),
         ...(isObj(s._sema_lsp) ? { lsp: s._sema_lsp } : {}),
         ...(isObj(s._sema_writeProtection) ? { writeProtection: s._sema_writeProtection } : {}),
         ...(isObj(s._sema_autoConsolidation) ? { autoConsolidation: s._sema_autoConsolidation } : {}),

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,23 @@
+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;

package/dist/checkpointRowVerdict.js

@@ -0,0 +1,89 @@
+import { readErrorString, slotReadOf } from './wireFailureShape.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;
+    }
+}