@sema-agent/client-core 0.104.1 → 0.105.0

package/dist/mcpWireCaps.d.ts

@@ -1,5 +1,6 @@
 import type { McpServerSpec } from '@sema-agent/sdk';
 import type { McpEntryKeyIssue } from './generated/settingsSchemaTypes.js';
+import { type McpTransportKindsReading } from './mcpTransportKindsCapability.js';
 import type { UiLanguage } from './env/uiLanguage.js';
 export type { McpServerSpec };
 export interface McpConfigLike {
@@ -16,6 +17,7 @@ export interface McpConfigLike {
     toolFaces?: unknown;
     toolAxes?: unknown;
     startupTimeoutMs?: number;
+    sessionMetaKey?: string;
 }
 export type McpTransportEntryLike = Pick<McpConfigLike, 'type' | 'command' | 'args' | 'env' | 'url' | 'headers' | 'principalHeader' | 'assertionHeader'>;
 export type McpTransportVerdict = {
@@ -72,7 +74,7 @@ export type McpAllowToolsVerdict = {
     readonly problem: string;
 };
 export declare function mcpAllowToolsVerdict(read: () => {} | null | undefined, keyPrefix?: string): McpAllowToolsVerdict;
-export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'name_reserved' | 'transport_invalid' | 'identity_headers_both_set' | 'tool_axes_invalid' | 'tool_faces_invalid' | 'elicitation_invalid' | 'allow_tools_invalid' | 'entry_not_object' | 'entry_unreadable';
+export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'name_reserved' | 'transport_invalid' | 'identity_headers_both_set' | 'tool_axes_invalid' | 'tool_faces_invalid' | 'elicitation_invalid' | 'allow_tools_invalid' | 'entry_not_object' | 'entry_unreadable' | 'transport_not_advertised';
 export type McpServerNameUnusableReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'name_reserved';
 export type McpServerNameVerdict = {
     readonly usable: true;
@@ -100,6 +102,7 @@ export interface McpConfigProjection {
 }
 export interface ProjectMcpConfigsOptions {
     readonly sourceLabel?: (serverName: string) => string | undefined;
+    readonly transportKinds?: McpTransportKindsReading;
     readonly lang?: UiLanguage;
 }
 export declare function projectMcpConfigs(servers: Record<string, McpConfigLike> | undefined, opts?: ProjectMcpConfigsOptions): McpConfigProjection;

package/dist/mcpWireCaps.js

@@ -4,14 +4,16 @@ import { appendOwnElement, guardedRead } from './ownKey.js';
 import { readMcpToolAxes, readToolFaces } from './coreValuePorts.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { mcpTransportNotAdvertised } from './mcpTransportKindsCapability.js';
 const _mcpServerSpecPin = true;
 void _mcpServerSpecPin;
-function transparentKeys(startupTimeoutMs, axes, faces, elicitation) {
+function transparentKeys(startupTimeoutMs, axes, faces, elicitation, sessionMetaKey) {
     return {
         ...(faces !== undefined ? { toolFaces: faces } : {}),
         ...(axes !== undefined ? { toolAxes: axes } : {}),
         ...(elicitation !== undefined ? { elicitation } : {}),
         ...(startupTimeoutMs !== undefined ? { startupTimeoutMs } : {}),
+        ...(sessionMetaKey !== undefined ? { sessionMetaKey } : {}),
     };
 }
 export function readMcpHttpIdentityHeaders(transport) {
@@ -36,7 +38,7 @@ function entryShapeOf(c) {
 function readEntryOwnKeys(c) {
     try {
         const allowTools = c.allowTools;
-        return { toolAxes: c.toolAxes, elicitation: c.elicitation, allowTools, startupTimeoutMs: c.startupTimeoutMs };
+        return { toolAxes: c.toolAxes, elicitation: c.elicitation, allowTools, startupTimeoutMs: c.startupTimeoutMs, sessionMetaKey: c.sessionMetaKey };
     }
     catch {
         return undefined;
@@ -153,7 +155,7 @@ function specOf(name, c, own, axes, faces, elicitation, allowTools) {
         name,
         transport: t.transport,
         ...(allowTools !== undefined ? { allowTools } : {}),
-        ...transparentKeys(own.startupTimeoutMs, axes, faces, elicitation),
+        ...transparentKeys(own.startupTimeoutMs, axes, faces, elicitation, own.sessionMetaKey),
     };
     return { kind: 'ok', spec, lost: t.lost };
 }
@@ -305,7 +307,7 @@ const DROP_LABEL_SHOWN = 140;
 const DROP_PROBLEM_SHOWN = 300;
 const DROP_BAD_NAME_SHOWN = 160;
 const DEGRADED_LOST_SHOWN = 400;
-function dropNotice(name, reason, problem, opts, path) {
+function dropNotice(name, reason, problem, opts, path, transportKind) {
     let label;
     try {
         label = opts?.sourceLabel?.(name);
@@ -332,15 +334,17 @@ function dropNotice(name, reason, problem, opts, path) {
                                 ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
                                 : reason === 'transport_invalid'
                                     ? msg('config.mcp.transportInvalid', { name: quoted, where, path: capForDisplay(path ?? 'transport', DROP_NAME_SHOWN), problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
-                                    : reason === 'name_blank'
-                                        ? msg('config.mcp.nameBlank', { name: badName(), where })
-                                        : reason === 'name_collides_after_trim'
-                                            ? msg('config.mcp.nameCollides', { name: badName(), where })
-                                            : reason === 'name_too_long'
-                                                ? msg('config.mcp.nameTooLong', { name: badName(), where })
-                                                : reason === 'name_reserved'
-                                                    ? msg('config.mcp.nameReserved', { name: badName(), where })
-                                                    : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
+                                    : reason === 'transport_not_advertised'
+                                        ? msg('config.mcp.transportNotAdvertised', { name: quoted, where, kind: capForDisplay(transportKind ?? '', DROP_NAME_SHOWN), supported: problem !== undefined && problem.length > 0 ? problem : renderMessage(msg('config.mcp.transportsNone'), opts?.lang) })
+                                        : reason === 'name_blank'
+                                            ? msg('config.mcp.nameBlank', { name: badName(), where })
+                                            : reason === 'name_collides_after_trim'
+                                                ? msg('config.mcp.nameCollides', { name: badName(), where })
+                                                : reason === 'name_too_long'
+                                                    ? msg('config.mcp.nameTooLong', { name: badName(), where })
+                                                    : reason === 'name_reserved'
+                                                        ? msg('config.mcp.nameReserved', { name: badName(), where })
+                                                        : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
     return renderMessage(ref, opts?.lang);
 }
 function degradedNotice(name, lost, opts) {
@@ -381,6 +385,13 @@ export function projectMcpConfigs(servers, opts) {
         }
         const out = slotUnreadable ? { spec: null, entryUnreadable: true } : mcpConfigEntry(name, c);
         if (out.spec !== null) {
+            const kind = out.spec.transport.kind;
+            const supported = opts?.transportKinds === undefined ? undefined : mcpTransportNotAdvertised(opts.transportKinds, kind);
+            if (supported !== undefined) {
+                const listed = supported.join(', ');
+                dropped.push({ name, reason: 'transport_not_advertised', path: 'transport.kind', problem: listed, notice: dropNotice(name, 'transport_not_advertised', listed, opts, 'transport.kind', kind) });
+                continue;
+            }
             specs.push(out.spec);
             if (out.transportLost !== undefined)
                 degraded.push({ name, lost: Object.freeze([...out.transportLost]), notice: degradedNotice(name, out.transportLost, opts) });

package/dist/notifications.d.ts

@@ -42,6 +42,14 @@ export declare function taskNotificationDedupKey(n: {
     seq?: number | string;
     taskType?: string;
 }): string;
+export interface TaskNotificationRenderKeyInput {
+    taskId: string;
+    status: string;
+    seq?: number | string;
+    taskType?: string;
+    completionId?: string;
+}
+export declare function taskNotificationRenderKeys(n: TaskNotificationRenderKeyInput): readonly [selfKey: string, ...completionKey: string[]];
 export declare function taskNotificationDedupKeyFromWire(raw: Record<string, unknown>): string;
 export interface TranscriptNotificationSeeds {
     renderedKeys: string[];
@@ -120,6 +128,7 @@ export interface EngineWorkflowCompletion {
     runId: string;
     status: 'completed' | 'failed';
     summary: string;
+    completionId?: string;
 }
 export declare function enqueueBgChildNotification(raw: {
     taskId: string;

package/dist/notifications.js

@@ -5,7 +5,7 @@ import { panelEndFact } from './panelReduce.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess } from './terminalStatuses.js';
 import { cycleSeqValue } from './cycleOrder.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS } from './generated/engineFactTables.js';
-import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataValue } from './ownKey.js';
+import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataValue, workflowCompletionExtrasOf } from './ownKey.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -244,6 +244,14 @@ export function taskNotificationDedupKey(n) {
     const lane = n.taskType === 'external' ? 'external:' : '';
     return `${lane}${n.taskId}:${n.status}${seq ? `:${seq}` : ''}`;
 }
+const COMPLETION_KEY_PREFIX = 'completion:';
+export function taskNotificationRenderKeys(n) {
+    const own = taskNotificationDedupKey(n);
+    const id = n.completionId;
+    if (n.taskType === 'external' || !isCoreTaskNotificationTerminal(n.status) || typeof id !== 'string' || id.length === 0)
+        return [own];
+    return [own, `${COMPLETION_KEY_PREFIX}${id}`];
+}
 export function taskNotificationDedupKeyFromWire(raw) {
     const n = ownSnapshotRecord(raw) ?? {};
     return taskNotificationDedupKey({
@@ -830,6 +838,7 @@ function enqueueBgChild(n, identity) {
         ...identity,
     }));
 }
+const completionIdOnly = (x) => (x.completionId !== undefined ? { completionId: x.completionId } : {});
 export function enqueueEngineWorkflowNotification(raw) {
     const c = ownSnapshotRecord(raw);
     if (c === undefined) {
@@ -843,7 +852,7 @@ export function enqueueEngineWorkflowNotification(raw) {
     }
     markRunNotified(c.runId);
     cardEnqueuedRunIds.add(c.runId);
-    port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary }));
+    port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary, ...completionIdOnly(workflowCompletionExtrasOf(c)) }));
 }
 export function _resetEngineTaskNotificationForTest() {
     notifiedRunIds.clear();

package/dist/ownKey.d.ts

@@ -71,3 +71,7 @@ export interface SampledRecord {
 export declare function ownSnapshotWhenTyped<V>(value: V, word: string): SampledJson;
 export declare function ownSnapshotTyped<T extends object>(value: T): T | undefined;
 export declare function ownSnapshotRecord<V>(value: V): SampledRecord | undefined;
+export declare function workflowCompletionExtrasOf(c: object): {
+    completionId?: string;
+    diagnostics?: string;
+};

package/dist/ownKey.js

@@ -440,3 +440,11 @@ function sampleObject(src, depth, run) {
         run.path.delete(src);
     }
 }
+export function workflowCompletionExtrasOf(c) {
+    const completionId = guardedRead(() => readOwnDataNonEmptyString(c, 'completionId'));
+    const diagnostics = guardedRead(() => readOwnDataNonEmptyString(c, 'diagnostics'));
+    return {
+        ...(completionId !== undefined ? { completionId } : {}),
+        ...(diagnostics !== undefined ? { diagnostics } : {}),
+    };
+}

package/dist/permissionModeWriteCapability.d.ts

@@ -0,0 +1,13 @@
+export type PermissionModeWriteReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'unreadable';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    value: boolean;
+};
+export declare function projectPermissionModeWriteCapability(caps: unknown): PermissionModeWriteReading | undefined;
+export declare function observedPermissionModeWrite(baseUrl?: string | undefined): PermissionModeWriteReading;
+export declare function permissionModeWriteAvailable(reading: PermissionModeWriteReading | undefined): boolean;

package/dist/permissionModeWriteCapability.js

@@ -0,0 +1,35 @@
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
+export function projectPermissionModeWriteCapability(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'permissionModeWrite');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        return typeof v === 'boolean' ? { kind: 'present', value: v } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({
+    name: 'permissionModeWrite',
+    project: projectPermissionModeWriteCapability,
+});
+export function observedPermissionModeWrite(baseUrl = engineWireTargetBaseUrl()) {
+    return reader.observed(baseUrl);
+}
+export function permissionModeWriteAvailable(reading) {
+    try {
+        if (reading === null || reading === undefined || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        if (readOwnDataValue(reading, 'kind') !== 'present')
+            return false;
+        return readOwnDataValue(reading, 'value') === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/permissionsAllowGrantCapability.d.ts

@@ -1,3 +1,4 @@
+export declare const RULE_LAYERS_CAP_LEAF: "layers";
 export type PermissionsAllowGrantReading = {
     kind: 'unobserved';
 } | {
@@ -8,10 +9,12 @@ export type PermissionsAllowGrantReading = {
     kind: 'present';
     grants: boolean;
     layer?: boolean;
+    layers?: boolean;
 };
 export declare function projectPermissionsAllowGrantCapability(caps: unknown): PermissionsAllowGrantReading | undefined;
 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 permissionRuleLayersOn(reading: PermissionsAllowGrantReading | undefined): boolean;
 export declare function permissionsAllowGrantDoctorDetail(reading: PermissionsAllowGrantReading, settingsRead?: 'clean' | 'partial' | 'unreadable'): string;

package/dist/permissionsAllowGrantCapability.js

@@ -4,6 +4,7 @@ import { ownDataField } from './ownKey.js';
 import { hasCoreValuePort } from './coreValuePorts.js';
 const ALLOW_GRANT_CAP_PATH = ['settings', 'permissions', 'allowGrant'];
 const ALLOW_LAYER_CAP_LEAF = 'allowLayer';
+export const RULE_LAYERS_CAP_LEAF = 'layers';
 export function projectPermissionsAllowGrantCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -18,9 +19,21 @@ export function projectPermissionsAllowGrantCapability(caps) {
                 if (typeof v !== 'boolean')
                     return undefined;
                 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;
+                if (layer !== undefined && typeof layer !== 'boolean')
+                    return undefined;
+                let layers;
+                try {
+                    layers = ownDataField(node, RULE_LAYERS_CAP_LEAF);
+                }
+                catch {
+                    layers = undefined;
+                }
+                return {
+                    kind: 'present',
+                    grants: v,
+                    ...(layer !== undefined ? { layer } : {}),
+                    ...(typeof layers === 'boolean' ? { layers } : {}),
+                };
             }
             if (v === null || typeof v !== 'object' || Array.isArray(v))
                 return undefined;
@@ -61,6 +74,16 @@ export function allowRulesGate(reading, settingsRead) {
         return 'capability_off';
     return settingsRead === 'clean' ? 'open' : 'settings_read_not_clean';
 }
+export function permissionRuleLayersOn(reading) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        return ownDataField(reading, 'kind') === 'present' && ownDataField(reading, RULE_LAYERS_CAP_LEAF) === true;
+    }
+    catch {
+        return false;
+    }
+}
 function ownReadingField(reading, key) {
     try {
         if (reading === null || typeof reading !== 'object' || Array.isArray(reading))

package/dist/permissionsDeclaration.d.ts

@@ -39,6 +39,24 @@ export interface PermissionsDeclarationBuckets {
 export interface PermissionsDeclaration {
     permissions?: PermissionsDeclarationBuckets;
 }
+export type SettingsRuleLayerOrigin = keyof typeof SETTINGS_SOURCE_TIERS;
+export interface TightenRuleContribution {
+    readonly rule: string;
+    readonly origin: WireRuleOrigin;
+}
+export interface LayeredTightenEntry {
+    readonly rule: string;
+    readonly layer: SettingsRuleLayerOrigin;
+}
+export type TightenWireEntry = string | LayeredTightenEntry;
+export interface HostPermissionsBuckets {
+    deny?: TightenWireEntry[];
+    ask?: TightenWireEntry[];
+    allow?: string[];
+}
+export interface HostPermissionsDeclaration {
+    permissions?: HostPermissionsBuckets;
+}
 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 {
@@ -86,8 +104,12 @@ export interface AssembledRuleRow {
     readonly origin?: WireRuleOrigin;
     readonly fate: AssembledRuleFate;
 }
+export interface LayeredTightenSources {
+    readonly deny: readonly TightenRuleContribution[];
+    readonly ask: readonly TightenRuleContribution[];
+}
 export declare function permissionsDeclaration(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): PermissionsDeclaration;
-export declare function projectPermissionsDeclaration(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading, projection: RulePortsProjection): PermissionsDeclaration;
+export declare function projectPermissionsDeclaration(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading, projection: RulePortsProjection, layered?: LayeredTightenSources): HostPermissionsDeclaration;
 export declare function permissionsDeclarationReport(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): PermissionsDeclarationReport;
 export declare function assembledRuleRows(input: PermissionsDeclarationInput, caps: PermissionsAllowGrantReading): readonly AssembledRuleRow[];
 export interface PermissionsAllowKeptFacts {

package/dist/permissionsDeclaration.js

@@ -244,45 +244,60 @@ function allowListVoiders(sent) {
         return 'unknown';
     }
 }
-function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'grant', dropWire, owned = [], serverVersion) {
+function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'grant', dropWire, owned = [], serverVersion, layeredFrom) {
     const firstSlot = new Map();
     for (const s of raw)
         if (!firstSlot.has(s.rule))
             firstSlot.set(s.rule, s);
     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 pairs = layeredFrom !== undefined ? layeredFrom.map((c) => [c.rule, c.origin]) : originOf;
+    const known = new Set();
+    if (pairs !== undefined) {
+        for (const [r, origin] of pairs) {
             const rank = rankOf(origin);
-            if (rank >= 0 && typeof r === 'string' && firstSlot.has(r))
+            if (rank >= 0 && typeof r === 'string' && firstSlot.has(r)) {
                 appendOwnElement(groups[rank], r);
+                known.add(r);
+            }
         }
     }
-    const unknownOrigin = [...firstSlot.keys()].filter((r) => originOf === undefined || rankOf(originOf.get(r)) < 0);
+    const unknownOrigin = [...firstSlot.keys()].filter((r) => !known.has(r));
     const fateOfRule = new Map();
     const sent = [];
+    const sentLayers = [];
+    const sentIds = [];
     const winnerOf = new Map();
     const cliFates = cli === undefined ? [] : [...cli.fates];
-    const place = (slot, fate) => {
+    const layerOf = (origin) => layeredFrom !== undefined && origin !== undefined && Object.hasOwn(SETTINGS_SOURCE_TIERS, origin) ? origin : undefined;
+    const place = (slot, fate, origin) => {
         if (!fate.sent)
             return fate;
         const dropped = dropWire?.(fate.wire);
         if (dropped !== undefined)
             return kept(dropped);
-        if (winnerOf.has(fate.wire))
+        const layer = layerOf(origin);
+        const id = layeredFrom === undefined ? fate.wire : JSON.stringify([layer ?? null, fate.wire]);
+        if (winnerOf.has(id))
             return kept('duplicate');
-        winnerOf.set(fate.wire, slot);
+        winnerOf.set(id, slot);
         appendOwnElement(sent, fate.wire);
+        appendOwnElement(sentLayers, layer);
+        appendOwnElement(sentIds, id);
         return fate;
     };
     const appendGroup = (group, origin) => {
         const held = settingsGate !== undefined && !outsideSettingsFiles(origin);
         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])));
+        group.forEach((r, k) => {
+            const f = place(firstSlot.get(r), fates[k], origin);
+            if (!fateOfRule.has(r))
+                fateOfRule.set(r, f);
+        });
     };
     WIRE_RULE_TRUST_ORDER.forEach((origin, rank) => {
         if (origin === 'cliArg' && cli !== undefined)
-            cli.slots.forEach((s, k) => (cliFates[k] = place(s, cliFates[k])));
+            cli.slots.forEach((s, k) => (cliFates[k] = place(s, cliFates[k], 'cliArg')));
         appendGroup(groups[rank], origin);
     });
     const ownedFates = owned.map((fate, k) => place({ rule: fate.sent ? fate.wire : '', list: 'allow', at: -1 - k }, fate));
@@ -293,7 +308,7 @@ function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'gr
             return f;
         return f.sent || f.reason === 'duplicate' ? kept('duplicate') : f;
     });
-    return { sent, fates: [...fates, ...cliFates], winnerOf, ownedFates };
+    return { sent, sentLayers, sentIds, fates: [...fates, ...cliFates], winnerOf, ownedFates };
 }
 function clientOwnedFate(server) {
     if (server.length === 0)
@@ -312,7 +327,7 @@ function ownField(obj, key, where) {
         throw malformed(`${WHO}: ${where}${key} 只在原型链上,不是自有字段 —— 拒绝读取(请交普通对象)。`);
     return undefined;
 }
-function ruleList(v, key) {
+function ruleList(v, key, tighten = false) {
     if (v === undefined || v === null)
         return undefined;
     if (!Array.isArray(v))
@@ -326,6 +341,9 @@ function ruleList(v, key) {
             continue;
         }
         const r = v[i];
+        if (tighten && r !== null && typeof r === 'object') {
+            throw malformed(`${WHO}: ${key}[${i}] 是对象(带出处层的条目形)—— 本口只收规则串:收紧方向的条目不静默丢,拒绝装配(带层条目由宿主设置入口在能力位恰真时铸)。`);
+        }
         if (typeof r === 'string')
             appendOwnElement(out, r);
     }
@@ -348,17 +366,17 @@ function originMap(v, key) {
     return snap;
 }
 const slotsOf = (list, name) => (list ?? []).map((rule, at) => ({ rule, list: name, at }));
-function assemble(input, caps, projection) {
+function assemble(input, caps, projection, layered) {
     const outer = activeRulePortsProjection;
     activeRulePortsProjection = projection;
     try {
-        return assembleNow(input, caps);
+        return assembleNow(input, caps, layered);
     }
     finally {
         activeRulePortsProjection = outer;
     }
 }
-function assembleNow(input, caps) {
+function assembleNow(input, caps, layered) {
     let read;
     try {
         read = readAssemblyInput(input, caps);
@@ -367,7 +385,7 @@ function assembleNow(input, caps) {
         throw asAssemblyRefusal(e, 'input_malformed', WHO);
     }
     try {
-        return judgeAssembly(read, caps);
+        return judgeAssembly(read, caps, layered);
     }
     catch (e) {
         throw asAssemblyRefusal(e, 'judge_unanswerable', WHO);
@@ -377,10 +395,10 @@ function readAssemblyInput(input, caps) {
     if (input === null || typeof input !== 'object' || Array.isArray(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');
+    const deny = ruleList(ownField(input, 'deny', ''), 'deny', true);
+    const ask = ruleList(ownField(input, 'ask', ''), 'ask', true);
     const allow = ruleList(ownField(input, 'allow', ''), 'allow');
-    const cliDeny = ruleList(ownField(input, 'cliDeny', ''), 'cliDeny');
+    const cliDeny = ruleList(ownField(input, 'cliDeny', ''), 'cliDeny', true);
     const ownedServers = [...new Set(ruleList(ownField(input, 'clientOwnedServers', ''), 'clientOwnedServers') ?? [])];
     const originsRaw = ownField(input, 'origins', '');
     let origins = {};
@@ -398,19 +416,19 @@ function readAssemblyInput(input, caps) {
     const serverVersion = typeof versionRaw === 'string' ? versionRaw : undefined;
     return { deny, ask, allow, cliDeny, ownedServers, origins, gate, serverVersion };
 }
-function judgeAssembly(read, caps) {
+function judgeAssembly(read, caps, layered) {
     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', '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, undefined, 'grant', undefined, [], serverVersion);
-    const askJ = judgeBucket(askSlots, 'ask', origins.ask, undefined, undefined, 'grant', undefined, [], serverVersion);
+    const denyJ = judgeBucket(denySlots, 'deny', origins.deny, cli, undefined, 'grant', undefined, [], serverVersion, layered?.deny);
+    const askJ = judgeBucket(askSlots, 'ask', origins.ask, undefined, undefined, 'grant', undefined, [], serverVersion, layered?.ask);
     const allowForm = allowWireForm(caps) === 'layer' ? 'layer' : 'grant';
     const settingsGate = gate === 'settings_read_not_clean' ? 'settings_read_not_clean' : undefined;
     let allowJ = gate === 'capability_off'
-        ? { sent: [], fates: allowSlots.map(() => kept('allow_capability_off')), winnerOf: new Map(), ownedFates: ownedServers.map(() => kept('allow_capability_off')) }
+        ? { sent: [], sentLayers: [], sentIds: [], fates: allowSlots.map(() => kept('allow_capability_off')), winnerOf: new Map(), ownedFates: ownedServers.map(() => kept('allow_capability_off')) }
         : judgeBucket(allowSlots, 'allow', origins.allow, undefined, settingsGate, allowForm, undefined, ownedServers.map(clientOwnedFate));
     if (gate !== 'capability_off' && allowForm === 'layer' && allowJ.sent.length > 0) {
         const voiders = allowListVoiders(allowJ.sent);
@@ -426,6 +444,17 @@ function judgeAssembly(read, caps) {
         buckets.ask = [...askJ.sent];
     if (allowJ.sent.length > 0)
         buckets.allow = [...allowJ.sent];
+    const entriesOf = (j) => j.sent.map((wire, i) => {
+        const layer = j.sentLayers[i];
+        return layer === undefined ? wire : Object.freeze({ rule: wire, layer });
+    });
+    const wireBuckets = {};
+    if (denyJ.sent.length > 0)
+        wireBuckets.deny = entriesOf(denyJ);
+    if (askJ.sent.length > 0)
+        wireBuckets.ask = entriesOf(askJ);
+    if (allowJ.sent.length > 0)
+        wireBuckets.allow = [...allowJ.sent];
     const keptRows = [];
     const rewritten = [];
     const ruleRows = [];
@@ -458,21 +487,22 @@ function judgeAssembly(read, caps) {
                 });
             }
         });
-        for (const wire of j.sent) {
-            const winner = j.winnerOf.get(wire);
+        j.sent.forEach((wire, i) => {
+            const winner = j.winnerOf.get(j.sentIds[i]);
             if (winner.at < 0)
-                continue;
+                return;
             if (winner.rule !== wire)
                 appendOwnElement(rewritten, { from: winner.rule, to: wire, bucket });
-        }
+        });
     }
-    return { buckets, report: { kept: keptRows, rewritten, ...(clientOwned.length > 0 ? { clientOwned } : {}) }, rows: ruleRows };
+    return { buckets, wireBuckets, report: { kept: keptRows, rewritten, ...(clientOwned.length > 0 ? { clientOwned } : {}) }, rows: ruleRows };
 }
 export function permissionsDeclaration(input, caps) {
     return declarationOf(assemble(input, caps));
 }
-export function projectPermissionsDeclaration(input, caps, projection) {
-    return declarationOf(assemble(input, caps, projection));
+export function projectPermissionsDeclaration(input, caps, projection, layered) {
+    const { wireBuckets } = assemble(input, caps, projection, layered);
+    return Object.keys(wireBuckets).length > 0 ? { permissions: wireBuckets } : {};
 }
 function declarationOf({ buckets }) {
     return Object.keys(buckets).length > 0 ? { permissions: buckets } : {};