@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/ownKey.js

@@ -34,6 +34,12 @@ export function readOwnDataValue(v, key) {
     const d = Object.getOwnPropertyDescriptor(v, key);
     return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
 }
+export function carriesAnswerText(text) {
+    return text.trim().length > 0;
+}
+export function appendOwnElement(list, value) {
+    Object.defineProperty(list, list.length, { value, writable: true, enumerable: true, configurable: true });
+}
 export function guardedRead(read) {
     try {
         return read();
@@ -106,7 +112,7 @@ function contextUsageSectionRowsOf(raw) {
     for (let i = 0; i < n; i++) {
         const row = guardedRead(() => contextUsageSectionRowOf(raw, i));
         if (row !== undefined)
-            rows.push(row);
+            appendOwnElement(rows, row);
     }
     return rows.length > 0 ? rows : undefined;
 }
@@ -157,7 +163,7 @@ export function humanInputAttachmentsOf(frame) {
                 return { ordinal, ...(kind !== undefined ? { kind } : {}), outcome, ...(label !== undefined ? { label } : {}) };
             });
             if (row !== undefined)
-                rows.push(row);
+                appendOwnElement(rows, row);
         }
         return rows.length > 0 ? rows : undefined;
     }
@@ -189,3 +195,233 @@ export function mcpSectionDroppedNamedRowsOf(rows, name) {
         return 0;
     }
 }
