@sema-agent/client-core 0.83.6 → 0.84.1

package/dist/engineNoticeCodes.js

@@ -74,8 +74,15 @@ export const ENGINE_NOTICE_CODES = Object.freeze([
     'tool_result.offload_put_failed',
 ]);
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
+export const SERVER_NOTICE_AUDIENCE = Object.freeze({
+    'instructions.source_changed': 'user',
+    'memory.layer_locked_legacy': 'operator',
+});
+function audienceRow(table, code) {
+    return Object.hasOwn(table, code) ? table[code] : undefined;
+}
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && CATALOG.has(code);
+    return typeof code === 'string' && (CATALOG.has(code) || Object.hasOwn(SERVER_NOTICE_AUDIENCE, code));
 }
 export const ENGINE_NOTICE_AUDIENCE = Object.freeze({
     'config.autocompact_window_clamped': 'operator',
@@ -153,10 +160,9 @@ export const ENGINE_NOTICE_AUDIENCE = Object.freeze({
     'tool_result.offload_put_failed': 'operator',
 });
 export function noticeAudienceOf(code) {
-    const row = typeof code === 'string' && Object.hasOwn(ENGINE_NOTICE_AUDIENCE, code)
-        ? ENGINE_NOTICE_AUDIENCE[code]
-        : undefined;
-    return row ?? 'operator';
+    if (typeof code !== 'string')
+        return 'operator';
+    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(SERVER_NOTICE_AUDIENCE, code) ?? 'operator';
 }
 export const MCP_INJECTION_DROP_REASONS = Object.freeze([
     'malformed_entry',
@@ -303,3 +309,110 @@ export function readMcpServerRedialed(notice) {
     const reason = str(o.reason);
     return { server, outcome, added, removed, ...(reason !== undefined ? { reason } : {}), sessionId, runId };
 }
+const READ_ROOT_GRANT_COVERS_EXACT = 'exact';
+const _grantCoversPin = true;
+void _grantCoversPin;
+export function readReadRootGrantNotice(notice) {
+    try {
+        return readRootGrantNoticeOf(notice);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRootGrantNoticeOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'approval.read_root_granted' && n.code !== 'approval.read_root_grant_rejected')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const toolCallId = str(o.toolCallId);
+    if (toolCallId === undefined)
+        return undefined;
+    const sessionId = str(o.sessionId);
+    if (n.code === 'approval.read_root_granted') {
+        const dir = str(o.dir);
+        const root = str(o.root);
+        if (dir === undefined || root === undefined)
+            return undefined;
+        if ('covers' in o && o.covers !== READ_ROOT_GRANT_COVERS_EXACT)
+            return undefined;
+        return {
+            outcome: 'granted',
+            toolCallId,
+            dir,
+            root,
+            ...('covers' in o ? { covers: READ_ROOT_GRANT_COVERS_EXACT } : {}),
+            ...(sessionId !== undefined ? { sessionId } : {}),
+        };
+    }
+    const reason = str(o.reason);
+    return { outcome: 'rejected', toolCallId, ...(reason !== undefined ? { reason } : {}), ...(sessionId !== undefined ? { sessionId } : {}) };
+}
+function ownPathOrNull(o, key) {
+    if (!Object.hasOwn(o, key))
+        return undefined;
+    const v = o[key];
+    if (v === null)
+        return null;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function readInstructionsSourceChanged(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    try {
+        const n = notice;
+        if (n.code !== 'instructions.source_changed')
+            return undefined;
+        const d = n.detail;
+        if (typeof d !== 'object' || d === null || Array.isArray(d))
+            return undefined;
+        const o = d;
+        const previous = ownPathOrNull(o, 'previous');
+        const current = ownPathOrNull(o, 'current');
+        const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
+        if (previous === undefined || current === undefined || sessionId === undefined)
+            return undefined;
+        return { previous, current, sessionId };
+    }
+    catch {
+        return undefined;
+    }
+}
+export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
+    'mcp.injection_dropped': readMcpInjectionDrop,
+    'delegation.ask_unresolvable': readAskUnresolvable,
+    'config.durable_gate_unavailable': readDurableGateUnavailable,
+    'skills.listing_truncated': readSkillsListingTruncated,
+    'mcp.server_redialed': readMcpServerRedialed,
+    'instructions.source_changed': readInstructionsSourceChanged,
+    'approval.read_root_granted': readReadRootGrantNotice,
+    'approval.read_root_grant_rejected': readReadRootGrantNotice,
+});
+const _factReaderTablePin = true;
+void _factReaderTablePin;
+export function readEngineNoticeFacts(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    let code;
+    let detail;
+    try {
+        code = notice.code;
+        if (typeof code !== 'string' || !Object.hasOwn(ENGINE_NOTICE_FACT_READERS, code))
+            return undefined;
+        detail = notice.detail;
+    }
+    catch {
+        return undefined;
+    }
+    const k = code;
+    const facts = ENGINE_NOTICE_FACT_READERS[k]({ code: k, detail });
+    if (facts === undefined)
+        return undefined;
+    return { code: k, audience: noticeAudienceOf(k), facts };
+}

package/dist/engineWireSdk.d.ts

@@ -6,11 +6,13 @@ export type WireAuthTokenSource = string | (() => string | undefined);
 export declare function isLoopbackWireUrl(url: string): boolean;
 export declare function resolveWireAuth(baseUrl: string | undefined, token?: string): WireAuthToken;
 export declare function wireAuthTokenFor(baseUrl: string, token?: string): WireAuthToken;
+export type EngineProbeClient = Pick<AgentClient, 'capabilities' | 'scenarioCapabilities'>;
 export type EngineProbeOpts = {
     fetchImpl?: typeof fetch;
     timeoutMs?: number;
     authToken?: WireAuthTokenSource | undefined;
     principal?: string | undefined;
+    client?: EngineProbeClient;
 };
 export type EngineWireClientConfig = {
     baseUrl: string;

package/dist/fleet/fleetProjection.js

@@ -1,6 +1,7 @@
 import { collapseLabel, escapeDisplayControlChars, taskDescFromName } from '../fleetTaskDesc.js';
 import { rowIdTail } from '../workflow.js';
-export const TERMINAL_FLEET_TASK_STATUSES = new Set([
+import { frozenSet } from '../frozenSet.js';
+export const TERMINAL_FLEET_TASK_STATUSES = frozenSet([
     'completed',
     'failed',
     'killed',
@@ -51,7 +52,7 @@ function deriveAgentLabel(agentType, agentName, name, id) {
     const tail = rowIdTail(id).slice(-8);
     return tail ? `agent ${tail}` : 'agent';
 }
-export const CONTROL_TOOL_VERBS = new Set([
+export const CONTROL_TOOL_VERBS = frozenSet([
     'Agent',
     'Task',
     'Fork',

package/dist/frozenSet.d.ts

@@ -0,0 +1 @@
+export declare function frozenSet<T>(members: Iterable<T>): ReadonlySet<T>;

package/dist/frozenSet.js

@@ -0,0 +1,20 @@
+class FrozenVerdictSet extends Set {
+    constructor(members) {
+        super();
+        for (const m of members)
+            super.add(m);
+    }
+    add(_value) {
+        throw new TypeError('This set is read-only: it is a verdict table shared by every caller; copy it into a new Set to change it.');
+    }
+    delete(_value) {
+        throw new TypeError('This set is read-only: it is a verdict table shared by every caller; copy it into a new Set to change it.');
+    }
+    clear() {
+        throw new TypeError('This set is read-only: it is a verdict table shared by every caller; copy it into a new Set to change it.');
+    }
+}
+Object.freeze(FrozenVerdictSet.prototype);
+export function frozenSet(members) {
+    return Object.freeze(new FrozenVerdictSet(members));
+}

package/dist/handsSeam.d.ts

@@ -0,0 +1,3 @@
+import type { WiringManifestHandsView } from './toolRoster.js';
+export declare function projectHandsSection(holder: object): WiringManifestHandsView | undefined;
+export declare const HANDS_REASON_NO_EXECUTION_ENV = "no_execution_env";

package/dist/handsSeam.js

@@ -0,0 +1,19 @@
+export function projectHandsSection(holder) {
+    if (!Object.hasOwn(holder, 'hands'))
+        return undefined;
+    const raw = holder.hands;
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return undefined;
+    if (!Object.hasOwn(raw, 'mounted'))
+        return undefined;
+    const mounted = raw.mounted;
+    if (typeof mounted !== 'boolean')
+        return undefined;
+    const reason = Object.hasOwn(raw, 'reason') ? raw.reason : undefined;
+    return { mounted, ...(typeof reason === 'string' && reason.length > 0 ? { reason } : {}) };
+}
+export const HANDS_REASON_NO_EXECUTION_ENV = 'no_execution_env';
+const _handsReasonPin = true;
+void _handsReasonPin;
+const _handsViewPin = true;
+void _handsViewPin;

package/dist/hitl/askGateWire.d.ts

@@ -8,7 +8,7 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {

package/dist/hitl/askGateWire.js

@@ -6,7 +6,7 @@ export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
 export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();
     const taskId = { current: opts?.taskId };

package/dist/hitl/hitlHostSurface.js

@@ -113,7 +113,7 @@ export function observeCancelByDeny(settle, taskId) {
             hostLog('debug', `[hitl-cancel-deny] cancel-by-deny no_pending for run ${taskId} (benign — already resolved)`);
             return;
         }
-        const rowNote = decideFailureNote(e);
+        const rowNote = decideFailureNote(e, 'deny');
         hostLog('error', `[hitl-cancel-deny] cancel-by-deny FAILED for run ${taskId}: ${String(e)}${rowNote}`);
         surfaceCancelDenyWarn(`${CANCEL_DENY_WARN_TEXT}${rowNote}`);
     })

package/dist/hitl/parkResolver.d.ts

@@ -34,6 +34,7 @@ export type GateOutcome = {
 };
 export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
 export declare function isGateStandingErrorCode(code: string | null | undefined): boolean;
+export declare function isCodeClassifiedGateFailure(code: string | null | undefined): boolean;
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;
 export type ParkResolution = {
     kind: 'reattach';

package/dist/hitl/parkResolver.js

@@ -1,6 +1,6 @@
 import { putOwnKey } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
-import { RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
+import { PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -44,13 +44,16 @@ function isAlreadyResolvedFailure(outcome) {
     const code = 'code' in outcome && isGateFailureCode(outcome.code) ? outcome.code : undefined;
     if (code !== undefined)
         return code === 'no_pending';
-    if ('errorCode' in outcome && isGateStandingErrorCode(outcome.errorCode))
+    if ('errorCode' in outcome && isCodeClassifiedGateFailure(outcome.errorCode))
         return false;
     return isAlreadyResolvedGateReason(outcome.reason);
 }
 export function isGateStandingErrorCode(code) {
     return code === RESUME_POLICY_FOLD_CODE || code === 'corrupt';
 }
+export function isCodeClassifiedGateFailure(code) {
+    return isGateStandingErrorCode(code) || code === PARKED_RESUME_STARTUP_FAILED;
+}
 export function toAnsweredOutput(questions, answer) {
     const answers = {};
     const annotations = {};
@@ -122,10 +125,12 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         return { kind: 'aborted', gatedCallId };
     }
     let declinedReceipt;
+    let attemptedDecision;
     try {
         const entries = answer.answers ?? [];
         const hasContent = entries.some(a => (a.selected?.length ?? 0) > 0 || (a.note?.length ?? 0) > 0);
         if (hasContent) {
+            attemptedDecision = 'approve';
             const raw = await bridge.answerQuestion(entries, gatedCallId, signal ? { signal } : undefined, pending);
             const receipt = readDecideReceipt(raw);
             return {
@@ -136,6 +141,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
             };
         }
         else {
+            attemptedDecision = 'deny';
             const raw = await bridge.decideTool({ decision: 'deny', reason: 'User declined to answer' }, gatedCallId, signal ? { signal } : undefined, pending);
             declinedReceipt = readDecideReceipt(raw);
         }
@@ -149,7 +155,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
             kind: 'failed',
             stage: 'decide',
             gatedCallId,
-            reason: `decide failed: ${String(e)}${decideFailureNote(e)}`,
+            reason: `decide failed: ${String(e)}${decideFailureNote(e, attemptedDecision)}`,
             ...(code !== undefined ? { code } : {}),
             ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
             ...(currentPending !== undefined ? { currentPending } : {}),

package/dist/hitl/planReviewWire.d.ts

@@ -1,5 +1,6 @@
 import { type QuestionAnswer } from '../liveQuestionStore.js';
 import { type PlanReviewModeAfter } from './hitlBridge.js';
+import type { AgentClient } from '@sema-agent/sdk';
 import type { ReopenCardVerdict } from '../adapter/activeRunSelfHeal.js';
 export declare const PLAN_REVIEW_APPROVE_LABEL = "Yes, approve and run the plan";
 export declare const PLAN_REVIEW_REJECT_LABEL = "No, reject it (keep planning)";
@@ -28,10 +29,13 @@ export declare function _resetArmedPlanReviewsForTest(): void;
 export type PlanReviewReopenTrigger = 'user' | 'automatic';
 export type PlanReviewGateInstanceReader = (taskId: string) => Promise<ReadonlySet<string> | null>;
 export declare function clearPlanReviewUserDismissals(sessionKey?: string): void;
-export declare function armPlanReviewApproval(result: unknown, sessionKey?: string, opts?: {
+export interface ArmPlanReviewOptions {
     submittedInPlanMode?: boolean;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
-}): boolean;
+    wire?: PlanReviewWire;
+    onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
+}
+export declare function armPlanReviewApproval(result: unknown, sessionKey?: string, opts?: ArmPlanReviewOptions): boolean;
 export type PlanReviewDecisionEffect = 'took_effect' | 'advanced' | 'still_parked' | 'not_sent' | 'not_applied' | 'unconfirmed';
 export interface PlanReviewOutcomeMeta {
     taskId: string;
@@ -40,12 +44,35 @@ export interface PlanReviewOutcomeMeta {
     effect: PlanReviewDecisionEffect;
 }
 export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect): string;
+export type PlanReviewWireClient = {
+    assistant: Pick<AgentClient['assistant'], 'planReview'>;
+    runs: Pick<AgentClient['runs'], 'get'>;
+};
+export interface PlanReviewWire {
+    client: PlanReviewWireClient;
+    capsBaseUrl?: string;
+}
+export interface PlanReviewDecisionOutcome extends PlanReviewOutcomeMeta {
+    detail: string;
+    tail: string;
+    prompt: string;
+    status?: string;
+}
+export interface PlanReviewDeliveryOptions {
+    wire?: PlanReviewWire;
+    onOutcome?: (outcome: PlanReviewDecisionOutcome) => void;
+}
+export interface DecidePlanReviewOptions extends PlanReviewDeliveryOptions {
+    reason?: string;
+}
 export declare function __resetPlanReviewDecisionLatchForTests(): void;
-export declare function decidePlanReview(taskId: string, decision: 'approve' | 'reject', permissionModeAfter?: string): Promise<void>;
+export declare function decidePlanReview(taskId: string, decision: 'approve' | 'reject', permissionModeAfter?: string, opts?: DecidePlanReviewOptions): Promise<void>;
 export interface ReopenPlanReviewOpts {
     mintFreshQuestionId?: boolean;
     deliverDecision?: (taskId: string, decision: 'approve' | 'reject') => void | Promise<void>;
     sessionKey?: string;
+    wire?: PlanReviewWire;
+    onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
     presentationReceiptMs?: number;
     trigger?: PlanReviewReopenTrigger;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;