@sema-agent/client-core 0.95.0 → 0.96.0

package/dist/noticePresentation.js

@@ -0,0 +1,247 @@
+import { capDisplay, displayUntrusted } from './displayUntrusted.js';
+import { engineNoticeInCatalog, noticeAudienceOf } from './engineNoticeCodes.js';
+import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+const DEFAULT_CUT_MARK = '…';
+const CUT_KEEP_DIVISOR = 2;
+const CLOSERS = '"\')]”’」』）】';
+const ASCII_SENTENCE_END = '.!?;';
+const WIDE_SENTENCE_END = '。！？；';
+const ASCII_CLAUSE_END = ',:';
+const WIDE_CLAUSE_END = '，、：';
+const EM_DASH = '—';
+function isWs(c) {
+    return c !== '' && c.trim() === '';
+}
+function readCutOptions(opts) {
+    if (typeof opts !== 'object' || opts === null)
+        return { boundary: 'sentence', mark: DEFAULT_CUT_MARK };
+    const boundary = guardedRead(() => readOwnDataValue(opts, 'boundary'));
+    const mark = guardedRead(() => readOwnDataValue(opts, 'mark'));
+    return { boundary: boundary === 'word' ? 'word' : 'sentence', mark: typeof mark === 'string' ? mark : DEFAULT_CUT_MARK };
+}
+function sentenceEndAt(src, j) {
+    const c = src.charAt(j);
+    const ascii = ASCII_SENTENCE_END.includes(c);
+    if (!ascii && !WIDE_SENTENCE_END.includes(c))
+        return -1;
+    let k = j + 1;
+    while (k < src.length && CLOSERS.includes(src.charAt(k)))
+        k++;
+    if (!ascii)
+        return k;
+    return k === src.length || isWs(src.charAt(k)) ? k : -1;
+}
+function clauseEndAt(src, j) {
+    const c = src.charAt(j);
+    if (WIDE_CLAUSE_END.includes(c))
+        return j + 1;
+    if (!ASCII_CLAUSE_END.includes(c))
+        return -1;
+    const k = j + 1;
+    return k === src.length || isWs(src.charAt(k)) ? k : -1;
+}
+function pickCut(src, limit, floor, boundary) {
+    let sentence = -1;
+    let clause = -1;
+    let word = -1;
+    for (let j = 0; j <= limit && j < src.length; j++) {
+        const c = src.charAt(j);
+        if (isWs(c)) {
+            word = j;
+            continue;
+        }
+        if (boundary === 'word')
+            continue;
+        const s = sentenceEndAt(src, j);
+        if (s !== -1 && s <= limit)
+            sentence = Math.max(sentence, s);
+        else if (c === EM_DASH && j > 0 && isWs(src.charAt(j - 1)) && (j + 1 === src.length || isWs(src.charAt(j + 1))))
+            sentence = Math.max(sentence, j);
+        const k = clauseEndAt(src, j);
+        if (k !== -1 && k <= limit)
+            clause = Math.max(clause, k);
+    }
+    if (boundary === 'word')
+        return word >= floor ? word : -1;
+    if (sentence >= floor)
+        return sentence;
+    if (clause >= floor)
+        return clause;
+    return word >= floor ? word : -1;
+}
+export function cutForDisplay(text, budget, opts) {
+    const src = typeof text === 'string' ? text : (guardedRead(() => String(text ?? '')) ?? '');
+    if (typeof budget !== 'number' || !Number.isFinite(budget))
+        return { shown: src, truncated: false };
+    const limit = Math.max(0, Math.floor(budget));
+    if (src.length <= limit)
+        return { shown: src, truncated: false };
+    const { boundary, mark } = readCutOptions(opts);
+    const room = limit - mark.length;
+    if (room <= 0)
+        return { shown: limit >= mark.length ? mark : '', truncated: true };
+    const head = capDisplay(src, room, 'escape');
+    const floor = Math.ceil(head.length / CUT_KEEP_DIVISOR);
+    const at = pickCut(src, head.length, floor, boundary);
+    const kept = (at === -1 ? head : src.slice(0, at)).trimEnd();
+    return { shown: `${kept}${mark}`, truncated: true };
+}
+export const NOTICE_SEAT_CLASS = Object.freeze({
+    user: Object.freeze({ present: 'persistent+hint', unknown: 'persistent+hint', absent: 'persistent' }),
+    operator: Object.freeze({ present: 'transient', unknown: 'transient', absent: 'diagnostic' }),
+    unknown: Object.freeze({ present: 'persistent+hint', unknown: 'persistent+hint', absent: 'persistent+hint' }),
+});
+export function noticeSeatClassOf(audience, outlet, deployment) {
+    const a = typeof audience === 'string' && Object.hasOwn(NOTICE_SEAT_CLASS, audience) ? audience : 'unknown';
+    const row = a === 'operator' && deployment !== 'remote' ? NOTICE_SEAT_CLASS.user : NOTICE_SEAT_CLASS[a];
+    return typeof outlet === 'string' && Object.hasOwn(row, outlet) ? row[outlet] : row.unknown;
+}
+const OCCURRENCE_KEY_BY_CODE = Object.freeze({
+    'memory.harvest_quarantined': 'reportId',
+    'memory.hold_opened': 'reportId',
+    'memory.hold_released': 'reportId',
+    'memory.hold_disposed': 'reportId',
+    'memory.consolidation_recommended': 'reportId',
+    'memory.capture_opted_out': 'sessionId',
+    'memory.delegation_static_mark_waived': 'runId',
+});
+export function noticePresentationFacts(notice, deployment) {
+    const envelope = typeof notice === 'object' && notice !== null ? notice : undefined;
+    const code = guardedRead(() => readOwnDataValue(envelope, 'code'));
+    const detailRaw = guardedRead(() => readOwnDataValue(envelope, 'detail'));
+    const detail = typeof detailRaw === 'object' && detailRaw !== null ? detailRaw : undefined;
+    const audience = typeof code === 'string' && engineNoticeInCatalog(code) ? noticeAudienceOf(code) : 'unknown';
+    const remedy = guardedRead(() => readOwnDataNonEmptyString(detail, 'remedy'));
+    const outlet = remedy !== undefined ? 'present' : 'unknown';
+    const keyField = typeof code === 'string' && Object.hasOwn(OCCURRENCE_KEY_BY_CODE, code) ? OCCURRENCE_KEY_BY_CODE[code] : undefined;
+    const identity = keyField !== undefined ? guardedRead(() => readOwnDataNonEmptyString(detail, keyField)) : undefined;
+    const occurrence = Object.freeze(identity !== undefined ? { kind: 'occurrence', key: identity } : { kind: 'event' });
+    return Object.freeze({
+        audience,
+        outlet,
+        ...(remedy !== undefined ? { remedy } : {}),
+        occurrence,
+        seatClass: noticeSeatClassOf(audience, outlet, deployment),
+    });
+}
+export const OUTLET_KINDS = Object.freeze(['slash-command', 'cli-command', 'http-endpoint', 'env-or-settings', 'operator-action', 'identity-attach', 'resend']);
+function ctxSlot(ctx, key, closed) {
+    if (typeof ctx !== 'object' || ctx === null)
+        return undefined;
+    const v = guardedRead(() => readOwnDataValue(ctx, key));
+    return typeof v === 'string' && closed.includes(v) ? v : undefined;
+}
+function isOutletKind(v) {
+    return typeof v === 'string' && OUTLET_KINDS.includes(v);
+}
+export function outletReachable(kind, ctx) {
+    if (!isOutletKind(kind))
+        return 'unknown';
+    const lane = ctxSlot(ctx, 'lane', ['interactive', 'print']);
+    switch (kind) {
+        case 'resend':
+        case 'cli-command':
+            return 'reachable';
+        case 'slash-command':
+            return lane === 'interactive' ? 'reachable' : lane === 'print' ? 'unreachable' : 'unknown';
+        case 'http-endpoint': {
+            if (lane === 'interactive')
+                return 'unreachable';
+            const access = ctxSlot(ctx, 'endpointAccess', ['has-address-and-credential', 'no', 'unknown']);
+            if (access === 'no')
+                return 'unreachable';
+            return lane === 'print' && access === 'has-address-and-credential' ? 'reachable' : 'unknown';
+        }
+        case 'env-or-settings': {
+            const scope = ctxSlot(ctx, 'configScope', ['reaches-engine', 'does-not', 'unknown']);
+            if (scope === 'reaches-engine')
+                return 'reachable';
+            if (scope === 'does-not')
+                return 'unreachable';
+            return ctxSlot(ctx, 'engineManagedByShell', ['shell', 'external-local', 'remote', 'unknown']) === 'remote' ? 'unreachable' : 'unknown';
+        }
+        case 'operator-action': {
+            const op = ctxSlot(ctx, 'operator', ['present', 'absent', 'unknown']);
+            return op === 'present' ? 'reachable' : op === 'absent' ? 'unreachable' : 'unknown';
+        }
+        case 'identity-attach': {
+            const id = ctxSlot(ctx, 'identityAttach', ['available', 'unavailable', 'unknown']);
+            return id === 'available' ? 'reachable' : id === 'unavailable' ? 'unreachable' : 'unknown';
+        }
+    }
+}
+const LIST_READ_MAX = 64;
+function listItems(list) {
+    if (guardedRead(() => (Array.isArray(list) ? true : undefined)) !== true)
+        return [];
+    const length = guardedRead(() => readOwnDataValue(list, 'length'));
+    if (typeof length !== 'number' || !Number.isInteger(length) || length < 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < Math.min(length, LIST_READ_MAX); i++) {
+        const item = guardedRead(() => readOwnDataValue(list, String(i)));
+        if (item !== undefined)
+            out.push(item);
+    }
+    return out;
+}
+export function planOutletRendering(kinds, ctx) {
+    const state = [];
+    const confirm = [];
+    const omit = [];
+    const seen = new Set();
+    for (const k of listItems(kinds)) {
+        if (!isOutletKind(k) || seen.has(k))
+            continue;
+        seen.add(k);
+        const r = outletReachable(k, ctx);
+        (r === 'reachable' ? state : r === 'unknown' ? confirm : omit).push(k);
+    }
+    return Object.freeze({
+        state: Object.freeze(state),
+        confirm: Object.freeze(confirm),
+        omit: Object.freeze(omit),
+        nothingReachable: state.length === 0 && confirm.length === 0 && omit.length > 0,
+    });
+}
+export const NOTICE_FULL_TEXT_CAP = 8000;
+const PRINT_BUDGET_USER = 1000;
+const PRINT_BUDGET_OPERATOR = 160;
+const PRINT_PREFIX = '[sema] ';
+const NO_TEXT_SENTENCE = 'Engine notice (no message text)';
+const PRINT_CODE_MAX = 160;
+const PRE_CAP_SLACK = 2;
+const PRINT_SESSION_MAX = 128;
+function lineFace(max) {
+    return max === undefined ? { foldLines: false, mark: 'dot' } : { foldLines: false, mark: 'dot', max };
+}
+function printCarrier(carrier) {
+    if (typeof carrier !== 'object' || carrier === null)
+        return { kind: 'none' };
+    const kind = guardedRead(() => readOwnDataValue(carrier, 'kind'));
+    if (kind === 'stream-json')
+        return { kind };
+    if (kind === 'transcript') {
+        const sid = guardedRead(() => readOwnDataNonEmptyString(carrier, 'sessionId'));
+        if (sid !== undefined) {
+            const shown = displayUntrusted(sid, lineFace(PRINT_SESSION_MAX));
+            if (shown !== '')
+                return { kind, sessionId: shown };
+        }
+    }
+    return { kind: 'none' };
+}
+export function noticePrintLine(input) {
+    const textRaw = guardedRead(() => readOwnDataValue(input, 'text'));
+    const audience = guardedRead(() => readOwnDataValue(input, 'audience'));
+    const codeRaw = guardedRead(() => readOwnDataValue(input, 'code'));
+    const carrier = printCarrier(guardedRead(() => readOwnDataValue(input, 'carrier')));
+    const washed = displayUntrusted(typeof textRaw === 'string' ? textRaw : '', lineFace(NOTICE_FULL_TEXT_CAP + PRE_CAP_SLACK));
+    const bounded = cutForDisplay(washed, NOTICE_FULL_TEXT_CAP);
+    const text = bounded.shown.trim() === '' ? NO_TEXT_SENTENCE : bounded.shown;
+    const budget = audience === 'operator' ? PRINT_BUDGET_OPERATOR : PRINT_BUDGET_USER;
+    const cut = carrier.kind === 'none' ? { shown: text, truncated: bounded.truncated } : cutForDisplay(text, budget);
+    const where = cut.truncated && carrier.kind === 'transcript' ? ` (full text: sema -r ${carrier.sessionId})` : '';
+    const code = typeof codeRaw === 'string' && codeRaw !== '' ? displayUntrusted(codeRaw, lineFace(PRINT_CODE_MAX)) : '';
+    return Object.freeze({ line: `${PRINT_PREFIX}${cut.shown}${where}${code !== '' ? ` [${code}]` : ''}`, truncated: cut.truncated });
+}

