@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/hitl/persistedRulesWire.js

@@ -133,6 +133,35 @@ export function readCcImportRedeemCounts(body) {
         return null;
     }
 }
+const isCount = (r) => r.presence === 'present' && typeof r.value === 'number' && Number.isSafeInteger(r.value) && r.value >= 0;
+const NO_REFUSED_ROWS = Object.freeze([]);
+const NO_REFUSED = Object.freeze({ count: 0, rows: NO_REFUSED_ROWS });
+export function refusedRowOf(counts) {
+    try {
+        if (typeof counts !== 'object' || counts === null)
+            return null;
+        if (!isCount(slotReadOf(counts, 'persisted')) || !isCount(slotReadOf(counts, 'deduped')))
+            return null;
+        const slot = slotReadOf(counts, 'refused');
+        if (slot.presence === 'absent')
+            return NO_REFUSED;
+        if (slot.presence !== 'present')
+            return null;
+        const rows = ownArrayItems(slot.value);
+        if (rows === undefined)
+            return null;
+        const kept = [];
+        for (const row of rows) {
+            if (typeof row !== 'object' || row === null)
+                return null;
+            kept.push(row);
+        }
+        return kept.length === 0 ? NO_REFUSED : Object.freeze({ count: kept.length, rows: Object.freeze(kept) });
+    }
+    catch {
+        return null;
+    }
+}
 export function classifyRulesFailure(e, context) {
     const { status, errorCode, message, retryAfterSec, committed } = wireFailureShapeOf(e);
     if (errorCode === 'capability.rule_store_required') {
@@ -635,6 +664,47 @@ export function classifySkippedReason(reason) {
         return { text };
     return { code: head, text };
 }
+const CC_IMPORT_SKIPPED_READ_BUDGET = 20_000;
+const CC_IMPORT_SKIPPED_SHOWN_MAX = 2000;
+function ccImportSkippedReading(shape, groups, unreadable) {
+    return Object.freeze({ shape, groups: Object.freeze([...groups]), unreadable });
+}
+export function ccImportSkippedRowsOf(skipped) {
+    if (skipped === undefined)
+        return ccImportSkippedReading('absent', [], 0);
+    const grouped = new Map();
+    let unreadable = 0;
+    try {
+        if (!Array.isArray(skipped))
+            return ccImportSkippedReading('malformed', [], 0);
+        const length = readOwnDataValue(skipped, 'length');
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0 || length > CC_IMPORT_SKIPPED_READ_BUDGET)
+            return ccImportSkippedReading('malformed', [], 0);
+        for (let i = 0; i < length; i++) {
+            const row = guardedRead(() => readOwnDataValue(skipped, String(i)));
+            const rule = typeof row === 'object' && row !== null ? guardedRead(() => readOwnDataValue(row, 'rule')) : undefined;
+            const reason = typeof row === 'object' && row !== null ? guardedRead(() => readOwnDataValue(row, 'reason')) : undefined;
+            if (typeof rule !== 'string' || typeof reason !== 'string') {
+                unreadable += 1;
+                continue;
+            }
+            const entries = grouped.get(reason);
+            if (entries === undefined)
+                grouped.set(reason, [displayUntrusted(rule, { max: CC_IMPORT_SKIPPED_SHOWN_MAX })]);
+            else
+                entries.push(displayUntrusted(rule, { max: CC_IMPORT_SKIPPED_SHOWN_MAX }));
+        }
+    }
+    catch {
+        return ccImportSkippedReading('malformed', [], 0);
+    }
+    const groups = [];
+    for (const [raw, entries] of grouped) {
+        const code = classifySkippedReason(raw).code;
+        groups.push(Object.freeze({ entries: Object.freeze(entries), reason: displayUntrusted(raw, { max: CC_IMPORT_SKIPPED_SHOWN_MAX }), ...(code !== undefined ? { code } : {}) }));
+    }
+    return ccImportSkippedReading('read', groups, unreadable);
+}
 export function readRulePersistOutcome(ack) {
     const parsed = readToolApprovalRespondAck(ack);
     if (parsed === undefined || isToolApprovalRespondReplayed(parsed) || isToolApprovalRespondParkedRedeemed(parsed))

package/dist/hitl/planReviewWire.d.ts

@@ -41,6 +41,8 @@ export interface PlanReviewCardView {
     readonly note?: string;
 }
 export declare function planReviewCardViewOf(frame: object | null | undefined, lang?: UiLanguage): PlanReviewCardView | undefined;
+export type PlanReviewEvidenceMove = 'same' | 'moved' | 'unknown';
+export declare function planReviewEvidenceMovedOf(shown: object | null | undefined, latest: object | null | undefined): PlanReviewEvidenceMove;
 export declare function notePlanReviewAnsweredIfDecisive(questionId: unknown, answer: QuestionAnswer | null | undefined): void;
 export { isPlanReviewPark };
 export declare function _resetArmedPlanReviewsForTest(): void;
@@ -79,6 +81,7 @@ export interface PlanReviewOutcomeMeta {
     decision: 'approve' | 'reject' | 'ask_again';
     effect: PlanReviewDecisionEffect;
     cause?: 'stored_form_unsupported';
+    questionId?: string;
 }
 export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect, cause?: 'stored_form_unsupported'): string;
 export type PlanReviewWireClient = {

package/dist/hitl/planReviewWire.js

@@ -150,6 +150,22 @@ export function planReviewCardViewOf(frame, lang) {
         return Object.freeze({ options: OPTIONS_BY_SHAPE.withheld, note: renderMessage(planReviewUnreadableNoteRef(), lang) });
     }
 }
+export function planReviewEvidenceMovedOf(shown, latest) {
+    try {
+        const a = planReviewCardFactsFrom(shown);
+        const b = planReviewCardFactsFrom(latest);
+        if (a === undefined || b === undefined || a.taskId !== b.taskId)
+            return 'unknown';
+        if (a.checkpointId !== undefined && b.checkpointId !== undefined && a.checkpointId !== b.checkpointId)
+            return 'moved';
+        if (a.evidenceRevision === undefined || b.evidenceRevision === undefined)
+            return 'unknown';
+        return a.evidenceRevision === b.evidenceRevision ? 'same' : 'moved';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 export function notePlanReviewAnsweredIfDecisive(questionId, answer) {
     notePlanReviewAnsweredIfDecisiveFor(DEFAULT_SESSION_KEY, questionId, answer);
 }
@@ -524,7 +540,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             const cardDelivery = cardReason !== undefined ? { ...delivery, reason: cardReason } : delivery;
             notePlanReviewAnswered(questionId);
             hostLog('debug', `planReviewWire: arm responder delivering ${decided} for task ${taskId} (path=arm)`);
-            void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, facts);
+            void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, facts, questionId);
             return { ok: true };
         };
         unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
