@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/permissionModesCapability.d.ts

@@ -1,5 +1,7 @@
 export type PermissionModesReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -7,9 +9,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

@@ -38,11 +38,7 @@ export function projectPermissionModesCapability(caps) {
 const reader = createEngineCapReader({
     name: 'permissionModes',
     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 +57,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/permissionRulesWriteCapability.d.ts

@@ -1,5 +1,7 @@
 export type PermissionRulesWriteReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/permissionRulesWriteCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectPermissionRulesWriteCapability(caps) {
     try {
@@ -21,7 +21,6 @@ export function projectPermissionRulesWriteCapability(caps) {
 const reader = createEngineCapReader({
     name: 'permissionRulesWrite',
     project: projectPermissionRulesWriteCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForPermissionRulesWrite(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -34,6 +33,8 @@ export function permissionRulesWriteAvailable(reading) {
 }
 export function permissionRulesWriteDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('permission-rule write entry');
         case 'unobserved':
             return 'permission-rule write entry not observed — the engine reports it on /v1/capabilities (permissionRulesWrite); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':

package/dist/permissionsAllowGrantCapability.d.ts

@@ -1,5 +1,7 @@
 export type PermissionsAllowGrantReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/permissionsAllowGrantCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 import { hasCoreValuePort } from './coreValuePorts.js';
 const ALLOW_GRANT_CAP_PATH = ['settings', 'permissions', 'allowGrant'];
@@ -35,7 +35,6 @@ export function projectPermissionsAllowGrantCapability(caps) {
 const reader = createEngineCapReader({
     name: ALLOW_GRANT_CAP_PATH.join('.'),
     project: projectPermissionsAllowGrantCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForPermissionsAllowGrant(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -95,6 +94,9 @@ export function permissionsAllowGrantDoctorDetail(reading, settingsRead) {
     if (kind === 'present' && ownReadingField(reading, 'grants') === false) {
         return 'allow rules kept on this side — this engine says it does not read allow rules as rules of that kind, so they are not sent and matching approvals are still answered here';
     }
+    if (kind === 'unreadable') {
+        return `${unreadableReadingDetail('how this engine reads allow rules')}; allow rules are kept on this side (not sent), and matching approvals are still answered here`;
+    }
     if (kind === 'not_reported') {
         return 'allow rules kept on this side — this engine does not say how it reads allow rules; sending them to an engine that reads them as an exclusive list would block every tool not on it, so they are not sent and matching approvals are still answered here';
     }

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';
@@ -29,19 +29,6 @@ export const PERMISSIONS_KEPT_REASONS = Object.freeze([
     'duplicate',
     'voids_allow_list',
 ]);
-function normalizeLegacyToolName(name) {
-    switch (name) {
-        case 'Task':
-            return 'Agent';
-        case 'KillShell':
-            return 'TaskStop';
-        case 'AgentOutputTool':
-        case 'BashOutputTool':
-            return 'TaskOutput';
-        default:
-            return name;
-    }
-}
 function unescapedIndex(str, char, fromEnd) {
     for (let k = 0; k < str.length; k++) {
         const i = fromEnd ? str.length - 1 - k : k;
@@ -61,35 +48,46 @@ function unescapeRuleContent(content) {
 function parseRule(rule) {
     const open = unescapedIndex(rule, '(', false);
     if (open === -1)
-        return { toolName: normalizeLegacyToolName(rule) };
+        return { toolName: rule };
     const close = unescapedIndex(rule, ')', true);
     if (close === -1 || close <= open || close !== rule.length - 1)
-        return { toolName: normalizeLegacyToolName(rule) };
+        return { toolName: rule };
     const toolName = rule.substring(0, open);
     const rawContent = rule.substring(open + 1, close);
     if (!toolName)
-        return { toolName: normalizeLegacyToolName(rule) };
+        return { toolName: rule };
     if (rawContent === '' || rawContent === '*')
-        return { toolName: normalizeLegacyToolName(toolName) };
-    return { toolName: normalizeLegacyToolName(toolName), ruleContent: unescapeRuleContent(rawContent) };
+        return { toolName };
+    return { 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 { retired: verdict.currentName !== undefined ? { currentName: verdict.currentName } : {} };
+    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 +99,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;
@@ -118,43 +121,46 @@ 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');
+            let name = wholeServerRuleName(parsed.toolName);
+            let check = nameCheck(name);
+            if ('retired' in check) {
+                const successor = check.retired.currentName;
+                if (behavior === 'allow' || successor === undefined)
+                    return kept('retired_tool_name');
+                name = successor;
+                check = nameCheck(name);
+                if ('retired' in check)
+                    return kept('retired_tool_name');
             }
+            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 ('retired' in check)
+            return kept('retired_tool_name');
+        if ('issue' in check)
+            return kept(check.issue);
         if (ruleToolGrammarOf(parsed.toolName) === 'path' && parsed.ruleContent.startsWith('~/'))
             return kept('home_relative_path');
         if (behavior === 'allow') {
             if (allowForm !== 'layer')
                 return kept('content_form_not_grantable');
-            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 +376,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;

package/dist/printToolResultFrame.js

@@ -1,14 +1,8 @@
 import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
-import { parseModelFacingBash } from './toolResult.js';
-import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
 import { toolResultEnvelopeParts, toolResultOutcomeOf } from './adapt/toolCards.js';
-function bashExitCodeFailed(toolName, text, structured) {
-    if (typeof toolName !== 'string' || toolName.toLowerCase() !== 'bash')
-        return false;
-    return bashExitReadingFailed(bashExitOf(structured, () => parseModelFacingBash(text)));
-}
+import { readFrameTrueMark } from './ownKey.js';
 export function toolEndResultToUserFrame(arm) {
     if (typeof arm.toolCallId !== 'string' || arm.toolCallId.length === 0)
         return null;
@@ -21,6 +15,7 @@ export function toolEndResultToUserFrame(arm) {
         isError: arm.isError === true,
     }, undefined, parent === null ? 'leader' : 'subagent');
     const envelope = toolResultEnvelopeParts(outcome);
+    const content = Array.isArray(outcome.body.content) ? outcome.body.content : arm.truncated === true ? `${text}\n…(truncated)` : text;
     return {
         type: 'user',
         message: {
@@ -29,13 +24,14 @@ export function toolEndResultToUserFrame(arm) {
                 {
                     type: 'tool_result',
                     tool_use_id: arm.toolCallId,
-                    content: arm.truncated === true ? `${text}\n…(truncated)` : text,
-                    is_error: arm.isError === true || bashExitCodeFailed(arm.toolName, text, arm.structured),
+                    content,
+                    is_error: outcome.body.isError,
                 },
             ],
         },
         parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
+        ...(readFrameTrueMark(arm, 'notExecuted') ? { _sema_not_executed: true } : {}),
         ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
         ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: arm.uuid,

package/dist/promptBlockedCopy.d.ts

@@ -0,0 +1,5 @@
+import type { RunTerminalRead } from './runTerminal.js';
+export declare const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = "UserPromptSubmit operation blocked by hook";
+export declare function runBlockedText(blocked: Extract<RunTerminalRead, {
+    kind: 'blocked';
+}>): string;

package/dist/promptBlockedCopy.js

@@ -0,0 +1,35 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { stripSystemReminderTagTokens, unwrapSystemReminder } from './systemReminderTag.js';
+export const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = 'UserPromptSubmit operation blocked by hook';
+const RUN_BLOCKED_REASONED = 'Run blocked';
+const RUN_BLOCKED_NO_REASON = 'Run blocked (the agent reported it cannot proceed)';
+const HOOK_WORDS_SHOWN_MAX = 1000;
+const CAUSE_CLAUSE = Object.freeze({
+    crashed: 'the hook failed before it answered; the prompt was not submitted',
+    timeout: 'the hook did not answer in time; the prompt was not submitted',
+    cancelled: 'the run was cancelled while the hook was checking the prompt; the prompt was not submitted',
+});
+function shownHookWords(words) {
+    if (words === undefined)
+        return undefined;
+    const shown = stripSystemReminderTagTokens(displayUntrusted(stripSystemReminderTagTokens(words), { max: HOOK_WORDS_SHOWN_MAX })).trim();
+    return shown === '' ? undefined : shown;
+}
+export function runBlockedText(blocked) {
+    const detail = blocked.detail;
+    if (detail !== undefined && detail.kind === 'prompt_blocked_by_hook') {
+        const clause = detail.cause !== 'unrecognized' && Object.hasOwn(CAUSE_CLAUSE, detail.cause) ? CAUSE_CLAUSE[detail.cause] : undefined;
+        const words = shownHookWords(detail.hookReason);
+        if (clause !== undefined)
+            return `${PROMPT_BLOCKED_BY_HOOK_ROW_LEAD}: ${clause}${words !== undefined ? `\n${words}` : ''}`;
+        return words !== undefined ? `${PROMPT_BLOCKED_BY_HOOK_ROW_LEAD}:\n${words}` : PROMPT_BLOCKED_BY_HOOK_ROW_LEAD;
+    }
+    const reason = blocked.reason;
+    if (reason === undefined)
+        return RUN_BLOCKED_NO_REASON;
+    const unwrapped = unwrapSystemReminder(reason);
+    if (unwrapped === reason)
+        return `${RUN_BLOCKED_REASONED}: ${reason}`;
+    const body = stripSystemReminderTagTokens(unwrapped).trim();
+    return body === '' ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${body}`;
+}

package/dist/protocolSegment.d.ts

@@ -1,12 +1,15 @@
-export type ProtocolSegment = {
-    readonly kind: 'ok';
+export type RuleToolNameReading = {
+    readonly kind: 'current';
 } | {
-    readonly kind: 'empty';
+    readonly kind: 'retired';
+    readonly currentName?: string;
 } | {
-    readonly kind: 'unminted';
-    readonly minted?: string;
+    readonly kind: 'unprefixed_namespace';
+} | {
+    readonly kind: 'unmintable_segment';
 } | {
     readonly kind: 'unknown';
 };
-export declare function protocolSegmentOf(name: string): ProtocolSegment;
+export declare function ruleToolNameVerdictOf(name: string): RuleToolNameReading;
+export declare function mintedPrefixOf(name: string): string | undefined;
 export declare function clientOwnedServerPrefix(server: string): string | undefined;

package/dist/protocolSegment.js

@@ -1,33 +1,43 @@
-import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
-import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
-export function protocolSegmentOf(name) {
-    if (CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix) && name.slice(prefix.length).split('__')[0] === ''))
-        return { kind: 'empty' };
-    const ns = protocolOf(name);
-    if (ns === undefined)
-        return hasCoreValuePort('protocolOf') ? { kind: 'ok' } : { kind: 'unknown' };
-    let parsed;
+import { mcpNamespace, mintNamespacePrefix, protocolOf, ruleToolNameJudgement } from './coreValuePorts.js';
+export function ruleToolNameVerdictOf(name) {
+    let kind;
+    let currentName;
     try {
-        parsed = ns.parse(name);
+        const v = ruleToolNameJudgement(name, new Set());
+        if (v === null || typeof v !== 'object')
+            return { kind: 'unknown' };
+        kind = v.kind;
+        if (kind === 'retired')
+            currentName = v.currentName;
     }
     catch {
         return { kind: 'unknown' };
     }
-    const peer = parsed?.peer;
-    if (typeof peer !== 'string')
-        return { kind: 'ok' };
-    if (peer.includes('*'))
-        return { kind: 'unminted' };
-    let minted;
+    switch (kind) {
+        case 'current':
+        case 'unprefixed_namespace':
+        case 'unmintable_segment':
+            return { kind };
+        case 'retired':
+            return typeof currentName === 'string' && currentName !== '' ? { kind, currentName } : { kind };
+        default:
+            return { kind: 'unknown' };
+    }
+}
+export function mintedPrefixOf(name) {
     try {
-        minted = mintNamespacePrefix(ns, peer);
+        const ns = protocolOf(name);
+        if (ns === undefined)
+            return undefined;
+        const peer = ns.parse(name)?.peer;
+        if (typeof peer !== 'string' || peer.includes('*'))
+            return undefined;
+        const minted = mintNamespacePrefix(ns, peer);
+        return typeof minted === 'string' ? minted : undefined;
     }
     catch {
-        return { kind: 'unknown' };
+        return undefined;
     }
-    if (typeof minted !== 'string')
-        return { kind: 'unknown' };
-    return minted === `${ns.prefix}${peer}__` ? { kind: 'ok' } : { kind: 'unminted', minted };
 }
 export function clientOwnedServerPrefix(server) {
     try {

package/dist/providerRejection.d.ts

@@ -1,8 +1,12 @@
 import { type RunTerminalFailureDetail } from './runTerminal.js';
 import { type ToolHistoryErrorCarrier } from './toolHistoryMismatch.js';
+export declare const PROVIDER_REJECTION_KINDS: readonly ["schema_invalid", "auth", "rate_limited", "resend_eligible", "unknown"];
+export type ProviderRejectionKind = (typeof PROVIDER_REJECTION_KINDS)[number];
 export interface ProviderRejectionResend {
     resend: 'edit_and_resend' | 'not_by_editing';
     text: string;
+    kind: ProviderRejectionKind;
 }
 export declare function readProviderRejectionResendKey(v: object | null | undefined): ProviderRejectionResend | undefined;
 export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined, carrier?: ToolHistoryErrorCarrier | null): ProviderRejectionResend | undefined;
+export declare function providerRejectionKind(detail: RunTerminalFailureDetail | null | undefined): ProviderRejectionKind;