package/dist/outputStyleSeatCapability.d.ts

@@ -12,4 +12,3 @@ export declare function noteEngineCapsForOutputStyleSeat(baseUrl: string, caps:
 }): void;
 export declare function observedOutputStyleSeat(baseUrl?: string | undefined): OutputStyleSeatReading;
 export declare function outputStyleSeatAdmitted(reading: OutputStyleSeatReading | undefined): boolean;
-export declare function __resetOutputStyleSeatReadingsForTests(): void;

package/dist/outputStyleSeatCapability.js

@@ -37,6 +37,3 @@ export function outputStyleSeatAdmitted(reading) {
         return false;
     }
 }
-export function __resetOutputStyleSeatReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/ownKey.d.ts

@@ -3,9 +3,11 @@ export declare function readOwnNonEmptyString(v: object | null | undefined, key:
 export declare function readAskOrigin(carrier: object | null | undefined): string | undefined;
 export declare function readOwnDataNonEmptyString(v: object | null | undefined, key: string): string | undefined;
 export declare function readOwnDataValue<T>(v: object | null | undefined, key: string): T | undefined;
+export declare function guardedRead<T>(read: () => T | undefined): T | undefined;
 export declare function ownDataField(v: object, key: string): unknown;
 export declare function ownSendableField(v: object, key: string): unknown;
 export declare function ownDataRefusalKeyOf(e: unknown): string | undefined;
 export declare function readFrameStringKey(frame: unknown, key: string): string | undefined;
+export declare function readFrameTrueMark(frame: object | null | undefined, key: string): boolean;
 export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;
 export declare function mcpSectionDroppedNamedRowsOf(rows: object | null | undefined, name: string): number;

package/dist/ownKey.js

@@ -25,6 +25,14 @@ export function readOwnDataValue(v, key) {
     const d = Object.getOwnPropertyDescriptor(v, key);
     return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
 }
+export function guardedRead(read) {
+    try {
+        return read();
+    }
+    catch {
+        return undefined;
+    }
+}
 export function ownDataField(v, key) {
     return ownField(v, key, false);
 }
@@ -56,6 +64,16 @@ export function readFrameStringKey(frame, key) {
         return undefined;
     }
 }
