@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/skillToolListsCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
 export function projectSkillToolListsCapability(caps) {
     try {
@@ -30,17 +31,18 @@ export function skillToolListsAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function skillToolListsDoctorDetail(reading) {
+export function skillToolListsDoctorDetail(reading, lang) {
+    const subject = msg('notice.capability.subject.skillToolLists');
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('skill tool lists');
+            return unreadableReadingDetail(renderMessage(subject, lang), lang);
         case 'unobserved':
-            return 'skill tool lists not observed — the engine reports it on /v1/capabilities (skillToolLists); 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)';
+            return renderMessage(msg('notice.capability.unobserved', { subject, key: 'skillToolLists' }), lang);
         case 'not_reported':
-            return 'skill tool lists not reported by this engine — the engine predates them: tool lists on request skills are not read, so they do not limit any tool';
+            return renderMessage(msg('notice.capability.skillToolLists.notReported'), lang);
         case 'absent':
-            return 'skill tool lists off on this deployment — tool lists on request skills are not read';
+            return renderMessage(msg('notice.capability.skillToolLists.absent'), lang);
         case 'present':
-            return 'skill tool lists on — a request skill’s allowed and disallowed tool lists are read as this run’s rules';
+            return renderMessage(msg('notice.capability.skillToolLists.present'), lang);
     }
 }

package/dist/skillsWireCaps.d.ts

@@ -1,8 +1,5 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import { type SkillToolListsReading } from './skillToolListsCapability.js';
-export declare const SKILL_CAPS: {
-    readonly content: 1048576;
-};
 export interface SkillCmdLike {
     type?: string;
     name?: string;

package/dist/skillsWireCaps.js

@@ -1,8 +1,7 @@
 import { skillToolListsAvailable } from './skillToolListsCapability.js';
-export const SKILL_CAPS = { content: 1_048_576 };
 export function toCappedSpec(name, description, whenToUse, body) {
     const n = name.trim();
-    const c = body.trim().slice(0, SKILL_CAPS.content);
+    const c = body.trim();
     if (!n || !c)
         return null;
     const desc = [description.trim(), whenToUse.trim()]

package/dist/sseIdleTriage.js

@@ -1,5 +1,6 @@
 import { hostEnv } from './hostEnv.js';
 import { SseIdleError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
+import { readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
 export const SSE_HEARTBEAT_GRACE_ENV = 'SEMA_SSE_HEARTBEAT_GRACE_MS';
 export const SSE_GRACE_MIN_MS = 5_000;
 export const SSE_GRACE_MAX_MS = 600_000;
@@ -27,9 +28,9 @@ export function engineAliveIdleElapsedMs(err) {
     return typeof e.elapsedMs === 'number' && Number.isFinite(e.elapsedMs) ? e.elapsedMs : 0;
 }
 export function isSseIdleError(err) {
-    if (err instanceof SseIdleError)
+    if (thrownIsInstanceOf(err, SseIdleError))
         return true;
-    return err?.name === 'SseIdleError';
+    return readThrownSlot(err, 'name', 'data') === 'SseIdleError';
 }
 export async function probeEngineAlive(baseUrl, timeoutMs = 2_000) {
     return (await sdkProbeHealth(baseUrl, timeoutMs)).alive;

package/dist/subagent/engineSubagentResume.js

@@ -1,5 +1,6 @@
 import { hostLog } from '../host.js';
-import { resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { isNotFoundFailure, resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
 import { RESUME_SESSION_NOT_FOUND } from '../engineErrorCodes.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
@@ -25,15 +26,22 @@ const RETENTION_LAPSED_CODES = new Set([
     RESUME_SESSION_NOT_FOUND,
 ]);
 function shapeOf(e) {
-    const o = (e ?? {});
+    const status = readThrownSlot(e ?? {}, 'status', 'data');
+    const errorCode = readThrownSlot(e ?? {}, 'errorCode', 'data');
+    const message = readThrownSlot(e ?? {}, 'message');
+    if (status === THROWN_SLOT_UNREADABLE || errorCode === THROWN_SLOT_UNREADABLE) {
+        return { message: typeof message === 'string' && message !== '' ? message : String(e), unreadable: true };
+    }
     return {
-        ...(typeof o.status === 'number' ? { status: o.status } : {}),
-        ...(typeof o.errorCode === 'string' ? { errorCode: o.errorCode } : {}),
-        message: typeof o.message === 'string' && o.message !== '' ? o.message : String(e),
+        ...(typeof status === 'number' ? { status } : {}),
+        ...(typeof errorCode === 'string' ? { errorCode } : {}),
+        message: typeof message === 'string' && message !== '' ? message : String(e),
     };
 }
 export function classifySubagentResumeFailure(e) {
-    const { status, errorCode, message } = shapeOf(e);
+    const { status, errorCode, message, unreadable } = shapeOf(e);
+    if (unreadable === true)
+        return { reason: 'error', detail: message };
     if (status === undefined && errorCode === undefined) {
         const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
         if (noAnswer !== null)
@@ -63,12 +71,10 @@ export function classifySubagentResumeFailure(e) {
         return { reason: 'row-contended', detail: message };
     if (errorCode === 'resume.row_gone')
         return { reason: 'row-gone', detail: message };
-    if (errorCode === undefined && status === 404)
+    if (isNotFoundFailure(e) !== false)
         return { reason: 'not-found', detail: message };
     if (errorCode === undefined && status === 400)
         return { reason: 'bad-request', detail: message };
-    if (errorCode?.startsWith('not_found.') === true)
-        return { reason: 'not-found', detail: message };
     return { reason: 'error', detail: message };
 }
 export function resolveOwnerRunId(childTaskId, activeRunId) {

package/dist/subagentContentStore.d.ts

@@ -33,6 +33,9 @@ export interface SubagentContentEvent {
     isError?: boolean | undefined;
 }
 export declare function coerceOutput(v: unknown): string | undefined;
+export declare function subagentContentEventOf(ev: {
+    readonly type: string;
+}): SubagentContentEvent | undefined;
 export interface SubagentContentStoreConfig {
     maxBytesPerTask: number;
     maxBytesTotal: number;
@@ -41,6 +44,7 @@ export declare const SUBAGENT_CONTENT_STORE_DEFAULTS: Readonly<SubagentContentSt
 export declare function configureSubagentContentStore(next: Partial<SubagentContentStoreConfig>): void;
 export declare function subagentContentStoreConfig(): SubagentContentStoreConfig;
 export declare function __resetSubagentContentStoreConfigForTests(): void;
+export declare function bindSubagentIdentityReader(fn: (id: string) => readonly string[] | undefined): void;
 export declare function registerSubagentContentAlias(parentToolCallId: string, taskId: string): void;
 export declare function registerSubagentAlias(parentToolCallId: string, taskId: string): void;
 export declare function publishSubagentContentEvent(ev: SubagentContentEvent): void;

package/dist/subagentContentStore.js

@@ -3,6 +3,28 @@ import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     return toolEndOutputText(v);
 }
+export function subagentContentEventOf(ev) {
+    const t = ev.type;
+    if (t !== 'text_delta' && t !== 'reasoning_delta' && t !== 'text' && t !== 'reasoning' && t !== 'tool_start' && t !== 'tool_end')
+        return undefined;
+    const sub = ev;
+    const parent = sub.parentToolCallId;
+    if (typeof parent !== 'string')
+        return undefined;
+    return {
+        type: sub.type,
+        taskId: sub.taskId ?? parent,
+        parentToolCallId: parent,
+        delta: sub.delta,
+        text: sub.text,
+        eventId: sub.eventId,
+        toolCallId: sub.toolCallId,
+        toolName: sub.toolName,
+        args: sub.args,
+        output: coerceOutput(sub.output),
+        isError: sub.isError,
+    };
+}
 const MAX_ITEMS_PER_TASK = 200;
 const MAX_TASKS = 32;
 const NOTIFY_COALESCE_MS = 250;
@@ -207,8 +229,40 @@ function dropTask(key) {
     totalBytes -= s.bytes;
     tasks.delete(key);
 }
+let subagentIdsReader;
+export function bindSubagentIdentityReader(fn) {
+    subagentIdsReader = fn;
+}
+function sameSubagentIds(id) {
+    let ids;
+    try {
+        ids = subagentIdsReader?.(id);
+    }
+    catch {
+        ids = undefined;
+    }
+    if (ids === undefined)
+        return [id];
+    return ids.includes(id) ? ids : [...ids, id];
+}
+function homeKeyOf(key) {
+    return sameSubagentIds(key).find((id) => tasks.has(id)) ?? key;
+}
+function contentKeyOf(taskId) {
+    const ids = sameSubagentIds(taskId);
+    const direct = ids.find((id) => tasks.has(id));
+    if (direct !== undefined)
+        return direct;
+    for (const id of ids) {
+        const parked = taskToParent.get(id)?.card;
+        if (parked !== undefined && tasks.has(parked))
+            return parked;
+    }
+    return '';
+}
 const parentToTask = new Map();
 const taskToParent = new Map();
+let parentStampSeq = 0;
 let notifyListener = null;
 const pendingNotify = new Set();
 let notifyTimer = null;
@@ -361,7 +415,8 @@ function aliasContentKey(parentToolCallId, taskId) {
 export function registerSubagentAlias(parentToolCallId, taskId) {
     if (!aliasContentKey(parentToolCallId, taskId))
         return;
-    taskToParent.set(taskId, parentToolCallId);
+    if (taskToParent.get(taskId)?.card !== parentToolCallId)
+        taskToParent.set(taskId, { card: parentToolCallId, stamp: ++parentStampSeq });
 }
 function replaySeen(s, ev) {
     const id = ev.eventId;
@@ -437,7 +492,7 @@ function canonicalKey(ev) {
     return parentToTask.get(ev.parentToolCallId) ?? ev.parentToolCallId;
 }
 export function publishSubagentContentEvent(ev) {
-    const key = canonicalKey(ev);
+    const key = homeKeyOf(canonicalKey(ev));
     const s = stateFor(key, ev.parentToolCallId);
     switch (ev.type) {
         case 'text_delta':
@@ -539,15 +594,17 @@ export function publishSubagentContentEvent(ev) {
     scheduleNotify(key);
 }
 export function pushSubagentLocalEcho(taskId, text) {
-    const s = stateFor(taskId, tasks.get(taskId)?.parentToolCallId ?? '');
+    const known = contentKeyOf(taskId);
+    const key = known !== '' ? known : taskId;
+    const s = stateFor(key, tasks.get(key)?.parentToolCallId ?? '');
     flushBuffers(s);
     pushItem(s, { kind: 'echo', text });
     enforceTaskCap(s);
-    enforceTotalCap(taskId);
-    scheduleNotify(taskId);
+    enforceTotalCap(key);
+    scheduleNotify(key);
 }
 export function getSubagentContentSnapshot(taskId) {
-    const key = tasks.has(taskId) ? taskId : (taskToParent.get(taskId) ?? '');
+    const key = contentKeyOf(taskId);
     const s = tasks.get(key);
     if (!s)
         return null;
@@ -593,17 +650,42 @@ export function planSubagentViewSlots(taskId) {
     return out;
 }
 export function parentToolCallIdOf(taskId) {
-    return taskToParent.get(taskId) ?? tasks.get(taskId)?.parentToolCallId;
+    const ids = sameSubagentIds(taskId);
+    let stated;
+    let statedStamp = -1;
+    for (const id of ids) {
+        const hit = taskToParent.get(id);
+        if (hit === undefined)
+            continue;
+        if (stated === undefined || hit.stamp > statedStamp) {
+            stated = hit.card;
+            statedStamp = hit.stamp;
+        }
+    }
+    if (stated !== undefined)
+        return stated;
+    for (const id of ids) {
+        const fromContent = tasks.get(id)?.parentToolCallId;
+        if (fromContent !== undefined)
+            return fromContent;
+    }
+    return undefined;
 }
 export function settleSubagentContent(taskId) {
-    const s = tasks.get(taskId);
+    const key = contentKeyOf(taskId);
+    const s = tasks.get(key);
     if (!s)
         return;
     flushBuffers(s);
-    scheduleNotify(taskId);
+    scheduleNotify(key);
 }
 export function clearSubagentContent(taskId) {
-    dropTask(taskId);
+    for (;;) {
+        const key = contentKeyOf(taskId);
+        if (key === '')
+            return;
+        dropTask(key);
+    }
 }
 const bgFacts = new Map();
 export function recordBgTerminalFacts(taskId, facts) {
@@ -619,10 +701,12 @@ export function recordBgTerminalFacts(taskId, facts) {
     scheduleNotify(taskId);
 }
 export function clearBgTerminalFacts(taskId) {
-    bgFacts.delete(taskId);
+    for (const id of sameSubagentIds(taskId))
+        bgFacts.delete(id);
 }
 export function getBgTerminalFacts(taskId) {
-    const key = bgFacts.has(taskId) ? taskId : (taskToParent.get(taskId) ?? '');
+    const ids = sameSubagentIds(taskId);
+    const key = ids.find((id) => bgFacts.has(id)) ?? ids.map((id) => taskToParent.get(id)?.card).find((c) => c !== undefined) ?? '';
     touchLru(bgFacts, key);
     return bgFacts.get(key);
 }
@@ -643,15 +727,35 @@ export function recordBgParentRun(taskId, runId, sessionId, sessionKey) {
 export function recordSubagentOwner(taskId, runId, sessionId, sessionKey) {
     if (!taskId || typeof runId !== 'string' || runId === '' || taskId === runId)
         return;
-    if (bgParentRun.size >= MAX_BG_PARENT_RUNS && !bgParentRun.has(taskId)) {
+    const ids = sameSubagentIds(taskId);
+    const heldKeys = ids.filter((k) => bgParentRun.has(k));
+    const heldRecs = [];
+    for (const k of heldKeys) {
+        const rec = bgParentRun.get(k);
+        if (rec !== undefined)
+            heldRecs.push(rec);
+    }
+    if (bgParentRun.size >= MAX_BG_PARENT_RUNS && heldKeys.length === 0) {
         const oldest = bgParentRun.keys().next().value;
         if (oldest !== undefined)
             bgParentRun.delete(oldest);
     }
-    const quarantinedRun = conflictQuarantine.get(taskId);
-    if (quarantinedRun !== undefined && quarantinedRun === runId)
+    const quarantinedHere = ids.some((k) => conflictQuarantine.get(k) === runId);
+    if (quarantinedHere)
         return;
-    const prior = bgParentRun.get(taskId);
+    const sameRunHeld = heldRecs.filter((r) => r.runId === runId);
+    const heldSlots = new Set(sameRunHeld.map((r) => r.sessionKey ?? DEFAULT_SESSION_KEY));
+    if (sameRunHeld.length > 1 && heldSlots.size > 1) {
+        ownerSessionConflictCount++;
+        const pairOf = (r) => ({
+            ...(r.sessionId !== undefined ? { sessionId: r.sessionId } : {}),
+            ...(r.sessionKey !== undefined ? { sessionKey: r.sessionKey } : {}),
+        });
+        lastOwnerSessionConflict = { taskId, runId, prior: pairOf(sameRunHeld[0]), next: pairOf(sameRunHeld[1]) };
+        quarantineRun(ids, runId);
+        return;
+    }
+    const prior = heldRecs.find((r) => r.runId === runId) ?? heldRecs[0];
     const sameRun = prior?.runId === runId;
     const incoming = typeof sessionId === 'string' && sessionId !== '' ? sessionId : undefined;
     const incomingKey = typeof sessionKey === 'string' && sessionKey !== '' ? sessionKey : undefined;
@@ -685,16 +789,13 @@ export function recordSubagentOwner(taskId, runId, sessionId, sessionKey) {
         const priorSlot = prior?.sessionKey ?? DEFAULT_SESSION_KEY;
         const nextSlot = nextPair.sessionKey ?? DEFAULT_SESSION_KEY;
         if (priorSlot !== nextSlot) {
-            bgParentRun.delete(taskId);
-            if (conflictQuarantine.size >= MAX_BG_PARENT_RUNS && !conflictQuarantine.has(taskId)) {
-                const oldestQ = conflictQuarantine.keys().next().value;
-                if (oldestQ !== undefined)
-                    conflictQuarantine.delete(oldestQ);
-            }
-            conflictQuarantine.set(taskId, runId);
+            quarantineRun(ids, runId);
             return;
         }
     }
+    for (const k of ids)
+        if (k !== taskId)
+            bgParentRun.delete(k);
     bgParentRun.delete(taskId);
     bgParentRun.set(taskId, { runId, ...nextPair });
 }
@@ -711,14 +812,43 @@ export function recordSubagentOwnerFromProgress(ev, ownerRunId, ownerSessionId,
     recordSubagentOwner(o.taskId, ownerRunId, ownerSessionId, ownerSessionKey);
 }
 export function getBgParentRun(taskId) {
-    touchLru(bgParentRun, taskId);
-    return bgParentRun.get(taskId)?.runId;
+    return getBgParentRunOwner(taskId)?.runId;
 }
 export function getBgParentRunOwner(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return undefined;
-    touchLru(bgParentRun, taskId);
-    return bgParentRun.get(taskId);
+    const live = liveOwnerEntries(sameSubagentIds(taskId));
+    const first = live[0];
+    if (first === undefined)
+        return undefined;
+    if (!live.every(([, rec]) => sameOwnerRecord(rec, first[1])))
+        return undefined;
+    touchLru(bgParentRun, first[0]);
+    return first[1];
+}
+function liveOwnerEntries(ids) {
+    const out = [];
+    for (const k of ids) {
+        const rec = bgParentRun.get(k);
+        if (rec === undefined)
+            continue;
+        if (ids.some((q) => conflictQuarantine.get(q) === rec.runId))
+            continue;
+        out.push([k, rec]);
+    }
+    return out;
+}
+const sameOwnerRecord = (a, b) => a.runId === b.runId && a.sessionId === b.sessionId && a.sessionKey === b.sessionKey;
+function quarantineRun(ids, runId) {
+    for (const k of ids) {
+        bgParentRun.delete(k);
+        if (conflictQuarantine.size >= MAX_BG_PARENT_RUNS && !conflictQuarantine.has(k)) {
+            const oldestQ = conflictQuarantine.keys().next().value;
+            if (oldestQ !== undefined)
+                conflictQuarantine.delete(oldestQ);
+        }
+        conflictQuarantine.set(k, runId);
+    }
 }
 export function __resetSubagentOwnerLedgerForTests() {
     bgParentRun.clear();

package/dist/toolHistoryMismatch.js

@@ -1,4 +1,5 @@
 import { rewindArchiveReadingAt, rewindConversationAvailability } from './rewindArchiveReading.js';
+import { ownDataField } from './ownKey.js';
 export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
     'tool_use_without_result',
     'orphan_tool_result',
@@ -191,8 +192,8 @@ export function classifyToolHistoryMismatch(err) {
     let status;
     let rawMessage;
     try {
-        code = err.code;
-        status = err.status;
+        code = ownDataField(err, 'code');
+        status = ownDataField(err, 'status');
         rawMessage = err.message;
     }
     catch {

package/dist/toolRoster.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface ToolRosterPathTargetView {
     param: string;
     access: string;
@@ -77,8 +78,8 @@ export type HandsSeamReading = {
 export declare function handsSeamReadingOf(view: {
     readonly hands?: WiringManifestHandsView;
 } | null | undefined): HandsSeamReading;
-export declare function handsSeamDetail(reading: HandsSeamReading): string;
-export declare function handsMountedDetail(reading: HandsMountedReading): string;
+export declare function handsSeamDetail(reading: HandsSeamReading, lang?: UiLanguage): string;
+export declare function handsMountedDetail(reading: HandsMountedReading, lang?: UiLanguage): string;
 export declare function toolRosterNames(roster: ToolRosterView | undefined): readonly string[];
 export interface ToolShim {
     name: string;

package/dist/toolRoster.js

@@ -1,4 +1,5 @@
 import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { HANDS_REASON_NO_EXECUTION_ENV, projectHandsSection } from './handsSeam.js';
 const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
 const strArr = (v) => Array.isArray(v) ? v.filter((x) => typeof x === 'string') : undefined;
@@ -144,55 +145,55 @@ export function handsSeamReadingOf(view) {
         return { kind: 'mounted' };
     return seam.reason !== undefined ? { kind: 'not_mounted', reason: seam.reason } : { kind: 'not_mounted' };
 }
-const HANDS_NONE_STEM = 'this leg of the run was assembled with NO built-in file-and-shell tools';
-const HANDS_NONE_TAIL = "so on this leg the model had no tool of the engine's own for editing files or running commands (tools mounted by other conditions, such as external servers, and sub-runs delegated to other legs are not covered by this reading)";
 const HANDS_REASON_DISPLAY_MAX = 64;
-const HANDS_NOT_REPORTED_SENTENCE = 'whether this leg has built-in file-and-shell tools is not stated here — the engine did not report its hands seam (older engines and servers, and the static half of a manifest, never do); the tool roster may still answer it';
-export function handsSeamDetail(reading) {
+function handsNotReported(lang) {
+    return renderMessage(msg('notice.capability.hands.notReported'), lang);
+}
+export function handsSeamDetail(reading, lang) {
     const kind = typeof reading === 'object' && reading !== null ? reading.kind : undefined;
     switch (kind) {
         case 'mounted':
-            return 'this leg of the run was assembled with its built-in file tools mounted — the engine says so; whether a shell is reachable is answered by the tool roster, not by this statement';
+            return renderMessage(msg('notice.capability.hands.seamMounted'), lang);
         case 'not_mounted': {
             const raw = reading.reason;
             const reason = typeof raw === 'string' && raw.length > 0 ? raw : undefined;
             const why = reason === undefined
-                ? 'the engine states it mounted no hands on this leg (it gave no reason)'
+                ? msg('notice.capability.hands.whyNoReason')
                 : reason === HANDS_REASON_NO_EXECUTION_ENV
-                    ? 'the engine states it mounted no hands on this leg because no execution environment was supplied'
-                    : `the engine states it mounted no hands on this leg (reason: ${displayUntrusted(reason, { max: HANDS_REASON_DISPLAY_MAX })}, a word this build does not know)`;
-            return `${HANDS_NONE_STEM} — ${why}, ${HANDS_NONE_TAIL}`;
+                    ? msg('notice.capability.hands.whyNoExecutionEnv')
+                    : msg('notice.capability.hands.whyUnknownReason', { reason: displayUntrusted(reason, { max: HANDS_REASON_DISPLAY_MAX }) });
+            return renderMessage(msg('notice.capability.hands.noneLine', { stem: msg('notice.capability.hands.noneStem'), why, tail: msg('notice.capability.hands.noneTail') }), lang);
         }
         default:
-            return HANDS_NOT_REPORTED_SENTENCE;
+            return handsNotReported(lang);
     }
 }
-export function handsMountedDetail(reading) {
+export function handsMountedDetail(reading, lang) {
     const r = reading;
     const kind = typeof r === 'object' && r !== null ? r.kind : undefined;
     switch (kind) {
         case 'mounted': {
             const rows = r.rows;
             if (typeof rows === 'number' && Number.isInteger(rows) && rows > 0)
-                return `this run was assembled with file-and-shell tools mounted (${rows} of them)`;
-            return HANDS_NOT_REPORTED_SENTENCE;
+                return renderMessage(msg('notice.capability.hands.rosterMounted', { rows }), lang);
+            return handsNotReported(lang);
         }
         case 'not-mounted':
-            return `${HANDS_NONE_STEM} — the engine reports a roster and not one row was mounted by that condition, ${HANDS_NONE_TAIL}`;
+            return renderMessage(msg('notice.capability.hands.rosterNotMounted', { stem: msg('notice.capability.hands.noneStem'), tail: msg('notice.capability.hands.noneTail') }), lang);
         case 'unknown':
             switch (r.why) {
                 case 'no-manifest':
-                    return 'whether this run has file-and-shell tools is unknown — no assembly manifest was observed for it';
+                    return renderMessage(msg('notice.capability.hands.unknownNoManifest'), lang);
                 case 'no-roster':
-                    return 'whether this run has file-and-shell tools is unknown — the manifest carries no tool roster (the static half never does; only an engine-minted effective manifest reports one)';
+                    return renderMessage(msg('notice.capability.hands.unknownNoRoster'), lang);
                 case 'roster-unreadable':
-                    return 'whether this run has file-and-shell tools is unknown — the tool roster could not be read in the shape this reader knows';
+                    return renderMessage(msg('notice.capability.hands.unknownRosterUnreadable'), lang);
                 case 'mount-condition-absent':
-                    return 'whether this run has file-and-shell tools is unknown — this engine does not report which condition mounted each tool, so an empty count here would be a fact about the reader, not about the run';
+                    return renderMessage(msg('notice.capability.hands.unknownMountConditionAbsent'), lang);
             }
-            return HANDS_NOT_REPORTED_SENTENCE;
+            return handsNotReported(lang);
     }
-    return HANDS_NOT_REPORTED_SENTENCE;
+    return handsNotReported(lang);
 }
 export function toolRosterNames(roster) {
     return roster?.entries.map((e) => e.name) ?? [];

package/dist/toolsFlagNames.d.ts

@@ -0,0 +1,8 @@
+export interface ToolsFlagNames {
+    readonly kept: readonly string[];
+    readonly excluded: readonly string[];
+    readonly bare: boolean;
+    readonly detached: readonly string[];
+    readonly scoped: readonly string[];
+}
+export declare function parseToolsFlagNames(values: readonly string[]): ToolsFlagNames;

package/dist/toolsFlagNames.js

@@ -0,0 +1,110 @@
+function readableStrings(values) {
+    const out = [];
+    try {
+        if (!Array.isArray(values))
+            return out;
+        const n = values.length;
+        for (let i = 0; i < n; i++) {
+            try {
+                const v = values[i];
+                if (typeof v === 'string')
+                    out.push(v);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return out;
+    }
+    return out;
+}
+function splitToolsFlagTokens(values) {
+    const out = [];
+    for (const value of values) {
+        if (value === '')
+            continue;
+        let cur = '';
+        let inParen = false;
+        for (const ch of value) {
+            if (ch === '(') {
+                inParen = true;
+                cur += ch;
+            }
+            else if (ch === ')') {
+                inParen = false;
+                cur += ch;
+            }
+            else if (ch === ',') {
+                if (inParen)
+                    cur += ch;
+                else {
+                    if (cur.trim() !== '')
+                        out.push(cur.trim());
+                    cur = '';
+                }
+            }
+            else if (ch === ' ') {
+                if (inParen)
+                    cur += ch;
+                else if (cur.trim() !== '') {
+                    out.push(cur.trim());
+                    cur = '';
+                }
+            }
+            else if (cur !== '' || ch.trim() !== '') {
+                cur += ch;
+            }
+        }
+        if (cur.trim() !== '')
+            out.push(cur.trim());
+    }
+    return out;
+}
+export function parseToolsFlagNames(values) {
+    const tokens = splitToolsFlagTokens(readableStrings(values));
+    const kept = [];
+    const excluded = new Set();
+    const detached = [];
+    const scoped = [];
+    let bare = false;
+    for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i];
+        if (token === undefined)
+            continue;
+        if (!token.startsWith('!')) {
+            kept.push(token);
+            continue;
+        }
+        let name = token.slice(1);
+        if (name === '') {
+            const next = tokens[i + 1];
+            if (next === undefined || next.startsWith('!') || next.startsWith('(')) {
+                bare = true;
+                continue;
+            }
+            i++;
+            detached.push(next);
+            token = `!${next}`;
+            name = next;
+        }
+        const paren = name.indexOf('(');
+        if (paren === 0) {
+            bare = true;
+            continue;
+        }
+        if (paren > 0) {
+            name = name.slice(0, paren);
+            scoped.push(token);
+        }
+        excluded.add(name);
+    }
+    return Object.freeze({
+        kept: Object.freeze(kept),
+        excluded: Object.freeze([...excluded]),
+        bare,
+        detached: Object.freeze(detached),
+        scoped: Object.freeze(scoped),
+    });
+}