@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/panelStateHolder.d.ts

@@ -1,16 +1,12 @@
-import type { EngineAgentPanelAbsence, EngineAgentPanelEvent } from './engineAgentPanelStore.js';
-import { type PanelDelta, type PanelFrame, type PanelReduceState } from './panelReduce.js';
+import { type PanelDelta, type PanelFact, 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 FactTap = (f: PanelFact) => void;
+export declare function __tapEnginePanelFactsForTests(fn: FactTap): () => void;
 type RowListener = (d: PanelDelta) => void;
 export declare function subscribeRows(fn: RowListener): () => void;
 export declare function clearEnginePanelRows(): void;

package/dist/panelStateHolder.js

@@ -1,4 +1,4 @@
-import { createPanelReduceState, isNewEngineAgentPanelCycle, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, stepPanelFrame, } from './panelReduce.js';
+import { createPanelReduceState, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, stepPanelFrame, } from './panelReduce.js';
 let state = createPanelReduceState();
 export function panelStateNow() {
     return state;
@@ -8,13 +8,14 @@ export function stepEnginePanel(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);
+    try {
+        if (factTap !== null)
+            for (const f of r.facts)
+                factTap(f);
+    }
+    finally {
+        drainRows();
     }
-    drainRows();
 }
 export function replaceEnginePanelState(fn) {
     state = fn(state);
@@ -27,135 +28,18 @@ export function clearEnginePanelAnchors() {
 }
 export function resetEnginePanelHolder() {
     state = createPanelReduceState();
-    listener = null;
-    buffer.length = 0;
-    absenceListener = null;
-    absenceBuffer.clear();
     rowListener = null;
     rowQueue.length = 0;
+    factTap = null;
 }
-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 {
-            }
-        }
-    }
+let factTap = null;
+export function __tapEnginePanelFactsForTests(fn) {
+    factTap = fn;
     return () => {
-        if (absenceListener === fn)
-            absenceListener = null;
+        if (factTap === fn)
+            factTap = null;
     };
 }
-export function resetAbsenceChannel() {
-    absenceListener = null;
-    absenceBuffer.clear();
-}
 let rowListener = null;
 const rowQueue = [];
 let rowDraining = false;

package/dist/peerLaneCapability.d.ts

@@ -10,10 +10,6 @@ export type PeerLaneReading = {
     kind: 'present';
 };
 export declare function projectPeerLaneCapability(caps: unknown): PeerLaneReading | undefined;