+export function readFrameTrueMark(frame, key) {
+    try {
+        if (frame === null || frame === undefined || typeof frame !== 'object' || Array.isArray(frame))
+            return false;
+        return ownDataField(frame, key) === true;
+    }
+    catch {
+        return false;
+    }
+}
 const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');
 export function markMcpSectionDroppedNamedRows(rows, dropped) {
     if (dropped.size === 0)

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/permissionModesCapability.d.ts

@@ -7,9 +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 __resetPermissionModesReadingsForTests(): void;

package/dist/permissionModesCapability.js

@@ -40,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);
 }
@@ -61,6 +58,3 @@ export function permissionModeAdmitted(reading, mode) {
         return false;
     }
 }
-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/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;

package/dist/permissionsDeclaration.js

@@ -1,5 +1,5 @@
-import { compileAllowList, hasCoreValuePort, protocolOf, retiredToolNames, ruleToolGrammarOf } from './coreValuePorts.js';
-import { clientOwnedServerPrefix, protocolSegmentOf } from './protocolSegment.js';
+import { compileAllowList, hasCoreValuePort, protocolOf, ruleToolGrammarOf } from './coreValuePorts.js';
+import { clientOwnedServerPrefix, mintedPrefixOf, ruleToolNameVerdictOf } from './protocolSegment.js';
 import { ruleCompileVerdict } from './ruleCompileVerdict.js';
 import { allowRulesGate, allowWireForm } from './permissionsAllowGrantCapability.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot } from './wireFailureShape.js';
