@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/hitl/decisionSend.js

@@ -10,6 +10,7 @@ import { readDecisionNoteAudit } from './approvalDecisionNoteAudit.js';
 import { carrierReadOf, deliverWithAttributionLadder, isLocalSafetyStop } from './attributionLadder.js';
 import { budgetSpent, deliverApprovalDecision, deliveryTiming, isAborted, newSendTally, PARKING_WAIT_CAP_MS, setDeliveryTimingForTests, sleepFor, settledTransportReadingOf, withTransportRetry, deliveryReadingOf, } from './approvalDelivery.js';
 import { ASK_DECIDED_CODE, classifyDeliveredDecisionRefusal, decisionRefusalClosesOut, notPendingAfterRetry } from './decisionRefusal.js';
+import { sessionAllowEligible } from './sessionAllowRoute.js';
 import { addDecisionOpKeys, closeDecisionOp, decisionLedgerKeysOf, decisionOpsWithKey, openDecisionOp } from './decisionLedger.js';
 import { hostHoldIsActive, takeHostHoldLedgerOp, tryHoldApprovalNow } from './approvalHolds.js';
 import { answerPayloadFor, decisionAttributionKeyOf, isToolApprovalRespondReplayed, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, } from './toolApprovalWire.js';
@@ -183,6 +184,9 @@ function bodyFacts(answer, payload, rememberUnsupported) {
         ...(rememberUnsupported && answer.kind === 'allow' && answer.allowSession === true ? { rememberDropped: true } : {}),
     };
 }
+function answerGateCannotTake(out) {
+    return out.kind === 'not_applied' && (out.cause === 'gone' || out.cause === 'parking' || out.cause === 'lane_disabled');
+}
 function ownTrue(raw, key) {
     return typeof raw === 'object' && raw !== null && guardedRead(() => readOwnDataValue(raw, key)) === true;
 }
@@ -190,6 +194,14 @@ async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
     const payload = answerPayloadFor(req.answer, 'respond', { approvalDecisionNoteCapable: ctx.noteCapable });
     if (payload === undefined)
         return { family: 'ask', attempts: ctx.tally.attempts, kind: 'not_sent', cause: 'not_an_answer' };
+    let fallbackRespond = respondForFallback;
+    if (req.answer.kind === 'allow' && req.answer.allowSession === true && respondForFallback !== undefined && req.approvalId !== undefined) {
+        const viaAnswerGate = await sendApprovalFamily(respondForFallback, req.approvalId, req.answer, ctx);
+        if (!answerGateCannotTake(viaAnswerGate))
+            return { ...viaAnswerGate, family: 'ask', allowSessionCarried: true };
+        hostLog('debug', `decisionSend: session-allow-fallback ask=${req.askId} cause=${String(viaAnswerGate.cause)} via=ask-decide-once`);
+        fallbackRespond = undefined;
+    }
     const verdict = verdictOf(payload.decision) ?? 'deny';
     const attribution = req.answer.kind === 'deny' ? decisionAttributionKeyOf(ctx.decidedBy, readApprovalDenySettledBy(req.answer)) : {};
     const body = {
@@ -232,8 +244,8 @@ async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
             }
             const out = outcomeOfThrown(e, 'ask', verdict, ctx.signal, ctx.tally, ctx.noteCapable, settled);
             if (out.kind === 'not_applied' && out.cause === 'lane_disabled' && code === ASK_DECISION_LANE_DISABLED && req.approvalId !== undefined) {
-                if (respondForFallback !== undefined && ctx.signal?.aborted !== true) {
-                    const fb = await sendApprovalFamily(respondForFallback, req.approvalId, req.answer, ctx);
+                if (fallbackRespond !== undefined && ctx.signal?.aborted !== true) {
+                    const fb = await sendApprovalFamily(fallbackRespond, req.approvalId, req.answer, ctx);
                     return { ...fb, family: 'ask', fallback: 'approval' };
                 }
             }
@@ -374,6 +386,14 @@ function snapshotAnswer(raw) {
     }
     return typeof kind === 'string' ? Object.freeze({ kind }) : undefined;
 }