-export declare function noteEngineCapsForPeerLane(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 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 __resetPeerLaneReadingsForTests(): void;

package/dist/peerLaneCapability.js

@@ -22,9 +22,6 @@ const reader = createEngineCapReader({
     name: 'peerLane',
     project: projectPeerLaneCapability,
 });
-export function noteEngineCapsForPeerLane(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedPeerLane(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -49,6 +46,3 @@ export function peerLaneDoctorDetail(reading) {
             return 'cross-session lane on — this engine can discover and deliver across sessions for the same caller';
     }
 }
-export function __resetPeerLaneReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/permissionRulesWriteCapability.d.ts

@@ -10,10 +10,6 @@ export type PermissionRulesWriteReading = {
     kind: 'present';
 };
 export declare function projectPermissionRulesWriteCapability(caps: unknown): PermissionRulesWriteReading | undefined;
-export declare function noteEngineCapsForPermissionRulesWrite(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 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 __resetPermissionRulesWriteReadingsForTests(): void;

package/dist/permissionRulesWriteCapability.js

@@ -22,9 +22,6 @@ const reader = createEngineCapReader({
     name: 'permissionRulesWrite',
     project: projectPermissionRulesWriteCapability,
 });
-export function noteEngineCapsForPermissionRulesWrite(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedPermissionRulesWrite(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -45,6 +42,3 @@ 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 __resetPermissionRulesWriteReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/permissionWireCaps.d.ts

@@ -1,6 +1,6 @@
-import { type TaskRequestPermissionMode } from './taskRequestWords.js';
+import type { PermissionMode } from '@sema-agent/sdk';
 import { type PermissionModesReading } from './permissionModesCapability.js';
-export type PermissionMode = TaskRequestPermissionMode;
+export type { PermissionMode };
 export interface PermissionModeField {
     permissionMode?: PermissionMode;
 }

package/dist/permissionWireCaps.js

@@ -1,5 +1,7 @@
 import { PERMISSION_MODE_WORDS } from './taskRequestWords.js';
 import { permissionModeAdmitted } from './permissionModesCapability.js';
+const _permissionModePin = true;
+void _permissionModePin;
 const BIT_GATED_MODE = 'dontAsk';
 const KNOWN = new Set(PERMISSION_MODE_WORDS.filter((w) => w !== BIT_GATED_MODE));
 export function permissionModeField(mode, opts) {

package/dist/permissionsAllowGrantCapability.d.ts

@@ -10,12 +10,8 @@ export type PermissionsAllowGrantReading = {
     layer?: boolean;
 };
 export declare function projectPermissionsAllowGrantCapability(caps: unknown): PermissionsAllowGrantReading | undefined;
-export declare function noteEngineCapsForPermissionsAllowGrant(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedPermissionsAllowGrant(baseUrl?: string | undefined): PermissionsAllowGrantReading;
 export declare function permissionsAllowGrantAvailable(reading: PermissionsAllowGrantReading): boolean;
 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 __resetPermissionsAllowGrantReadingsForTests(): void;

package/dist/permissionsAllowGrantCapability.js

@@ -36,9 +36,6 @@ const reader = createEngineCapReader({
     name: ALLOW_GRANT_CAP_PATH.join('.'),
     project: projectPermissionsAllowGrantCapability,
 });
-export function noteEngineCapsForPermissionsAllowGrant(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedPermissionsAllowGrant(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -102,6 +99,3 @@ 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 __resetPermissionsAllowGrantReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/permissionsDeclaration.d.ts

@@ -38,20 +38,9 @@ export interface PermissionsRewrittenRule {
     to: string;
     bucket: 'deny' | 'ask' | 'allow';
 }
-export interface PermissionsUncheckedRule {
-    rule: string;
-    bucket: 'deny' | 'ask';
-}
-export interface PermissionsUnreachableRule {
-    rule: string;
-    bucket: 'deny' | 'ask';
-    mintedPrefix?: string;
-}
 export interface PermissionsDeclarationReport extends PermissionsDeclaration {
     kept: PermissionsKeptRule[];
     rewritten: PermissionsRewrittenRule[];
-    unchecked: PermissionsUncheckedRule[];
-    unreachable: PermissionsUnreachableRule[];
     clientOwned?: PermissionsClientOwnedStatement[];
 }
 export interface PermissionsClientOwnedStatement {

package/dist/permissionsDeclaration.js

@@ -1,8 +1,8 @@
 import { compileAllowList, hasCoreValuePort, protocolOf, ruleToolGrammarOf } from './coreValuePorts.js';
-import { clientOwnedServerPrefix, mintedPrefixOf, ruleToolNameVerdictOf } from './protocolSegment.js';
+import { clientOwnedServerPrefix, ruleToolNameVerdictOf } from './protocolSegment.js';
 import { ruleCompileVerdict } from './ruleCompileVerdict.js';
 import { allowRulesGate, allowWireForm } from './permissionsAllowGrantCapability.js';
-import { THROWN_SLOT_UNREADABLE, readThrownSlot } from './wireFailureShape.js';
+import { THROWN_SLOT_UNREADABLE, asAssemblyRefusal, readThrownSlot, withAssemblyRefusal } from './wireFailureShape.js';
 export const WIRE_RULE_TRUST_ORDER = Object.freeze([
     'policySettings',
     'cliArg',
@@ -65,16 +65,16 @@ function requireRulePorts() {
     const missing = required.filter((p) => !hasCoreValuePort(p));
     if (missing.length === 0)
         return;
-    throw new Error(`permissionsDeclaration: 规则判据端口缺席(${missing.join(' / ')})—— 先用 installCoreValuePorts 装上 core 的同名实现。` +
-        '缺席不等于全部合格:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。');
+    throw withAssemblyRefusal(new Error(`permissionsDeclaration: 规则判据端口缺席(${missing.join(' / ')})—— 先用 installCoreValuePorts 装上 core 的同名实现。` +
+        '缺席不等于全部合格:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。'), 'ports_missing');
 }
 function nameCheck(name) {
     if (name.includes('('))
         return { issue: 'paren_in_tool_name' };
     const verdict = ruleToolNameVerdictOf(name);
     if (verdict.kind === 'unknown') {
-        throw new Error('permissionsDeclaration: 规则工具名判官(judgeRuleToolName)答不上来(抛 / 回的不是 current · retired · unprefixed_namespace · unmintable_segment 之一)—— ' +
-            '装的必须是 core 的同名实现、原样装。判不出不等于够得着:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。');
+        throw withAssemblyRefusal(new Error('permissionsDeclaration: 规则工具名判官(judgeRuleToolName)答不上来(抛 / 回的不是 current · retired · unprefixed_namespace · unmintable_segment 之一)—— ' +
+            '装的必须是 core 的同名实现、原样装。判不出不等于够得着:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。'), 'judge_unanswerable');
     }
     if (verdict.kind === 'retired')
         return { retired: verdict.currentName !== undefined ? { currentName: verdict.currentName } : {} };
@@ -83,10 +83,8 @@ function nameCheck(name) {
     const ns = protocolOf(name);
     if (ns !== undefined && ns.parse(name) === undefined)
         return { issue: 'incomplete_protocol_name' };
-    if (verdict.kind === 'unmintable_segment') {
-        const minted = mintedPrefixOf(name);
-        return { unminted: minted !== undefined ? { minted } : {} };
-    }
+    if (verdict.kind === 'unmintable_segment')
+        return { unminted: true };
     return { ok: true };
 }
 function wholeServerRuleName(name) {
@@ -107,8 +105,14 @@ function compileRefused(verdict) {
         ...(verdict.message !== undefined ? { message: verdict.message } : {}),
     };
 }
-function sentFate(wire, check, unchecked) {
-    return 'unminted' in check ? { sent: true, wire, unchecked, unreachable: check.unminted } : { sent: true, wire, unchecked };
+function tighteningWholeName(name, check) {
+    if (!('retired' in check))
+        return name;
+    const successor = check.retired.currentName;
+    if (successor === undefined)
+        return name;
+    const next = nameCheck(successor);
+    return 'retired' in next || 'issue' in next ? name : successor;
 }
 function judgeList(rules, behavior, allowForm = 'grant') {
     let portsChecked = false;
@@ -121,46 +125,37 @@ function judgeList(rules, behavior, allowForm = 'grant') {
         }
         const parsed = parseRule(rule);
         if (parsed.ruleContent === undefined) {
-            let name = wholeServerRuleName(parsed.toolName);
-            let check = nameCheck(name);
-            if ('retired' in check) {
-                const successor = check.retired.currentName;
-                if (behavior === 'allow' || successor === undefined)
-                    return kept('retired_tool_name');
-                name = successor;
-                check = nameCheck(name);
-                if ('retired' in check)
-                    return kept('retired_tool_name');
-            }
+            const name = wholeServerRuleName(parsed.toolName);
+            const check = nameCheck(name);
+            if (behavior !== 'allow')
+                return { sent: true, wire: tighteningWholeName(name, check) };
+            if ('retired' in check)
+                return kept('retired_tool_name');
             if ('issue' in check)
                 return kept(check.issue);
-            if (behavior === 'allow' && 'unminted' in check)
+            if ('unminted' in check)
                 return kept('unminted_protocol_segment');
-            const verdict = compileVerdict(name, behavior === 'ask' ? 'ask' : 'deny');
+            const verdict = compileVerdict(name, 'deny');
             if (verdict.kind === 'refused')
                 return compileRefused(verdict);
-            if (verdict.kind === 'unknown' && behavior === 'allow')
+            if (verdict.kind === 'unknown')
                 return kept('judge_failed');
-            return behavior === 'allow' ? { sent: true, wire: name, unchecked: false } : sentFate(name, check, verdict.kind === 'unknown');
+            return { sent: true, wire: name };
         }
         const check = nameCheck(parsed.toolName);
+        if (behavior !== 'allow')
+            return { sent: true, wire: rule };
         if ('retired' in check)
             return kept('retired_tool_name');
         if ('issue' in check)
             return kept(check.issue);
         if (ruleToolGrammarOf(parsed.toolName) === 'path' && parsed.ruleContent.startsWith('~/'))
             return kept('home_relative_path');
-        if (behavior === 'allow') {
-            if (allowForm !== 'layer')
-                return kept('content_form_not_grantable');
-            if ('unminted' in check)
-                return kept('unminted_protocol_segment');
-            return { sent: true, wire: rule, unchecked: false };
-        }
-        const verdict = compileVerdict(rule, behavior);
-        if (verdict.kind === 'refused')
-            return compileRefused(verdict);
-        return sentFate(rule, check, verdict.kind === 'unknown');
+        if (allowForm !== 'layer')
+            return kept('content_form_not_grantable');
+        if ('unminted' in check)
+            return kept('unminted_protocol_segment');
+        return { sent: true, wire: rule };
     });
 }
 function outsideSettingsFiles(origin) {
@@ -269,24 +264,25 @@ function clientOwnedFate(server) {
     return judgeList([`${prefix}*`], 'allow')[0];
 }
 const WHO = 'permissionsDeclaration';
+const malformed = (sentence) => withAssemblyRefusal(new TypeError(sentence), 'input_malformed');
 function ownField(obj, key, where) {
     if (Object.hasOwn(obj, key))
         return obj[key];
     if (key in obj)
-        throw new TypeError(`${WHO}: ${where}${key} 只在原型链上,不是自有字段 —— 拒绝读取(请交普通对象)。`);
+        throw malformed(`${WHO}: ${where}${key} 只在原型链上,不是自有字段 —— 拒绝读取(请交普通对象)。`);
     return undefined;
 }
 function ruleList(v, key) {
     if (v === undefined || v === null)
         return undefined;
     if (!Array.isArray(v))
-        throw new TypeError(`${WHO}: ${key} 必须是规则串数组或缺席 —— 收到 typeof=${typeof v}。`);
+        throw malformed(`${WHO}: ${key} 必须是规则串数组或缺席 —— 收到 typeof=${typeof v}。`);
     const out = [];
     const n = v.length;
     for (let i = 0; i < n; i++) {
         if (!Object.hasOwn(v, i)) {
             if (i in v)
-                throw new TypeError(`${WHO}: ${key}[${i}] 是空洞,而原型链上在这个下标有值 —— 拒绝读取(请交不带空洞的普通数组)。`);
+                throw malformed(`${WHO}: ${key}[${i}] 是空洞,而原型链上在这个下标有值 —— 拒绝读取(请交不带空洞的普通数组)。`);
             continue;
         }
         const r = v[i];
@@ -302,7 +298,7 @@ function originMap(v, key) {
         typeof v.get === 'function' &&
         typeof v[Symbol.iterator] === 'function';
     if (!ok)
-        throw new TypeError(`${WHO}: origins.${key} 必须是 Map(规则原串 → 来源)或缺席 —— 收到 typeof=${typeof v}。`);
+        throw malformed(`${WHO}: origins.${key} 必须是 Map(规则原串 → 来源)或缺席 —— 收到 typeof=${typeof v}。`);
     const snap = new Map();
     for (const entry of v) {
         const [r, origin] = entry;
@@ -313,8 +309,23 @@ function originMap(v, key) {
 }
 const slotsOf = (list, name) => (list ?? []).map((rule, at) => ({ rule, list: name, at }));
 function assemble(input, caps) {
+    let read;
+    try {
+        read = readAssemblyInput(input, caps);
+    }
+    catch (e) {
+        throw asAssemblyRefusal(e, 'input_malformed', WHO);
+    }
+    try {
+        return judgeAssembly(read, caps);
+    }
+    catch (e) {
+        throw asAssemblyRefusal(e, 'judge_unanswerable', WHO);
+    }
+}
+function readAssemblyInput(input, caps) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        throw new TypeError(`${WHO}: 入参必须是对象 —— 收到 ${input === null ? 'null' : Array.isArray(input) ? 'array' : `typeof=${typeof input}`}。`);
+        throw malformed(`${WHO}: 入参必须是对象 —— 收到 ${input === null ? 'null' : Array.isArray(input) ? 'array' : `typeof=${typeof input}`}。`);
     }
     const deny = ruleList(ownField(input, 'deny', ''), 'deny');
     const ask = ruleList(ownField(input, 'ask', ''), 'ask');
@@ -325,7 +336,7 @@ function assemble(input, caps) {
     let origins = {};
     if (originsRaw !== undefined && originsRaw !== null) {
         if (typeof originsRaw !== 'object' || Array.isArray(originsRaw)) {
-            throw new TypeError(`${WHO}: origins 必须是 { deny?, ask?, allow? } 对象或缺席 —— 收到 typeof=${typeof originsRaw}。`);
+            throw malformed(`${WHO}: origins 必须是 { deny?, ask?, allow? } 对象或缺席 —— 收到 typeof=${typeof originsRaw}。`);
         }
         const od = originMap(ownField(originsRaw, 'deny', 'origins.'), 'deny');
         const oa = originMap(ownField(originsRaw, 'ask', 'origins.'), 'ask');
@@ -333,6 +344,10 @@ function assemble(input, caps) {
         origins = { ...(od ? { deny: od } : {}), ...(oa ? { ask: oa } : {}), ...(ol ? { allow: ol } : {}) };
     }
     const gate = allowRulesGate(caps, ownField(input, 'settingsRead', ''));
+    return { deny, ask, allow, cliDeny, ownedServers, origins, gate };
+}
+function judgeAssembly(read, caps) {
+    const { deny, ask, allow, cliDeny, ownedServers, origins, gate } = read;
     const cliSlots = slotsOf(cliDeny, 'cliDeny');
     const cli = cliDeny === undefined ? undefined : { slots: cliSlots, fates: judgeList(cliDeny, 'deny') };
     const denySlots = slotsOf(deny, 'deny');
@@ -361,8 +376,6 @@ function assemble(input, caps) {
         buckets.allow = [...allowJ.sent];
     const keptRows = [];
     const rewritten = [];
-    const unchecked = [];
-    const unreachable = [];
     const rows = [
         ['deny', [...denySlots, ...cliSlots], denyJ],
         ['ask', askSlots, askJ],
@@ -392,15 +405,9 @@ function assemble(input, caps) {
                 continue;
             if (winner.rule !== wire)
                 rewritten.push({ from: winner.rule, to: wire, bucket });
-            const f = (winner.list === 'cliDeny' ? j.fates[denySlots.length + winner.at] : j.fates[winner.at]);
-            if (f.sent && f.unchecked && bucket !== 'allow')
-                unchecked.push({ rule: wire, bucket });
-            if (f.sent && f.unreachable !== undefined && bucket !== 'allow') {
-                unreachable.push({ rule: wire, bucket, ...(f.unreachable.minted !== undefined ? { mintedPrefix: f.unreachable.minted } : {}) });
-            }
         }
     }
-    return { buckets, report: { kept: keptRows, rewritten, unchecked, unreachable, ...(clientOwned.length > 0 ? { clientOwned } : {}) } };
+    return { buckets, report: { kept: keptRows, rewritten, ...(clientOwned.length > 0 ? { clientOwned } : {}) } };
 }
 export function permissionsDeclaration(input, caps) {
     const { buckets } = assemble(input, caps);

package/dist/pluginHooksWire.d.ts

@@ -110,7 +110,7 @@ export interface PluginHookDecision {
     readonly unreadable: number;
 }
 export declare function decidePluginHooks(input: PluginHookDecisionInput): PluginHookDecision;
-export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, failLoudMcpTool: boolean, judge?: SettingsHookJudge): SettingsHookFilterResult;
+export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge): SettingsHookFilterResult;
 export interface SettingsHookFilterResult {
     readonly groups: WireHookGroup[];
     readonly drops: SettingsHookDrop[];

package/dist/pluginHooksWire.js

@@ -312,14 +312,13 @@ function carriesArgs(entry) {
     }
     return true;
 }
-export function filterSettingsHookGroups(source, event, groups, execFormCapable, shellRunsType, failLoudMcpTool, judge) {
+export function filterSettingsHookGroups(source, event, groups, execFormCapable, shellRunsType, judge) {
     const drops = [];
     const verdicts = [];
     const excluded = [];
     const out = [];
     let stripped = 0;
     const engineEvent = ENGINE_EVENTS.has(event);
-    const keepMcpTool = failLoudMcpTool && engineEvent;
     groups.forEach((group, groupIndex) => {
         if (!isRecord(group) || !Array.isArray(group.hooks)) {
             out.push(group);
@@ -331,9 +330,7 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
             const reason = !isRecord(entry)
                 ? undefined
                 : entry.type === 'mcp_tool'
-                    ? keepMcpTool
-                        ? undefined
-                        : 'mcp_tool_unsupported'
+                    ? 'mcp_tool_unsupported'
                     : entry.type === 'command' && carriesArgs(entry) && !execFormCapable
                         ? 'exec_form_unsupported'
                         : undefined;
@@ -342,7 +339,7 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
                 changed = true;
                 return;
             }
-            if (judge !== undefined && engineEvent && isRecord(entry) && judgeableSettingsEntry(entry)) {
+            if (engineEvent && isRecord(entry) && judgeableSettingsEntry(entry)) {
                 const ex = judge(event, group, entry);
                 if (ex.kind === 'excluded') {
                     excluded.push({ source, event, groupIndex, hookIndex, reason: ex.reason });

package/dist/preemptWire.d.ts

@@ -0,0 +1,44 @@
+import type { AssistantTaskStatus, CancelAck } from '@sema-agent/sdk';
+import { type SdkRunTerminalStatus } from './terminalStatuses.js';
+export type PreemptParkedStatus = 'suspended' | 'needs_review';
+export type PreemptOutcome = {
+    readonly kind: 'yield-requested';
+    readonly taskId: string;
+} | {
+    readonly kind: 'not-eligible';
+    readonly taskId: string;
+} | {
+    readonly kind: 'already-ended';
+    readonly taskId: string;
+    readonly status: SdkRunTerminalStatus;
+} | {
+    readonly kind: 'already-parked';
+    readonly status?: PreemptParkedStatus;
+} | {
+    readonly kind: 'approval-settled';
+} | {
+    readonly kind: 'not-found';
+} | {
+    readonly kind: 'unconfirmed';
+    readonly why: 'transport' | 'server-error' | 'unreadable-answer';
+    readonly status?: number;
+} | {
+    readonly kind: 'refused';
+    readonly status: number;
+    readonly errorCode?: string;
+} | {
+    readonly kind: 'no-run';
+} | {
+    readonly kind: 'cancelled-instead';
+    readonly ack: CancelAck;
+} | {
+    readonly kind: 'unavailable';
+};
+export type PreemptReading = Exclude<PreemptOutcome, {
+    readonly kind: 'no-run' | 'cancelled-instead' | 'unavailable';
+}> | {
+    readonly kind: 'lane-absent';
+};
+export declare function preemptReadingOfAck(taskId: string, ack: AssistantTaskStatus): PreemptReading;
+export declare function preemptReadingOfError(e: {} | null | undefined): PreemptReading;
+export declare function preemptReceiptLine(outcome: PreemptOutcome): string;