@sema-agent/client-core 0.83.6 → 0.84.0

package/dist/adapter/downstream/wiringManifestView.js

@@ -14,6 +14,7 @@ export function wiringManifestViewOf(s) {
         ...(isObj(s._sema_writeProtection) ? { writeProtection: s._sema_writeProtection } : {}),
         ...(isObj(s._sema_autoConsolidation) ? { autoConsolidation: s._sema_autoConsolidation } : {}),
         ...(isObj(s._sema_readDeny) ? { readDeny: s._sema_readDeny } : {}),
+        ...(isObj(s._sema_hands) && typeof s._sema_hands.mounted === 'boolean' ? { hands: s._sema_hands } : {}),
     };
     if (Object.keys(view).length === 0)
         return undefined;

package/dist/agentSession/engineAgentRegistryRead.d.ts

@@ -0,0 +1,18 @@
+import type { AgentClient, Capabilities } from '@sema-agent/sdk';
+import type { EngineAgentRegistryListing, EngineAgentRegistryRowView } from '../engineAgentAbsence.js';
+export interface EngineAgentRegistryClient {
+    readonly sessions: Pick<AgentClient['sessions'], 'background'>;
+}
+export declare function registryClockNowMs(): number;
+export interface RegistryListingProvenance {
+    readonly superseded: boolean;
+    readonly sessionId: string;
+    readonly rows: readonly EngineAgentRegistryRowView[];
+    readonly rawRowCount: number;
+    firstSeenAtMs(id: string): number | undefined;
+}
+export declare function registryListingProvenanceOf(listing: EngineAgentRegistryListing | null | undefined): RegistryListingProvenance | undefined;
+export declare function isEngineAgentRegistryListingSuperseded(listing: EngineAgentRegistryListing | null | undefined): boolean;
+export declare function readEngineAgentRegistry(client: EngineAgentRegistryClient, sessionId: string, caps: Pick<Capabilities, 'background'> | null | undefined, opts?: {
+    readonly signal?: AbortSignal;
+}): Promise<EngineAgentRegistryListing>;

package/dist/agentSession/engineAgentRegistryRead.js