+export function promptManifestSectionViewOf(row) {
+    const o = row;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const id = str(o.id);
+    const chars = typeof o.chars === 'number' && Number.isFinite(o.chars) && o.chars >= 0 ? o.chars : undefined;
+    if (id === undefined || chars === undefined)
+        return undefined;
+    const band = str(o.band);
+    const locale = str(o.locale);
+    const variant = str(o.variant);
+    const contentHash = band !== undefined ? str(o.contentHash) : undefined;
+    const slot = str(o.slot);
+    return {
+        id,
+        chars,
+        ...(band !== undefined ? { band } : {}),
+        ...(locale !== undefined ? { locale } : {}),
+        ...(variant !== undefined ? { variant } : {}),
+        ...(contentHash !== undefined ? { contentHash } : {}),
+        ...(slot !== undefined ? { slot } : {}),
+    };
+}
+export function promptManifestIdentityOfFrame(frame) {
+    let raw;
+    try {
+        raw = frame.identity;
+    }
+    catch {
+        return undefined;
+    }
+    return promptManifestIdentityOf(typeof raw === 'object' && raw !== null ? raw : undefined);
+}
+export function promptManifestIdentityOf(raw) {
+    try {
+        const plain = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+        const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+        if (!plain(raw))
+            return undefined;
+        const artifact = str(raw.artifact);
+        const activatedBy = str(raw.activatedBy);
+        const epochRaw = raw.epoch;
+        const epoch = typeof epochRaw === 'number' && Number.isInteger(epochRaw) && epochRaw >= 0 ? epochRaw : undefined;
+        const layersRaw = raw.layers;
+        if (artifact === undefined || activatedBy === undefined || epoch === undefined || !plain(layersRaw))
+            return undefined;
+        const catalog = str(layersRaw.catalog);
+        const binding = str(layersRaw.binding);
+        if (catalog === undefined || binding === undefined)
+            return undefined;
+        const optional = {};
+        for (const k of ['center', 'deploy', 'task']) {
+            const v = layersRaw[k];
+            if (v === undefined)
+                continue;
+            const t = str(v);
+            if (t === undefined)
+                return undefined;
+            optional[k] = t;
+        }
+        const renderersRaw = layersRaw.renderers;
+        if (!plain(renderersRaw))
+            return undefined;
+        const entries = [];
+        for (const [k, v] of Object.entries(renderersRaw)) {
+            if (typeof v !== 'number' || !Number.isFinite(v))
+                return undefined;
+            appendOwnElement(entries, [k, v]);
+        }
+        const renderers = Object.fromEntries(entries);
+        return { artifact, layers: { catalog, renderers, ...optional, binding }, epoch, activatedBy };
+    }
+    catch {
+        return undefined;
+    }
+}
+const SAMPLED = new WeakSet();
+const SAMPLE_MAX_DEPTH = 256;
+export function isOwnSnapshot(v) {
+    return isBranded(v);
+}
+function isBranded(v) {
+    return typeof v === 'object' && v !== null && SAMPLED.has(v);
+}
+function arrayIndexOfKey(k) {
+    if (!/^(?:0|[1-9]\d*)$/.test(k))
+        return undefined;
+    const n = Number(k);
+    return n < 4294967295 ? n : undefined;
+}
+export function ownSnapshot(value) {
+    return snapshotOf(value);
+}
+function snapshotOf(value) {
+    if (typeof value === 'object' && value !== null) {
+        if (SAMPLED.has(value))
+            return value;
+        return sampleObject(value, 0, { done: new Map(), path: new Set(), seen: new Set(), rework: 0, depthCuts: 0 });
+    }
+    return samplePrimitive(value);
+}
+export function ownSnapshotWhenTyped(value, word) {
+    return snapshotWhenTyped(value, word);
+}
+function snapshotWhenTyped(value, word) {
+    if (typeof value !== 'object' || value === null)
+        return value;
+    if (guardedRead(() => Array.isArray(value)) === true)
+        return value;
+    const read = guardedRead(() => ({ own: Object.getOwnPropertyDescriptor(value, 'type') }));
+    if (read !== undefined) {
+        const own = read.own;
+        if (own === undefined) {
+            if (guardedRead(() => 'type' in value) === false)
+                return value;
+        }
+        else if (Object.hasOwn(own, 'value') && typeof own.value === 'string' && own.value !== '' && own.value !== word) {
+            return value;
+        }
+    }
+    return recordOf(value);
+}
+export function ownSnapshotTyped(value) {
+    return recordOf(value);
+}
+export function ownSnapshotRecord(value) {
+    return recordOf(value);
+}
+function recordOf(value) {
+    const s = snapshotOf(value);
+    return typeof s === 'object' && s !== null && !Array.isArray(s) ? s : undefined;
+}
+function samplePrimitive(v) {
+    return typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' ? v : v === null ? null : undefined;
+}
+const SAMPLE_MAX_TRAILING_HOLES = 1024;
+const SAMPLE_MAX_INDEX = 1 << 20;
+const SAMPLE_MAX_REWORK = 2048;
+function sampleValue(v, depth, run) {
+    return typeof v === 'object' && v !== null ? sampleObject(v, depth, run) : samplePrimitive(v);
+}
+function sampleObject(src, depth, run) {
+    const hit = run.done.get(src);
+    if (hit !== undefined)
+        return hit ?? undefined;
+    if (SAMPLED.has(src))
+        return src;
+    if (run.path.has(src))
+        return undefined;
+    if (depth >= SAMPLE_MAX_DEPTH) {
+        run.depthCuts++;
+        return undefined;
+    }
+    if (run.seen.has(src)) {
+        if (++run.rework > SAMPLE_MAX_REWORK) {
+            run.depthCuts++;
+            return undefined;
+        }
+    }
+    else {
+        run.seen.add(src);
+    }
+    let isArray;
+    let keys;
+    try {
+        isArray = Array.isArray(src);
+        keys = Reflect.ownKeys(src);
+    }
+    catch {
+        run.done.set(src, null);
+        return undefined;
+    }
+    run.path.add(src);
+    const cutsBefore = run.depthCuts;
+    try {
+        const rec = {};
+        const arr = [];
+        let tail = 0;
+        let good = 0;
+        let declared = 0;
+        for (const k of keys) {
+            if (typeof k !== 'string')
+                continue;
+            if (isArray && k === 'length') {
+                const lv = guardedRead(() => {
+                    const ld = Object.getOwnPropertyDescriptor(src, 'length');
+                    return ld !== undefined && Object.hasOwn(ld, 'value') ? ld.value : undefined;
+                });
+                if (typeof lv === 'number' && Number.isInteger(lv) && lv > 0 && lv <= 0xffffffff)
+                    declared = lv;
+                continue;
+            }
+            const index = isArray ? arrayIndexOfKey(k) : undefined;
+            if (isArray && index === undefined)
+                continue;
+            if (index !== undefined && index >= SAMPLE_MAX_INDEX)
+                continue;
+            if (index !== undefined && index + 1 > tail)
+                tail = index + 1;
+            const d = guardedRead(() => Object.getOwnPropertyDescriptor(src, k));
+            if (d === undefined)
+                continue;
+            if (d.enumerable !== true || !Object.hasOwn(d, 'value'))
+                continue;
+            const child = sampleValue(d.value, depth + 1, run);
+            if (child === undefined)
+                continue;
+            if (index !== undefined) {
+                Object.defineProperty(arr, index, { value: child, writable: true, enumerable: true, configurable: true });
+                if (index + 1 > good)
+                    good = index + 1;
+            }
+            else
+                putOwnKey(rec, k, child);
+        }
+        if (isArray) {
+            const want = Math.max(good, Math.min(Math.max(tail, declared), good + SAMPLE_MAX_TRAILING_HOLES));
+            if (arr.length < want)
+                arr.length = want;
+        }
+        const out = isArray ? arr : rec;
+        Object.freeze(out);
+        SAMPLED.add(out);
+        if (run.depthCuts === cutsBefore)
+            run.done.set(src, out);
+        return out;
+    }
+    finally {
+        run.path.delete(src);
+    }
+}