+function sessionGatedAnswer(answer, card) {
+    if (answer.kind !== 'allow' || answer.allowSession !== true)
+        return { answer };
+    const why = card === undefined ? 'card_absent' : typeof card === 'object' && card !== null ? sessionAllowEligible(card) : 'card_unreadable';
+    if (why === 'given')
+        return { answer };
+    return { answer: Object.freeze({ ...answer, allowSession: false }), dropped: why };
+}
 function readRequest(req) {
     if (typeof req !== 'object' || req === null)
         return undefined;
@@ -387,17 +407,19 @@ function readRequest(req) {
     const rawAnswer = guardedRead(() => readOwnDataValue(req, 'answer'));
     if (typeof rawAnswer !== 'object' || rawAnswer === null)
         return undefined;
-    const answer = snapshotAnswer(rawAnswer);
-    if (answer === undefined)
+    const snapshot = snapshotAnswer(rawAnswer);
+    if (snapshot === undefined)
         return undefined;
+    const { answer, dropped } = sessionGatedAnswer(snapshot, guardedRead(() => readOwnDataValue(req, 'card')));
+    const droppedFact = dropped !== undefined ? { sessionAllowDropped: dropped } : {};
     if (family === 'approval') {
         const approvalId = s('approvalId');
-        return approvalId !== undefined ? { family, approvalId, taskId: s('taskId'), toolCallId: s('toolCallId'), answer } : undefined;
+        return approvalId !== undefined ? { family, approvalId, taskId: s('taskId'), toolCallId: s('toolCallId'), answer, ...droppedFact } : undefined;
     }
     if (family === 'ask') {
         const taskId = s('taskId');
         const askId = s('askId');
-        return taskId !== undefined && askId !== undefined ? { family, taskId, askId, approvalId: s('approvalId'), toolCallId: s('toolCallId'), answer } : undefined;
+        return taskId !== undefined && askId !== undefined ? { family, taskId, askId, approvalId: s('approvalId'), toolCallId: s('toolCallId'), answer, ...droppedFact } : undefined;
     }
     return undefined;
 }
@@ -507,6 +529,10 @@ export async function sendHitlDecision(request, deps) {
                 out = outcomeOfThrown(e, 'elicitation', undefined, signal, ctx.tally, false);
             }
         }
+        if (req.family !== 'elicitation' && req.sessionAllowDropped !== undefined) {
+            hostLog('debug', `decisionSend: session-allow-not-eligible ${req.family}=${req.family === 'ask' ? req.askId : req.approvalId} why=${req.sessionAllowDropped} via=allow-once`);
+            out = { ...out, rememberDropped: true };
+        }
         const ambiguous = out.kind === 'unconfirmed' || (out.kind === 'not_applied' && (out.cause === 'parking' || out.cause === 'refused' || out.cause === 'idempotency_crossed'));
         if (ambiguous && out.cause !== 'aborted') {
             const gate = req.family === 'elicitation'

package/dist/hitl/frameRouter.js

@@ -20,6 +20,7 @@ import { ccToolDenialKindForSettledBy } from '../gateVocabulary.js';
 import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
 import { RUN_CANCELLED_CODE } from '../runCancelContext.js';
 import { durableDecideLegOf } from '../adapter/activeRunSelfHeal.js';
+import { subagentSourceSessionOf } from './subagentSource.js';
 export const HITL_REJECT_MESSAGE = REJECT_MESSAGE;
 export const HITL_POLICY_DENY_MESSAGE = 'Permission for this tool use was denied: it requires interactive approval, and permission prompts are ' +
     'not available in this session. The action was NOT performed. Do not claim it succeeded, and do not retry ' +
@@ -135,13 +136,11 @@ export function parkGateArmOf(gate) {
         return null;
     }
     const leg = durableDecideLegOf(typeof kind === 'string' ? { gateKind: kind } : null);
-    if (leg !== 'approval' && leg !== 'absent')
+    if (leg !== 'approval')
         return null;
     if (questionCardVerdict(gate) ?? isAskToolLoose(toolName))
         return 'ask';
-    if (leg === 'approval')
-        return 'fs';
-    return isFsOrShellToolName(toolName) ? 'fs' : null;
+    return 'fs';
 }
 const ENGINE_GATE_PARKED_ERROR_CODE = GATE_PARKED_ERROR_CODE;
 function isEngineAbortToolEnd(ev) {
@@ -336,7 +335,7 @@ async function routeToolApprovalFrame(ev, ctx) {
         }
     }
     const fromSubagent = isFromSubagent(ev);
