@sema-agent/client-core 0.94.0 → 0.96.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/peerFrames.js

@@ -1,4 +1,4 @@
-import { applyDisplayFace, LEGACY_NAME_FACE } from './displayUntrusted.js';
+import { applyDisplayFace, PEER_NAME_FACE } from './displayUntrusted.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS, CORE_PERMISSION_MODE_CLASSES } from './generated/engineFactTables.js';
 const WIRE_KEY_FROM = 'from';
 const WIRE_KEY_BODY = 'body';
@@ -42,14 +42,16 @@ function nonEmptyString(v) {
 function finiteNumber(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
 }
-function provenanceAgrees(n, lane, carrierFrom) {
+function provenanceAgrees(n, lane, carrierFromRaw) {
     const prov = dataProp(n, WIRE_KEY_PROVENANCE);
     if (prov === null || typeof prov !== 'object')
         return false;
     if (dataProp(prov, WIRE_KEY_KIND) !== lane)
         return false;
-    const provFrom = cleanName(dataProp(prov, WIRE_KEY_FROM));
-    if (provFrom === undefined || (carrierFrom !== undefined && provFrom !== carrierFrom))
+    const provFromRaw = dataProp(prov, WIRE_KEY_FROM);
+    if (typeof provFromRaw !== 'string' || cleanName(provFromRaw) === undefined)
+        return false;
+    if (carrierFromRaw !== undefined && provFromRaw !== carrierFromRaw)
         return false;
     const taskId = nonEmptyString(dataProp(n, WIRE_KEY_TASK_ID));
     if (taskId === undefined || nonEmptyString(dataProp(prov, WIRE_KEY_PROV_TASK_ID)) !== taskId)
@@ -61,9 +63,10 @@ export function classifyPeerNotification(n) {
     const seq = finiteNumber(dataProp(n, WIRE_KEY_SEQ));
     const agentMessage = dataProp(n, WIRE_KEY_AGENT_MESSAGE);
     if (agentMessage !== undefined) {
-        const from = cleanName(dataProp(agentMessage, WIRE_KEY_FROM));
+        const fromRaw = dataProp(agentMessage, WIRE_KEY_FROM);
+        const from = cleanName(fromRaw);
         const body = dataProp(agentMessage, WIRE_KEY_BODY);
-        if (from !== undefined && typeof body === 'string' && provenanceAgrees(n, 'agent_message', from)) {
+        if (from !== undefined && typeof fromRaw === 'string' && typeof body === 'string' && provenanceAgrees(n, 'agent_message', fromRaw)) {
             const agentType = nonEmptyString(dataProp(dataProp(n, WIRE_KEY_PROVENANCE), WIRE_KEY_AGENT_TYPE));
             return {
                 lane: 'agent_message',
@@ -77,9 +80,10 @@ export function classifyPeerNotification(n) {
     }
     const crossSessionMessage = dataProp(n, WIRE_KEY_CROSS_SESSION_MESSAGE);
     if (crossSessionMessage !== undefined) {
-        const from = cleanName(dataProp(crossSessionMessage, WIRE_KEY_FROM));
+        const fromRaw = dataProp(crossSessionMessage, WIRE_KEY_FROM);
+        const from = cleanName(fromRaw);
         const body = dataProp(crossSessionMessage, WIRE_KEY_BODY);
-        if (from === undefined || typeof body !== 'string' || !provenanceAgrees(n, 'cross_session_message', from))
+        if (from === undefined || typeof fromRaw !== 'string' || typeof body !== 'string' || !provenanceAgrees(n, 'cross_session_message', fromRaw))
             return null;
         const fromSession = nonEmptyString(dataProp(crossSessionMessage, WIRE_KEY_FROM_SESSION));
         const fromName = cleanName(dataProp(crossSessionMessage, WIRE_KEY_FROM_NAME));
@@ -117,7 +121,7 @@ function neutralizeAuthorityTags(text) {
 function cleanName(v) {
     if (typeof v !== 'string')
         return undefined;
-    const t = applyDisplayFace(v, LEGACY_NAME_FACE);
+    const t = applyDisplayFace(v, PEER_NAME_FACE);
     return t.length > 0 ? t : undefined;
 }
 function escapeEnvelopeTag(tag, text) {

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

@@ -7,10 +7,5 @@ export type PermissionModesReading = {
     modes: readonly string[];
 };
 export declare function projectPermissionModesCapability(caps: unknown): PermissionModesReading | undefined;
-export declare function noteEngineCapsForPermissionModes(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): 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);
@@ -42,9 +40,6 @@ const reader = createEngineCapReader({
     project: projectPermissionModesCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForPermissionModes(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedPermissionModes(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -63,9 +58,3 @@ export function permissionModeAdmitted(reading, mode) {
         return false;
     }
 }
-export function forgetPermissionModesReading(baseUrl) {
-    reader.forget(baseUrl);
-}
-export function __resetPermissionModesReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/permissionRuleIssue.js

@@ -34,9 +34,6 @@ const ISSUE_SENTENCES = Object.freeze({
     'unsupported.path_base': 'this path rule is not supported as spelled: the base it is relative to is missing or is not a usable absolute path, so it would reach nothing and is refused rather than compiled',
     'unsupported.mcp_paren': 'a parenthesised parameter rule is not supported on an MCP tool name',
     'unsupported.covering_paren': 'a parenthesised parameter rule is not supported on a covering protocol name — the parameter grammar is keyed by an exact tool name, so no mounted tool could ever bear it',
-    'invalid.allow_param_rule': 'this rule is invalid: an allow rule cannot carry a parameter pattern — only bare tool rules auto-allow',
-    'unsupported.bash_prefix': 'a standing approval for a command belongs in the persisted-rule store, so this allow rule is not supported here (deny and ask rules with the same shape do compile)',
-    'unsupported.file_glob': 'a standing approval by path belongs in the consent store, so this allow rule is not supported here (deny and ask path rules do compile)',
 });
 const PARAM_SPLIT_WITH_COLON = 'this rule is invalid: a parameter rule is written name:pattern, and the name before the colon or the pattern after it is empty';
 const PARAM_SPLIT_NO_COLON = 'this rule is invalid: there is no colon inside the parentheses, so this is not a parameter rule (a parameter rule is written name:pattern)';

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

@@ -30,6 +30,8 @@ export interface PermissionsKeptRule {
     rule: string;
     bucket: 'deny' | 'ask' | 'allow';
     reason: PermissionsKeptReason;
+    code?: string;
+    message?: string;
 }
 export interface PermissionsRewrittenRule {
     from: string;
@@ -60,4 +62,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 {};