@sema-agent/client-core 0.112.1 → 0.113.0

package/dist/hitl/legacyApprovalShapes.d.ts

@@ -0,0 +1,142 @@
+import type { AllowRuleShadow, ApprovalCardDelegation, ApprovalDecidedBy, ApprovalDecisionResult, ApprovalSettleCause, AskClass, AskOrigin, AutoModeFallbackCause, BoundGrantAbsence, BoundSkillGrants, DenialLimitFallback, PersistedRuleAnchor, PersistedRuleMandate, PersistRuleSelection, ReadRootCover, RuleOffer, RuleOffersAbsence, RuleRefusalReason, ToolApprovalCardWord } from '@sema-agent/sdk';
+import type { ToolApprovalRespondDecision } from './toolApprovalWire.js';
+type KnownOf<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+export type LegacyAskReason = {
+    by: 'hook';
+    cause: 'asked' | 'verdict_unreadable' | 'verdict_unfinished';
+    registration?: string;
+    words?: string;
+} | {
+    by: 'policy' | 'content_question' | 'plan_review' | 'ancestor_marked' | 'org_unavailable' | 'org_rule' | 'rule_store_unavailable' | 'ask_rule' | 'denial_limit_fallback' | 'shell_gate_tighten' | 'safety_tighten';
+    words: string;
+};
+export type LegacyExtensionRequester = {
+    kind: 'extension';
+    name: string;
+};
+export type LegacyProbeCause = {
+    code: string;
+    roots: {
+        shown: string[];
+        total: number;
+    };
+    further?: {
+        shown: string[];
+        total: number;
+    };
+};
+export type LegacyRuleEvidence = {
+    orgRevision?: number;
+    orgRevisionAbsent?: 'not_wired' | 'not_adjudicated' | 'unavailable' | 'no_match' | 'not_reported' | (string & {});
+    orgRule?: string;
+    orgRuleAbsent?: 'not_wired' | 'not_adjudicated' | 'unavailable' | 'no_match' | 'not_reported' | (string & {});
+    personalRuleDots?: Array<{
+        actor: string;
+        counter: number;
+    }>;
+    personalRuleDotsAbsent?: 'not_wired' | 'not_adjudicated' | 'unavailable' | 'no_match' | 'not_reported' | (string & {});
+};
+export type LegacyReadRootCandidate = {
+    dir: string;
+    covers?: ReadRootCover;
+    clearsThisAsk: true;
+};
+export interface LegacyToolApprovalFrame {
+    type: 'tool_approval' | 'tool_approval_complete';
+    approvalId: string;
+    toolName?: string;
+    toolCallId?: string;
+    sourceSessionId?: string;
+    agentId?: string;
+    askReasons?: LegacyAskReason[];
+    fromSubagent?: true;
+    sourceAgentName?: string;
+    message?: string;
+    args?: unknown;
+    argsOmitted?: boolean;
+    governanceForced?: true;
+    rememberRefused?: true;
+    requiresRealApproval?: true;
+    origin?: AskOrigin;
+    approvalCard?: ToolApprovalCardWord;
+    askClass?: AskClass;
+    classes?: AskClass[];
+    boundGrantDigest?: string;
+    boundGrants?: BoundSkillGrants;
+    boundGrantAbsence?: BoundGrantAbsence;
+    classifierNoRuling?: AutoModeFallbackCause;
+    inputHasBidi?: true;
+    expiresAtMs?: number;
+    expiresInMs?: number;
+    serverNowMs?: number;
+    ruleOffers?: RuleOffer[];
+    ruleOffersAbsence?: RuleOffersAbsence | (string & {});
+    mandated?: true;
+    mandate?: PersistedRuleMandate;
+    denialLimitFallback?: DenialLimitFallback;
+    allowRuleShadowed?: AllowRuleShadow[];
+    probeCause?: LegacyProbeCause;
+    probeReason?: string;
+    requestedBy?: LegacyExtensionRequester;
+    ruleEvidence?: LegacyRuleEvidence;
+    delegation?: ApprovalCardDelegation;
+    parked?: true;
+    outcome?: 'allowed' | 'denied' | 'expired';
+    cause?: ApprovalSettleCause;
+    readRootCandidate?: LegacyReadRootCandidate;
+    [k: string]: unknown;
+}
+export interface LegacyToolApprovalRespondApplied {
+    approvalId: string;
+    delivery: 'applied';
+    decision: ToolApprovalRespondDecision;
+    rememberApplied?: boolean;
+    updatedInputForwarded?: boolean;
+    rulePersisted?: boolean;
+    ruleRefusal?: RuleRefusalReason;
+    persistedRule?: string;
+    persistedRules?: string[];
+    persistedRuleAnchors?: PersistedRuleAnchor[];
+    noteRecorded?: boolean;
+    consumerState?: 'absent';
+}
+export interface LegacyToolApprovalRespondReplayed {
+    approvalId: string;
+    askId: string;
+    idempotent: true;
+    decision: 'allow' | 'deny';
+    decidedAtMs: number;
+    decisionNote?: string;
+    rememberApplied?: false;
+    noteRecorded?: boolean;
+    rulePersisted?: false;
+    ruleRefusal?: Extract<RuleRefusalReason, 'rule_lane_unavailable'>;
+}
+export interface LegacyToolApprovalRespondParkedRedeemed extends KnownOf<ApprovalDecisionResult> {
+    approvalId: string;
+    askId: string;
+    accepted: 'parked_redeemed';
+    rememberApplied?: boolean;
+    rulePersisted?: boolean;
+    ruleRefusal?: RuleRefusalReason;
+    persistedRule?: string;
+    persistedRules?: string[];
+    persistedRuleAnchors?: PersistedRuleAnchor[];
+}
+export type LegacyToolApprovalRespondAck = LegacyToolApprovalRespondApplied | LegacyToolApprovalRespondReplayed | LegacyToolApprovalRespondParkedRedeemed;
+export interface LegacyToolApprovalRespondBody {
+    decision: ToolApprovalRespondDecision;
+    updatedInput?: unknown;
+    persistRule?: PersistRuleSelection;
+    note?: string;
+    decidedBy?: ApprovalDecidedBy;
+    readRootGrant?: string;
+}
+export interface LegacyToolApprovalRespondVerb {
+    respond(id: string, body: LegacyToolApprovalRespondBody, opts?: {
+        signal?: AbortSignal;
+    }): Promise<LegacyToolApprovalRespondAck>;
+}
+export {};