-    hostLog('debug', `liveHitlAskWire: tool_approval frame ${ev.approvalId} tool=${String(ev.toolName)}${fromSubagent ? ` from-subagent=${String(ev.sourceTaskId ?? ev.sourceAgentName ?? 'explicit')}` : ''}`);
+    hostLog('debug', `liveHitlAskWire: tool_approval frame ${ev.approvalId} tool=${String(ev.toolName)}${fromSubagent ? ` from-subagent=${String(subagentSourceSessionOf(ev) ?? ev.sourceAgentName ?? 'explicit')}` : ''}`);
     const frameCallId = !fromSubagent && typeof ev.toolCallId === 'string' && ev.toolCallId !== '' ? ev.toolCallId : undefined;
     const gatedCallId = fromSubagent ? undefined : frameCallId ?? led.lastPendingFsCall();
     const argsCallId = frameCallId === undefined ? gatedCallId : typeof ev.toolName === 'string' && toolNameIsFsWrite(ev.toolName) ? frameCallId : undefined;

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;
@@ -26,7 +27,7 @@ export interface AssistantResourceLike {
     planReview(taskId: string, req: PlanReviewRequest, opts?: {
         signal?: AbortSignal;
     }): Promise<AssistantTaskStatus>;
-    resume(taskId: string, opts?: {
+    resume(taskId: string, body?: undefined, opts?: {
         signal?: AbortSignal;
     }): Promise<AssistantTaskStatus>;
 }
@@ -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

@@ -10,6 +10,9 @@ import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_INVALID_OUTCOME, RESUME_POLICY_FO
 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 { checkpointRowBarOf, checkpointRowBarSentence } from '../checkpointRowVerdict.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -28,6 +31,15 @@ export function denyReasonForWire(reason, tag) {
         `(server caps approval reason at ${MAX_DENY_REASON_CHARS}; over-cap is a 413 reason_too_large that would drop the DECISION, not just the reason)`);
     return cut;
 }
+function resumeTakesRestatementBody(client) {
+    if (typeof Reflect.get(client.approvals, 'decidePeerInbound') === 'function')
+        return true;
+    return client.assistant.resume.length >= 3;
+}
+const _realClientFitsHitlSlice = true;
+void _realClientFitsHitlSlice;
+const _bindingKeysEchoed = true;
+void _bindingKeysEchoed;
 export const PLAN_REVIEW_MODE_AFTER_WORDS = Object.freeze(['default', 'acceptEdits']);
 export function isPlanReviewModeAfter(v) {
     return v !== undefined && PLAN_REVIEW_MODE_AFTER_WORDS.includes(v);
@@ -258,7 +270,13 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
         hostLog('debug', `hitlBridge: approvals.list failed: ${t.log}`);
         return { ok: false, reason: `approvals.list failed: ${t.reason}` };
     }
-    const readings = rows.map((r) => ({ r, foreign: askParkForeignGateKind(r) }));
+    const readings = rows.flatMap((r) => {
+        const sort = checkpointQueueRowSortOf(r);
+        if (sort === 'excluded')
+            return [];
+        const cp = r;
+        return [{ r: cp, foreign: sort === 'unreadable' ? QUEUE_ROW_FAMILY_UNREADABLE_GATE : askParkForeignGateKind(cp) }];
+    });
     const decidable = readings.filter((x) => x.foreign === null).map((x) => x.r);
     const identityRow = callId !== undefined
         ? decidable.find((r) => r.taskId === taskId && (r.boundCallId === callId || r.toolCallId === callId))
@@ -267,6 +285,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`,
@@ -278,8 +299,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 {
@@ -328,18 +360,22 @@ export class HitlBridge {
         throw new Error(found.reason);
     }
     bindingOf(p) {
-        if (p.boundCallId === undefined || p.boundInputHash === undefined) {
+        const boundCallId = readOwnDataValue(p, 'boundCallId');
+        const boundInputHash = readOwnDataValue(p, 'boundInputHash');
+        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(p.boundCallId)}, boundInputHash=${String(p.boundInputHash)}) — ` +
-                'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_missing');
+                `(boundCallId=${String(boundCallId)}, boundInputHash=${String(boundInputHash)}) — ` +
+                `the row itself carries no binding to echo, so ${renderMessage(msg('approval.decide.unboundWayOut'))}`, 'binding_missing');
         }
