@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/panelStateHolder.d.ts

@@ -0,0 +1,17 @@
+import type { EngineAgentPanelAbsence, EngineAgentPanelEvent } from './engineAgentPanelStore.js';
+import { type PanelDelta, type PanelFrame, type PanelReduceState } from './panelReduce.js';
+export declare function panelStateNow(): PanelReduceState;
+export declare function stepEnginePanel(frame: PanelFrame): void;
+export declare function replaceEnginePanelState(fn: (s: PanelReduceState) => PanelReduceState): void;
+export declare function clearEnginePanelIdentity(): void;
+export declare function clearEnginePanelAnchors(): void;
+export declare function resetEnginePanelHolder(): void;
+type Listener = (ev: EngineAgentPanelEvent) => void;
+export declare function subscribeLegacyEvents(fn: Listener): () => void;
+type AbsenceListener = (ev: EngineAgentPanelAbsence) => void;
+export declare function subscribeAbsence(fn: AbsenceListener): () => void;
+export declare function resetAbsenceChannel(): void;
+type RowListener = (d: PanelDelta) => void;
+export declare function subscribeRows(fn: RowListener): () => void;
+export declare function clearEnginePanelRows(): void;
+export {};

package/dist/panelStateHolder.js

@@ -0,0 +1,201 @@
+import { createPanelReduceState, isNewEngineAgentPanelCycle, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, stepPanelFrame, } from './panelReduce.js';
+let state = createPanelReduceState();
+export function panelStateNow() {
+    return state;
+}
+export function stepEnginePanel(frame) {
+    const r = stepPanelFrame(state, frame);
+    state = r.state;
+    if (rowListener !== null)
+        rowQueue.push(...r.deltas);
+    for (const f of r.facts) {
+        if (f.ch === 'event')
+            deliverLegacyEvent(f.ev);
+        else
+            deliverAbsence(f.absence);
+    }
+    drainRows();
+}
+export function replaceEnginePanelState(fn) {
+    state = fn(state);
+}
+export function clearEnginePanelIdentity() {
+    state = panelClearIdentity(state);
+}
+export function clearEnginePanelAnchors() {
+    state = panelClearAnchors(state);
+}
+export function resetEnginePanelHolder() {
+    state = createPanelReduceState();
+    listener = null;
+    buffer.length = 0;
+    absenceListener = null;
+    absenceBuffer.clear();
+    rowListener = null;
+    rowQueue.length = 0;
+}
+const MAX_BUFFER = 200;
+let listener = null;
+const buffer = [];
+function launchAnchorChanged(prev, next) {
+    if (prev.kind !== 'fleet-row' || next.kind !== 'fleet-row')
+        return false;
+    return isNewEngineAgentPanelCycle(prev, next);
+}
+function deliverLegacyEvent(ev) {
+    if (ev.kind !== 'sweep')
+        absenceBuffer.delete(ev.taskId);
+    if (listener) {
+        try {
+            listener(ev);
+        }
+        catch {
+        }
+        return;
+    }
+    if (ev.kind === 'sweep' && buffer.length > 0 && buffer[buffer.length - 1]?.kind === 'sweep')
+        return;
+    const progress = ev.kind === 'tick' || ev.kind === 'fleet-row';
+    if (progress) {
+        const kind = ev.kind;
+        const taskId = ev.taskId;
+        let i = -1;
+        for (let at = buffer.length - 1; at >= 0; at--) {
+            const b = buffer[at];
+            if (b === undefined)
+                continue;
+            if (b.kind === 'sweep')
+                break;
+            if (b.kind === 'end') {
+                if (b.taskId === taskId)
+                    break;
+                continue;
+            }
+            if (b.taskId !== taskId)
+                continue;
+            if (b.kind === kind && !launchAnchorChanged(b, ev))
+                i = at;
+            break;
+        }
+        if (i >= 0) {
+            const merged = { ...buffer[i], ...ev };
+            buffer.splice(i, 1);
+            buffer.push(merged);
+            return;
+        }
+    }
+    if (buffer.length < MAX_BUFFER) {
+        buffer.push(ev);
+        return;
+    }
+    const evictAt = buffer.findIndex(b => b.kind === 'tick' || b.kind === 'fleet-row');
+    if (evictAt >= 0) {
+        buffer.splice(evictAt, 1);
+        buffer.push(ev);
+        return;
+    }
+    buffer.shift();
+    buffer.push(ev);
+}
+export function subscribeLegacyEvents(fn) {
+    listener = fn;
+    if (buffer.length > 0) {
+        const pending = buffer.splice(0, buffer.length);
+        for (const ev of pending) {
+            try {
+                fn(ev);
+            }
+            catch {
+            }
+        }
+    }
+    return () => {
+        if (listener === fn)
+            listener = null;
+    };
+}
+const MAX_ABSENCE_BUFFER = 200;
+let absenceListener = null;
+const absenceBuffer = new Map();
+function deliverAbsence(ev) {
+    if (absenceListener) {
+        try {
+            absenceListener(ev);
+        }
+        catch {
+        }
+        return;
+    }
+    absenceBuffer.delete(ev.taskId);
+    absenceBuffer.set(ev.taskId, ev);
+    if (absenceBuffer.size > MAX_ABSENCE_BUFFER) {
+        const oldest = absenceBuffer.keys().next().value;
+        if (oldest !== undefined)
+            absenceBuffer.delete(oldest);
+    }
+}
+export function subscribeAbsence(fn) {
+    absenceListener = fn;
+    if (absenceBuffer.size > 0) {
+        const pending = [...absenceBuffer.values()];
+        absenceBuffer.clear();
+        for (const ev of pending) {
+            try {
+                fn(ev);
+            }
+            catch {
+            }
+        }
+    }
+    return () => {
+        if (absenceListener === fn)
+            absenceListener = null;
+    };
+}
+export function resetAbsenceChannel() {
+    absenceListener = null;
+    absenceBuffer.clear();
+}
+let rowListener = null;
+const rowQueue = [];
+let rowDraining = false;
+function drainRows() {
+    if (rowListener === null) {
+        rowQueue.length = 0;
+        return;
+    }
+    if (rowDraining)
+        return;
+    rowDraining = true;
+    try {
+        while (rowQueue.length > 0) {
+            const d = rowQueue.shift();
+            const fn = rowListener;
+            if (fn === null) {
+                rowQueue.length = 0;
+                break;
+            }
+            try {
+                fn(d);
+            }
+            catch {
+            }
+        }
+    }
+    finally {
+        rowDraining = false;
+    }
+}
+export function subscribeRows(fn) {
+    rowListener = fn;
+    rowQueue.length = 0;
+    rowQueue.push(...panelRowSnapshot(state));
+    drainRows();
+    return () => {
+        if (rowListener === fn)
+            rowListener = null;
+    };
+}
+export function clearEnginePanelRows() {
+    state = panelClearRows(state);
+}