package/dist/panelReduce.d.ts

@@ -116,6 +116,11 @@ export declare function reducePanelFrame(state: PanelReduceState, frame: PanelFr
 };
 export declare function panelRowSnapshot(state: PanelReduceState): PanelDelta[];
 export declare function panelResolveTaskId(state: PanelReduceState, wireTaskId: string): EnginePanelTaskIdentity;
+export interface PanelSubagentIdentity {
+    readonly key: string;
+    readonly ids: readonly string[];
+}
+export declare function panelSubagentOf(state: PanelReduceState, id: string): PanelSubagentIdentity | undefined;
 export declare function panelIsResident(state: PanelReduceState, taskId: string): boolean;
 export declare function panelAnchorOf(state: PanelReduceState, taskId: string): string | undefined;
 export declare function panelPresenceSize(state: PanelReduceState, sessionKey: string): number;

package/dist/panelReduce.js

@@ -1,6 +1,6 @@
 import { rowIdTail } from './workflow.js';
 import { isSdkFleetTaskTerminal, isSdkFleetTaskTerminalNotSuccess } from './terminalStatuses.js';
-import { carryCycle, cycleEmpty, cycleKeysChanged, cycleOf, cycleOrder, mergeCycle, } from './cycleOrder.js';
+import { carryCycle, cycleEmpty, cycleKeysChanged, cycleOf, cycleOrder, cycleSeqValue, mergeCycle, } from './cycleOrder.js';
 export function isStaleEngineAgentPanelEnd(end, current) {
     return cycleOrder(end, current) === 'before';
 }
@@ -575,10 +575,26 @@ function fullUsage(key, row) {
         return undefined;
     return usageDelta(key, { ...(row.totalTokens !== undefined ? { totalTokens: row.totalTokens } : {}), ...(row.toolUses !== undefined ? { toolUses: row.toolUses } : {}), ...(fin !== undefined ? { final: fin } : {}) });
 }