-        return { boundCallId: p.boundCallId, boundInputHash: p.boundInputHash };
+        return { boundCallId, boundInputHash };
     }
     async decideTool(outcome, toolUseID, opts, preResolvedPending) {
         const pending = preResolvedPending ?? (await this.pendingForDecide(toolUseID, wireOptsOf(opts)));
         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',
@@ -365,6 +401,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)) },
@@ -406,7 +444,10 @@ export class HitlBridge {
         if (kind && kind !== 'resource_limit') {
             throw new HitlSafetyError(`cannot resume a "${kind}" gate — "continue" must never bypass a human approval; use decide`, 'wrong_gate');
         }
-        return this.client.assistant.resume(this.taskId, opts);
+        const assistant = this.client.assistant;
+        if (resumeTakesRestatementBody(this.client))
+            return assistant.resume(this.taskId, undefined, opts);
+        return Reflect.apply(assistant.resume, assistant, [this.taskId, opts]);
     }
     async decideRaw(sessionId, decision, optsIn) {
         const opts = wireOptsOf(optsIn);
@@ -520,6 +561,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.d.ts

@@ -1,6 +1,7 @@
 import { type ApprovalRequestFrame } from '@sema-agent/sdk';
 import type { ApprovalResolution } from './approvalResolution.js';
 import type { ApprovalsFeedEmission } from './approvalsFeed.js';
+import type { ApprovalMandateWord } from '../gateVocabulary.js';
 import { type RespondToolApprovalFn, type ToolApprovalFrame, type ToolApprovalFrameLaneOpts } from './toolApprovalWire.js';
 export interface LivePendingAskView {
     approvalId: string;
@@ -13,6 +14,10 @@ export interface LivePendingAskView {
     fromSubagent?: true;
     originTaskId?: string;
     frame?: ToolApprovalFrame | ApprovalRequestFrame;
+    mandated?: true;
+    mandate?: ApprovalMandateWord;
+    origin?: string;
+    liveFactsUnknown?: true;
 }
 export type LivePendingReading = {
     kind: 'not_reported';

package/dist/hitl/livePendingAsk.js

@@ -1,6 +1,8 @@
 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';
 function nonEmptyString(v) {
@@ -61,6 +63,8 @@ export function readLivePendingRows(body) {
             continue;
         }
         seen.add(o.approvalId);
+        const opening = openingFrameOf(o.frame);
+        const frame = opening !== undefined && opening.approvalId === o.approvalId ? opening : undefined;
         rows.push({
             approvalId: o.approvalId,
             toolName: o.toolName,
@@ -71,7 +75,8 @@ export function readLivePendingRows(body) {
             ...(o.governanceForced === true ? { governanceForced: true } : {}),
             ...(o.fromSubagent === true ? { fromSubagent: true } : {}),
             ...(nonEmptyString(o.originTaskId) ? { originTaskId: o.originTaskId } : {}),
-            ...((f) => (f !== undefined && f.approvalId === o.approvalId ? { frame: f } : {}))(openingFrameOf(o.frame)),
+            ...(frame !== undefined ? { frame } : {}),
+            ...(frame === undefined ? liveFaceCarried(approvalLiveFaceOf(o)) : {}),
         });
     }
     if (members.length > 0 && rows.length === 0)
@@ -120,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)
@@ -134,9 +140,10 @@ 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)),
     };
 }
 export function surfaceSuspendedAskAndRespond(row, respond, signal, lane) {

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

@@ -12,6 +12,7 @@ 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';
 export const MAX_GATE_HOPS = 2;
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
@@ -63,7 +64,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
@@ -284,7 +285,8 @@ export async function resolvePark(park, ctx) {
                 ? 'the approval card was retracted by the host without a decision (nothing was sent; the run stays parked and remains decidable elsewhere)'
                 : failureReasonOf(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) };
+        const undecidableHere = outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing'));
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface, undecidableHere) };
     }
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
@@ -307,15 +309,17 @@ export async function resolvePark(park, ctx) {
         ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
     };
 }
-function failsoftReasonSentence(park, failedReason, terminal) {
+function failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut = false) {
     if (terminal !== undefined)
         return terminal.errorMessage;
     if (failedReason === undefined)
         return undefined;
+    if (reasonCarriesWayOut)
+        return renderMessage(msg('approval.park.stillParked', { gate: park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion', 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, reasonCarriesWayOut = false) {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -323,7 +327,7 @@ function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, no
             gateAbortedByUser,
         }),
     ];
-    const reason = failsoftReasonSentence(park, failedReason, terminal);
+    const reason = failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut);
     if (park.pendingDone) {
         events.push(reason === undefined || noDecisionSurface ? park.pendingDone : inheritFrameBinding(park.pendingDone, { ...park.pendingDone, _sema_park_failed_reason: 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,9 @@ export type ParkRowProbe<Row> = {
 } | {
     kind: 'settled';
     reason: string;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 };
 export type ParkRowWaitVerdict<Row> = {
     kind: 'row';
@@ -23,6 +27,9 @@ export type ParkRowWaitVerdict<Row> = {
     reason: string;
     waitedMs: number;
     probes: number;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 } | {
     kind: 'aborted';
     waitedMs: number;

package/dist/hitl/parkRowBirthWait.js

@@ -103,7 +103,7 @@ 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 } : {}) };
         }
         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,29 @@ 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 CcImportRedeemCounts {
     persisted: number;
     deduped: number;
+    indeterminate: readonly CcImportRedeemIndeterminate[];
 }
-export declare function readCcImportRedeemCounts(result: unknown): CcImportRedeemCounts | null;
+export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'indeterminate';
+export declare function readCcImportRedeemCounts(body: unknown): CcImportRedeemCounts | null;
 export type RulesFailure = {
     kind: 'lane-unavailable';
     message: string;