@sema-agent/client-core 0.107.0 → 0.109.0

package/dist/hitl/livePendingAsk.js

@@ -1,10 +1,10 @@
 import { isApprovalRequestFrameV1 } from '@sema-agent/sdk';
-import { appendOwnElement } from '../ownKey.js';
+import { appendOwnElement, readOwnDataNonEmptyString } 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';
+import { isToolApprovalFrame, surfaceApprovalFrameWithId, } from './toolApprovalWire.js';
 function nonEmptyString(v) {
     return typeof v === 'string' && v !== '';
 }
@@ -24,7 +24,9 @@ function snapshotMembers(raw) {
     }
     return raw.length === length ? out : undefined;
 }
-function openingFrameOf(f) {
+function openingFrameOf(f, approvalId) {
+    if (typeof f !== 'object' || f === null || readOwnDataNonEmptyString(f, 'approvalId') !== approvalId)
+        return undefined;
     if (isToolApprovalFrame(f))
         return f.type === 'tool_approval' ? f : undefined;
     return isApprovalRequestFrameV1(f) ? f : undefined;
@@ -54,19 +56,19 @@ export function readLivePendingRows(body) {
             continue;
         }
         const o = item;
-        if (!nonEmptyString(o.approvalId) || !nonEmptyString(o.toolName) || !nonNegativeFinite(o.ts) || !nonNegativeFinite(o.expiresAtMs)) {
+        const approvalId = readOwnDataNonEmptyString(o, 'approvalId');
+        if (approvalId === undefined || !nonEmptyString(o.toolName) || !nonNegativeFinite(o.ts) || !nonNegativeFinite(o.expiresAtMs)) {
             dropped++;
             continue;
         }
-        if (seen.has(o.approvalId)) {
+        if (seen.has(approvalId)) {
             dropped++;
             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,
+        seen.add(approvalId);
+        const frame = openingFrameOf(o.frame, approvalId);
+        appendOwnElement(rows, {
+            approvalId,
             toolName: o.toolName,
             ts: o.ts,
             expiresAtMs: o.expiresAtMs,
@@ -147,13 +149,12 @@ export function livePendingRowToApprovalFrame(row) {
     };
 }
 export function surfaceSuspendedAskAndRespond(row, respond, signal, lane) {
-    if (row.frame !== undefined) {
-        return surfaceToolApprovalFrameAndRespond(row.frame, respond, undefined, signal, lane);
+    const frame = row.frame;
+    const approvalId = row.approvalId;
+    if (frame !== undefined) {
+        return surfaceApprovalFrameWithId(frame, approvalId, respond, undefined, signal, lane, undefined);
     }
-    return surfaceToolApprovalFrameAndRespond(livePendingRowToApprovalFrame(row), respond, undefined, signal, {
-        ...lane,
-        argsUnavailable: true,
-    });
+    return surfaceApprovalFrameWithId(livePendingRowToApprovalFrame(row), approvalId, respond, undefined, signal, { ...lane, argsUnavailable: true }, undefined);
 }
 const TRACKER_UNSEEN_CLAIMS_MAX = 512;
 export function createSuspendedAskTracker(filter) {

package/dist/hitl/localAllowRule.js

@@ -1,4 +1,5 @@
 import { reasonOfThrownWithSink } from '../hostCallbackGuard.js';
+import { isWholeToolRuleValue } from './permissionRuleScope.js';
 const BASH_TOOL_NAME_FOR_RULES = 'Bash';
 export function parseLocalAllowRule(rule, expectedToolName, deps) {
     if (typeof rule !== 'string' || rule === '') {
@@ -14,7 +15,7 @@ export function parseLocalAllowRule(rule, expectedToolName, deps) {
     if (typeof value.toolName !== 'string' || value.toolName === '') {
         return { ok: false, error: 'rule text carries no tool name' };
     }
-    if (value.ruleContent === undefined || value.ruleContent === '') {
+    if (isWholeToolRuleValue(value)) {
         return {
             ok: false,
             error: 'candidate is a whole-tool allow rule (broader than this ask) — not offered locally',

package/dist/hitl/noAllowCause.d.ts

@@ -1,4 +1,4 @@
-export type NoAllowCause = 'no_allow_rule' | 'ask_rule' | 'engine_ask_rule' | 'budget' | 'other';
+export type NoAllowCause = 'no_allow_rule' | 'ask_rule' | 'engine_ask_rule' | 'budget' | 'whole_tool_rule_only' | 'other';
 export interface RuleLadderNoAllowFacts {
     readonly allowed?: boolean;
     readonly denied?: boolean;

package/dist/hitl/noAllowCause.js

@@ -1,4 +1,4 @@
-import { automaticAnswerVerdict } from './automaticAnswerVerdict.js';
+import { askLevelVerdict } from './automaticAnswerVerdict.js';
 function ladderSays(ladder, key) {
     if (typeof ladder !== 'object' || ladder === null)
         return false;
@@ -17,11 +17,13 @@ export function noAllowCauseOf(card, ladder) {
         return 'ask_rule';
     if (ladderSays(ladder, 'budgetExhausted'))
         return 'budget';
-    const standing = automaticAnswerVerdict(card, 'standing_rule');
+    const standing = askLevelVerdict(card, 'standing_rule');
     if (standing.kind === 'must_ask' && (standing.askClass === 'ask_rule' || standing.origin === 'ask_rule')) {
         return ladderSays(ladder, 'noAskRuleMatched') || ladderSays(ladder, 'noRuleMatched') ? 'engine_ask_rule' : 'ask_rule';
     }
     if (ladderSays(ladder, 'noRuleMatched') && standing.kind === 'may_answer')
         return 'no_allow_rule';
+    if (standing.kind === 'may_answer')
+        return 'whole_tool_rule_only';
     return 'other';
 }

package/dist/hitl/parkExpiryJudgements.js

@@ -1,11 +1,36 @@
+import { isApprovalCompleteFrameV1 } from '@sema-agent/sdk';
 import { APPROVAL_EXPIRED } from '../engineErrorCodes.js';
 import { approvalCompleteParked } from './approvalCompleteParked.js';
 export function classifyApprovalCompleteFrame(frame) {
     if (typeof frame !== 'object' || frame === null)
         return null;
     const f = frame;
-    if (f.type !== 'tool_approval_complete')
+    const type = f.type;
+    if (type === 'tool_approval_complete')
+        return dispositionOf(frame, f);
+    if (type === 'approval_complete')
+        return presentedFamilyDisposition(frame);
+    return null;
+}
+function presentedFamilyDisposition(frame) {
+    try {
+        const snapshot = ownDataSnapshot(frame);
+        return isApprovalCompleteFrameV1(snapshot) ? dispositionOf(snapshot, snapshot) : null;
+    }
+    catch {
         return null;
+    }
+}
+function ownDataSnapshot(frame) {
+    const snapshot = Object.create(null);
+    for (const key of Object.getOwnPropertyNames(frame)) {
+        const d = Object.getOwnPropertyDescriptor(frame, key);
+        if (d !== undefined && Object.hasOwn(d, 'value'))
+            snapshot[key] = d.value;
+    }
+    return snapshot;
+}
+function dispositionOf(frame, f) {
     const outcome = f.outcome;
     if (outcome === 'allowed' || outcome === 'denied')
         return 'settled';

package/dist/hitl/parkOwnership.d.ts

@@ -6,5 +6,7 @@ export interface ParkOwnershipDeps {
     isOwnRun?: (taskIdTail: string) => boolean;
 }
 export declare function pendingRowIsOwnedByThisSession(row: PendingCheckpoint, deps?: ParkOwnershipDeps): boolean;
+export declare function pendingRowOwnershipOf(row: object, deps?: ParkOwnershipDeps): 'owned' | 'foreign' | 'unknown';
+export declare function usableAskQuestions(value: unknown): AskQuestion[] | null;
 export declare function askQuestionsFromPending(pending: PendingCheckpoint): AskQuestion[] | null;
 export declare function isHitlSafetyErrorLike(e: unknown): boolean;

package/dist/hitl/parkOwnership.js

@@ -3,31 +3,71 @@ import { rowIdTail } from '../workflow.js';
 import { hostSessionFor } from '../host.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { pendingRowIsOfSession } from './parkRowDelegation.js';
+import { slotReadOf } from '../wireFailureShape.js';
 export function pendingRowIsOwnedByThisSession(row, deps) {
+    return ownershipVerdictOf(row, deps) === 'owned';
+}
+export function pendingRowOwnershipOf(row, deps) {
+    try {
+        return ownershipVerdictOf(row, deps);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function ownershipVerdictOf(row, deps) {
     const sessionKey = deps?.sessionKey ?? DEFAULT_SESSION_KEY;
     const rowTaskId = typeof row.taskId === 'string' ? row.taskId : '';
     if (rowTaskId.length > 0) {
         const tail = rowIdTail(rowTaskId);
         if (deps?.isOwnRun !== undefined && deps.isOwnRun(tail))
-            return true;
+            return 'owned';
         if (sessionKey === DEFAULT_SESSION_KEY && isOwnEngineRun(tail))
-            return true;
+            return 'owned';
     }
     const currentSessionId = deps?.currentSessionId ?? (() => hostSessionFor(sessionKey)?.currentSessionId());
     const sessionId = currentSessionId();
     if (typeof sessionId !== 'string' || sessionId.length === 0)
+        return 'unknown';
+    if (pendingRowIsOfSession(row, sessionId))
+        return 'owned';
+    return rowIsProvablyForeign(row, sessionId) ? 'foreign' : 'unknown';
+}
+function rowIsProvablyForeign(row, selfSessionId) {
+    const own = slotReadOf(row, 'sessionId');
+    if (own.presence !== 'present' || typeof own.value !== 'string' || own.value === '' || own.value === selfSessionId)
+        return false;
+    const agent = slotReadOf(row, 'agent');
+    if (agent.presence === 'absent')
+        return true;
+    if (agent.presence !== 'present' || typeof agent.value !== 'object' || agent.value === null)
         return false;
-    return pendingRowIsOfSession(row, sessionId);
+    for (const key of ['parentSessionId', 'rootSessionId']) {
+        const link = slotReadOf(agent.value, key);
+        if (link.presence === 'absent')
+            continue;
+        if (link.presence !== 'present' || typeof link.value !== 'string' || link.value === selfSessionId)
+            return false;
+    }
+    return true;
+}
+export function usableAskQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return null;
+    for (let i = 0; i < value.length; i++) {
+        if (!Object.hasOwn(value, i))
+            return null;
+        const q = value[i];
+        if (typeof q !== 'object' || q === null || typeof q.question !== 'string')
+            return null;
+    }
+    return value;
 }
 export function askQuestionsFromPending(pending) {
     const input = pending.input;
     if (typeof input !== 'object' || input === null)
         return null;
-    const qs = input.questions;
-    if (!Array.isArray(qs) || qs.length === 0)
-        return null;
-    const ok = qs.every(q => typeof q === 'object' && q !== null && typeof q.question === 'string');
-    return ok ? qs : null;
+    return usableAskQuestions(input.questions);
 }
 export function isHitlSafetyErrorLike(e) {
     return typeof e === 'object' && e !== null && e.name === 'HitlSafetyError';

package/dist/hitl/parkResolver.js

@@ -1,18 +1,21 @@
 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 { usableAskQuestions } from './parkOwnership.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;
@@ -67,12 +70,11 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         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
-        ? askArgsByCall.get(gatedCallId)?.questions
-        : undefined;
-    const fromPending = pending.input?.questions;
-    const questions = Array.isArray(fromArgs) && fromArgs.length > 0 ? fromArgs : fromPending;
-    if (!Array.isArray(questions) || questions.length === 0) {
+    const rowQuestions = usableAskQuestions(pending.input?.questions);
+    const streamQuestions = usableAskQuestions(gatedCallId ? askArgsByCall.get(gatedCallId)?.questions : undefined);
+    const questionsFromModelCall = rowQuestions === null && streamQuestions !== null;
+    const questions = rowQuestions ?? streamQuestions;
+    if (questions === null) {
         const truncated = pending.input?.truncated === true;
         return {
             kind: 'not_sent',
@@ -105,7 +107,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         }
         signal?.addEventListener('abort', onAbort, { once: true });
         onPresented?.();
-        publishQuestionFrame({ type: 'question', questionId, questions });
+        publishQuestionFrame({ type: 'question', questionId, questions, ...(questionsFromModelCall ? { _sema_questionsFromModelCall: true } : {}) });
     });
     const bridge = new HitlBridge(deps.client, taskId, deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : undefined);
     if (answer === null) {
@@ -160,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 };
 }
@@ -180,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;
     }
@@ -283,10 +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);
-        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) };
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface, failsoftWayOutOf(outcome)) };
     }
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
@@ -309,17 +311,27 @@ export async function resolvePark(park, ctx) {
         ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
     };
 }
-function failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut = false) {
+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;
-    if (reasonCarriesWayOut)
-        return renderMessage(msg('approval.park.stillParked', { gate: park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion', reason: failedReason }));
+    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, reasonCarriesWayOut = false) {
+function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false, wayOut = 'card') {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -327,7 +339,7 @@ function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, no
             gateAbortedByUser,
         }),
     ];
-    const reason = failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut);
+    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 }));
     }
@@ -356,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

@@ -11,6 +11,7 @@ export type ParkRowProbe<Row> = {
     rowVerdict?: Exclude<CheckpointRowVerdictReading, {
         readonly kind: 'ok';
     }>;
+    rowTaskId?: string;
 };
 export type ParkRowWaitVerdict<Row> = {
     kind: 'row';
@@ -30,6 +31,7 @@ export type ParkRowWaitVerdict<Row> = {
     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, ...(probed.rowVerdict !== undefined ? { rowVerdict: probed.rowVerdict } : {}) };
+            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/parkedUnresumable.d.ts

@@ -0,0 +1,13 @@
+import { type CheckpointRowBar } from '../checkpointRowVerdict.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+import type { OwnedPendingListView } from './askParkRowRouting.js';
+import { type ParkOwnershipDeps } from './parkOwnership.js';
+export interface ParkedUnresumableRow {
+    readonly rowVerdict: CheckpointRowBar;
+    readonly rowKey?: string;
+    readonly taskId?: string;
+    readonly toolName?: string;
+    readonly rowDeadline?: 'armed' | 'none';
+}
+export declare function parkedUnresumableRowsOf(listed: OwnedPendingListView | null | undefined, deps?: ParkOwnershipDeps): readonly ParkedUnresumableRow[];
+export declare function parkedUnresumableLine(row: ParkedUnresumableRow, lang?: UiLanguage | (string & {})): string;

package/dist/hitl/parkedUnresumable.js

@@ -0,0 +1,80 @@
+import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, rowBarWayOutContent, } from '../checkpointRowVerdict.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
+import { approvalCallKey } from './gateIdentity.js';
+import { checkpointQueueReadingOf } from './hitlBridge.js';
+import { pendingRowIsOwnedByThisSession } from './parkOwnership.js';
+function ownNonEmpty(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+}
+function memberOf(row, rowVerdict) {
+    const taskId = ownNonEmpty(row, 'taskId');
+    const callId = ownNonEmpty(row, 'toolCallId') ?? ownNonEmpty(row, 'boundCallId');
+    const rowKey = callId !== undefined || taskId !== undefined ? approvalCallKey(callId, taskId ?? '') : undefined;
+    const toolName = ownNonEmpty(row, 'toolName');
+    const deadline = checkpointDeadlineStateOf(row);
+    return Object.freeze({
+        rowVerdict,
+        ...(rowKey !== undefined ? { rowKey } : {}),
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(toolName !== undefined ? { toolName } : {}),
+        ...(deadline !== 'unknown' ? { rowDeadline: deadline } : {}),
+    });
+}
+export function parkedUnresumableRowsOf(listed, deps) {
+    if (typeof listed !== 'object' || listed === null || Array.isArray(listed)) {
+        throw new Error('approvals.list answered without a readable body — the rows this engine cannot continue are unknown');
+    }
+    const pending = listed.pending;
+    if (!Array.isArray(pending)) {
+        throw new Error('approvals.list answered without a readable `pending` array — the rows this engine cannot continue are unknown');
+    }
+    const out = [];
+    for (const row of pending) {
+        const member = parkedMemberOf(row, deps);
+        if (member !== undefined)
+            out.push(member);
+    }
+    return Object.freeze(out);
+}
+function parkedMemberOf(row, deps) {
+    try {
+        if (typeof row !== 'object' || row === null)
+            return undefined;
+        const reading = checkpointQueueReadingOf(row);
+        if (reading === undefined)
+            return undefined;
+        if (reading.foreign !== null && reading.foreign !== QUEUE_ROW_FAMILY_UNREADABLE_GATE)
+            return undefined;
+        const bar = checkpointRowBarOf(reading.r);
+        if (bar === undefined)
+            return undefined;
+        if (!pendingRowIsOwnedByThisSession(reading.r, deps))
+            return undefined;
+        return memberOf(reading.r, bar);
+    }
+    catch {
+        return undefined;
+    }
+}
+const UNREADABLE_BAR = Object.freeze({ kind: 'unreadable' });
+export function parkedUnresumableLine(row, lang) {
+    let bar = UNREADABLE_BAR;
+    let state = 'unknown';
+    try {
+        if (typeof row === 'object' && row !== null) {
+            const v = slotReadOf(row, 'rowVerdict');
+            if (v.presence === 'present')
+                bar = checkpointRowBarOf({ rowVerdict: v.value }) ?? UNREADABLE_BAR;
+            const d = slotReadOf(row, 'rowDeadline');
+            if (d.presence === 'present' && (d.value === 'armed' || d.value === 'none'))
+                state = d.value;
+        }
+    }
+    catch {
+        bar = UNREADABLE_BAR;
+        state = 'unknown';
+    }
+    return `${checkpointRowBarSentence(bar, lang)} · ${rowBarWayOutContent(bar, state, lang)}`;
+}

package/dist/hitl/permissionRuleScope.d.ts

@@ -0,0 +1,4 @@
+import type { PermissionRuleValue } from '@sema-agent/agent-types';
+export declare function isWholeToolRuleValue(value: PermissionRuleValue): boolean;
+export type AllowRuleScope = 'whole_tool' | 'content' | 'unreadable';
+export declare function allowRuleScopeOf(value: object | null | undefined): AllowRuleScope;

package/dist/hitl/permissionRuleScope.js

@@ -0,0 +1,31 @@
+import { readOwnDataValue } from '../ownKey.js';
+import { inSlotReadOf } from '../wireFailureShape.js';
+export function isWholeToolRuleValue(value) {
+    return value.ruleContent === undefined || value.ruleContent === '';
+}
+export function allowRuleScopeOf(value) {
+    try {
+        if (typeof value !== 'object' || value === null)
+            return 'unreadable';
+        const toolName = readOwnDataValue(value, 'toolName');
+        if (typeof toolName !== 'string' || toolName === '')
+            return 'unreadable';
+        let ruleContent;
+        const slot = inSlotReadOf(value, 'ruleContent');
+        if (slot.state === 'present') {
+            const raw = slot.value;
+            if (raw !== undefined) {
+                if (typeof raw !== 'string' || raw === '')
+                    return 'unreadable';
+                ruleContent = raw;
+            }
+        }
+        else if (slot.state !== 'absent')
+            return 'unreadable';
+        const snapshot = Object.freeze(Object.assign(Object.create(null), ruleContent !== undefined ? { toolName, ruleContent } : { toolName }));
+        return isWholeToolRuleValue(snapshot) ? 'whole_tool' : 'content';
+    }
+    catch {
+        return 'unreadable';
+    }
+}

package/dist/hitl/persistedRulesWire.d.ts

@@ -31,12 +31,18 @@ export interface CcImportRedeemRuleKey {
     readonly rule: string;
     readonly scope: string;
 }
+export interface CcImportRedeemRefused {
+    readonly key?: CcImportRedeemRuleKey;
+    readonly reason?: string;
+    readonly detail?: string;
+}
 export interface CcImportRedeemCounts {
     persisted: number;
     deduped: number;
     indeterminate: readonly CcImportRedeemIndeterminate[];
+    refused?: readonly CcImportRedeemRefused[];
 }
-export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'indeterminate';
+export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'refused' | 'indeterminate';
 export declare function readCcImportRedeemCounts(body: unknown): CcImportRedeemCounts | null;
 export type RulesFailure = {
     kind: 'lane-unavailable';