+function ownDataOf(o, key) {
+    if (typeof o !== 'object' || o === null)
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function publisherFinality(f) {
+    return { ...(ownDataOf(f, 'totalTokens') === true ? { totalTokens: true } : {}), ...(ownDataOf(f, 'toolUses') === true ? { toolUses: true } : {}) };
+}
 function fleetCarrier(ev) {
-    const f = ev.final;
-    const final = { ...(f?.totalTokens === true ? { totalTokens: true } : {}), ...(f?.toolUses === true ? { toolUses: true } : {}) };
-    return { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final };
+    return { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final: publisherFinality(ownDataOf(ev, 'final')) };
+}
+function tickCycleOf(ev) {
+    const c = cycleSeqValue(ownDataOf(ev, 'cycleSeq'));
+    return c === undefined ? undefined : { cycleSeq: c };
 }
 function finalityOf(tokens, toolUses) {
     if (tokens === undefined && toolUses === undefined)
@@ -638,17 +654,20 @@ function announce(d, rid) {
     if (row.phase === 'ended')
         mintTerminal(d, key, row.isError === true, row.report, 'end');
 }
-function foldTick(d, rid, ev, cardBound) {
+function foldTick(d, rid, ev, cardBound, final) {
     const r = d.rec(rid);
     if (r === undefined)
         return;
     const row = r.row;
     const gate = cardBound ? { gateBound: true } : {};
     const wireId = ev.wireTaskId ?? ev.taskId;
-    const attributable = !hasCycleSeq(r.cycle) && (r.currentRun === undefined || r.currentRun === wireId);
+    const tickCycle = tickCycleOf(ev);
+    const attributable = hasCycleSeq(r.cycle)
+        ? tickCycle !== undefined && cycleOrder(tickCycle, r.cycle) === 'same'
+        : r.currentRun === undefined || r.currentRun === wireId;
     if (!attributable)
         d.counts.unattributedTicks++;
-    const carrier = attributable ? { totalTokens: ev.totalTokens, toolUses: ev.toolUses } : {};
+    const carrier = attributable ? { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final } : {};
     if (row === undefined || !row.announced) {
         const base = row !== undefined
             ? { ...row, ...gate, tickSeen: true, fields: { ...row.fields, ...tickFields(ev) } }
@@ -789,28 +808,37 @@ function foldAbsence(d, rid, a) {
     d.deltas.push({ op: 'upsert', canonicalId: keyOf(r), fields: { absence } });
     d.put(rid, { row: { ...row, fields: { ...row.fields, absence } } });
 }
-function stripCardBound(ev) {
-    const { cardBound: _cardBound, ...rest } = ev;
-    void _cardBound;
-    return rest;
+function tickFactBase(ev) {
+    const out = {};
+    for (const k of Reflect.ownKeys(ev)) {
+        if (typeof k !== 'string' || k === 'cardBound' || k === 'final' || k === 'cycleSeq')
+            continue;
+        if (!Object.prototype.propertyIsEnumerable.call(ev, k))
+            continue;
+        out[k] = Reflect.get(ev, k);
+    }
+    return out;
 }
 function emitTick(d, ev) {
     const found = d.find(ev.taskId);
     const fr = found !== undefined ? d.rec(found) : undefined;
     if (fr !== undefined && formerGeneration(fr, ev.taskId))
         return;
+    const tickCycle = tickCycleOf(ev);
+    if (fr !== undefined && tickCycle !== undefined && cycleOrder(tickCycle, genOf(fr)) === 'before')
+        return;
     const rid = found ?? d.create({ id: ev.taskId });
     d.records.touch(rid);
     const r = d.rec(rid);
     if (r === undefined)
         return;
     const key = keyOf(r);
-    const plain = stripCardBound(ev);
+    const plain = { ...tickFactBase(ev), ...(tickCycle !== undefined ? { cycleSeq: tickCycle.cycleSeq } : {}) };
     const fact = key === ev.taskId
         ? { ...plain, taskIdOrigin: 'wire' }
         : { ...plain, taskId: key, wireTaskId: ev.taskId, taskIdOrigin: key === r.tail ? 'fleet-row' : 'wire' };
     d.facts.push({ ch: 'event', ev: fact });
-    foldTick(d, rid, fact, ev.cardBound === true);
+    foldTick(d, rid, fact, ev.cardBound === true, publisherFinality(ownDataOf(ev, 'final')));
 }
 function flushHeld(d, wireTaskId) {
     const held = d.pending.get(wireTaskId);
@@ -1278,6 +1306,10 @@ export function panelResolveTaskId(state, wireTaskId) {
         return { taskId: wireTaskId, origin: 'wire' };
     return { taskId: r.tail, origin: 'fleet-row', ...cycleOf(bindingOf(r, wireTaskId)?.gen) };
 }
+export function panelSubagentOf(state, id) {
+    const r = recordOfId(state, id);
+    return r === undefined ? undefined : { key: keyOf(r), ids: idsOf(r) };
+}
 export function panelIsResident(state, taskId) {
     return recordOfId(state, taskId)?.resident === true;
 }

package/dist/panelStateHolder.d.ts

@@ -1,5 +1,6 @@
 import { type PanelDelta, type PanelFact, type PanelFrame, type PanelReduceState } from './panelReduce.js';
 export declare function panelStateNow(): PanelReduceState;
+export declare function panelSubagentIdsNow(id: string): readonly string[] | undefined;
 export declare function stepEnginePanel(frame: PanelFrame): void;
 export declare function replaceEnginePanelState(fn: (s: PanelReduceState) => PanelReduceState): void;
 export declare function clearEnginePanelIdentity(): void;

package/dist/panelStateHolder.js

@@ -1,9 +1,17 @@
-import { createPanelReduceState, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, stepPanelFrame, } from './panelReduce.js';
+import { createPanelReduceState, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, panelSubagentOf, stepPanelFrame, } from './panelReduce.js';
+import { bindSubagentIdentityReader } from './subagentContentStore.js';
 let state = createPanelReduceState();
 export function panelStateNow() {
     return state;
 }
+export function panelSubagentIdsNow(id) {
+    return panelSubagentOf(state, id)?.ids;
+}
+function bindIdentityReader() {
+    bindSubagentIdentityReader(panelSubagentIdsNow);
+}
 export function stepEnginePanel(frame) {
+    bindIdentityReader();
     const r = stepPanelFrame(state, frame);
     state = r.state;
     if (rowListener !== null)
@@ -18,6 +26,7 @@ export function stepEnginePanel(frame) {
     }
 }
 export function replaceEnginePanelState(fn) {
+    bindIdentityReader();
     state = fn(state);
 }
 export function clearEnginePanelIdentity() {

package/dist/peerFrames.d.ts

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

package/dist/peerFrames.js

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

package/dist/peerLaneCapability.js

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

package/dist/permissionModesCapability.js

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

package/dist/permissionRuleIssue.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare const PERMISSION_RULE_ISSUE_CODES: readonly string[];
 export declare const RETIRED_PERMISSION_RULE_ISSUE_CODES: readonly string[];
-export declare function permissionRuleIssueDetail(code: unknown, message: unknown, rule?: string): string;
+export declare function permissionRuleIssueDetail(code: unknown, message: unknown, rule?: string, lang?: UiLanguage): string;

package/dist/permissionRuleIssue.js

@@ -1,4 +1,5 @@
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
     'invalid.empty_tool',
     'invalid.paren',
@@ -13,6 +14,7 @@ export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
     'unsupported.param_unknown',
     'unsupported.param_non_scalar',
     'unsupported.tool_unknown',
+    'invalid.name_ambiguous',
     'unsupported.path_base',
     'unsupported.mcp_paren',
     'unsupported.covering_paren',
@@ -20,25 +22,26 @@ export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
 export const RETIRED_PERMISSION_RULE_ISSUE_CODES = Object.freeze(['unsupported.unknown_param']);
 const ISSUE_MESSAGE_MAX = 200;
 const ISSUE_SENTENCES = Object.freeze({
-    'invalid.empty_tool': 'this rule is invalid: it names no tool',
-    'invalid.paren': 'this rule is invalid: its parentheses do not parse (escape a literal one as \\( or \\))',
-    'invalid.tool_name': "this rule is invalid: its tool name is not spelled as a tool name (blanks around the rule, an invisible or disallowed character in the name or before the parenthesis, a leading '-', or the wildcard '*', which names no tool), so it would reach no tool or the wrong one",
-    'invalid.param_split': 'this rule is invalid: its parentheses do not hold a parameter rule written name:pattern',
-    'invalid.primary_field': "this rule is invalid: it patterns the tool's primary field, which matches the whole trimmed string rather than a prefix",
-    'invalid.cap_exceeded': 'this rule set is invalid: it is over one of the deployment caps (rule count, rule length, pattern length, or star count); this client cannot tell which from the code alone',
-    'invalid.behavior': 'this rule is invalid: its behavior is neither deny nor ask, so it would never fire',
-    'invalid.command_rule': 'this rule is invalid: the command pattern was rejected by the command-rule validator',
-    'invalid.entry_type': 'this allow list is invalid: it must be a list of rule strings, and it or one of its entries is not a string',
-    'unsupported.allow': 'an allow rule is not supported in a rule set that only says deny or ask — a standing approval belongs on the allow list instead',
-    'unsupported.param_unknown': 'this parameter rule is not supported: the tool carries no such parameter, so it could never match',
-    'unsupported.param_non_scalar': 'this parameter rule is not supported: that parameter holds an object or an array, so it could never match',
-    'unsupported.tool_unknown': "this rule is not supported on this leg: the resolver it supplied does not know the tool, so the rule's face cannot be checked",
-    '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.empty_tool': 'rules.issue.emptyTool',
+    'invalid.paren': 'rules.issue.paren',
+    'invalid.tool_name': 'rules.issue.toolName',
+    'invalid.param_split': 'rules.issue.paramSplit',
+    'invalid.primary_field': 'rules.issue.primaryField',
+    'invalid.cap_exceeded': 'rules.issue.capExceeded',
+    'invalid.behavior': 'rules.issue.behavior',
+    'invalid.command_rule': 'rules.issue.commandRule',
+    'invalid.entry_type': 'rules.issue.entryType',
+    'invalid.name_ambiguous': 'rules.issue.nameAmbiguous',
+    'unsupported.allow': 'rules.issue.allowRule',
+    'unsupported.param_unknown': 'rules.issue.paramUnknown',
+    'unsupported.param_non_scalar': 'rules.issue.paramNonScalar',
+    'unsupported.tool_unknown': 'rules.issue.toolUnknown',
+    'unsupported.path_base': 'rules.issue.pathBase',
+    'unsupported.mcp_paren': 'rules.issue.mcpParen',
+    'unsupported.covering_paren': 'rules.issue.coveringParen',
 });
-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)';
+const PARAM_SPLIT_WITH_COLON = 'rules.issue.paramSplitWithColon';
+const PARAM_SPLIT_NO_COLON = 'rules.issue.paramSplitNoColon';
 function colonInsideParens(rule) {
     if (typeof rule !== 'string')
         return undefined;
@@ -53,7 +56,7 @@ function colonInsideParens(rule) {
     }
     return undefined;
 }
-export function permissionRuleIssueDetail(code, message, rule) {
+export function permissionRuleIssueDetail(code, message, rule, lang) {
     const colon = code === 'invalid.param_split' ? colonInsideParens(rule) : undefined;
     const known = colon !== undefined
         ? colon ? PARAM_SPLIT_WITH_COLON : PARAM_SPLIT_NO_COLON
@@ -63,7 +66,7 @@ export function permissionRuleIssueDetail(code, message, rule) {
         : '';
     const codeWord = typeof code === 'string' && code.length > 0 ? escapeDisplayControlChars(code) : '(no code)';
     const head = known !== undefined
-        ? known
-        : `this rule was refused with ${codeWord}, a code newer than this client`;
+        ? renderMessage(msg(known), lang)
+        : renderMessage(msg('rules.issue.newerCode', { code: codeWord }), lang);
     return text.length > 0 ? `${head} — ${text}` : head;
 }

package/dist/permissionRulesWriteCapability.js

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

package/dist/permissionsAllowGrantCapability.js

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