@sema-agent/client-core 0.106.0 → 0.108.0

package/dist/hitl/frameRouter.js

@@ -13,6 +13,8 @@ import { surfaceForCurrentSession, surfaceReplayedApprovalListUnreadable } from
 import { liveCardHoldOf, noteEngineClosedApproval, settleEngineClosedApproval } from './approvalHolds.js';
 import { approvalCompleteParked } from './approvalCompleteParked.js';
 import { liveFrameCallKey } from './gateIdentity.js';
+import { readPolicyDenyCause } from './policyDenyCause.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { SEMA_DENIAL_KIND_KEY, hasLedgerPositionKey } from './gateLedger.js';
 import { replayedApprovalClosesCardFrame, replayedApprovalDisposition, settledApprovalDisposition } from './replayedApproval.js';
 import { settleWithinDeadline } from '../abortableSleep.js';
@@ -64,10 +66,33 @@ export function policyDenyReason(facts) {
 function denyOutputForRender(attribution) {
     if (attribution?.settledBy !== 'policy')
         return HITL_REJECT_MESSAGE;
+    const head = policyDenyHeadFor(readPolicyDenyCause(attribution));
     const reason = attribution.reason;
     return reason !== undefined && reason.trim() !== ''
-        ? `${HITL_POLICY_DENY_MESSAGE}\n${reason}`
-        : HITL_POLICY_DENY_MESSAGE;
+        ? `${head}\n${reason}`
+        : head;
+}
+function policyDenyHeadFor(cause) {
+    const tail = msg('approval.policyDeny.tail');
+    switch (cause) {
+        case 'dont_ask':
+            return renderMessage(msg('approval.policyDeny.dontAsk', { tail }));
+        case 'deny_rule':
+            return renderMessage(msg('approval.policyDeny.denyRule', { tail }));
+        case 'engine_floor':
+            return renderMessage(msg('approval.policyDeny.engineFloor', { tail }));
+        case 'no_approval_ui':
+        case undefined:
+            return HITL_POLICY_DENY_MESSAGE;
+    }
+}
+export function denyAttributionOf(deny) {
+    const policyCause = readPolicyDenyCause(deny);
+    return {
+        ...(deny?.settledBy !== undefined ? { settledBy: deny.settledBy } : {}),
+        ...(deny?.reason !== undefined ? { reason: deny.reason } : {}),
+        ...(policyCause !== undefined ? { policyCause } : {}),
+    };
 }
 function denialKindForTranscript(attribution) {
     return ccToolDenialKindForSettledBy(attribution?.settledBy);
@@ -354,10 +379,7 @@ function settleLiveCardOutcome(ev, outcome, ctx, fromSubagent, gatedCallId) {
         invokeHostCallbackIsolated('liveHitlAskWire: onToolApprovalOutcome', () => deps.onToolApprovalOutcome?.(ev, outcome));
     }
     if (outcome.kind === 'decided' && outcome.decision === 'deny' && !fromSubagent) {
-        const attribution = {
-            ...(outcome.deny?.settledBy !== undefined ? { settledBy: outcome.deny.settledBy } : {}),
-            ...(outcome.deny?.reason !== undefined ? { reason: outcome.deny.reason } : {}),
-        };
+        const attribution = denyAttributionOf(outcome.deny);
         if (gatedCallId !== undefined)
             led.markDenied(gatedCallId, attribution);
         else

package/dist/hitl/gateLedger.d.ts

@@ -1,9 +1,11 @@
 import type { AgentEvent } from '@sema-agent/sdk';
+import { type PolicyDenyCause } from './policyDenyCause.js';
 export declare const SEMA_COLLATERAL_ABORT_KEY = "_sema_collateral_abort";
 export declare const SEMA_DENIAL_KIND_KEY = "_sema_denial_kind";
 export interface GateDenyAttribution {
     settledBy?: 'human' | 'policy';
     reason?: string;
+    policyCause?: PolicyDenyCause;
 }
 export interface AskAnsweredOutput {
     type: 'ask-user-question';

package/dist/hitl/gateLedger.js

@@ -1,5 +1,6 @@
 import { parkedToolEndRoleOf } from '../engineRowRef.js';
 import { inheritFrameBinding } from '../frameBinding.js';
+import { readPolicyDenyCause } from './policyDenyCause.js';
 export const SEMA_COLLATERAL_ABORT_KEY = '_sema_collateral_abort';
 export const SEMA_DENIAL_KIND_KEY = '_sema_denial_kind';
 export function durableSeqOf(ev) {
@@ -27,9 +28,10 @@ function normalizeDenyAttribution(a) {
         return undefined;
     const settledBy = a.settledBy === 'human' || a.settledBy === 'policy' ? a.settledBy : undefined;
     const reason = typeof a.reason === 'string' && a.reason.trim() !== '' ? a.reason : undefined;
+    const policyCause = settledBy === 'policy' ? readPolicyDenyCause(a) : undefined;
     if (settledBy === undefined && reason === undefined)
         return undefined;
-    return { ...(settledBy !== undefined ? { settledBy } : {}), ...(reason !== undefined ? { reason } : {}) };
+    return { ...(settledBy !== undefined ? { settledBy } : {}), ...(reason !== undefined ? { reason } : {}), ...(policyCause !== undefined ? { policyCause } : {}) };
 }
 export function createGateLedger() {
     const startedCalls = new Set();

package/dist/hitl/hitlBridge.d.ts

@@ -3,6 +3,7 @@ import type { PermissionResult } from '@sema-agent/agent-types';
 import { type CapturedLocalCode, type CauseSlotRead } from '../engineWireFor.js';
 import type { ApprovalsListEnvelope } from './crashConverged.js';
 import { type SuspendedReopenReading } from './suspendedReopen.js';
+import type { CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 export declare const DEFAULT_DENY_REASON = "The user rejected this tool use";
 export declare const MAX_DENY_REASON_CHARS = 4096;
 export declare function denyReasonForWire(reason: string | undefined, tag: string): string | undefined;
@@ -132,7 +133,10 @@ export type FindPendingOutcome = {
 } | {
     ok: false;
     reason: string;
-    code?: 'no_pending' | 'wrong_gate';
+    code?: 'no_pending' | 'wrong_gate' | 'row_unresumable';
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 };
 export declare function findPendingForTask(client: HitlClientLike, taskId: string, matches: (toolName: string | undefined) => boolean, opts?: {
     signal?: AbortSignal;

package/dist/hitl/hitlBridge.js

@@ -11,6 +11,7 @@ import { suspendedReopenOf } from './suspendedReopen.js';
 import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisionLedger.js';
 import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
 import { checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
+import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, unboundWayOutContent } from '../checkpointRowVerdict.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -283,6 +284,9 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
         ? readings.find((x) => x.r.taskId === taskId && (x.r.boundCallId === callId || x.r.toolCallId === callId) && x.foreign !== null)
         : undefined;
     if (identityForeign !== undefined) {
+        const identityBar = identityForeign.foreign === QUEUE_ROW_FAMILY_UNREADABLE_GATE ? checkpointRowBarOf(identityForeign.r) : undefined;
+        if (identityBar !== undefined)
+            return { ok: false, reason: checkpointRowBarSentence(identityBar), code: 'row_unresumable', rowVerdict: identityBar };
         return {
             ok: false,
             reason: `the pending row this park names (call ${callId}) is parked on a '${String(identityForeign.foreign)}' gate — not an approval this leg decides; refusing to decide a different row`,
@@ -294,8 +298,19 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
     const pending = (identityConflicts ? undefined : identityRow) ??
         pool.find((r) => r.taskId === taskId && matches(typeof r.toolName === 'string' ? r.toolName : undefined)) ??
         pool.find((r) => r.taskId === taskId);
-    if (!pending)
+    if (!pending) {
+        for (const x of readings) {
+            if (x.r.taskId !== taskId || x.foreign !== QUEUE_ROW_FAMILY_UNREADABLE_GATE)
+                continue;
+            const unreadableBar = checkpointRowBarOf(x.r);
+            if (unreadableBar !== undefined)
+                return { ok: false, reason: checkpointRowBarSentence(unreadableBar), code: 'row_unresumable', rowVerdict: unreadableBar };
+        }
         return { ok: false, reason: 'no pending checkpoint for this run (resolved/expired?)', code: 'no_pending' };
+    }
+    const bar = checkpointRowBarOf(pending);
+    if (bar !== undefined)
+        return { ok: false, reason: checkpointRowBarSentence(bar), code: 'row_unresumable', rowVerdict: bar };
     return { ok: true, pending, gatedCallId: pending.toolCallId ?? pending.boundCallId ?? undefined };
 }
 export class HitlBridge {
@@ -349,7 +364,7 @@ export class HitlBridge {
         if (typeof boundCallId !== 'string' || boundCallId.length === 0 || typeof boundInputHash !== 'string' || boundInputHash.length === 0) {
             throw new HitlSafetyError(`pending checkpoint ${p.id ?? '<no-id>'} is missing D-1 binding fields ` +
                 `(boundCallId=${String(boundCallId)}, boundInputHash=${String(boundInputHash)}) — ` +
-                'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_missing');
+                `the row itself carries no binding to echo, so ${unboundWayOutContent(checkpointDeadlineStateOf(p))}`, 'binding_missing');
         }
         return { boundCallId, boundInputHash };
     }
@@ -358,6 +373,8 @@ export class HitlBridge {
         if (!pending) {
             throw new HitlSafetyError('no pending checkpoint to decide (resolved/expired under the human) — refetch + re-present', 'no_pending');
         }
+        if (preResolvedPending !== undefined)
+            assertPendingRowResumable(preResolvedPending);
         const decision = outcome.decision === 'approve'
             ? {
                 decision: 'approve',
@@ -383,6 +400,8 @@ export class HitlBridge {
         if (!pending) {
             throw new HitlSafetyError('no pending AskUserQuestion checkpoint to answer — refetch + re-present', 'no_pending');
         }
+        if (preResolvedPending !== undefined)
+            assertPendingRowResumable(preResolvedPending);
         const decision = {
             decision: 'approve',
             answer: { answers: answers.map((a) => marshalAnswer(a)) },
@@ -541,6 +560,11 @@ export function makeHitlCanUseTool(bridge, prompt) {
         return decision;
     };
 }
+function assertPendingRowResumable(pending) {
+    const bar = checkpointRowBarOf(pending);
+    if (bar !== undefined)
+        throw new Error(checkpointRowBarSentence(bar));
+}
 function assertAnswersSendable(answers) {
     if (!Array.isArray(answers) || answers.length === 0) {
         throw new HitlSafetyError('refusing to send an EMPTY AskUserQuestion answer set — `{answers:[]}` is the wire\'s DENY/NO_HUMAN form, ' +

package/dist/hitl/livePendingAsk.js

@@ -1,6 +1,7 @@
 import { isApprovalRequestFrameV1 } from '@sema-agent/sdk';
 import { appendOwnElement } from '../ownKey.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
+import { pendingRowIsOfSession } from './parkRowDelegation.js';
 import { approvalLiveFaceOf, liveFaceCarried } from './approvalLiveFace.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot } from '../wireFailureShape.js';
 import { isToolApprovalFrame, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
@@ -124,7 +125,8 @@ export function countApprovalsAwaitingDecision(snapshot, filter) {
     if (snapshot.kind === 'unknown')
         return { durable: null, live: null, suspendedSubagent: null };
     const bySession = (rows) => scope.kind === 'session' ? rows.filter(r => r.sessionId === scope.sessionId) : [...rows];
-    const durable = (snapshot.pendingDropped ?? 0) > 0 ? null : Array.isArray(snapshot.pending) ? bySession(snapshot.pending).length : null;
+    const durableOfSession = (rows) => scope.kind === 'session' ? rows.filter(r => pendingRowIsOfSession(r, scope.sessionId)).length : rows.length;
+    const durable = (snapshot.pendingDropped ?? 0) > 0 ? null : Array.isArray(snapshot.pending) ? durableOfSession(snapshot.pending) : null;
     if (!Array.isArray(snapshot.livePending))
         return { durable, live: null, suspendedSubagent: null };
     if ((snapshot.livePendingDropped ?? 0) > 0)
@@ -138,7 +140,7 @@ export function livePendingRowToApprovalFrame(row) {
         approvalId: row.approvalId,
         toolName: row.toolName,
         ...(row.fromSubagent === true ? { fromSubagent: true } : {}),
-        ...(row.originTaskId !== undefined ? { sourceTaskId: row.originTaskId } : {}),
+        ...(row.originTaskId !== undefined ? { sourceSessionId: row.originTaskId } : {}),
         ...(row.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(row) ? { requiresRealApproval: true } : {}),
         ...liveFaceCarried(approvalLiveFaceOf(row)),

package/dist/hitl/parkOwnership.js

@@ -2,6 +2,7 @@ import { isOwnEngineRun } from '../subagentContentStore.js';
 import { rowIdTail } from '../workflow.js';
 import { hostSessionFor } from '../host.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { pendingRowIsOfSession } from './parkRowDelegation.js';
 export function pendingRowIsOwnedByThisSession(row, deps) {
     const sessionKey = deps?.sessionKey ?? DEFAULT_SESSION_KEY;
     const rowTaskId = typeof row.taskId === 'string' ? row.taskId : '';
@@ -14,11 +15,9 @@ export function pendingRowIsOwnedByThisSession(row, deps) {
     }
     const currentSessionId = deps?.currentSessionId ?? (() => hostSessionFor(sessionKey)?.currentSessionId());
     const sessionId = currentSessionId();
-    const rowSessionId = typeof row.sessionId === 'string' ? row.sessionId : '';
-    return (typeof sessionId === 'string' &&
-        sessionId.length > 0 &&
-        rowSessionId.length > 0 &&
-        rowSessionId === sessionId);
+    if (typeof sessionId !== 'string' || sessionId.length === 0)
+        return false;
+    return pendingRowIsOfSession(row, sessionId);
 }
 export function askQuestionsFromPending(pending) {
     const input = pending.input;

package/dist/hitl/parkResolver.js

@@ -1,17 +1,20 @@
 import { putOwnKey, readOwnDataValue } from '../ownKey.js';
 import { HitlBridge, NO_QUESTION_OVERLAY_REASON, findPendingForTask, isNoDecisionSurfaceReason, } from './hitlBridge.js';
-import { approvalResolutionDetail, directSafetyStopOf, resolutionOfDecisionFailure } from './approvalResolution.js';
+import { approvalResolutionDetail, approvalResolutionStatusTag, directSafetyStopOf, resolutionOfDecisionFailure } from './approvalResolution.js';
 import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
 import { INTERRUPT_DENY_REASON, observeCancelByDeny } from './hitlHostSurface.js';
-import { flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
+import { denyAttributionOf, flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { refusedParkFromError } from '../resumeRefusalCopy.js';
 export const MAX_GATE_HOPS = 2;
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
@@ -63,7 +66,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
     }
     const found = await findPendingForTask(deps.client, taskId, isAskTool, signal ? { signal } : undefined, parkGatedCallId, (row) => isAskTool(typeof row.toolName === 'string' ? row.toolName : undefined));
     if (!found.ok)
-        return { kind: 'not_sent', lane: 'ask', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}) };
+        return { kind: 'not_sent', lane: 'ask', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}), ...(found.rowVerdict !== undefined ? { rowVerdict: found.rowVerdict } : {}) };
     const { pending, gatedCallId } = found;
     const at = { lane: 'ask', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     const fromArgs = gatedCallId
@@ -159,6 +162,10 @@ function failureReasonOf(r) {
         return '';
     return r.detail ?? approvalResolutionDetail(r) ?? r.cause;
 }
+function failsoftReasonOf(r) {
+    const tag = approvalResolutionStatusTag(r);
+    return tag === '' ? failureReasonOf(r) : `${failureReasonOf(r)} ${tag}`;
+}
 function orchestrationEnd(park, gatedCallId, detail) {
     return { kind: 'unsettled', lane: park.gate === 'fs' ? 'decide' : 'ask', cause: 'orchestration', ...(gatedCallId !== undefined ? { gatedCallId } : {}), detail };
 }
@@ -179,10 +186,7 @@ async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
             ...(decidedByReading !== undefined ? { approvalDecidedBy: decidedByReading } : {}),
         }, taskId, argsByCallOf(led), ctx.signal, gatedCallId, park.toolName);
         if (outcome.kind === 'decided' && outcome.decision === 'deny' && outcome.gatedCallId) {
-            led.markDenied(outcome.gatedCallId, {
-                ...(outcome.deny?.settledBy !== undefined ? { settledBy: outcome.deny.settledBy } : {}),
-                ...(outcome.deny?.reason !== undefined ? { reason: outcome.deny.reason } : {}),
-            });
+            led.markDenied(outcome.gatedCallId, denyAttributionOf(outcome.deny));
         }
         return outcome;
     }
@@ -282,9 +286,9 @@ export async function resolvePark(park, ctx) {
             ? undefined
             : outcome.kind === 'not_sent' && outcome.cause === 'retracted'
                 ? 'the approval card was retracted by the host without a decision (nothing was sent; the run stays parked and remains decidable elsewhere)'
-                : failureReasonOf(outcome);
+                : failsoftReasonOf(outcome);
         const noDecisionSurface = outcome.kind === 'not_sent' && outcome.cause === 'card_unavailable' && outcome.detail !== undefined && isNoDecisionSurfaceReason(outcome.detail);
-        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface) };
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface, failsoftWayOutOf(outcome)) };
     }
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
@@ -307,15 +311,27 @@ export async function resolvePark(park, ctx) {
         ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
     };
 }
-function failsoftReasonSentence(park, failedReason, terminal) {
+function failsoftWayOutOf(outcome) {
+    if (outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing')))
+        return 'reason';
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && refusedParkFromError(outcome.refusal) !== null)
+        return 'cancel';
+    return 'card';
+}
+function failsoftReasonSentence(park, failedReason, terminal, wayOut = 'card') {
     if (terminal !== undefined)
         return terminal.errorMessage;
     if (failedReason === undefined)
         return undefined;
+    const gate = park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion';
+    if (wayOut === 'reason')
+        return renderMessage(msg('approval.park.stillParked', { gate, reason: failedReason }));
+    if (wayOut === 'cancel')
+        return renderMessage(msg('approval.park.refusedNotResumable', { gate, reason: failedReason }));
     return (`${park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion'} gate could not be answered: ${failedReason}` +
         ' — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.');
 }
-function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false) {
+function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false, wayOut = 'card') {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -323,7 +339,7 @@ function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, no
             gateAbortedByUser,
         }),
     ];
-    const reason = failsoftReasonSentence(park, failedReason, terminal);
+    const reason = failsoftReasonSentence(park, failedReason, terminal, wayOut);
     if (park.pendingDone) {
         events.push(reason === undefined || noDecisionSurface ? park.pendingDone : inheritFrameBinding(park.pendingDone, { ...park.pendingDone, _sema_park_failed_reason: reason }));
     }
@@ -352,15 +368,12 @@ export function stalledTerminal(park, ctx, stalledRounds, lastStallReason, decid
     return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, reason) };
 }
 function notifyParkReattach(ctx, attempt, max, reason) {
-    const cb = ctx.deps.onParkReattach;
-    if (typeof cb !== 'function')
-        return;
-    try {
-        cb({ attempt, max, reason });
-    }
-    catch (e) {
-        hostLog('debug', `liveHitlAskWire: onParkReattach threw (${String(e)}) — ignored`);
-    }
+    invokeHostCallbackIsolated('liveHitlAskWire: onParkReattach', () => {
+        const cb = ctx.deps.onParkReattach;
+        if (typeof cb !== 'function' || ctx.signal?.aborted === true)
+            return;
+        return cb.call(ctx.deps, { attempt, max, reason });
+    });
 }
 function transportReasonToken(reason) {
     const m = /(ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|EAI_AGAIN|TimeoutError|AbortError|fetch failed|network)/i.exec(reason);

package/dist/hitl/parkRowBirthWait.d.ts

@@ -1,3 +1,4 @@
+import type { CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 export type ParkRowProbe<Row> = {
     kind: 'row';
     row: Row;
@@ -7,6 +8,10 @@ export type ParkRowProbe<Row> = {
 } | {
     kind: 'settled';
     reason: string;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
+    rowTaskId?: string;
 };
 export type ParkRowWaitVerdict<Row> = {
     kind: 'row';
@@ -23,6 +28,10 @@ export type ParkRowWaitVerdict<Row> = {
     reason: string;
     waitedMs: number;
     probes: number;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
+    rowTaskId?: string;
 } | {
     kind: 'aborted';
     waitedMs: number;

package/dist/hitl/parkRowBirthWait.js

@@ -103,7 +103,14 @@ export async function waitForParkRowBirth(deps) {
         if (probed.kind === 'row')
             return { kind: 'row', row: probed.row, waitedMs: now() - startedAt, probes };
         if (probed.kind === 'settled') {
-            return { kind: 'settled', reason: probed.reason, waitedMs: now() - startedAt, probes };
+            return {
+                kind: 'settled',
+                reason: probed.reason,
+                waitedMs: now() - startedAt,
+                probes,
+                ...(probed.rowVerdict !== undefined ? { rowVerdict: probed.rowVerdict } : {}),
+                ...(probed.rowTaskId !== undefined ? { rowTaskId: probed.rowTaskId } : {}),
+            };
         }
         lastReason = probed.reason;
         const remainingMs = budgetMs - (now() - startedAt);

package/dist/hitl/parkRowDelegation.d.ts

@@ -0,0 +1,6 @@
+export interface ParkRowDelegationLinks {
+    readonly parentSessionId?: string;
+    readonly rootSessionId?: string;
+}
+export declare function pendingRowIsOfSession(row: object, sessionId: string): boolean;
+export declare function parkRowDelegationLinksOf(row: object | null | undefined): ParkRowDelegationLinks | undefined;

package/dist/hitl/parkRowDelegation.js

@@ -0,0 +1,33 @@
+import { slotReadOf } from '../wireFailureShape.js';
+export function pendingRowIsOfSession(row, sessionId) {
+    if (sessionId.length === 0)
+        return false;
+    const rowSessionId = typeof row.sessionId === 'string' ? row.sessionId : '';
+    if (rowSessionId.length > 0 && rowSessionId === sessionId)
+        return true;
+    const links = parkRowDelegationLinksOf(row);
+    return links !== undefined && (links.parentSessionId === sessionId || links.rootSessionId === sessionId);
+}
+export function parkRowDelegationLinksOf(row) {
+    try {
+        if (typeof row !== 'object' || row === null)
+            return undefined;
+        const a = slotReadOf(row, 'agent');
+        if (a.presence !== 'present' || typeof a.value !== 'object' || a.value === null)
+            return undefined;
+        const agent = a.value;
+        const link = (key) => {
+            const r = slotReadOf(agent, key);
+            return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+        };
+        const parentSessionId = link('parentSessionId');
+        const rootSessionId = link('rootSessionId');
+        return Object.freeze({
+            ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+            ...(rootSessionId !== undefined ? { rootSessionId } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/persistedRulesWire.d.ts

@@ -1,4 +1,4 @@
-import type { CcImportLayer, CcImportPrepareResult, CcImportRedeemResult, PersistedRule, RuleBehavior, RuleListParams, RuleListResult, RuleRevokeRequest, RemovalLiveness, RuleRevokeResult, RuleWriteRequest, RuleWriteResult } from '@sema-agent/sdk';
+import type { CcImportLayer, CcImportPrepareResult, PersistedRule, RuleBehavior, RuleListParams, RuleListResult, RuleRevokeRequest, RemovalLiveness, RuleRevokeResult, RuleWriteRequest, RuleWriteResult, RulesResource } from '@sema-agent/sdk';
 import type { UiLanguage } from '../env/uiLanguage.js';
 export interface RulesFacade {
     list(params?: RuleListParams, opts?: {
@@ -15,17 +15,33 @@ export interface RulesFacade {
     }): Promise<CcImportPrepareResult>;
     ccImportRedeem(ticket: string, opts?: {
         signal?: AbortSignal;
-    }): Promise<CcImportRedeemResult>;
+    }): ReturnType<RulesResource['ccImportRedeem']>;
 }
 export type RulesListFacade = Pick<RulesFacade, 'list'>;
 export declare function persistedRulesLaneAvailable(baseUrl: string | undefined): boolean;
 export declare function persistedRulesGovernanceAvailable(baseUrl: string | undefined): boolean;
 export declare function persistedRulesWriteAvailable(baseUrl: string | undefined): boolean;
+export interface CcImportRedeemIndeterminate {
+    readonly key?: CcImportRedeemRuleKey;
+    readonly reason?: string;
+    readonly detail?: string;
+}
+export interface CcImportRedeemRuleKey {
+    readonly behavior: string;
+    readonly rule: string;
+    readonly scope: string;
+}
+export interface CcImportRedeemRefused {
+    readonly key?: CcImportRedeemRuleKey;
+}
 export interface CcImportRedeemCounts {
     persisted: number;
     deduped: number;
+    indeterminate: readonly CcImportRedeemIndeterminate[];
+    refused?: readonly CcImportRedeemRefused[];
 }
-export declare function readCcImportRedeemCounts(result: unknown): CcImportRedeemCounts | null;
+export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'refused' | 'indeterminate';
+export declare function readCcImportRedeemCounts(body: unknown): CcImportRedeemCounts | null;
 export type RulesFailure = {
     kind: 'lane-unavailable';
     message: string;