@@ -0,0 +1,167 @@
+import { errCodes } from '../controlRouter.js';
+import { hostLog } from '../host.js';
+const unavailable = (why) => ({
+    kind: 'unavailable',
+    why,
+});
+function noteReadFailed(cause, diag) {
+    try {
+        const bits = [
+            diag?.status !== undefined ? `status=${diag.status}` : '',
+            diag?.errorCode !== undefined ? `errorCode=${diag.errorCode}` : '',
+        ].filter((b) => b.length > 0);
+        hostLog('debug', `[sema][registry] read_failed (${cause})${bits.length > 0 ? ` ${bits.join(' ')}` : ''}`);
+    }
+    catch {
+    }
+}
+const readLedgers = new WeakMap();
+const listingRecords = new WeakMap();
+function ledgerFor(sessions, sessionId) {
+    let bySession = readLedgers.get(sessions);
+    if (bySession === undefined) {
+        bySession = new Map();
+        readLedgers.set(sessions, bySession);
+    }
+    let ledger = bySession.get(sessionId);
+    if (ledger === undefined) {
+        ledger = { issued: 0, deliveredMax: 0, firstSeen: new Map() };
+        bySession.set(sessionId, ledger);
+    }
+    return ledger;
+}
+export function registryClockNowMs() {
+    const p = globalThis.performance;
+    if (typeof p === 'object' && p !== null && typeof p.now === 'function' && typeof p.timeOrigin === 'number') {
+        const v = p.timeOrigin + p.now.call(p);
+        if (Number.isFinite(v))
+            return v;
+    }
+    return Date.now();
+}
+export function registryListingProvenanceOf(listing) {
+    if (typeof listing !== 'object' || listing === null)
+        return undefined;
+    const rec = listingRecords.get(listing);
+    if (rec === undefined)
+        return undefined;
+    return {
+        superseded: rec.ledger.deliveredMax > rec.seq,
+        sessionId: rec.sessionId,
+        rows: rec.rows,
+        rawRowCount: rec.rawRowCount,
+        firstSeenAtMs: (id) => rec.ledger.firstSeen.get(id),
+    };
+}
+export function isEngineAgentRegistryListingSuperseded(listing) {
+    return registryListingProvenanceOf(listing)?.superseded === true;
+}
+function listFaceOn(caps) {
+    if (typeof caps !== 'object' || caps === null || !Object.hasOwn(caps, 'background'))
+        return false;
+    const bg = caps.background;
+    if (typeof bg !== 'object' || bg === null || !Object.hasOwn(bg, 'listFace'))
+        return false;
+    return bg.listFace === true;
+}
+function readRow(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    const o = v;
+    const id = Object.hasOwn(o, 'id') ? o.id : undefined;
+    const type = Object.hasOwn(o, 'type') ? o.type : undefined;
+    const status = Object.hasOwn(o, 'status') ? o.status : undefined;
+    if (typeof id !== 'string' || id.length === 0 || typeof type !== 'string' || type.length === 0 || typeof status !== 'string' || status.length === 0)
+        return undefined;
+    const description = Object.hasOwn(o, 'description') ? o.description : undefined;
+    const createdAt = Object.hasOwn(o, 'createdAt') ? o.createdAt : undefined;
+    return {
+        id,
+        type,
+        status,
+        ...(typeof description === 'string' && description.length > 0 ? { description } : {}),
+        ...(typeof createdAt === 'number' && Number.isFinite(createdAt) ? { createdAt } : {}),
+    };
+}
+export async function readEngineAgentRegistry(client, sessionId, caps, opts) {
+    try {
+        return await readOnce(client, sessionId, caps, opts);
+    }
+    catch {
+        noteReadFailed('reader threw');
+        return unavailable('read_failed');
+    }
+}
+async function readOnce(client, sessionId, caps, opts) {
+    if (!listFaceOn(caps))
+        return unavailable('no_list_face');
+    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+        noteReadFailed('bad session id');
+        return unavailable('read_failed');
+    }
+    if (typeof client !== 'object' || client === null) {
+        noteReadFailed('bad client');
+        return unavailable('read_failed');
+    }
+    const sessions = client.sessions;
+    if (typeof sessions !== 'object' || sessions === null) {
+        noteReadFailed('bad client');
+        return unavailable('read_failed');
+    }
+    const ledger = ledgerFor(sessions, sessionId);
+    const seq = ++ledger.issued;
+    let body;
+    try {
+        const signal = opts?.signal;
+        body = await sessions.background(sessionId, signal !== undefined ? { signal } : undefined);
+    }
+    catch (e) {
+        const { code, status } = errCodes(e);
+        if (status === 404 && code === 'not_found.route')
+            return unavailable('route_absent');
+        if (status === 501 && code === 'capability.session_ownership_required')
+            return unavailable('ownership_required');
+        const diag = {
+            ...(typeof status === 'number' && Number.isInteger(status) ? { status } : {}),
+            ...(typeof code === 'string' && code.length > 0 ? { errorCode: code } : {}),
+        };
+        noteReadFailed('request failed', diag);
+        return { kind: 'unavailable', why: 'read_failed', ...diag };
+    }
+    if (typeof body !== 'object' || body === null || !Object.hasOwn(body, 'rows')) {
+        noteReadFailed('body is not { rows }');
+        return unavailable('read_failed');
+    }
+    const raw = body.rows;
+    if (!Array.isArray(raw)) {
+        noteReadFailed('body is not { rows }');
+        return unavailable('read_failed');
+    }
+    const rows = [];
+    for (const r of raw) {
+        const row = readRow(r);
+        if (row === undefined) {
+            noteReadFailed('a row could not be read');
+            return unavailable('read_failed');
+        }
+        rows.push(Object.freeze(row));
+    }
+    const rawRowCount = raw.length;
+    if (seq > ledger.deliveredMax) {
+        ledger.deliveredMax = seq;
+        const now = registryClockNowMs();
+        const present = new Set();
+        for (const row of rows) {
+            present.add(row.id);
+            if (!ledger.firstSeen.has(row.id))
+                ledger.firstSeen.set(row.id, now);
+        }
+        for (const id of [...ledger.firstSeen.keys()])
+            if (!present.has(id))
+                ledger.firstSeen.delete(id);
+    }
+    const frozenRows = Object.freeze(rows);
+    const listing = Object.freeze({ kind: 'rows', rows: frozenRows, sessionId, seq });
+    listingRecords.set(listing, { ledger, seq, sessionId, rows: frozenRows, rawRowCount });
+    return listing;
+}

