@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/hitl/approvalQueueRow.js

@@ -0,0 +1,69 @@
+import { slotReadOf } from '../wireFailureShape.js';
+import { SDK_APPROVAL_QUEUE_KINDS } from '../generated/sdkFactTables.js';
+const _queueKindsPin = true;
+void _queueKindsPin;
+const isApprovalQueueKind = (v) => SDK_APPROVAL_QUEUE_KINDS.includes(v);
+export function approvalQueueRowFamilyOf(row) {
+    const kind = slotReadOf(row, 'kind');
+    if (kind.presence === 'absent')
+        return 'checkpoint';
+    if (kind.presence !== 'present' || typeof kind.value !== 'string')
+        return 'unreadable';
+    return isApprovalQueueKind(kind.value) ? kind.value : 'unknown';
+}
+export function checkpointQueueRowSortOf(row) {
+    try {
+        if (typeof row !== 'object' || row === null || Array.isArray(row))
+            return 'excluded';
+        const family = approvalQueueRowFamilyOf(row);
+        return family === 'checkpoint' ? 'checkpoint' : family === 'unreadable' ? 'unreadable' : 'excluded';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export const QUEUE_ROW_FAMILY_UNREADABLE_GATE = '(unreadable)';
+const ownString = (row, key, nonEmpty) => {
+    const r = slotReadOf(row, key);
+    return r.presence === 'present' && typeof r.value === 'string' && (!nonEmpty || r.value !== '') ? r.value : undefined;
+};
+const ownTime = (row, key) => {
+    const r = slotReadOf(row, key);
+    return r.presence === 'present' && typeof r.value === 'number' && Number.isFinite(r.value) && r.value >= 0 ? r.value : undefined;
+};
+export function peerInboundQueueRowOf(row) {
+    try {
+        const id = ownString(row, 'id', true);
+        const recipientSessionId = ownString(row, 'recipientSessionId', true);
+        if (id === undefined || recipientSessionId === undefined)
+            return undefined;
+        const out = { id, recipientSessionId };
+        const lane = ownString(row, 'lane', true);
+        if (lane !== undefined)
+            out.lane = lane;
+        const cause = ownString(row, 'cause', true);
+        if (cause !== undefined)
+            out.cause = cause;
+        const content = ownString(row, 'content', false);
+        if (content !== undefined)
+            out.content = content;
+        const sentAt = ownTime(row, 'sentAt');
+        if (sentAt !== undefined)
+            out.sentAt = sentAt;
+        const heldAt = ownTime(row, 'heldAt');
+        if (heldAt !== undefined)
+            out.heldAt = heldAt;
+        const deadline = ownTime(row, 'deadline');
+        if (deadline !== undefined)
+            out.deadline = deadline;
+        for (const k of ['fromSession', 'fromName', 'fromScope']) {
+            const v = ownString(row, k, true);
+            if (v !== undefined)
+                out[k] = v;
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/approvalsFeed.d.ts

@@ -1,13 +1,13 @@
 import type { PendingCheckpoint } from '@sema-agent/sdk';
 import { type LivePendingAskView } from './livePendingAsk.js';
+import { type ApprovalQueuePeerInboundRow } from './approvalQueueRow.js';
+import type { ApprovalsListEnvelope } from './crashConverged.js';
+export type { ApprovalQueuePeerInboundRow } from './approvalQueueRow.js';
 export interface ApprovalsFeedClientLike {
     approvals: {
         list(opts?: {
             signal?: AbortSignal;
-        }): Promise<{
-            pending: PendingCheckpoint[];
-            livePending?: unknown[];
-        }>;
+        }): Promise<ApprovalsListEnvelope>;
         stream?(opts?: {
             signal?: AbortSignal;
         }): AsyncGenerator<{
@@ -20,6 +20,7 @@ export type ApprovalsFeedMode = 'push' | 'poll' | 'idle';
 export interface ApprovalsFeedSnapshot {
     kind: 'snapshot';
     pending: PendingCheckpoint[];
+    peerInbound?: ApprovalQueuePeerInboundRow[];
     livePending?: LivePendingAskView[];
     livePendingDropped?: number;
     pendingDropped?: number;

package/dist/hitl/approvalsFeed.js

@@ -2,17 +2,40 @@ import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
+import { approvalQueueRowFamilyOf, peerInboundQueueRowOf } from './approvalQueueRow.js';
+import { checkpointRowVerdictOf } from '../checkpointRowVerdict.js';
+const _realClientFitsFeedSlice = true;
+void _realClientFitsFeedSlice;
 const MAX_CONSECUTIVE_POLL_ESCAPES = 5;
 function readDurablePendingRows(raw) {
     if (!Array.isArray(raw))
         return { kind: 'malformed' };
     const rows = [];
+    const peer = [];
     let dropped = 0;
+    let skipped = 0;
     for (const item of raw) {
         if (item === null || typeof item !== 'object' || Array.isArray(item)) {
             dropped++;
             continue;
         }
+        const family = approvalQueueRowFamilyOf(item);
+        if (family === 'unknown') {
+            skipped++;
+            continue;
+        }
+        if (family === 'peer_inbound') {
+            const view = peerInboundQueueRowOf(item);
+            if (view === undefined)
+                dropped++;
+            else
+                peer.push(view);
+            continue;
+        }
+        if (family === 'unreadable') {
+            dropped++;
+            continue;
+        }
         const sid = item.sessionId;
         if (typeof sid !== 'string' || sid === '') {
             dropped++;
@@ -20,13 +43,13 @@ function readDurablePendingRows(raw) {
         }
         rows.push(item);
     }
-    if (raw.length > 0 && rows.length === 0)
+    if (raw.length > 0 && rows.length + peer.length + skipped === 0)
         return { kind: 'malformed' };
-    return { kind: 'present', rows, dropped };
+    return { kind: 'present', rows, peer, dropped };
 }
 function durableDigestOf(rows) {
     return rows
-        .map(r => [r.sessionId ?? '', r.taskId ?? '', r.toolCallId ?? '', r.boundCallId ?? '', r.boundInputHash ?? '', r.toolName ?? '']
+        .map(r => [r.sessionId ?? '', r.taskId ?? '', r.toolCallId ?? '', r.boundCallId ?? '', r.boundInputHash ?? '', r.toolName ?? '', JSON.stringify(checkpointRowVerdictOf(r) ?? null)]
         .join('
'))
         .sort()
         .join('');
@@ -34,14 +57,20 @@ function durableDigestOf(rows) {
 const LIVE_FIELD_SEP = String.fromCharCode(1);
 const LIVE_ROW_SEP = String.fromCharCode(2);
 const LIVE_SECTION_SEP = String.fromCharCode(3);
-function digestOf(rows, live, dropped = 0, droppedDurable = 0) {
+function peerDigestOf(peer) {
+    return peer
+        .map(r => JSON.stringify(r))
+        .sort()
+        .join(LIVE_ROW_SEP);
+}
+function digestOf(rows, live, dropped = 0, droppedDurable = 0, peer = []) {
     const liveDigest = live === undefined
         ? 'absent'
         : live
             .map(r => [r.approvalId, r.toolName, String(r.expiresAtMs), r.sessionId ?? '', r.originTaskId ?? '', r.frame !== undefined ? 'f' : ''].join(LIVE_FIELD_SEP))
             .sort()
             .join(LIVE_ROW_SEP);
-    return `${durableDigestOf(rows)}${LIVE_SECTION_SEP}${liveDigest}${LIVE_SECTION_SEP}${dropped}${LIVE_SECTION_SEP}${droppedDurable}`;
+    return `${durableDigestOf(rows)}${LIVE_SECTION_SEP}${liveDigest}${LIVE_SECTION_SEP}${dropped}${LIVE_SECTION_SEP}${droppedDurable}${LIVE_SECTION_SEP}${peerDigestOf(peer)}`;
 }
 export function startApprovalsFeed(client, onSnapshot, opts) {
     const pollIntervalMs = opts?.pollIntervalMs ?? 5000;
@@ -158,6 +187,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             return;
         const seq = ++takeSeq;
         let rows;
+        let peer;
         let live;
         let dropped = 0;
         let droppedDurable = 0;
@@ -212,6 +242,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 throw new TypeError('approvalsFeed: unreadable pending section');
             }
             rows = durableRead.rows;
+            peer = durableRead.peer;
             droppedDurable = durableRead.dropped;
             if (durableRead.dropped > 0)
                 hostLog('debug', `approvalsFeed: dropped ${durableRead.dropped} malformed pending row(s) — snapshot carries pendingDropped`);
@@ -220,7 +251,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             return;
         let d;
         try {
-            d = digestOf(rows, live, dropped, droppedDurable);
+            d = digestOf(rows, live, dropped, droppedDurable, peer);
         }
         catch (e) {
             noteTakeMissed(via, seq);
@@ -252,6 +283,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         const snap = {
             kind: 'snapshot',
             pending: rows,
+            ...(peer.length > 0 ? { peerInbound: peer } : {}),
             ...(live !== undefined ? { livePending: live } : {}),
             ...(dropped > 0 ? { livePendingDropped: dropped } : {}),
             ...(droppedDurable > 0 ? { pendingDropped: droppedDurable } : {}),

package/dist/hitl/askGateWire.js

@@ -1,9 +1,10 @@
 import { createGateLedger } from './gateLedger.js';
-import { flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from './frameRouter.js';
+import { bridgeRunHandleFallbackOf, flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from './frameRouter.js';
 import { resolvePark, nextHopBudget, stalledTerminal, MAX_GATE_HOPS } from './parkResolver.js';
 import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
 import { abortableSleep } from '../abortableSleep.js';
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { decideAcceptedNotResolved, readDecideReceipt } from '../decideReceipt.js';
 import { APPROVAL_EXPIRED } from '../engineErrorCodes.js';
 import { isNotFoundFailure } from '../wireErrorTriage.js';
@@ -37,11 +38,14 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     let lastRoundDecided = false;
     let unverifiableParks = 0;
     const drains = createStreamDrainingLegs();
+    let lastDrainFrame;
     while (true) {
         let park = null;
         for await (const ev of stream) {
-            if (drains.see(ev))
+            if (drains.see(ev)) {
+                lastDrainFrame = ev;
                 continue;
+            }
             const answering = led.answeringLiveCards();
             if (answering.length > 0)
                 await Promise.all(answering);
@@ -77,6 +81,11 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             const drained = drains.legEnded('returned');
             if (drained !== undefined) {
                 const reopenAfterMs = 'reconnectAfterMs' in drained ? drained.reconnectAfterMs : undefined;
+                if (taskId.current === undefined) {
+                    const bound = bridgeRunHandleFallbackOf(deps);
+                    if (bound !== undefined && reopenAfterMs !== undefined)
+                        taskId.current = bound;
+                }
                 if (reopenAfterMs !== undefined && taskId.current !== undefined && !opts?.signal?.aborted) {
                     hostLog('debug', `liveHitlAskWire: runs.events(${taskId.current}) ended on the drain end frame — the engine is going down; reopening in ${reopenAfterMs}ms`);
                     await abortableSleep(reopenAfterMs, opts?.signal ?? new AbortController().signal);
@@ -91,6 +100,13 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
                     }
                 }
                 hostLog('debug', `liveHitlAskWire: runs.events ended on the drain end frame and is not reopened (${'giveUp' in drained ? drained.giveUp : taskId.current === undefined ? 'no run handle' : 'aborted'}) — ending this leg like a dropped stream`);
+                if (!opts?.signal?.aborted) {
+                    const runId = taskId.current;
+                    const event = 'giveUp' in drained
+                        ? { cause: 'stream_draining', ladder: 'exhausted', ...(runId !== undefined ? { runId } : {}) }
+                        : { cause: 'stream_draining', frame: lastDrainFrame ?? {}, ...(runId !== undefined ? { runId } : {}) };
+                    notifyBreak(deps, Object.freeze(event), opts?.signal);
+                }
             }
             yield* flushHeldWithInterruptRewrite(led, { signal: opts?.signal });
             return;
@@ -161,6 +177,14 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
         });
     }
 }
+function notifyBreak(deps, event, signal) {
+    invokeHostCallbackIsolated('liveHitlAskWire: onBreak', () => {
+        const cb = deps.onBreak;
+        if (typeof cb !== 'function' || signal?.aborted === true)
+            return;
+        return cb.call(deps, event);
+    });
+}
 export const LATE_DECIDE_OUTCOMES = Object.freeze(['accepted-not-resolved', 'resumed', 'expired-reaped', 'settled-elsewhere', 'unknown']);
 const LATE_DECIDE_TASK_ID_MAX = 64;
 export function lateDecideOutcomeOf(reply, opts) {

package/dist/hitl/askParkRowRouting.d.ts

@@ -1,4 +1,5 @@
 import type { PendingCheckpoint } from '@sema-agent/sdk';
+import type { ApprovalQueueRow } from './crashConverged.js';
 import type { ParkRowProbe } from './parkRowBirthWait.js';
 import { type ParkOwnershipDeps } from './parkOwnership.js';
 export declare const ASK_PARK_ROW_WAIT_MS = 15000;
@@ -7,7 +8,7 @@ export interface AskParkRowScanDeps {
     isOwned?: (row: PendingCheckpoint) => boolean;
     ownership?: ParkOwnershipDeps;
 }
-export declare function classifyAskParkRows(rows: readonly PendingCheckpoint[], taskId: string, deps?: AskParkRowScanDeps): ParkRowProbe<PendingCheckpoint>;
+export declare function classifyAskParkRows(queueRows: readonly ApprovalQueueRow[], taskId: string, deps?: AskParkRowScanDeps): ParkRowProbe<PendingCheckpoint>;
 export interface AskParkRowIdentity {
     rowTaskId: string;
     gatedCallId: string | undefined;
@@ -15,7 +16,7 @@ export interface AskParkRowIdentity {
 }
 export declare function askParkRowIdentity(taskId: string, row: PendingCheckpoint): AskParkRowIdentity;
 export declare function askParkRowArm(row: PendingCheckpoint): 'question' | 'tool-gate';
-export declare function askParkRowStillPending(rows: readonly PendingCheckpoint[], identity: AskParkRowIdentity): boolean;
+export declare function askParkRowStillPending(rows: readonly ApprovalQueueRow[], identity: AskParkRowIdentity): boolean;
 export type AskParkChainFailureDisposition = 'retry' | 'row-gone-after-card' | 'row-unborn';
 export declare function classifyAskParkChainFailure(i: {
     rowStillPending: boolean;
@@ -29,6 +30,6 @@ export interface RowArmSingleFlight<T> {
 export declare function createRowArmSingleFlight<T>(): RowArmSingleFlight<T>;
 export declare function pendingRowIsOwnedAndDecidable(row: PendingCheckpoint, deps?: ParkOwnershipDeps): boolean;
 export interface OwnedPendingListView {
-    readonly pending?: readonly PendingCheckpoint[] | null;
+    readonly pending?: readonly ApprovalQueueRow[] | null;
 }
 export declare function countOwnedPendingRows(listed: OwnedPendingListView | null | undefined, deps?: ParkOwnershipDeps): number;

package/dist/hitl/askParkRowRouting.js

@@ -2,10 +2,17 @@ import { askParkForeignGateKind, durableDecideLegOf } from '../adapter/activeRun
 import { isAskTool, questionCardVerdict } from './frameRouter.js';
 import { approvalCallKey } from './gateIdentity.js';
 import { askQuestionsFromPending, pendingRowIsOwnedByThisSession } from './parkOwnership.js';
+import { approvalQueueRowFamilyOf, checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
 export const ASK_PARK_ROW_WAIT_MS = 15000;
 export const ASK_PARK_ROW_POLL_MS = 500;
-export function classifyAskParkRows(rows, taskId, deps) {
+export function classifyAskParkRows(queueRows, taskId, deps) {
     const isOwned = deps?.isOwned ?? ((row) => pendingRowIsOwnedByThisSession(row, deps?.ownership));
+    const sorted = queueRows.flatMap((r) => {
+        const sort = checkpointQueueRowSortOf(r);
+        return sort === 'excluded' ? [] : [{ r: r, unreadable: sort === 'unreadable' }];
+    });
+    const rows = sorted.map((x) => x.r);
+    const familyUnreadable = new Set(sorted.filter((x) => x.unreadable).map((x) => x.r));
     const own = rows.find(r => r.taskId === taskId);
     const sole = rows.length === 1 ? rows[0] : undefined;
     const soleUnowned = sole !== undefined && !isOwned(sole);
@@ -21,7 +28,7 @@ export function classifyAskParkRows(rows, taskId, deps) {
                     : `${String(rows.length)} pending rows but none for task ${taskId} — ambiguous queue, refusing to surface an unrelated row`,
         };
     }
-    const foreignKind = askParkForeignGateKind(pending);
+    const foreignKind = familyUnreadable.has(pending) ? QUEUE_ROW_FAMILY_UNREADABLE_GATE : askParkForeignGateKind(pending);
     if (foreignKind !== null) {
         return {
             kind: 'unborn',
@@ -120,7 +127,7 @@ export function pendingRowIsOwnedAndDecidable(row, deps) {
     const leg = durableDecideLegOf(row);
     if (leg === 'plan_review')
         return true;
-    if (leg !== 'approval' && leg !== 'absent')
+    if (leg !== 'approval')
         return false;
     return askParkRowArm(row) === 'question' ? askQuestionsFromPending(row) !== null : true;
 }
@@ -137,6 +144,11 @@ export function countOwnedPendingRows(listed, deps) {
         if (typeof row !== 'object' || row === null) {
             throw new Error('approvals.list answered with a pending row that is not an object — the owned pending count is unknown');
         }
+        const family = approvalQueueRowFamilyOf(row);
+        if (family === 'unreadable')
+            throw new Error('approvals.list answered with a pending row whose family (`kind`) cannot be read — the owned pending count is unknown');
+        if (family !== 'checkpoint')
+            continue;
         if (pendingRowIsOwnedAndDecidable(row, deps))
             n++;
     }

package/dist/hitl/automaticAnswerVerdict.js

@@ -125,6 +125,17 @@ function evidenceUnreadable(card) {
     const nested = evidenceSlotOf(risk.value, 'requiresRealApproval');
     return nested.kind !== 'data' || typeof nested.value !== 'boolean';
 }
+function registryUnreadable(card) {
+    const slot = evidenceSlotOf(card, 'unreadableEvidence');
+    if (slot.kind === 'absent' || (slot.kind === 'data' && slot.value === undefined))
+        return false;
+    if (slot.kind === 'unreadable')
+        return true;
+    const list = slot.value;
+    if (!Array.isArray(list) || list.some((k) => typeof k !== 'string'))
+        return true;
+    return list.some((k) => k !== 'rememberRefused' && k !== 'ruleOffers');
+}
 function readHostAskRuleMatched(facts) {
     if (typeof facts !== 'object' || facts === null)
         return undefined;
@@ -137,17 +148,9 @@ export function automaticAnswerVerdict(card, lane, facts) {
     try {
         if (typeof card !== 'object' || card === null)
             return UNKNOWN.card_unreadable;
+        const unreadableAtEntry = registryUnreadable(card) || evidenceUnreadable(card) || (retiredAllowRuleShadowKeyPresent(card, 'frame') && !approvalAllowRuleShadowed(card));
         if (card.cardPayloadUnreadable === true)
             return UNKNOWN.card_unreadable;
-        const unreadable = card.unreadableEvidence;
-        if (unreadable !== undefined) {
-            if (!Array.isArray(unreadable) || unreadable.some((k) => typeof k !== 'string'))
-                return UNKNOWN.card_unreadable;
-            if (unreadable.some((k) => k !== 'rememberRefused' && k !== 'ruleOffers'))
-                return UNKNOWN.card_unreadable;
-        }
-        if (!approvalAllowRuleShadowed(card) && retiredAllowRuleShadowKeyPresent(card, 'frame'))
-            return UNKNOWN.card_unreadable;
         const face = lane === 'mode_posture' ? askFaceOfCard(card) : undefined;
         const origin = readAskOrigin(evidenceView(card, 'origin'));
         if (origin !== undefined && Object.hasOwn(ORIGIN_IMPLIES_CLASS, origin)) {
@@ -175,7 +178,7 @@ export function automaticAnswerVerdict(card, lane, facts) {
                     return mustAsk('allow_rule_shadow');
             }
         }
-        if (evidenceUnreadable(card))
+        if (unreadableAtEntry)
             return UNKNOWN.card_unreadable;
         const pair = readAskClassPairState(card);
         if (pair.state === 'malformed')

package/dist/hitl/crashConverged.d.ts

@@ -4,8 +4,12 @@ export interface CrashConvergedRowReading extends Readonly<CrashConvergedRow> {
     readonly needsHumanReason?: 'approved_then_interrupted' | 'pending_unsafe' | 'unstable_row' | 'contradictory';
 }
 export declare const isCrashConvergedCause: (v: unknown) => v is CrashConvergedRowReading["cause"];
+export interface ApprovalQueueKindedRow {
+    readonly kind: string;
+}
+export type ApprovalQueueRow = PendingCheckpoint | ApprovalQueueKindedRow;
 export interface ApprovalsListEnvelope {
-    pending: PendingCheckpoint[];
+    pending: ApprovalQueueRow[];
     livePending?: unknown[];
     crashConverged?: CrashConvergedRowReading[];
 }

package/dist/hitl/decisionConflict.js

@@ -1,8 +1,9 @@
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_UNSUPPORTED_VERSION, RESUME_OUTCOME_INVALID } from '../engineErrorCodes.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { ownDataField } from '../ownKey.js';
+import { SDK_DECIDE_BINDING_KEYS } from '../generated/sdkFactTables.js';
 import { isSlotCarrier, PROTOCOL_ERROR_NAME, protocolErrorNameReading, readRefusalSlots, readThrownExtraSnapshot } from '../wireFailureShape.js';
-const BINDING_SEAT_FIELDS = new Set(['boundCallId', 'boundInputHash']);
+const BINDING_SEAT_FIELDS = new Set(SDK_DECIDE_BINDING_KEYS);
 const ANSWER_FIELD = 'answer';
 const REFUSAL_WORD_KEYS = Object.freeze(['field', 'reason']);
 const GRANT_DIGEST_FIELD = 'boundGrantDigest';

package/dist/hitl/decisionRefusal.js

@@ -146,7 +146,7 @@ export function readDecisionRefusalAsk(failure, answer, read) {
     if (name === 'HitlSafetyError')
         return facts('not_settled');
     const code = typeof errorCode === 'string' && errorCode.length > 0 ? errorCode : undefined;
-    if (code === RESUME_PREFLIGHT_REJECTED && (preflightSettledBitsPresent(carrier) || retriable !== true))
+    if (code === RESUME_PREFLIGHT_REJECTED && preflightSettledBitsPresent(carrier))
         return facts('not_settled', true);
     if (isCodeClassifiedGateFailure(code, retriable))
         return facts('not_settled');

package/dist/hitl/decisionSend.d.ts

@@ -63,6 +63,7 @@ interface HitlDecisionOutcomeBase {
     readonly fallback?: 'approval';
     readonly noteDropped?: true;
     readonly rememberDropped?: true;
+    readonly allowSessionCarried?: true;
     readonly attributionDropped?: true;
     readonly attributionRenamed?: true;
     readonly pending?: LiveAskPendingReading;

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 { sessionAllowCarried } 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 && sessionAllowCarried('v1', req.approvalId)) {
+        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' };
                 }
             }

package/dist/hitl/frameRouter.d.ts

@@ -5,6 +5,7 @@ import type { ApprovalResolution } from './approvalResolution.js';
 import type { GateLedger } from './gateLedger.js';
 import type { NoAllowCause } from './noAllowCause.js';
 import { type ReplayedApprovalDisposition } from './replayedApproval.js';
+import type { ReattachDrainingEvent } from '../runReattachPolicy.js';
 export declare const HITL_REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
 export declare const HITL_POLICY_DENY_MESSAGE: string;
 export type PolicyDenyLane = 'no_approval_ui' | 'dont_ask';
@@ -31,11 +32,14 @@ export interface AskGateWireDeps {
     }) => AsyncGenerator<AgentEvent>;
     respondToolApproval?: RespondToolApprovalFn;
     onParkReattach?: (e: ParkReattachNotice) => void;
+    onBreak?: (event: ReattachDrainingEvent) => void;
     approvalLane?: ToolApprovalFrameLaneOpts;
     onToolApprovalOutcome?: (frame: ToolApprovalFrame, resolution: ApprovalResolution) => void | Promise<void>;
     onDecideOperation?: DecideOperationObserver;
     onReplayedApproval?: (frame: ToolApprovalFrame, disposition: ReplayedApprovalDisposition) => void | Promise<void>;
 }
+export declare function setBridgeRunHandleFallback(deps: object, read: () => string | undefined): void;
+export declare function bridgeRunHandleFallbackOf(deps: object): string | undefined;
 type GateKind = 'ask' | 'fs';
 export interface GatePark {
     gate: GateKind;

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 ' +
@@ -83,6 +84,20 @@ function denyStampedEnd(ev, attribution) {
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
 const RUN_CANCELLED_ERROR_CODE = RUN_CANCELLED_CODE;
 export const ENGINE_ABORT_TOOL_RESULT = 'Operation aborted';
+const bridgeRunHandleFallbacks = new WeakMap();
+export function setBridgeRunHandleFallback(deps, read) {
+    bridgeRunHandleFallbacks.set(deps, read);
+}
+export function bridgeRunHandleFallbackOf(deps) {
+    try {
+        const read = bridgeRunHandleFallbacks.get(deps);
+        const v = read?.();
+        return typeof v === 'string' && v !== '' ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function isAskToolLoose(name) {
     return typeof name === 'string' && name.replace(/[\s_-]+/g, '').toLowerCase() === 'askuserquestion';
 }
@@ -121,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) {
@@ -322,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/gateIdentity.d.ts

@@ -3,6 +3,7 @@ export declare const REOPEN_ID_TAIL = "#reopen-";
 export declare function approvalCallKey(gatedCallId: string | undefined, taskId: string): string;
 export declare function askGateQuestionId(callKey: string): string;
 export declare function planReviewQuestionId(taskId: string): string;
+export declare function freshPlanReviewQuestionId(taskId: string, suffix: string): string;
 export declare function liveFrameCallKey(approvalId: string): string;
 export declare function taskIdFromPlanReviewQuestionId(questionId: string): string | undefined;
 export declare function armedKeyFromQuestionId(questionId: string): string;

package/dist/hitl/gateIdentity.js

@@ -11,6 +11,9 @@ export function askGateQuestionId(callKey) {
 export function planReviewQuestionId(taskId) {
     return `${PLAN_REVIEW_QUESTION_ID_PREFIX}${taskId}`;
 }
+export function freshPlanReviewQuestionId(taskId, suffix) {
+    return `${planReviewQuestionId(taskId)}${REOPEN_ID_TAIL}${suffix}`;
+}
 export function liveFrameCallKey(approvalId) {
     return `${HITL_FRAME_CALL_KEY_PREFIX}${approvalId}`;
 }

package/dist/hitl/hitlBridge.d.ts

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