@@ -725,7 +741,7 @@ function askAgainReasonOf(card, opts) {
         return renderMessage(msg('approval.planReview.askAgain.unknown'), DATA_FACE_LANGUAGE);
     }
 }
-async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, card) {
+async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, card, cardId) {
     if (typeof taskId === 'string' && planReviewOpsOf(taskId).some((op) => op.phase === 'posting')) {
         hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
@@ -758,7 +774,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     try {
         const wireDecision = decision === 'ask_again' ? 'reject' : decision;
         const wireOpts = decision === 'ask_again' ? { ...opts, reason: askAgainReasonOf(card, opts) } : opts;
-        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, decision);
+        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, decision, cardId);
     }
     finally {
         releaseLatch();
@@ -779,7 +795,7 @@ function planReviewClientsFor(resolved) {
         repull: () => resolved.make({ timeoutMs: 15_000 }),
     };
 }
-async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, card, semanticDecision) {
+async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, card, semanticDecision, cardId) {
     let outcome;
     let decisionReason;
     const gateBefore = card?.checkpointId;
@@ -1019,7 +1035,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
     const onOutcome = opts?.onOutcome;
     settle(effect === 'not_sent' || effect === 'still_parked');
     try {
-        const delivered = enqueuePlanReviewOutcome(prompt, { taskId, dispatchNo, decision: semanticDecision, effect, ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}) });
+        const delivered = enqueuePlanReviewOutcome(prompt, { taskId, dispatchNo, decision: semanticDecision, effect, ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}), ...(cardId !== undefined ? { questionId: cardId } : {}) });
         if (!delivered) {
             if (onOutcome !== undefined) {
                 hostLog('debug', `planReviewWire: outcome queue port not installed for task ${taskId} — outcome handed to the host's onOutcome callback only`);
@@ -1039,6 +1055,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             decision: semanticDecision,
             effect,
             ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}),
