@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/peerFrames.d.ts

@@ -28,7 +28,7 @@ export type CrossSessionNoticeFrame = {
     text: string;
 };
 export type PeerFrameProjection = AgentMessageFrame | CrossSessionMessageFrame | CrossSessionNoticeFrame;
-export declare function classifyPeerNotification(n: Record<string, unknown>): PeerFrameProjection | null;
+export declare function classifyPeerNotification(raw: Record<string, unknown>): PeerFrameProjection | null;
 export declare function renderPeerFrameTranscriptText(p: PeerFrameProjection): string;
 export declare function parsePeerFrameText(text: string): AgentMessageFrame | CrossSessionMessageFrame | null;
 export declare function peerFrameDisplayName(p: AgentMessageFrame | CrossSessionMessageFrame): string;

package/dist/peerFrames.js

@@ -1,4 +1,5 @@
 import { applyDisplayFace, PEER_NAME_FACE } from './displayUntrusted.js';
+import { ownSnapshotRecord } from './ownKey.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';
@@ -32,7 +33,7 @@ function dataProp(o, key) {
     catch {
         return undefined;
     }
-    if (d === undefined || !('value' in d))
+    if (d === undefined || !Object.hasOwn(d, 'value'))
         return undefined;
     return d.value;
 }
@@ -59,7 +60,10 @@ function provenanceAgrees(n, lane, carrierFromRaw) {
     const seq = finiteNumber(dataProp(n, WIRE_KEY_SEQ));
     return seq !== undefined && finiteNumber(dataProp(prov, WIRE_KEY_SEQ)) === seq;
 }