package/dist/hitl/legacyApprovalShapes.js

@@ -0,0 +1 @@
+export {};

package/dist/hitl/livePendingAsk.d.ts

@@ -2,7 +2,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';
+import { type RespondToolApprovalFn, type LegacyToolApprovalFrame, type ToolApprovalFrameLaneOpts } from './toolApprovalWire.js';
 export interface LivePendingAskView {
     approvalId: string;
     toolName: string;
@@ -12,8 +12,8 @@ export interface LivePendingAskView {
     requiresRealApproval?: true;
     governanceForced?: true;
     fromSubagent?: true;
-    originTaskId?: string;
-    frame?: ToolApprovalFrame | ApprovalRequestFrame;
+    sourceSessionId?: string;
+    frame?: LegacyToolApprovalFrame | ApprovalRequestFrame;
     mandated?: true;
     mandate?: ApprovalMandateWord;
     origin?: string;
@@ -49,7 +49,7 @@ export interface ApprovalsAwaitingDecisionCount {
     suspendedSubagent: number | null;
 }
 export declare function countApprovalsAwaitingDecision(snapshot: ApprovalsFeedEmission | null | undefined, filter: SuspendedAskFilter): ApprovalsAwaitingDecisionCount;
-export declare function livePendingRowToApprovalFrame(row: LivePendingAskView): ToolApprovalFrame;
+export declare function livePendingRowToApprovalFrame(row: LivePendingAskView): LegacyToolApprovalFrame;
 export declare function surfaceSuspendedAskAndRespond(row: LivePendingAskView, respond: RespondToolApprovalFn, signal?: AbortSignal, lane?: ToolApprovalFrameLaneOpts): Promise<ApprovalResolution>;
 export interface SuspendedAskDelta {
     appeared: LivePendingAskView[];

package/dist/hitl/livePendingAsk.js

@@ -1,8 +1,10 @@
 import { isApprovalRequestFrameV1 } from '@sema-agent/sdk';
 import { appendOwnElement, readOwnDataNonEmptyString } from '../ownKey.js';
+import { settledApprovalOf, settledForDurableLane } from './approvalHolds.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
 import { pendingRowIsOfSession } from './parkRowDelegation.js';
 import { approvalLiveFaceOf, liveFaceCarried } from './approvalLiveFace.js';
+import { livePendingRowSourceSessionOf } from './subagentSource.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot } from '../wireFailureShape.js';
 import { isToolApprovalFrame, surfaceApprovalFrameWithId, } from './toolApprovalWire.js';
 function nonEmptyString(v) {
@@ -76,7 +78,7 @@ export function readLivePendingRows(body) {
             ...(readRequiresRealApproval(o) ? { requiresRealApproval: true } : {}),
             ...(o.governanceForced === true ? { governanceForced: true } : {}),
             ...(o.fromSubagent === true ? { fromSubagent: true } : {}),
-            ...(nonEmptyString(o.originTaskId) ? { originTaskId: o.originTaskId } : {}),
+            ...((src) => (src !== undefined ? { sourceSessionId: src } : {}))(livePendingRowSourceSessionOf(o)),
             ...(frame !== undefined ? { frame } : {}),
             ...(frame === undefined ? liveFaceCarried(approvalLiveFaceOf(o)) : {}),
         });
@@ -133,7 +135,7 @@ export function countApprovalsAwaitingDecision(snapshot, filter) {
         return { durable, live: null, suspendedSubagent: null };
     if ((snapshot.livePendingDropped ?? 0) > 0)
         return { durable, live: null, suspendedSubagent: null };
-    const live = bySession(snapshot.livePending);
+    const live = bySession(snapshot.livePending).filter(r => !settledForDurableLane(settledApprovalOf(r.approvalId)));
     return { durable, live: live.length, suspendedSubagent: live.filter(r => r.fromSubagent === true).length };
 }
 export function livePendingRowToApprovalFrame(row) {
@@ -142,7 +144,7 @@ export function livePendingRowToApprovalFrame(row) {
         approvalId: row.approvalId,
         toolName: row.toolName,
         ...(row.fromSubagent === true ? { fromSubagent: true } : {}),
-        ...(row.originTaskId !== undefined ? { sourceSessionId: row.originTaskId } : {}),
+        ...(row.sourceSessionId !== undefined ? { sourceSessionId: row.sourceSessionId } : {}),
         ...(row.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(row) ? { requiresRealApproval: true } : {}),
         ...liveFaceCarried(approvalLiveFaceOf(row)),

package/dist/hitl/parkResolver.js

@@ -339,7 +339,7 @@ function failsoftWayOutOf(outcome) {
         return 'cancel';
     if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && (refusedParkFromError(outcome.refusal) !== null || outcome.refusal?.conflict === 'row_integrity'))
         return 'cancel';
-    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused')
+    if (outcome.kind === 'unsettled' && (outcome.cause === 'engine_refused' || outcome.cause === 'route_missing'))
         return 'speak';
     return 'card';
 }

package/dist/hitl/persistedRulesWire.js

@@ -2,7 +2,7 @@ import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted
 import { engineCapTrue } from '../engineCapsCache.js';
 import { CORE_RULE_BEHAVIORS } from '../generated/engineFactTables.js';
 import { inValueOf, slotReadOf, wireFailureShapeOf } from '../wireFailureShape.js';
-import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED } from '../engineErrorCodes.js';
+import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED, ROUTE_NOT_FOUND } from '../engineErrorCodes.js';
 import { hostLog } from '../host.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { appendOwnElement, guardedRead, readOwnDataValue } from '../ownKey.js';
@@ -168,7 +168,7 @@ export function classifyRulesFailure(e, context) {
         return { kind: 'lane-unavailable', message };
     }
     if (status === 404) {
-        if (errorCode === 'not_found.route')
+        if (errorCode === ROUTE_NOT_FOUND)
             return { kind: 'route-missing', message };
         if (errorCode === 'not_found.rule_ticket')
             return { kind: 'ticket-dead', message };

package/dist/hitl/planReviewCard.d.ts

@@ -1,6 +1,6 @@
 import { type PlanReviewCardFacts, type PlanReviewFactsTaken } from '../planReviewCardFacts.js';
 import { type MessageRef } from '../i18n/translate.js';
-import type { PlanReviewOutcomeCause } from '../planReviewOutcomeCause.js';
+import { type PlanReviewOutcomeCause } from '../planReviewOutcomeCause.js';
 import type { MessageKey } from '../i18n/messages.en.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
 export declare function planReviewCardNoteRef(facts: PlanReviewCardFacts): MessageRef | undefined;
@@ -9,6 +9,7 @@ export declare function planReviewCardNote(facts: PlanReviewCardFacts, lang?: Ui
 export declare function planReviewAskAgainKey(facts: PlanReviewCardFacts | undefined): MessageKey;
 export type PlanReviewDecisionReason = Exclude<PlanReviewOutcomeCause, 'stored_form_unsupported'>;
 export declare function planReviewDecisionReasonRef(reason: PlanReviewOutcomeCause, card?: PlanReviewCardFacts): MessageRef | undefined;
+export declare function planReviewOutcomeNotice(outcome: object | null | undefined, cardOnScreen?: boolean, lang?: UiLanguage): string | undefined;
 export interface PlanReviewLedgerSource {
     readonly runRow: (taskId: string, signal: AbortSignal) => Promise<object>;
     readonly frames: (taskId: string, signal: AbortSignal) => AsyncIterable<object>;

package/dist/hitl/planReviewCard.js

@@ -1,5 +1,8 @@
 import { currentPlanReviewGateOf, isPlanReviewClaimFrame, mintPlanReviewCardFacts, openPlanReviewLedgerFold, planGateRowReadOf, planReviewBodyOf, planReviewCardFactsFrom, planReviewLedgerClaimOf, planReviewRunGeneration, beginPlanReviewFactsRead, commitPlanReviewFacts, samePlanClaim, stepPlanReviewLedgerFold, unknownBody, } from '../planReviewCardFacts.js';
-import { msg, renderMessage } from '../i18n/translate.js';
+import { msg, renderLanguageOf, renderMessage } from '../i18n/translate.js';
+import { planReviewOutcomeCauseOf } from '../planReviewOutcomeCause.js';
+import { decisionRefusalWayOutContent, isDecisionRefusalWayOut } from '../checkpointRowVerdict.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 import { readRunLedgerSnapshot } from '../runLedgerSnapshot.js';
 import { snapshotIsSubFlow, snapshotSegmentIdentity } from '../adapter/types.js';
 import { settleWithinDeadline } from '../abortableSleep.js';
@@ -69,6 +72,66 @@ export function planReviewDecisionReasonRef(reason, card) {
             return msg('approval.planReview.decision.gateUntrusted');
     }
 }
+function noticeWhatKey(decision) {
+    switch (decision) {
+        case 'approve':
+            return 'approval.planReview.notice.what.approve';
+        case 'reject':
+            return 'approval.planReview.notice.what.reject';
+        case 'ask_again':
+            return 'approval.planReview.notice.what.askAgain';
+        default:
+            return 'approval.planReview.notice.what.unknown';
+    }
+}
+export function planReviewOutcomeNotice(outcome, cardOnScreen, lang) {
+    try {
+        if (outcome === null || typeof outcome !== 'object')
+            return undefined;
+        const own = (key) => guardedRead(() => readOwnDataValue(outcome, key));
+        const effect = own('effect');
+        const cause = planReviewOutcomeCauseOf(effect, own('cause'));
+        const decision = own('decision');
+        const gateIdOmitted = own('gateIdOmitted') === true;
+        const wayOutWord = own('wayOut');
+        let head;
+        switch (effect) {
+            case 'not_sent':
+                head = 'approval.planReview.notice.notSent';
+                break;
+            case 'not_applied':
+                head = 'approval.planReview.notice.refused';
+                break;
+            case 'still_parked':
+                head = cause === 'stored_form_unsupported' ? 'approval.planReview.notice.storedForm' : 'approval.planReview.notice.stillParked';
+                break;
+            case 'unconfirmed':
+                head = 'approval.planReview.notice.unconfirmed';
+                break;
+            case 'took_effect':
+            case 'advanced':
+                head = undefined;
+                break;
+            default:
+                return undefined;
+        }
+        const whatKey = noticeWhatKey(decision);
+        const reason = cause === 'card_missing' || cause === 'gate_moved' || cause === 'gate_untrusted' ? planReviewDecisionReasonRef(cause) : undefined;
+        const wayOut = effect === 'not_applied' && isDecisionRefusalWayOut(wayOutWord) ? decisionRefusalWayOutContent(wayOutWord, lang) : undefined;
+        const parts = [
+            head === undefined ? undefined : renderMessage(msg(head, { what: msg(whatKey) }), lang),
+            reason === undefined ? undefined : renderMessage(reason, lang),
+            wayOut === undefined ? undefined : renderMessage(msg('approval.planReview.notice.wayOut', { wayOut }), lang),
+            gateIdOmitted && effect !== 'not_sent' ? renderMessage(msg('approval.planReview.decision.sentWithoutGateId'), lang) : undefined,
+            cardOnScreen === true && head !== undefined ? renderMessage(msg('approval.planReview.notice.cardOnScreen'), lang) : undefined,
+        ];
+        const shown = parts.filter((p) => p !== undefined && p.length > 0);
+        return shown.length === 0 ? undefined : shown.join(renderLanguageOf(lang) === 'zh' ? '' : ' ');
+    }
+    catch {
+        return undefined;
+    }
+}
 const PLAN_REVIEW_LEDGER_BUDGET_MS = 3_000;
 const planReviewFactsFlights = new Map();
 export function _resetPlanReviewFactsFlightsForTest() {

package/dist/hitl/planReviewWire.d.ts

@@ -1,5 +1,6 @@
 import { type QuestionAnswer } from '../liveQuestionStore.js';
 import type { EngineWireInjection } from '../engineWireSdk.js';
+import { type DecisionRefusalWayOut } from './decisionRefusal.js';
 import { type PlanReviewModeAfter } from './hitlBridge.js';
 import type { AgentClient } from '@sema-agent/sdk';
 import { isPlanReviewPark, type PlanReviewCardFacts } from '../planReviewCardFacts.js';
@@ -41,6 +42,7 @@ export interface PlanReviewCardView {
     readonly facts?: PlanReviewCardFacts;
     readonly options: readonly PlanReviewOption[];
     readonly note?: string;
+    readonly heading: string;
 }
 export declare function planReviewCardViewOf(frame: object | null | undefined, lang?: UiLanguage): PlanReviewCardView | undefined;
 export type PlanReviewEvidenceMove = 'same' | 'moved' | 'unknown';
@@ -74,6 +76,8 @@ export interface ArmPlanReviewOptions {
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
     wire?: PlanReviewWire;
     onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
+    onAccepted?: PlanReviewDeliveryOptions['onAccepted'];
+    stillHere?: () => boolean | undefined;
 }
 export declare function armPlanReviewApproval(result: unknown, sessionKey?: string, opts?: ArmPlanReviewOptions): boolean;
 export type PlanReviewDecisionEffect = 'took_effect' | 'advanced' | 'still_parked' | 'not_sent' | 'not_applied' | 'unconfirmed';
@@ -84,6 +88,27 @@ export interface PlanReviewOutcomeMeta {
     effect: PlanReviewDecisionEffect;
     cause?: PlanReviewOutcomeCause;
     questionId?: string;
+    delivery?: 'submit' | 'follow';
+    gateIdOmitted?: true;
+    wayOut?: DecisionRefusalWayOut | (string & {});
+}
+export interface PlanReviewAcceptedEngine {
+    readonly taskId?: string;
+    readonly sessionId?: string;
+    readonly status?: string;
+    readonly decisionCommitted?: true;
+    readonly checkpointId?: string;
+}
+export interface PlanReviewDecisionAccepted {
+    readonly taskId: string;
+    readonly dispatchNo: number;
+    readonly decision: 'approve' | 'reject' | 'ask_again';
+    readonly questionId?: string;
+    readonly engine: PlanReviewAcceptedEngine;
+    readonly decided?: {
+        readonly verdict: 'approved' | 'rejected';
+        readonly plan: string;
+    };
 }
 export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect, cause?: PlanReviewOutcomeCause): string;
 export type PlanReviewWireClient = {
@@ -102,6 +127,7 @@ export interface PlanReviewDecisionOutcome extends PlanReviewOutcomeMeta {
 export interface PlanReviewDeliveryOptions {
     wire?: PlanReviewWire;
     onOutcome?: (outcome: PlanReviewDecisionOutcome) => void;
+    onAccepted?: (accepted: PlanReviewDecisionAccepted) => void;
 }
 export interface DecidePlanReviewOptions extends PlanReviewDeliveryOptions {
     reason?: string;
@@ -126,18 +152,21 @@ export interface ReopenPlanReviewSharedOpts {
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
     pendingReadStartedAt?: number;
     checkpointId?: string;
+    stillHere?: () => boolean | undefined;
 }
 export interface ReopenPlanReviewFreshOpts extends ReopenPlanReviewSharedOpts {
     mintFreshQuestionId?: true;
     deliverDecision?: (taskId: string, decision: Parameters<typeof decidePlanReview>[1], reason: string | undefined, card: PlanReviewCardFacts) => void | Promise<void>;
     wire?: PlanReviewWire;
     onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
+    onAccepted?: PlanReviewDeliveryOptions['onAccepted'];
 }
 export interface ReopenPlanReviewReuseOpts extends ReopenPlanReviewSharedOpts {
     mintFreshQuestionId: false;
     deliverDecision?: never;
     wire?: never;
     onOutcome?: never;
+    onAccepted?: never;
 }
 export type ReopenPlanReviewOpts = ReopenPlanReviewFreshOpts | ReopenPlanReviewReuseOpts;
 export declare function _resetActiveReopenRespondersForTest(): void;
@@ -148,3 +177,4 @@ export interface ReadPlanReviewCardFactsOptions {
     readonly signal?: AbortSignal;
 }
 export declare function readPlanReviewCardFacts(taskId: string, opts?: ReadPlanReviewCardFactsOptions): Promise<PlanReviewCardFacts>;
+export declare function readPlanReviewCurrentGate(e: {} | null | undefined): string | undefined;