+            ...(cardId !== undefined ? { questionId: cardId } : {}),
             detail: outcome,
             tail,
             prompt,
@@ -1160,7 +1177,7 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         ((tid, decision, reason, card) => {
             hostLog('debug', `planReviewWire: reopen responder delivering ${decision} for task ${tid} (path=reopen-default)`);
             const withReason = reason === undefined ? delivery : { ...delivery, reason };
-            void decidePlanReviewFor(tid, decision, undefined, withReason, card);
+            void decidePlanReviewFor(tid, decision, undefined, withReason, card, questionId);
         });
     const activeKey = `${sessionKey}\u0000${canonicalId}`;
     let unregister = () => { };

package/dist/hitl/policyDenyCause.d.ts

@@ -1,3 +1,3 @@
-export declare const POLICY_DENY_CAUSES: readonly ["no_approval_ui", "dont_ask", "deny_rule", "engine_floor"];
+export declare const POLICY_DENY_CAUSES: readonly ["no_approval_ui", "dont_ask", "deny_rule", "engine_floor", "hook"];
 export type PolicyDenyCause = (typeof POLICY_DENY_CAUSES)[number];
 export declare function readPolicyDenyCause(decision: object | null | undefined): PolicyDenyCause | undefined;

package/dist/hitl/policyDenyCause.js