-export function classifyPeerNotification(n) {
+export function classifyPeerNotification(raw) {
+    const n = ownSnapshotRecord(raw);
+    if (n === undefined)
+        return null;
     const seq = finiteNumber(dataProp(n, WIRE_KEY_SEQ));
     const agentMessage = dataProp(n, WIRE_KEY_AGENT_MESSAGE);
     if (agentMessage !== undefined) {

package/dist/peerLaneCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectPeerLaneCapability(caps) {
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'peerLane',
     project: projectPeerLaneCapability,
 });
-export function observedPeerLane(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedPeerLane(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function peerLaneAvailable(reading) {

package/dist/permissionModesCapability.js

@@ -1,6 +1,6 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { ownDataField, readOwnDataValue } from './ownKey.js';
+import { appendOwnElement, ownDataField, readOwnDataValue } from './ownKey.js';
 function readModesStrict(v) {
     try {
         if (!Array.isArray(v))
@@ -13,7 +13,7 @@ function readModesStrict(v) {
             const item = ownDataField(v, String(i));
             if (typeof item !== 'string' || item.length === 0)
                 return undefined;
-            modes.push(item);
+            appendOwnElement(modes, item);
         }
         return modes;
     }
@@ -39,7 +39,7 @@ const reader = createEngineCapReader({
     name: 'permissionModes',
     project: projectPermissionModesCapability,
 });
-export function observedPermissionModes(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedPermissionModes(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function permissionModeAdmitted(reading, mode) {

package/dist/permissionRuleIssue.js

@@ -14,6 +14,7 @@ export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
     'unsupported.param_unknown',
     'unsupported.param_non_scalar',
     'unsupported.tool_unknown',
+    'invalid.name_ambiguous',
     'unsupported.path_base',
     'unsupported.mcp_paren',
     'unsupported.covering_paren',
@@ -30,6 +31,7 @@ const ISSUE_SENTENCES = Object.freeze({
     'invalid.behavior': 'rules.issue.behavior',
     'invalid.command_rule': 'rules.issue.commandRule',
     'invalid.entry_type': 'rules.issue.entryType',
+    'invalid.name_ambiguous': 'rules.issue.nameAmbiguous',
     'unsupported.allow': 'rules.issue.allowRule',
     'unsupported.param_unknown': 'rules.issue.paramUnknown',
     'unsupported.param_non_scalar': 'rules.issue.paramNonScalar',

package/dist/permissionRulesWriteCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
@@ -23,7 +23,7 @@ const reader = createEngineCapReader({
     name: 'permissionRulesWrite',
     project: projectPermissionRulesWriteCapability,
 });
-export function observedPermissionRulesWrite(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedPermissionRulesWrite(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function permissionRulesWriteAvailable(reading) {

package/dist/permissionsAllowGrantCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 import { hasCoreValuePort } from './coreValuePorts.js';
@@ -36,7 +36,7 @@ const reader = createEngineCapReader({
     name: ALLOW_GRANT_CAP_PATH.join('.'),
     project: projectPermissionsAllowGrantCapability,
 });
-export function observedPermissionsAllowGrant(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedPermissionsAllowGrant(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function permissionsAllowGrantAvailable(reading) {

package/dist/permissionsDeclaration.d.ts

@@ -1,7 +1,21 @@
+import { type CoreValuePortName } from './coreValuePorts.js';
 import { type PermissionsAllowGrantReading } from './permissionsAllowGrantCapability.js';
-export declare const WIRE_RULE_TRUST_ORDER: readonly ["policySettings", "cliArg", "flagSettings", "session", "userSettings", "localSettings", "projectSettings"];
-declare const RULE_TRUST_ORDER: readonly ["policySettings", "cliArg", "flagSettings", "session", "userSettings", "localSettings", "projectSettings"];
-export type WireRuleOrigin = (typeof RULE_TRUST_ORDER)[number];
+declare const SETTINGS_SOURCE_TIERS: Readonly<{
+    readonly policySettings: "managed";
+    readonly flagSettings: "global";
+    readonly userSettings: "global";
+    readonly localSettings: "project";
+    readonly projectSettings: "project";
+}>;
+declare const OFF_LADDER_ROWS: readonly [{
+    readonly origin: "cliArg";
+    readonly after: "policySettings";
+}, {
+    readonly origin: "session";
+    readonly after: "flagSettings";
+}];
+export type WireRuleOrigin = keyof typeof SETTINGS_SOURCE_TIERS | (typeof OFF_LADDER_ROWS)[number]['origin'];
+export declare const WIRE_RULE_TRUST_ORDER: readonly WireRuleOrigin[];
 export interface WireRuleOrigins {
     readonly deny?: ReadonlyMap<string, WireRuleOrigin>;
     readonly ask?: ReadonlyMap<string, WireRuleOrigin>;
@@ -15,6 +29,7 @@ export interface PermissionsDeclarationInput {
     readonly cliDeny?: readonly string[];
     readonly settingsRead: 'clean' | 'partial' | 'unreadable';
     readonly clientOwnedServers?: readonly string[];
+    readonly serverVersion?: string;
 }
 export interface PermissionsDeclarationBuckets {
     deny?: string[];
@@ -24,7 +39,7 @@ export interface PermissionsDeclarationBuckets {
 export interface PermissionsDeclaration {
     permissions?: PermissionsDeclarationBuckets;
 }
-export declare const PERMISSIONS_KEPT_REASONS: readonly ["allow_capability_off", "settings_read_not_clean", "empty_rule", "paren_in_tool_name", "retired_tool_name", "unprefixed_namespaced_name", "incomplete_protocol_name", "unminted_protocol_segment", "home_relative_path", "compile_refused", "content_form_not_grantable", "judge_failed", "duplicate", "voids_allow_list"];
+export declare const PERMISSIONS_KEPT_REASONS: readonly ["allow_capability_off", "settings_read_not_clean", "empty_rule", "paren_in_tool_name", "retired_tool_name", "unprefixed_namespaced_name", "incomplete_protocol_name", "unminted_protocol_segment", "home_relative_path", "compile_refused", "content_form_not_grantable", "content_form_never_matches", "judge_failed", "duplicate", "voids_allow_list"];
 export type PermissionsKeptReason = (typeof PERMISSIONS_KEPT_REASONS)[number];
 export interface PermissionsKeptRule {
     rule: string;
@@ -49,8 +64,32 @@ export interface PermissionsClientOwnedStatement {
     sent: boolean;
     reason?: PermissionsKeptReason;
 }
+export interface RulePortsProjection {
+    readonly kind: 'rule-ports-projection';
+}
+export declare function newRulePortsProjection(): RulePortsProjection;
+export declare function rulePortsMissingOf(thrown: {} | null | undefined, projection: RulePortsProjection): readonly CoreValuePortName[] | undefined;
+type RuleFate = {
+    readonly sent: true;
+    readonly wire: string;
+} | {
+    readonly sent: false;
+    readonly reason: PermissionsKeptReason;
+    readonly code?: string;
+    readonly message?: string;
+};
+export type AssembledRuleFate = RuleFate;
+export interface AssembledRuleRow {
+    readonly rule: string;
+    readonly list: 'deny' | 'cliDeny' | 'ask' | 'allow';
+    readonly bucket: 'deny' | 'ask' | 'allow';
+    readonly origin?: WireRuleOrigin;
+    readonly fate: AssembledRuleFate;
+}
 export declare function permissionsDeclaration(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): PermissionsDeclaration;
+export declare function projectPermissionsDeclaration(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading, projection: RulePortsProjection): PermissionsDeclaration;
 export declare function permissionsDeclarationReport(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): PermissionsDeclarationReport;
+export declare function assembledRuleRows(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): readonly AssembledRuleRow[];
 export interface PermissionsAllowKeptFacts {
     readonly problemCount?: number;
     readonly managedPolicyPending?: true;

package/dist/permissionsDeclaration.js

@@ -1,18 +1,40 @@
 import { compileAllowList, hasCoreValuePort, protocolOf, ruleToolGrammarOf } from './coreValuePorts.js';
 import { clientOwnedServerPrefix, ruleToolNameVerdictOf } from './protocolSegment.js';
-import { ruleCompileVerdict } from './ruleCompileVerdict.js';
+import { ruleCompileVerdict, tightenEntryNeverMatches } from './ruleCompileVerdict.js';
 import { allowRulesGate, allowWireForm } from './permissionsAllowGrantCapability.js';
-import { THROWN_SLOT_UNREADABLE, asAssemblyRefusal, readThrownSlot, withAssemblyRefusal } from './wireFailureShape.js';
-export const WIRE_RULE_TRUST_ORDER = Object.freeze([
-    'policySettings',
-    'cliArg',
-    'flagSettings',
-    'session',
-    'userSettings',
-    'localSettings',
-    'projectSettings',
+import { SETTINGS_IS_AT_LEAST } from './generated/settingsSchemaFns.js';
+import { THROWN_SLOT_UNREADABLE, asAssemblyRefusal, assemblyRefusalOf, isSlotCarrier, readThrownSlot, withAssemblyRefusal } from './wireFailureShape.js';
+import { appendOwnElement } from './ownKey.js';
+const SETTINGS_SOURCE_TIERS = Object.freeze({
+    policySettings: 'managed',
+    flagSettings: 'global',
+    userSettings: 'global',
+    localSettings: 'project',
+    projectSettings: 'project',
+});
+const SAME_TIER_ORDER = ['flagSettings', 'userSettings', 'localSettings', 'projectSettings'];
+const OFF_LADDER_ROWS = Object.freeze([
+    { origin: 'cliArg', after: 'policySettings' },
+    { origin: 'session', after: 'flagSettings' },
 ]);
-const RULE_TRUST_ORDER = WIRE_RULE_TRUST_ORDER;
+function deriveWireRuleTrustOrder() {
+    const sources = Object.keys(SETTINGS_SOURCE_TIERS).sort((a, b) => {
+        const ta = SETTINGS_SOURCE_TIERS[a];
+        const tb = SETTINGS_SOURCE_TIERS[b];
+        const aAtLeastB = SETTINGS_IS_AT_LEAST(ta, tb);
+        const bAtLeastA = SETTINGS_IS_AT_LEAST(tb, ta);
+        if (aAtLeastB && !bAtLeastA)
+            return -1;
+        if (bAtLeastA && !aAtLeastB)
+            return 1;
+        return SAME_TIER_ORDER.indexOf(a) - SAME_TIER_ORDER.indexOf(b);
+    });
+    const out = [...sources];
+    for (const row of OFF_LADDER_ROWS)
+        out.splice(out.indexOf(row.after) + 1, 0, row.origin);
+    return out;
+}
+export const WIRE_RULE_TRUST_ORDER = Object.freeze(deriveWireRuleTrustOrder());
 export const PERMISSIONS_KEPT_REASONS = Object.freeze([
     'allow_capability_off',
     'settings_read_not_clean',
@@ -25,6 +47,7 @@ export const PERMISSIONS_KEPT_REASONS = Object.freeze([
     'home_relative_path',
     'compile_refused',
     'content_form_not_grantable',
+    'content_form_never_matches',
     'judge_failed',
     'duplicate',
     'voids_allow_list',
@@ -62,11 +85,26 @@ function parseRule(rule) {
 }
 function requireRulePorts() {
     const required = ['MCP_NAMESPACE', 'judgeRuleToolName', 'protocolOf', 'ruleToolGrammarOf', 'validatePermissionRules'];
-    const missing = required.filter((p) => !hasCoreValuePort(p));
+    const missing = Object.freeze(required.filter((p) => !hasCoreValuePort(p)));
     if (missing.length === 0)
         return;
-    throw withAssemblyRefusal(new Error(`permissionsDeclaration: 规则判据端口缺席(${missing.join(' / ')})—— 先用 installCoreValuePorts 装上 core 的同名实现。` +
+    const refused = withAssemblyRefusal(new Error(`permissionsDeclaration: 规则判据端口缺席(${missing.join(' / ')})—— 先用 installCoreValuePorts 装上 core 的同名实现。` +
         '缺席不等于全部合格:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。'), 'ports_missing');
+    RULE_PORTS_MISSING.set(refused, Object.freeze({ ports: missing, projection: activeRulePortsProjection }));
+    throw refused;
+}
+export function newRulePortsProjection() {
+    return Object.freeze({ kind: 'rule-ports-projection' });
+}
+const RULE_PORTS_MISSING = new WeakMap();
+let activeRulePortsProjection;
+export function rulePortsMissingOf(thrown, projection) {
+    if (!isSlotCarrier(thrown))
+        return undefined;
+    const r = RULE_PORTS_MISSING.get(thrown);
+    if (r === undefined || r.projection !== projection)
+        return undefined;
+    return assemblyRefusalOf(thrown)?.cause === 'ports_missing' ? r.ports : undefined;
 }
 function nameCheck(name) {
     if (name.includes('('))
@@ -87,12 +125,14 @@ function nameCheck(name) {
         return { unminted: true };
     return { ok: true };
 }
-function wholeServerRuleName(name) {
+function wholeServerRuleName(name, keepWildcardPeer) {
     const read = name.trim();
     const ns = protocolOf(read);
     if (ns === undefined || !read.startsWith(ns.prefix))
         return name;
     const peer = read.slice(ns.prefix.length);
+    if (keepWildcardPeer && peer === '*')
+        return name;
     return peer !== '' && !peer.includes('__') && !peer.endsWith('_') ? `${read}__*` : name;
 }
 const compileVerdict = ruleCompileVerdict;
@@ -114,7 +154,7 @@ function tighteningWholeName(name, check) {
     const next = nameCheck(successor);
     return 'retired' in next || 'issue' in next ? name : successor;
 }
-function judgeList(rules, behavior, allowForm = 'grant') {
+function judgeList(rules, behavior, allowForm = 'grant', serverVersion) {
     let portsChecked = false;
     return rules.map((rule) => {
         if (rule === '')
@@ -125,7 +165,7 @@ function judgeList(rules, behavior, allowForm = 'grant') {
         }
         const parsed = parseRule(rule);
         if (parsed.ruleContent === undefined) {
-            const name = wholeServerRuleName(parsed.toolName);
+            const name = wholeServerRuleName(parsed.toolName, behavior !== 'allow');
             const check = nameCheck(name);
             if (behavior !== 'allow')
                 return { sent: true, wire: tighteningWholeName(name, check) };
@@ -144,7 +184,7 @@ function judgeList(rules, behavior, allowForm = 'grant') {
         }
         const check = nameCheck(parsed.toolName);
         if (behavior !== 'allow')
-            return { sent: true, wire: rule };
+            return tightenEntryNeverMatches(rule, serverVersion) ? kept('content_form_never_matches') : { sent: true, wire: rule };
         if ('retired' in check)
             return kept('retired_tool_name');
         if ('issue' in check)
@@ -204,18 +244,18 @@ function allowListVoiders(sent) {
         return 'unknown';
     }
 }
-function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'grant', dropWire, owned = []) {
+function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'grant', dropWire, owned = [], serverVersion) {
     const firstSlot = new Map();
     for (const s of raw)
         if (!firstSlot.has(s.rule))
             firstSlot.set(s.rule, s);
-    const groups = RULE_TRUST_ORDER.map(() => []);
-    const rankOf = (origin) => RULE_TRUST_ORDER.indexOf(origin);
+    const groups = WIRE_RULE_TRUST_ORDER.map(() => []);
+    const rankOf = (origin) => WIRE_RULE_TRUST_ORDER.indexOf(origin);
     if (originOf !== undefined) {
         for (const [r, origin] of originOf) {
             const rank = rankOf(origin);
             if (rank >= 0 && typeof r === 'string' && firstSlot.has(r))
-                groups[rank].push(r);
+                appendOwnElement(groups[rank], r);
         }
     }
     const unknownOrigin = [...firstSlot.keys()].filter((r) => originOf === undefined || rankOf(originOf.get(r)) < 0);
@@ -232,15 +272,15 @@ function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'gr
         if (winnerOf.has(fate.wire))
             return kept('duplicate');
         winnerOf.set(fate.wire, slot);
-        sent.push(fate.wire);
+        appendOwnElement(sent, fate.wire);
         return fate;
     };
     const appendGroup = (group, origin) => {
         const held = settingsGate !== undefined && !outsideSettingsFiles(origin);
-        const fates = held ? group.map(() => kept(settingsGate)) : judgeList(group, behavior, allowForm);
+        const fates = held ? group.map(() => kept(settingsGate)) : judgeList(group, behavior, allowForm, serverVersion);
         group.forEach((r, k) => fateOfRule.set(r, place(firstSlot.get(r), fates[k])));
     };
-    RULE_TRUST_ORDER.forEach((origin, rank) => {
+    WIRE_RULE_TRUST_ORDER.forEach((origin, rank) => {
         if (origin === 'cliArg' && cli !== undefined)
             cli.slots.forEach((s, k) => (cliFates[k] = place(s, cliFates[k])));
         appendGroup(groups[rank], origin);
@@ -287,7 +327,7 @@ function ruleList(v, key) {
         }
         const r = v[i];
         if (typeof r === 'string')
-            out.push(r);
+            appendOwnElement(out, r);
     }
     return out;
 }
@@ -308,7 +348,17 @@ function originMap(v, key) {
     return snap;
 }
 const slotsOf = (list, name) => (list ?? []).map((rule, at) => ({ rule, list: name, at }));
-function assemble(input, caps) {
+function assemble(input, caps, projection) {
+    const outer = activeRulePortsProjection;
+    activeRulePortsProjection = projection;
+    try {
+        return assembleNow(input, caps);
+    }
+    finally {
+        activeRulePortsProjection = outer;
+    }
+}
+function assembleNow(input, caps) {
     let read;
     try {
         read = readAssemblyInput(input, caps);
@@ -344,17 +394,19 @@ function readAssemblyInput(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 };
+    const versionRaw = ownField(input, 'serverVersion', '');
+    const serverVersion = typeof versionRaw === 'string' ? versionRaw : undefined;
+    return { deny, ask, allow, cliDeny, ownedServers, origins, gate, serverVersion };
 }
 function judgeAssembly(read, caps) {
-    const { deny, ask, allow, cliDeny, ownedServers, origins, gate } = read;
+    const { deny, ask, allow, cliDeny, ownedServers, origins, gate, serverVersion } = read;
     const cliSlots = slotsOf(cliDeny, 'cliDeny');
-    const cli = cliDeny === undefined ? undefined : { slots: cliSlots, fates: judgeList(cliDeny, 'deny') };
+    const cli = cliDeny === undefined ? undefined : { slots: cliSlots, fates: judgeList(cliDeny, 'deny', 'grant', serverVersion) };
     const denySlots = slotsOf(deny, 'deny');
     const askSlots = slotsOf(ask, 'ask');
     const allowSlots = slotsOf(allow, 'allow');
-    const denyJ = judgeBucket(denySlots, 'deny', origins.deny, cli);
-    const askJ = judgeBucket(askSlots, 'ask', origins.ask, undefined);
+    const denyJ = judgeBucket(denySlots, 'deny', origins.deny, cli, undefined, 'grant', undefined, [], serverVersion);
+    const askJ = judgeBucket(askSlots, 'ask', origins.ask, undefined, undefined, 'grant', undefined, [], serverVersion);
     const allowForm = allowWireForm(caps) === 'layer' ? 'layer' : 'grant';
     const settingsGate = gate === 'settings_read_not_clean' ? 'settings_read_not_clean' : undefined;
     let allowJ = gate === 'capability_off'
@@ -376,6 +428,11 @@ function judgeAssembly(read, caps) {
         buckets.allow = [...allowJ.sent];
     const keptRows = [];
     const rewritten = [];
+    const ruleRows = [];
+    const knownOrigin = (table, rule) => {
+        const o = table?.get(rule);
+        return typeof o === 'string' && WIRE_RULE_TRUST_ORDER.includes(o) ? o : undefined;
+    };
     const rows = [
         ['deny', [...denySlots, ...cliSlots], denyJ],
         ['ask', askSlots, askJ],
@@ -389,8 +446,10 @@ function judgeAssembly(read, caps) {
     for (const [bucket, slots, j] of rows) {
         slots.forEach((s, k) => {
             const f = j.fates[k];
+            const origin = s.list === 'cliDeny' ? 'cliArg' : knownOrigin(origins[bucket], s.rule);
+            appendOwnElement(ruleRows, { rule: s.rule, list: s.list, bucket, ...(origin !== undefined ? { origin } : {}), fate: f });
             if (!f.sent) {
-                keptRows.push({
+                appendOwnElement(keptRows, {
                     rule: s.rule,
                     bucket,
                     reason: f.reason,
@@ -404,19 +463,27 @@ function judgeAssembly(read, caps) {
             if (winner.at < 0)
                 continue;
             if (winner.rule !== wire)
-                rewritten.push({ from: winner.rule, to: wire, bucket });
+                appendOwnElement(rewritten, { from: winner.rule, to: wire, bucket });
         }
     }
-    return { buckets, report: { kept: keptRows, rewritten, ...(clientOwned.length > 0 ? { clientOwned } : {}) } };
+    return { buckets, report: { kept: keptRows, rewritten, ...(clientOwned.length > 0 ? { clientOwned } : {}) }, rows: ruleRows };
 }
 export function permissionsDeclaration(input, caps) {
-    const { buckets } = assemble(input, caps);
+    return declarationOf(assemble(input, caps));
+}
+export function projectPermissionsDeclaration(input, caps, projection) {
+    return declarationOf(assemble(input, caps, projection));
+}
+function declarationOf({ buckets }) {
     return Object.keys(buckets).length > 0 ? { permissions: buckets } : {};
 }
 export function permissionsDeclarationReport(input, caps) {
     const { buckets, report } = assemble(input, caps);
     return { ...(Object.keys(buckets).length > 0 ? { permissions: buckets } : {}), ...report };
 }
+export function assembledRuleRows(input, caps) {
+    return assemble(input, caps).rows;
+}
 const ALLOW_KEPT_ROWS_READ_MAX = 4096;
 function allowHeldBySettingsReadCount(report) {
     if (typeof report !== 'object' || report === null)

package/dist/pluginHooksWire.d.ts

@@ -1,11 +1,14 @@
+import type { HostSettingsSource } from './hostSettingsSource.js';
 import type { WireHooksConfig } from './finalVerifyWire.js';
 import type { PluginHookSource, SessionHookOrigin, SessionHookSource } from './host.js';
+import type { HttpPolicyDropRow } from './httpHookPolicy.js';
+import type { SubmissionIdentity } from './request/submissionIdentity.js';
 import { type HooksSalvageDrop, type HooksSalvageMask, type HooksSalvageRejection } from './settingsHooksSalvage.js';
 export declare const ENGINE_FIRED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreCompact", "PostCompact", "Stop", "StopFailure", "UserPromptSubmit"];
 export type EngineFiredHookEvent = (typeof ENGINE_FIRED_HOOK_EVENTS)[number];
 export declare const PLUGIN_HOOK_DISPOSITIONS: readonly ["engine", "shell", "not_run"];
 export type PluginHookDisposition = (typeof PLUGIN_HOOK_DISPOSITIONS)[number];
-export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event", "no_executor", "engine_not_local", "engine_locality_unknown", "engine_capability_absent", "engine_capability_unknown", "not_command", "sensitive_options", "engine_limit", "shell_form_user_config", "user_config_unset", "malformed_entry", "engine_hooks_off", "engine_hooks_unknown", "engine_type_skipped", "engine_llm_limit", "engine_unconfirmed", "engine_elsewhere", "hooks_module", "scope_unsupported", "source_incomplete"];
+export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event", "no_executor", "engine_not_local", "engine_locality_unknown", "engine_capability_absent", "engine_capability_unknown", "not_command", "sensitive_options", "engine_limit", "shell_form_user_config", "user_config_unset", "malformed_entry", "engine_hooks_off", "engine_hooks_unknown", "engine_type_skipped", "engine_llm_limit", "engine_unconfirmed", "engine_elsewhere", "hooks_module", "scope_unsupported", "source_incomplete", "compaction_local_fallback"];
 export type PluginHookReason = (typeof PLUGIN_HOOK_REASONS)[number];
 export declare const PLUGIN_HOOK_EXCLUSION_REASONS: readonly ["workspace_untrusted", "governance_unreadable", "policy_disable_all", "startup_mode", "managed_plugins_only", "prompt_not_user_authored"];
 export type PluginHookExclusionReason = (typeof PLUGIN_HOOK_EXCLUSION_REASONS)[number];
@@ -56,6 +59,11 @@ export interface SettingsHooksSalvageRow {
     readonly rejections: readonly HooksSalvageRejection[];
     readonly notice: string;
 }
+export interface SettingsLayerWithheldRow {
+    readonly source: HookSettingsSource;
+    readonly cause: 'trust_withheld';
+    readonly notice: string;
+}
 export interface PluginHookModuleVerdict {
     readonly pluginId: string;
     readonly pluginName: string;
@@ -86,19 +94,25 @@ export interface HooksWirePlan {
     readonly settingsVerdicts: readonly SettingsHookVerdict[];
     readonly settingsExcluded: readonly SettingsHookExclusion[];
     readonly settingsSalvage: readonly SettingsHooksSalvageRow[];
+    readonly httpPolicyDrops: readonly HttpPolicyDropRow[];
     readonly moduleVerdicts: readonly PluginHookModuleVerdict[];
     readonly sessionVerdicts: readonly SessionHookVerdict[];
     readonly sessionReader: PluginHookReaderState;
     readonly closedBy: Extract<PluginHookExclusionReason, 'workspace_untrusted' | 'governance_unreadable' | 'policy_disable_all'> | null;
+    readonly settingsSources: readonly HookSettingsSource[];
+    readonly settingsWithheld: readonly SettingsLayerWithheldRow[];
     readonly wire: WireHooksConfig | undefined;
 }
 export interface HooksWirePlanOptions {
+    readonly settings: HostSettingsSource;
     readonly baseUrl?: string;
     readonly engineOwnedByThisShell?: boolean;
     readonly shellHookEvents?: readonly string[];
     readonly shellHookTypesByEvent?: Readonly<Record<string, readonly string[]>>;
+    readonly identity?: SubmissionIdentity;
     readonly promptAuthoredByUser?: boolean;
     readonly suppressedLocally?: readonly string[];
+    readonly compactionOnShell?: boolean;
 }
 export declare function hooksWirePlanShapeOf(v: unknown): 'plan' | 'not' | 'threw';
 export declare const ENGINE_HOOK_LIMITS: {
@@ -161,7 +175,7 @@ export interface SettingsHookFilterResult {
     readonly excluded: SettingsHookExclusion[];
 }
 export type SettingsHookJudge = (event: string, group: WireHookGroup, entry: WireHookEntry) => HookExecutor;
-export declare function createSettingsHookJudge(engine: HooksWireEngineFacts, shellRuns: ShellRunsHook, promptAuthoredByUser: boolean): SettingsHookJudge;
+export declare function createSettingsHookJudge(engine: HooksWireEngineFacts, shellRuns: ShellRunsHook, promptAuthoredByUser: boolean, compactionOnShell?: boolean): SettingsHookJudge;
 export interface SourcedSettingsHookGroup {
     readonly source: HookSettingsSource;
     readonly group: WireHookGroup;
@@ -172,10 +186,12 @@ export interface SettingsHookDedupResult {
     readonly removed: number;
 }
 export declare function pluginHookVerdictOf(plan: HooksWirePlan, pluginId: string, event: string, groupIndex: number, hookIndex: number): PluginHookVerdict | undefined;
-export declare function settingsHooksKeptLocally<T>(plan: HooksWirePlan, event: string, group: {
+export interface SettingsHooksLocalGroup<T> {
     readonly matcher?: string;
     readonly hooks: readonly T[];
-}, opts?: {
+    readonly source?: HookSettingsSource;
+}
+export declare function settingsHooksKeptLocally<T>(plan: HooksWirePlan, event: string, group: SettingsHooksLocalGroup<T>, opts?: {
     readonly engineCompaction?: 'performed' | 'not_performed';
 }): readonly T[];
 export declare function pluginHookReasonText(reason: PluginHookReason): string;