package/dist/peerLaneCapability.d.ts

@@ -14,5 +14,4 @@ export declare function noteEngineCapsForPeerLane(baseUrl: string, caps: unknown
 export declare function observedPeerLane(baseUrl?: string | undefined): PeerLaneReading;
 export declare function peerLaneAvailable(reading: PeerLaneReading): 'yes' | 'no' | 'unknown';
 export declare function peerLaneDoctorDetail(reading: PeerLaneReading): string;
-export declare function forgetPeerLaneReading(baseUrl: string | undefined): void;
 export declare function __resetPeerLaneReadingsForTests(): void;

package/dist/peerLaneCapability.js

@@ -1,14 +1,13 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectPeerLaneCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object')
             return undefined;
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'peerLane'))
-            return { kind: 'not_reported' };
-        const v = caps.peerLane;
+        const v = ownDataField(caps, 'peerLane');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -49,9 +48,6 @@ export function peerLaneDoctorDetail(reading) {
             return 'cross-session lane on — this engine can discover and deliver across sessions for the same caller';
     }
 }
-export function forgetPeerLaneReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetPeerLaneReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/permissionModesCapability.d.ts

@@ -12,5 +12,4 @@ export declare function noteEngineCapsForPermissionModes(baseUrl: string, caps:
 }): void;
 export declare function observedPermissionModes(baseUrl?: string | undefined): PermissionModesReading;
 export declare function permissionModeAdmitted(reading: PermissionModesReading | undefined, mode: string): boolean;
-export declare function forgetPermissionModesReading(baseUrl: string | undefined): void;
 export declare function __resetPermissionModesReadingsForTests(): void;

package/dist/permissionModesCapability.js