@@ -1,4 +1,4 @@
-export const POLICY_DENY_CAUSES = Object.freeze(['no_approval_ui', 'dont_ask', 'deny_rule', 'engine_floor']);
+export const POLICY_DENY_CAUSES = Object.freeze(['no_approval_ui', 'dont_ask', 'deny_rule', 'engine_floor', 'hook']);
 export function readPolicyDenyCause(decision) {
     if (decision === null || typeof decision !== 'object')
         return undefined;

package/dist/hitl/resumeRunningCard.d.ts

@@ -21,6 +21,7 @@ export declare function runningAttachOffered(canAttach: boolean | undefined): bo
 export declare function resumeRunningOptions(i: ResumeRunningCardInput): ResumeRunningCardOption[];
 export declare function resumeChoiceFromLabels(selected: readonly string[] | null | undefined): ResumeRunningChoice;
 export declare const RESUME_RUNNING_NO_UI_EXIT_CODE = 75;
+export declare const ENGINE_UNAVAILABLE_EXIT_CODE = 69;
 export declare const RESUME_RUNNING_GUIDANCE_TAG = "sema: resume-running:";
 export declare function resumeRunningNoUiGuidance(i: {
     taskId: string;

package/dist/hitl/resumeRunningCard.js

@@ -50,6 +50,7 @@ export function resumeChoiceFromLabels(selected) {
     return 'background';
 }
 export const RESUME_RUNNING_NO_UI_EXIT_CODE = 75;
+export const ENGINE_UNAVAILABLE_EXIT_CODE = 69;
 export const RESUME_RUNNING_GUIDANCE_TAG = 'sema: resume-running:';
 export function resumeRunningNoUiGuidance(i) {
     const sid = typeof i.sessionId === 'string' && i.sessionId.length > 0 ? i.sessionId : null;

package/dist/hitl/screenCardCarriers.d.ts

@@ -0,0 +1,15 @@
+export declare const PARK_GATE_KEY = "_sema_parkGate";
+export declare function sourceGenerationNow(deps: {
+    readonly engineGeneration?: () => number;
+} | null | undefined): number | undefined;
+export declare function parkQuestionFrameBits(taskId: string, gatedCallId: string | undefined, sourceGeneration: number | undefined): {
+    readonly _sema_parkGate?: {
+        readonly taskId: string;
+        readonly gatedCallId: string;
+    };
+    readonly _sema_sourceGeneration?: number;
+};
+export declare function sourceGenerationBit(sourceGeneration: number | undefined): {
+    readonly sourceGeneration?: number;
+};
+export declare function questionFrameSourceGenerationOf(frame: object | null | undefined): number | undefined;

package/dist/hitl/screenCardCarriers.js

@@ -0,0 +1,41 @@
+import { slotReadOf } from '../wireFailureShape.js';
+import { engineGenerationReadingOf } from '../engineGenerationPort.js';
+export const PARK_GATE_KEY = '_sema_parkGate';
+const SOURCE_GENERATION_KEY = '_sema_sourceGeneration';
+const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+const finite = (v) => typeof v === 'number' && Number.isFinite(v);
+export function sourceGenerationNow(deps) {
+    try {
+        if (typeof deps !== 'object' || deps === null)
+            return undefined;
+        const read = deps.engineGeneration;
+        if (typeof read !== 'function')
+            return undefined;
+        const r = engineGenerationReadingOf(() => read.call(deps));
+        return r.known ? r.generation : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parkQuestionFrameBits(taskId, gatedCallId, sourceGeneration) {
+    return {
+        ...(nonEmpty(taskId) && nonEmpty(gatedCallId) ? { _sema_parkGate: Object.freeze({ taskId, gatedCallId }) } : {}),
+        ...(finite(sourceGeneration) ? { _sema_sourceGeneration: sourceGeneration } : {}),
+    };
+}
+export function sourceGenerationBit(sourceGeneration) {
+    return finite(sourceGeneration) ? { sourceGeneration } : {};
+}
+export function questionFrameSourceGenerationOf(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null)
+            return undefined;
+        const r = slotReadOf(frame, SOURCE_GENERATION_KEY);
+        const v = r.presence === 'present' ? r.value : undefined;
+        return finite(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/screenDecisionCards.d.ts

@@ -0,0 +1,98 @@
+import { type ScreenCardOrigin } from './gateIdentity.js';
+import { type EndedGenerationOpenedCall, type EndedGenerationPhaseChange, type EndedGenerationPhaseHold } from '../engineGenerationConvergence.js';
+import type { HostWithdrawal } from './hostWithdrawal.js';
+export type ScreenCardGate = {
+    readonly kind: 'tool';
+    readonly taskId: string;
+    readonly gatedCallId: string;
+} | {
+    readonly kind: 'plan';
+    readonly taskId: string;
+    readonly checkpointId?: string;
+};
+export interface ScreenCardWindow {
+    readonly leftMs?: number;
+    readonly closedByEngine?: boolean;
+}
+export interface ScreenDecisionCard {
+    readonly instance: string;
+    readonly origin?: ScreenCardOrigin;
+    readonly gate?: ScreenCardGate;
+    readonly sourceGeneration?: number;
+    readonly toolCallId?: string;
+    readonly window?: ScreenCardWindow;
+}
+export declare const SCREEN_CARD_KEEP_REASONS: readonly ["not-ready", "generation-moved", "not-withdrawable", "no-gate", "not-early", "no-row", "not-owned", "verdict-ok", "verdict-absent"];
+export type ScreenCardKeepReason = (typeof SCREEN_CARD_KEEP_REASONS)[number];
+export interface EngineGenerationEndedCardFacts {
+    readonly phase: 'ended';
+    readonly endedGeneration: number;
+    readonly cards: readonly ScreenDecisionCard[];
+    readonly opened: readonly EndedGenerationOpenedCall[];
+    readonly phases?: readonly EndedGenerationPhaseHold[];
+}
+export interface EngineGenerationReadyCardFacts<R extends object> {
+    readonly phase: 'ready';
+    readonly generation: number;
+    readonly ready: boolean;
+    readonly readGeneration: number;
+    readonly cards: readonly ScreenDecisionCard[];
+    readonly rows: readonly R[];
+    readonly isOwned: (row: R) => boolean;
+    readonly withdrawable: readonly ScreenCardOrigin[];
+}
+export interface EngineGenerationEndedCardPlan {
+    readonly phase: 'ended';
+    readonly retract: readonly string[];
+    readonly phases: readonly EndedGenerationPhaseChange[];
+}
+export interface ScreenCardWithdrawal<R extends object> {
+    readonly instance: string;
+    readonly origin: ScreenCardOrigin;
+    readonly row: R;
+    readonly withdrawal: HostWithdrawal;
+}
+export interface ScreenCardKeep {
+    readonly instance: string;
+    readonly why: ScreenCardKeepReason;
+}
+export interface EngineGenerationReadyCardPlan<R extends object> {
+    readonly phase: 'ready';
+    readonly withdraw: readonly ScreenCardWithdrawal<R>[];
+    readonly keep: readonly ScreenCardKeep[];
+}
+export interface EngineGenerationCardRecheckDueFacts {
+    readonly generation: number;
+    readonly ready: boolean;
+    readonly cards: readonly ScreenDecisionCard[];
+    readonly withdrawable: readonly ScreenCardOrigin[];
+}
+export declare function questionFrameGateOf(frame: object | null | undefined): ScreenCardGate | undefined;
+export declare function approvalCardGateOf(card: object | null | undefined): ScreenCardGate | undefined;
+export declare function approvalCardOriginOf(card: object | null | undefined): 'live-approval' | 'park-approval';
+export declare function screenCardsHoldEngineDecision(cards: readonly {
+    readonly origin?: ScreenCardOrigin;
+}[] | null | undefined): boolean;
+export declare function engineGenerationCardPlan(facts: EngineGenerationEndedCardFacts): EngineGenerationEndedCardPlan;
+export declare function engineGenerationCardPlan<R extends object>(facts: EngineGenerationReadyCardFacts<R>): EngineGenerationReadyCardPlan<R>;
+export declare function engineGenerationCardRecheckDue(facts: EngineGenerationCardRecheckDueFacts): boolean;
+export interface ScreenCardGoldenRow {
+    readonly taskId?: string;
+    readonly toolCallId?: string;
+    readonly boundCallId?: string;
+    readonly checkpointId?: string;
+    readonly rowVerdict?: ScreenCardGoldenRowVerdict;
+    readonly owned: boolean;
+}
+export interface ScreenCardGoldenRowVerdict {
+    readonly kind: string;
+    readonly code?: string;
+    readonly reason?: string;
+    readonly sentence?: string;
+}
+export interface EngineGenerationCardPlanGoldenCase {
+    readonly name: string;
+    readonly facts: EngineGenerationEndedCardFacts | Omit<EngineGenerationReadyCardFacts<ScreenCardGoldenRow>, 'isOwned'>;
+    readonly plan: EngineGenerationEndedCardPlan | EngineGenerationReadyCardPlan<ScreenCardGoldenRow>;
+}
+export declare const ENGINE_GENERATION_CARD_PLAN_GOLDEN: readonly EngineGenerationCardPlanGoldenCase[];