package/dist/agentsWireCaps.js

@@ -1,5 +1,6 @@
 import { hostEnv } from './hostEnv.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
+import { frozenSet } from './frozenSet.js';
 export const MAX_TASK_AGENTS = 32;
 export const MAX_AGENT_NAME_CHARS = 64;
 export const MAX_AGENT_TEXT_CHARS = 4_096;
@@ -25,7 +26,7 @@ export const TASK_AGENT_WIRE_FIELDS = [
     'observer',
     'observerMessage',
 ];
-export const AGENT_MEMORY_WORDS = new Set(['user', 'project', 'local']);
+export const AGENT_MEMORY_WORDS = frozenSet(['user', 'project', 'local']);
 const SOURCE_RANK = {
     policySettings: 0,
     flagSettings: 1,

package/dist/attachmentsWireCaps.js

@@ -1,7 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
 export const ATTACHMENTS_ENV = 'SEMA_ATTACHMENTS';
-export const ATTACHMENTS_SPEC_KEYS = [
+export const ATTACHMENTS_SPEC_KEYS = Object.freeze([
     'todoReminder',
     'todoReminderMode',
     'changedFiles',
@@ -12,7 +12,7 @@ export const ATTACHMENTS_SPEC_KEYS = [
     'mcpInstructions',
     'agentListing',
     'skillsListing',
-];
+]);
 export const ATTACHMENTS_DEFAULT_ON_KEYS = ['agentListing', 'skillsListing', 'backgroundTasks'];
 const OPT_IN_KEYS = [
     'todoReminder',

package/dist/controlRouter.js

@@ -83,7 +83,7 @@ export class ControlRouter {
             }
             if (isCancelSuspendedConflict(e)) {
                 throw new ControlSafetyError('runs.cancel 409 — the pending gate was decided or expired concurrently (lost CAS race); ' +
-                    're-read the run state and retry cancel if it is still active', 'cancel_lost_race', e);
+                    'check what that decision did to the run before retrying the cancel', 'cancel_lost_race', e);
             }
             if (isNotFound(e)) {
                 throw new ControlSafetyError('runs.cancel 404 — non-owner / unknown run (no existence leak)', 'not_found', e);

package/dist/engineAgentAbsence.d.ts

@@ -49,4 +49,41 @@ export interface EngineAgentAbsenceReapOptions {
 export declare function reapEngineAgentAbsentRows(rows: Readonly<Record<string, EngineAgentAbsenceReapRow | null | undefined>>, opts: EngineAgentAbsenceReapOptions): EngineAgentAbsenceReap;
 export declare function engineAgentAbsenceDroppedLine(label: string, ttlMs?: number, removeReason?: string | null): string;
 export declare function engineAgentTerminalAfterDropLine(label: string, status: RunTerminalStatus, hasReport: boolean): string;
+export interface EngineAgentRegistryRowView {
+    readonly id: string;
+    readonly type: string;
+    readonly status: string;
+    readonly description?: string;
+    readonly createdAt?: number;
+}
+export type EngineAgentRegistryUnavailableWhy = 'no_list_face' | 'route_absent' | 'ownership_required' | 'read_failed';
+export type EngineAgentRegistryListing = {
+    readonly kind: 'rows';
+    readonly rows: readonly EngineAgentRegistryRowView[];
+    readonly sessionId: string;
+    readonly seq: number;
+} | {
+    readonly kind: 'unavailable';
+    readonly why: EngineAgentRegistryUnavailableWhy;
+    readonly status?: number;
+    readonly errorCode?: string;
+};
+export declare function engineAgentRegistryKeyOf(ev: Pick<EngineAgentPanelAbsence, 'taskId' | 'wireTaskId'> | null | undefined): string | undefined;
+export interface EngineAgentRegistryReadingOptions {
+    readonly singleReplica?: true;
+    readonly sessionId?: string;
+}
+export declare function engineAgentRegistryReadingOf(listing: EngineAgentRegistryListing | null | undefined, registryKey: string | null | undefined, opts?: EngineAgentRegistryReadingOptions | null): EngineAgentRegistryReading;
+export interface EngineAgentRegistryMissingRow {
+    readonly id: string;
+    readonly status: string;
+    readonly description?: string;
+    readonly createdAt: number;
+}
+export interface EngineAgentRegistryFillOptions {
+    readonly nowMs?: number;
+    readonly goneSinceRead?: ReadonlySet<string> | readonly string[];
+    readonly sessionId?: string;
+}
+export declare function engineAgentRegistryRowsMissingFromHost(listing: EngineAgentRegistryListing | null | undefined, hostRegistryKeys: ReadonlySet<string> | readonly string[], opts?: EngineAgentRegistryFillOptions | null): readonly EngineAgentRegistryMissingRow[];
 export {};

package/dist/engineAgentAbsence.js

@@ -1,4 +1,6 @@
+import { registryClockNowMs, registryListingProvenanceOf } from './agentSession/engineAgentRegistryRead.js';
 import { displayUntrusted } from './displayUntrusted.js';
+import { ABSENT_SETTLE_MS } from './fleetAgentPanelProjection.js';
 import { isEnginePanelTaskResident, isStaleEngineAgentPanelEnd, } from './engineAgentPanelStore.js';
 export const ENGINE_AGENT_ABSENT_ROW_TEXT = 'engine no longer reports this agent · it may still be running';
 export const ENGINE_AGENT_ABSENCE_TTL_MS = 30 * 60_000;
@@ -129,3 +131,143 @@ export function engineAgentTerminalAfterDropLine(label, status, hasReport) {
     const tail = hasReport ? ' · its final report arrived too late to keep in the panel' : '';
     return `${displayUntrusted(label)} reported ${displayUntrusted(status)} after it was dropped from the task panel${tail}`;
 }
+const REGISTRY_LIST_LIMIT = 500;
+const REGISTRY_AGENT_HANDLE_RE = /^a[0-9a-f]{6,32}$/;
+const REGISTRY_AGENT_TYPE = 'background_agent';
+function registryStatusReading(status) {
+    const s = status;
+    switch (s) {
+        case 'pending':
+        case 'running':
+        case 'parked':
+            return 'running';
+        case 'completed':
+        case 'failed':
+        case 'killed':
+        case 'cancelled':
+            return 'ended';
+        default: {
+            const unhandled = s;
+            void unhandled;
+            return 'unknown';
+        }
+    }
+}
+export function engineAgentRegistryKeyOf(ev) {
+    if (typeof ev !== 'object' || ev === null)
+        return undefined;
+    const w = ev.wireTaskId;
+    const t = ev.taskId;
+    const wire = typeof w === 'string' && w.length > 0 ? w : undefined;
+    const task = typeof t === 'string' && t.length > 0 ? t : undefined;
+    if (wire !== undefined && REGISTRY_AGENT_HANDLE_RE.test(wire))
+        return wire;
+    if (task !== undefined && REGISTRY_AGENT_HANDLE_RE.test(task))
+        return task;
+    return wire ?? task;
+}
+function ownOpt(opts, key) {
+    if (typeof opts !== 'object' || opts === null || !Object.hasOwn(opts, key))
+        return { given: false, value: undefined };
+    const value = opts[key];
+    return { given: value !== undefined, value };
+}
+function sessionMismatch(readSessionId, opts) {
+    const { given, value } = ownOpt(opts, 'sessionId');
+    if (!given)
+        return false;
+    return typeof value !== 'string' || value.length === 0 || readSessionId !== value;
+}
+export function engineAgentRegistryReadingOf(listing, registryKey, opts) {
+    try {
+        return readingOf(listing, registryKey, opts);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function readingOf(listing, registryKey, opts) {
+    const rec = registryListingProvenanceOf(listing);
+    if (rec === undefined || rec.superseded)
+        return 'unknown';
+    if (sessionMismatch(rec.sessionId, opts))
+        return 'unknown';
+    return readingFromRecord(rec, registryKey, opts);
+}
+function readingFromRecord(rec, registryKey, opts) {
+    if (typeof registryKey !== 'string' || registryKey.length === 0)
+        return 'unknown';
+    let reading;
+    for (const r of rec.rows) {
+        if (r.id !== registryKey)
+            continue;
+        const here = r.type === REGISTRY_AGENT_TYPE ? registryStatusReading(r.status) : 'unknown';
+        reading = reading === undefined || reading === here ? here : 'unknown';
+    }
+    if (reading !== undefined)
+        return reading;
+    if (rec.rawRowCount >= REGISTRY_LIST_LIMIT)
+        return 'unknown';
+    if (!ownOpt(opts, 'sessionId').given)
+        return 'unknown';
+    const single = ownOpt(opts, 'singleReplica');
+    return single.given && single.value === true && REGISTRY_AGENT_HANDLE_RE.test(registryKey) ? 'not_listed' : 'unknown';
+}
+function keySetOf(v) {
+    if (v instanceof Set)
+        return (k) => v.has(k);
+    if (Array.isArray(v))
+        return (k) => v.includes(k);
+    return undefined;
+}
+export function engineAgentRegistryRowsMissingFromHost(listing, hostRegistryKeys, opts) {
+    try {
+        return rowsMissingFromHost(listing, hostRegistryKeys, opts);
+    }
+    catch {
+        return [];
+    }
+}
+function rowsMissingFromHost(listing, hostRegistryKeys, opts) {
+    const rec = registryListingProvenanceOf(listing);
+    if (rec === undefined || rec.superseded)
+        return [];
+    if (sessionMismatch(rec.sessionId, opts))
+        return [];
+    const has = keySetOf(hostRegistryKeys);
+    if (has === undefined)
+        return [];
+    const goneOpt = ownOpt(opts, 'goneSinceRead');
+    const gone = goneOpt.given ? keySetOf(goneOpt.value) : () => false;
+    if (gone === undefined)
+        return [];
+    const nowOpt = ownOpt(opts, 'nowMs');
+    const now = nowOpt.given ? nowOpt.value : registryClockNowMs();
+    if (typeof now !== 'number' || !Number.isFinite(now))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const r of rec.rows) {
+        if (r.type !== REGISTRY_AGENT_TYPE)
+            continue;
+        if (seen.has(r.id))
+            continue;
+        if (readingFromRecord(rec, r.id, undefined) !== 'running')
+            continue;
+        seen.add(r.id);
+        if (has(r.id) || gone(r.id))
+            continue;
+        const firstSeen = rec.firstSeenAtMs(r.id);
+        if (firstSeen === undefined || now - firstSeen <= ABSENT_SETTLE_MS)
+            continue;
+        if (typeof r.createdAt !== 'number' || !Number.isFinite(r.createdAt))
+            continue;
+        out.push({
+            id: r.id,
+            status: r.status,
+            ...(typeof r.description === 'string' && r.description.length > 0 ? { description: r.description } : {}),
+            createdAt: r.createdAt,
+        });
+    }
+    return out;
+}

package/dist/engineErrorCodes.js

@@ -1,3 +1,4 @@
+import { frozenSet } from './frozenSet.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
 export const LIMITS_MAX_TURNS_EXCEEDED = 'limits.max_turns_exceeded';
@@ -15,7 +16,7 @@ export const CONFIG_LIMIT_UNKNOWN_KEY = 'config.limit_unknown_key';
 export const CONFIG_DELEGATION_ENTRY_CAPS = 'config.delegation_entry_caps';
 export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spelling';
 export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
-export const CONFIG_REFUSAL_CODES = new Set([
+export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_LIMIT_INVALID,
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
     CONFIG_STRATEGY_MAX_SIZE_INVALID,
@@ -26,7 +27,7 @@ export const CONFIG_REFUSAL_CODES = new Set([
 ]);
 export const DELEGATION_CONCURRENCY_CAP = 'delegation.concurrency_cap';
 export const DELEGATION_SESSION_CAP = 'delegation.session_cap';
-export const DELEGATION_CAP_CODES = new Set([
+export const DELEGATION_CAP_CODES = frozenSet([
     DELEGATION_CONCURRENCY_CAP,
     DELEGATION_SESSION_CAP,
 ]);
@@ -61,17 +62,17 @@ export const STOP_PARK_RESUME_WON = 'stop.park_resume_won';
 export const STOP_NOT_LANDED = 'stop.not_landed';
 export const STOP_NOT_LOCAL = 'stop.not_local';
 export const STOP_PARKED = 'stop.parked';
-export const STOP_CONFLICT_CODES = [
+export const STOP_CONFLICT_CODES = Object.freeze([
     STOP_PARK_ARBITER_UNREACHABLE,
     STOP_PARK_RESUME_WON,
     STOP_NOT_LANDED,
     STOP_NOT_LOCAL,
     STOP_PARKED,
-];
+]);
 export const OUTPUT_INVALID = 'output.invalid';
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
 export const RESUME_AT_ERROR_CODE_PREFIX = 'resume_at.';
-export const REWIND_ERROR_CODE_PREFIXES = [RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.'];
+export const REWIND_ERROR_CODE_PREFIXES = Object.freeze([RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.']);
 export function isRewindFamilyCode(code) {
     return typeof code === 'string' && REWIND_ERROR_CODE_PREFIXES.some((p) => code.startsWith(p));
 }

package/dist/engineNoticeCodes.d.ts

@@ -52,3 +52,20 @@ export interface McpServerRedialedFactsView {
     runId: string;
 }
 export declare function readMcpServerRedialed(notice: unknown): McpServerRedialedFactsView | undefined;
+export type ReadRootGrantNoticeFactsView = {
+    outcome: 'granted';
+    toolCallId: string;
+    dir: string;
+    root: string;
+    covers?: 'exact';
+    sessionId?: string;
+} | {
+    outcome: 'rejected';
+    toolCallId: string;
+    reason?: string;
+    sessionId?: string;
+};
+export declare function readReadRootGrantNotice(notice: {
+    readonly code?: string;
+    readonly detail?: object | null;
+} | null | undefined): ReadRootGrantNoticeFactsView | undefined;

package/dist/engineNoticeCodes.js

@@ -303,3 +303,48 @@ export function readMcpServerRedialed(notice) {
     const reason = str(o.reason);
     return { server, outcome, added, removed, ...(reason !== undefined ? { reason } : {}), sessionId, runId };
 }
+const READ_ROOT_GRANT_COVERS_EXACT = 'exact';
+const _grantCoversPin = true;
+void _grantCoversPin;
+export function readReadRootGrantNotice(notice) {
+    try {
+        return readRootGrantNoticeOf(notice);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRootGrantNoticeOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'approval.read_root_granted' && n.code !== 'approval.read_root_grant_rejected')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const toolCallId = str(o.toolCallId);
+    if (toolCallId === undefined)
+        return undefined;
+    const sessionId = str(o.sessionId);
+    if (n.code === 'approval.read_root_granted') {
+        const dir = str(o.dir);
+        const root = str(o.root);
+        if (dir === undefined || root === undefined)
+            return undefined;
+        if ('covers' in o && o.covers !== READ_ROOT_GRANT_COVERS_EXACT)
+            return undefined;
+        return {
+            outcome: 'granted',
+            toolCallId,
+            dir,
+            root,
+            ...('covers' in o ? { covers: READ_ROOT_GRANT_COVERS_EXACT } : {}),
+            ...(sessionId !== undefined ? { sessionId } : {}),
+        };
+    }
+    const reason = str(o.reason);
+    return { outcome: 'rejected', toolCallId, ...(reason !== undefined ? { reason } : {}), ...(sessionId !== undefined ? { sessionId } : {}) };
+}

package/dist/fleet/fleetProjection.js

@@ -1,6 +1,7 @@
 import { collapseLabel, escapeDisplayControlChars, taskDescFromName } from '../fleetTaskDesc.js';
 import { rowIdTail } from '../workflow.js';
-export const TERMINAL_FLEET_TASK_STATUSES = new Set([
+import { frozenSet } from '../frozenSet.js';
+export const TERMINAL_FLEET_TASK_STATUSES = frozenSet([
     'completed',
     'failed',
     'killed',
@@ -51,7 +52,7 @@ function deriveAgentLabel(agentType, agentName, name, id) {
     const tail = rowIdTail(id).slice(-8);
     return tail ? `agent ${tail}` : 'agent';
 }
-export const CONTROL_TOOL_VERBS = new Set([
+export const CONTROL_TOOL_VERBS = frozenSet([
     'Agent',
     'Task',
     'Fork',

package/dist/frozenSet.d.ts

@@ -0,0 +1 @@
+export declare function frozenSet<T>(members: Iterable<T>): ReadonlySet<T>;

package/dist/frozenSet.js

@@ -0,0 +1,20 @@
+class FrozenVerdictSet extends Set {
+    constructor(members) {
+        super();
+        for (const m of members)
+            super.add(m);
+    }
+    add(_value) {
+        throw new TypeError('This set is read-only: it is a verdict table shared by every caller; copy it into a new Set to change it.');
+    }
+    delete(_value) {
+        throw new TypeError('This set is read-only: it is a verdict table shared by every caller; copy it into a new Set to change it.');
+    }
+    clear() {
+        throw new TypeError('This set is read-only: it is a verdict table shared by every caller; copy it into a new Set to change it.');
+    }
+}
+Object.freeze(FrozenVerdictSet.prototype);
+export function frozenSet(members) {
+    return Object.freeze(new FrozenVerdictSet(members));
+}

package/dist/handsSeam.d.ts

@@ -0,0 +1,3 @@
+import type { WiringManifestHandsView } from './toolRoster.js';
+export declare function projectHandsSection(holder: object): WiringManifestHandsView | undefined;
+export declare const HANDS_REASON_NO_EXECUTION_ENV = "no_execution_env";

package/dist/handsSeam.js

@@ -0,0 +1,19 @@
+export function projectHandsSection(holder) {
+    if (!Object.hasOwn(holder, 'hands'))
+        return undefined;
+    const raw = holder.hands;
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return undefined;
+    if (!Object.hasOwn(raw, 'mounted'))
+        return undefined;
+    const mounted = raw.mounted;
+    if (typeof mounted !== 'boolean')
+        return undefined;
+    const reason = Object.hasOwn(raw, 'reason') ? raw.reason : undefined;
+    return { mounted, ...(typeof reason === 'string' && reason.length > 0 ? { reason } : {}) };
+}
+export const HANDS_REASON_NO_EXECUTION_ENV = 'no_execution_env';
+const _handsReasonPin = true;
+void _handsReasonPin;
+const _handsViewPin = true;
+void _handsViewPin;