@@ -1,16 +1,16 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 function readModesStrict(v) {
     try {
         if (!Array.isArray(v))
             return undefined;
-        const length = v.length;
-        if (length === 0)
+        const length = ownDataField(v, 'length');
+        if (typeof length !== 'number' || length === 0)
             return undefined;
         const modes = [];
         for (let i = 0; i < length; i++) {
-            const item = readOwnDataValue(v, String(i));
+            const item = ownDataField(v, String(i));
             if (typeof item !== 'string' || item.length === 0)
                 return undefined;
             modes.push(item);
@@ -25,9 +25,7 @@ export function projectPermissionModesCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'permissionModes'))
-            return { kind: 'not_reported' };
-        const v = caps.permissionModes;
+        const v = ownDataField(caps, 'permissionModes');
         if (v === undefined)
             return { kind: 'not_reported' };
         const modes = readModesStrict(v);
@@ -63,9 +61,6 @@ export function permissionModeAdmitted(reading, mode) {
         return false;
     }
 }
-export function forgetPermissionModesReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetPermissionModesReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/permissionRulesWriteCapability.d.ts

@@ -14,5 +14,4 @@ export declare function noteEngineCapsForPermissionRulesWrite(baseUrl: string, c
 export declare function observedPermissionRulesWrite(baseUrl?: string | undefined): PermissionRulesWriteReading;
 export declare function permissionRulesWriteAvailable(reading: PermissionRulesWriteReading): boolean;
 export declare function permissionRulesWriteDoctorDetail(reading: PermissionRulesWriteReading): string;
-export declare function forgetPermissionRulesWriteReading(baseUrl: string | undefined): void;
 export declare function __resetPermissionRulesWriteReadingsForTests(): void;

package/dist/permissionRulesWriteCapability.js

@@ -1,14 +1,13 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectPermissionRulesWriteCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object')
             return undefined;
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'permissionRulesWrite'))
-            return { kind: 'not_reported' };
-        const v = caps.permissionRulesWrite;
+        const v = ownDataField(caps, 'permissionRulesWrite');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -45,9 +44,6 @@ export function permissionRulesWriteDoctorDetail(reading) {
             return 'permission-rule write entry reachable for this call — a per-call attempt still answers for itself whether the direction, text, and scope are accepted';
     }
 }
-export function forgetPermissionRulesWriteReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetPermissionRulesWriteReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/permissionsAllowGrantCapability.d.ts