@@ -74,22 +74,33 @@ function parseRule(rule) {
     return { toolName: normalizeLegacyToolName(toolName), ruleContent: unescapeRuleContent(rawContent) };
 }
 function requireRulePorts() {
-    const required = ['MCP_NAMESPACE', 'RETIRED_TOOL_NAMES', 'protocolOf', 'ruleToolGrammarOf', 'validatePermissionRules'];
+    const required = ['MCP_NAMESPACE', 'judgeRuleToolName', 'protocolOf', 'ruleToolGrammarOf', 'validatePermissionRules'];
     const missing = required.filter((p) => !hasCoreValuePort(p));
     if (missing.length === 0)
         return;
     throw new Error(`permissionsDeclaration: 规则判据端口缺席(${missing.join(' / ')})—— 先用 installCoreValuePorts 装上 core 的同名实现。` +
         '缺席不等于全部合格:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。');
 }
-function wireIssue(name) {
+function nameCheck(name) {
     if (name.includes('('))
-        return 'paren_in_tool_name';
-    if (retiredToolNames().has(name))
-        return 'retired_tool_name';
+        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 规则,所以这里拒绝装配。');
+    }
+    if (verdict.kind === 'retired')
+        return { issue: 'retired_tool_name' };
+    if (verdict.kind === 'unprefixed_namespace')
+        return { issue: 'unprefixed_namespaced_name' };
     const ns = protocolOf(name);
-    if (ns === undefined)
-        return name.includes('__') ? 'unprefixed_namespaced_name' : undefined;
-    return ns.parse(name) !== undefined ? undefined : 'incomplete_protocol_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 } : {} };
+    }
+    return { ok: true };
 }
 function wholeServerRuleName(name) {
     const read = name.trim();
@@ -101,11 +112,16 @@ function wholeServerRuleName(name) {
 }
 const compileVerdict = ruleCompileVerdict;
 const kept = (reason) => ({ sent: false, reason });
-function sentFate(wire, toolName, unchecked) {
-    const segment = protocolSegmentOf(toolName);
-    return segment.kind === 'unminted'
-        ? { sent: true, wire, unchecked, unreachable: segment.minted !== undefined ? { minted: segment.minted } : {} }
-        : { sent: true, wire, unchecked };
+function compileRefused(verdict) {
+    return {
+        sent: false,
+        reason: 'compile_refused',
+        ...(verdict.code !== undefined ? { code: verdict.code } : {}),
+        ...(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 judgeList(rules, behavior, allowForm = 'grant') {
     let portsChecked = false;
@@ -119,42 +135,34 @@ function judgeList(rules, behavior, allowForm = 'grant') {
         const parsed = parseRule(rule);
         if (parsed.ruleContent === undefined) {
             const name = wholeServerRuleName(parsed.toolName);
-            const issue = wireIssue(name);
-            if (issue !== undefined)
-                return kept(issue);
-            if (behavior === 'allow') {
-                const segment = protocolSegmentOf(name);
-                if (segment.kind === 'unminted')
-                    return kept('unminted_protocol_segment');
-                if (segment.kind === 'unknown')
-                    return kept('judge_failed');
-            }
+            const check = nameCheck(name);
+            if ('issue' in check)
+                return kept(check.issue);
+            if (behavior === 'allow' && 'unminted' in check)
+                return kept('unminted_protocol_segment');
             const verdict = compileVerdict(name, behavior === 'ask' ? 'ask' : 'deny');
-            if (verdict === 'refused')
-                return kept('compile_refused');
-            if (verdict === 'unknown' && behavior === 'allow')
+            if (verdict.kind === 'refused')
+                return compileRefused(verdict);
+            if (verdict.kind === 'unknown' && behavior === 'allow')
                 return kept('judge_failed');
-            return behavior === 'allow' ? { sent: true, wire: name, unchecked: false } : sentFate(name, name, verdict === 'unknown');
+            return behavior === 'allow' ? { sent: true, wire: name, unchecked: false } : sentFate(name, check, verdict.kind === 'unknown');
         }
-        const issue = wireIssue(parsed.toolName);
-        if (issue !== undefined)
-            return kept(issue);
+        const check = nameCheck(parsed.toolName);
+        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');
-            const segment = protocolSegmentOf(parsed.toolName);
-            if (segment.kind === 'unminted')
+            if ('unminted' in check)
                 return kept('unminted_protocol_segment');
-            if (segment.kind === 'unknown')
-                return kept('judge_failed');
             return { sent: true, wire: rule, unchecked: false };
         }
         const verdict = compileVerdict(rule, behavior);
-        if (verdict === 'refused')
-            return kept('compile_refused');
-        return sentFate(rule, parsed.toolName, verdict === 'unknown');
+        if (verdict.kind === 'refused')
+            return compileRefused(verdict);
+        return sentFate(rule, check, verdict.kind === 'unknown');
     });
 }
 function outsideSettingsFiles(origin) {
@@ -370,8 +378,15 @@ function assemble(input, caps) {
     for (const [bucket, slots, j] of rows) {
         slots.forEach((s, k) => {
             const f = j.fates[k];
-            if (!f.sent)
-                keptRows.push({ rule: s.rule, bucket, reason: f.reason });
+            if (!f.sent) {
+                keptRows.push({
+                    rule: s.rule,
+                    bucket,
+                    reason: f.reason,
+                    ...(f.code !== undefined ? { code: f.code } : {}),
+                    ...(f.message !== undefined ? { message: f.message } : {}),
+                });
+            }
         });
         for (const wire of j.sent) {
             const winner = j.winnerOf.get(wire);

package/dist/printPermissionOutcome.d.ts

@@ -0,0 +1,12 @@
+import { type GateOutcomeView } from './gateOutcome.js';
+import { type NoticeOutlet, type NoticeSeatClass } from './noticePresentation.js';
+export declare const PRINT_PERMISSION_OUTCOME_FORMS: readonly ["mode_denied", "no_approver", "mode_released"];
+export type PrintPermissionOutcomeForm = (typeof PRINT_PERMISSION_OUTCOME_FORMS)[number];
+export interface PrintPermissionOutcome {
+    readonly form: PrintPermissionOutcomeForm;
+    readonly sentence: string;
+    readonly audience: 'user';
+    readonly outlet: NoticeOutlet;
+    readonly seatClass: NoticeSeatClass;
+}
+export declare function printPermissionOutcomeOf(gate: GateOutcomeView | undefined): PrintPermissionOutcome | undefined;

package/dist/printPermissionOutcome.js

@@ -0,0 +1,50 @@
+import { modeReleaseReasonSentence } from './gateOutcome.js';
+import { noticeSeatClassOf } from './noticePresentation.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+export const PRINT_PERMISSION_OUTCOME_FORMS = Object.freeze(['mode_denied', 'no_approver', 'mode_released']);
+const ALLOW_RULE_REMEDY = 'add an allow rule for the tool in settings (or pass --allowedTools)';
+const SENTENCES = Object.freeze({
+    dontAsk: {
+        sentence: `the dontAsk permission mode denies tools that need approval unless a permission rule allows them — ${ALLOW_RULE_REMEDY}`,
+        outlet: 'present',
+    },
+    bypassPermissions: {
+        sentence: 'the bypassPermissions permission mode refused a call because it could not tell whether the write it makes lands on a protected path',
+        outlet: 'absent',
+    },
+    mode: { sentence: "the session's permission mode denied a call that needed approval", outlet: 'absent' },
+    no_approver: {
+        sentence: `print mode has no approval channel: tools that need approval are denied unless a permission rule allows them — ${ALLOW_RULE_REMEDY}, or pass --permission-mode acceptEdits or auto`,
+        outlet: 'present',
+    },
+});
+function outcomeOf(form, sentence, outlet) {
+    return Object.freeze({ form, sentence, audience: 'user', outlet, seatClass: noticeSeatClassOf('user', outlet) });
+}
+function slot(from, key) {
+    return typeof from === 'object' && from !== null ? guardedRead(() => readOwnDataValue(from, key)) : undefined;
+}
+export function printPermissionOutcomeOf(gate) {
+    const disposition = slot(gate, 'disposition');
+    const kind = slot(disposition, 'kind');
+    if (kind === 'denied') {
+        const deniedBy = slot(disposition, 'deniedBy');
+        if (deniedBy === 'mode') {
+            const mode = slot(disposition, 'mode');
+            const row = mode === 'dontAsk' ? SENTENCES.dontAsk : mode === 'bypassPermissions' ? SENTENCES.bypassPermissions : SENTENCES.mode;
+            return outcomeOf('mode_denied', row.sentence, row.outlet);
+        }
+        if (deniedBy === 'ask_resolution') {
+            const settled = slot(slot(gate, 'settlement'), 'kind');
+            if (settled === 'no_approver' || settled === 'approver_unavailable')
+                return outcomeOf('no_approver', SENTENCES.no_approver.sentence, SENTENCES.no_approver.outlet);
+        }
+        return undefined;
+    }
+    if (kind === 'allowed') {
+        const reason = slot(slot(disposition, 'released'), 'reason');
+        const sentence = typeof reason === 'string' ? modeReleaseReasonSentence(reason) : undefined;
+        return sentence === undefined ? undefined : outcomeOf('mode_released', sentence, 'absent');
+    }
+    return undefined;
+}

package/dist/printToolResultFrame.d.ts

@@ -13,6 +13,7 @@ export interface ToolEndResultArmLike {
     delivered?: unknown;
     gatedCallId?: unknown;
     _sema_denial_kind?: unknown;
+    notExecuted?: true;
     parentToolCallId?: unknown;
     uuid?: unknown;
     session_id?: unknown;