@@ -16,5 +16,4 @@ export declare function permissionsAllowGrantAvailable(reading: PermissionsAllow
 export declare function allowWireForm(reading: PermissionsAllowGrantReading): 'layer' | 'grant' | 'off';
 export declare function allowRulesGate(reading: PermissionsAllowGrantReading, settingsRead: 'clean' | 'partial' | 'unreadable' | undefined): 'open' | 'capability_off' | 'settings_read_not_clean';
 export declare function permissionsAllowGrantDoctorDetail(reading: PermissionsAllowGrantReading, settingsRead?: 'clean' | 'partial' | 'unreadable'): string;
-export declare function forgetPermissionsAllowGrantReading(baseUrl: string | undefined): void;
 export declare function __resetPermissionsAllowGrantReadingsForTests(): void;

package/dist/permissionsAllowGrantCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 import { hasCoreValuePort } from './coreValuePorts.js';
 const ALLOW_GRANT_CAP_PATH = ['settings', 'permissions', 'allowGrant'];
 const ALLOW_LAYER_CAP_LEAF = 'allowLayer';
@@ -10,17 +11,13 @@ export function projectPermissionsAllowGrantCapability(caps) {
         let node = caps;
         for (let i = 0; i < ALLOW_GRANT_CAP_PATH.length; i++) {
             const seg = ALLOW_GRANT_CAP_PATH[i];
-            if (!Object.hasOwn(node, seg))
-                return { kind: 'not_reported' };
-            const v = node[seg];
+            const v = ownDataField(node, seg);
             if (v === undefined)
                 return { kind: 'not_reported' };
             if (i === ALLOW_GRANT_CAP_PATH.length - 1) {
                 if (typeof v !== 'boolean')
                     return undefined;
-                if (!Object.hasOwn(node, ALLOW_LAYER_CAP_LEAF))
-                    return { kind: 'present', grants: v };
-                const layer = node[ALLOW_LAYER_CAP_LEAF];
+                const layer = ownDataField(node, ALLOW_LAYER_CAP_LEAF);
                 if (layer === undefined)
                     return { kind: 'present', grants: v };
                 return typeof layer === 'boolean' ? { kind: 'present', grants: v, layer } : undefined;
@@ -103,9 +100,6 @@ export function permissionsAllowGrantDoctorDetail(reading, settingsRead) {
     }
     return 'allow rules kept on this side — no usable capabilities reading is cached for this engine (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which), so allow rules are not sent and matching approvals are still answered here';
 }
-export function forgetPermissionsAllowGrantReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetPermissionsAllowGrantReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/permissionsDeclaration.d.ts

@@ -60,4 +60,10 @@ export interface PermissionsClientOwnedStatement {
 }
 export declare function permissionsDeclaration(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): PermissionsDeclaration;
 export declare function permissionsDeclarationReport(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): PermissionsDeclarationReport;
+export interface PermissionsAllowKeptFacts {
+    readonly problemCount?: number;
+    readonly managedPolicyPending?: true;
+    readonly where?: string;
+}
+export declare function permissionsAllowKeptNotice(report: Pick<PermissionsDeclarationReport, 'kept'>, settingsRead: 'clean' | 'partial' | 'unreadable', facts?: PermissionsAllowKeptFacts): string | undefined;
 export {};

package/dist/permissionsDeclaration.js

@@ -2,6 +2,7 @@ import { compileAllowList, hasCoreValuePort, protocolOf, retiredToolNames, ruleT
 import { clientOwnedServerPrefix, protocolSegmentOf } from './protocolSegment.js';
 import { ruleCompileVerdict } from './ruleCompileVerdict.js';
 import { allowRulesGate, allowWireForm } from './permissionsAllowGrantCapability.js';
+import { THROWN_SLOT_UNREADABLE, readThrownSlot } from './wireFailureShape.js';
 export const WIRE_RULE_TRUST_ORDER = Object.freeze([
     'policySettings',
     'cliArg',
@@ -396,3 +397,47 @@ export function permissionsDeclarationReport(input, caps) {
     const { buckets, report } = assemble(input, caps);
     return { ...(Object.keys(buckets).length > 0 ? { permissions: buckets } : {}), ...report };
 }
+const ALLOW_KEPT_ROWS_READ_MAX = 4096;
+function allowHeldBySettingsReadCount(report) {
+    if (typeof report !== 'object' || report === null)
+        return 0;
+    const kept = readThrownSlot(report, 'kept');
+    if (typeof kept !== 'object' || kept === null)
+        return 0;
+    const length = readThrownSlot(kept, 'length');
+    if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0)
+        return 0;
+    let n = 0;
+    for (let i = 0; i < Math.min(length, ALLOW_KEPT_ROWS_READ_MAX); i++) {
+        const row = readThrownSlot(kept, String(i));
+        if (typeof row === 'object' && row !== null && readThrownSlot(row, 'reason') === 'settings_read_not_clean')
+            n++;
+    }
+    return n;
+}
+export function permissionsAllowKeptNotice(report, settingsRead, facts) {
+    const held = allowHeldBySettingsReadCount(report);
+    if (held <= 0)
+        return undefined;
+    const readFact = (key) => {
+        if (typeof facts !== 'object' || facts === null)
+            return undefined;
+        const v = readThrownSlot(facts, key);
+        return v === THROWN_SLOT_UNREADABLE ? undefined : v;
+    };
+    const rawCount = readFact('problemCount');
+    const rawWhere = readFact('where');
+    const managedPending = readFact('managedPolicyPending') === true;
+    const count = typeof rawCount === 'number' && Number.isInteger(rawCount) && rawCount >= 1 ? rawCount : undefined;
+    const where = typeof rawWhere === 'string' && rawWhere.length >= 1 && rawWhere.length <= 200 && !/\p{Cc}/u.test(rawWhere) ? rawWhere : undefined;
+    const head = `${String(held)} permissions.allow rule${held === 1 ? ' was' : 's were'} not sent to the engine for this run because `;
+    if (settingsRead === 'partial' && managedPending && count === 1) {
+        return (`${head}the managed policy for your account has not been received yet (sema keeps fetching it; allow rules apply once it arrives). ` +
+            'Run again once it has been received (deny and ask rules, and rules given with --allowedTools, are still sent).');
+    }
+    const why = settingsRead === 'partial'
+        ? `the settings read reported ${count === undefined ? 'problems' : `${String(count)} problem${count === 1 ? '' : 's'}`}${where === undefined ? '' : ` (${where})`}`
+        : 'the health of this settings read could not be checked';
+    return (`${head}${why}; an allow rule from a settings file is only sent from a settings read with no problems. Fix the reported settings, then run again ` +
+        '(deny and ask rules from this read, and rules given with --allowedTools, are still sent).');
+}

package/dist/printToolResultFrame.js

@@ -2,20 +2,12 @@ import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
 import { parseModelFacingBash } from './toolResult.js';
+import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
 import { toolResultEnvelopeParts, toolResultOutcomeOf } from './adapt/toolCards.js';
 function bashExitCodeFailed(toolName, text, structured) {
     if (typeof toolName !== 'string' || toolName.toLowerCase() !== 'bash')
         return false;
-    const st = structured;
-    if (typeof st?.returnCodeInterpretation === 'string' && st.returnCodeInterpretation.length > 0)
-        return false;
-    const ec = st?.exitCode;
-    if (typeof ec === 'number')
-        return ec !== 0;
-    if (parseModelFacingBash(text)?.note !== undefined)
-        return false;
-    const m = /^exit code: (\d+)\b/.exec(text);
-    return m !== null && m[1] !== '0';
+    return bashExitReadingFailed(bashExitOf(structured, () => parseModelFacingBash(text)));
 }
 export function toolEndResultToUserFrame(arm) {
     if (typeof arm.toolCallId !== 'string' || arm.toolCallId.length === 0)

package/dist/promptDelivery.js

@@ -132,14 +132,6 @@ export function frameProvesDelivery(event) {
         const type = event.type;
         if (typeof type !== 'string' || type.length === 0 || PRE_RUN_FRAME_TYPES.has(type))
             return false;
-        if (type === 'done') {
-            const result = event.result;
-            if (typeof result === 'object' && result !== null && !Array.isArray(result) && result.status === undefined) {
-                const r = result;
-                if (activeRunBusySignal({ type: 'failed', errorCode: r.errorCode, activeTaskId: r.activeTaskId }) !== null)
-                    return false;
-            }
-        }
         return activeRunBusySignal(event) === null;
     }
     catch {

package/dist/resumeRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { RESUME_CONTEXT_UNAVAILABLE } from './engineErrorCodes.js';
+import { RESUME_CONTEXT_UNAVAILABLE, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED } from './engineErrorCodes.js';
 export declare const RESUME_REFUSAL_CODES: readonly string[];
 export interface ResumeRefusalDetail {
     code: string;
@@ -50,6 +50,8 @@ export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDe
 export interface CheckpointUnsupportedVersionDetail {
     code: 'checkpoint.unsupported_version';
     retriable: true;
+    writerVersion?: string;
+    readerVersion?: string;
 }
 export declare function checkpointUnsupportedVersionFromError(err: unknown): CheckpointUnsupportedVersionDetail | null;
 export type CheckpointUnsupportedParkKind = 'tool_approval' | 'plan_review' | 'resource_park' | 'wake' | 'workflow_host';
@@ -58,3 +60,18 @@ export interface CheckpointUnsupportedVersionContext {
     readonly runId?: string;
 }
 export declare function checkpointUnsupportedVersionContent(detail: CheckpointUnsupportedVersionDetail, ctx?: CheckpointUnsupportedVersionContext): string;
+export type RefusedParkCode = typeof CHECKPOINT_UNSUPPORTED_VERSION | typeof CHECKPOINT_WALLTIME_AXIS_RETIRED | typeof CHECKPOINT_CONFIG_REFUSED;
+export interface RefusedParkFacts {
+    readonly code: RefusedParkCode;
+    readonly field?: string;
+    readonly stillPending?: boolean;
+}
+export declare function refusedParkFromError(failure: unknown): RefusedParkFacts | null;
+export interface RefusedParkContentInput {
+    readonly what: string;
+    readonly facts: RefusedParkFacts;
+    readonly lane: 'interactive' | 'print';
+    readonly runId?: string;
+}
+export declare function refusedParkContent(input: RefusedParkContentInput): string;
+export declare function refusedParkBlockedContent(taskId: string, lane?: 'interactive' | 'print'): string;