@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/sessionMap.js

@@ -1,22 +1,41 @@
+import { tupleOriginUrlOf } from './engineAddress.js';
+import { readOwnDataValue } from './ownKey.js';
 export function engineNamespaceKeyFor(baseUrl) {
     if (!baseUrl)
         return 'local';
-    try {
-        const u = new URL(baseUrl);
-        if (!/^(?:https?|wss?|ftp):$/.test(u.protocol))
-            return baseUrl.toLowerCase();
-        return u.origin.toLowerCase() + u.pathname.replace(/\/+$/, '');
-    }
-    catch {
+    const u = tupleOriginUrlOf(baseUrl);
+    if (u === undefined)
         return baseUrl.toLowerCase();
-    }
+    return u.origin.toLowerCase() + u.pathname.replace(/\/+$/, '');
+}
+function boundEntryKept(prior, nextEngines) {
+    const key = prior?.boundEngine?.key;
+    if (typeof key !== 'string')
+        return true;
+    const before = prior?.engines !== undefined && Object.hasOwn(prior.engines, key) ? prior.engines[key] : undefined;
+    const has = nextEngines !== undefined && nextEngines !== null && Object.hasOwn(nextEngines, key);
+    const after = has ? readOwnDataValue(nextEngines, key) : undefined;
+    if (has && after === undefined)
+        return false;
+    if (before === undefined || after === undefined)
+        return before === after;
+    if (after === before)
+        return true;
+    return typeof after === 'object' && after !== null && readOwnDataValue(after, 'engineSessionId') === before.engineSessionId;
 }
 const isoNow = () => new Date().toISOString();
 export function mergeSessionMapRecord(prior, partial, now = isoNow) {
     const shellSessionId = partial.shellSessionId ?? prior?.shellSessionId;
     if (!shellSessionId)
         return { ok: false, reason: 'no-shell-session-id' };
-    return { ok: true, record: { ...prior, ...partial, shellSessionId, updatedAt: now() } };
+    const record = { ...prior, ...partial, shellSessionId, updatedAt: now() };
+    if (prior?.boundEngine !== undefined)
+        record.boundEngine = prior.boundEngine;
+    else
+        delete record.boundEngine;
+    if (!boundEntryKept(prior, record.engines))
+        return { ok: false, reason: 'bound-entry-conflict' };
+    return { ok: true, record };
 }
 export function mergeEngineEntry(prior, key, partial, shellSessionId, now = isoNow) {
     const priorEntry = prior?.engines?.[key];
@@ -26,6 +45,13 @@ export function mergeEngineEntry(prior, key, partial, shellSessionId, now = isoN
     const sid = shellSessionId ?? prior?.shellSessionId;
     if (!sid)
         return { ok: false, reason: 'no-shell-session-id' };
+    if (prior?.boundEngine !== undefined && key === prior.boundEngine.key) {
+        if (priorEntry === undefined ||
+            engineSessionId !== priorEntry.engineSessionId ||
+            (Object.hasOwn(partial, 'engineSessionId') && readOwnDataValue(partial, 'engineSessionId') !== priorEntry.engineSessionId)) {
+            return { ok: false, reason: 'bound-entry-conflict' };
+        }
+    }
     const entry = { ...priorEntry, ...partial, engineSessionId, updatedAt: now() };
     return {
         ok: true,

package/dist/sessionMemoryErase.d.ts

@@ -33,7 +33,7 @@ export type SessionMemoryEraseAnswer = {
     detail: string;
 };
 export declare function eraseSessionMemory(call: SessionMemoryEraseCall, wire: SessionMemoryEraseWire, opts?: SessionMemoryEraseOptions): Promise<SessionMemoryEraseAnswer>;
-export type SessionMemoryEraseRefusalReason = 'bad_input' | 'no_connection' | 'cancelled_before_send' | 'credentials_required' | 'not_permitted' | 'memory_engine_absent' | 'session_not_found' | 'route_absent' | 'request_rejected' | 'evidence_unavailable' | 'request_id_reused' | 'store_unreadable';
+export type SessionMemoryEraseRefusalReason = 'bad_input' | 'no_connection' | 'cancelled_before_send' | 'credentials_required' | 'not_permitted' | 'memory_engine_absent' | 'session_not_found' | 'route_absent' | 'request_rejected' | 'evidence_unavailable' | 'request_id_reused' | 'store_unreadable' | 'personal_store_unjudged';
 export type SessionMemoryEraseUnconfirmedWhy = 'no_answer' | 'receipt_unreadable' | 'receipt_mismatch' | 'store_link_outside' | 'store_home_not_directory' | 'control_plane_corrupt' | 'engine_fault' | 'unclassified' | 'no_code' | 'unreadable';
 export type SessionMemoryEraseRetry = 'not_needed' | 'same_request_id' | 'new_request_id' | 'needs_operator' | 'needs_consent' | 'human_decision' | 'pointless';
 type SessionMemoryEraseReceipt = Extract<MemoryEraseReceiptReading, {

package/dist/sessionMemoryErase.js

@@ -3,6 +3,7 @@ import { INJECTED_WIRE_SETTLE_MS, connectionLostDetail, noAnswerDetailFrom, noAn
 import { memoryEraseReplayPosture, readMemoryEraseReceipt } from './memoryEntriesWire.js';
 import { normalizeWirePrincipal } from './principalWire.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const PRINCIPAL_HEADER = 'x-agent-principal';
 const MAX_TIMER_MS = 2_147_483_647;
 const NOT_SENT = ' — nothing was sent';
@@ -231,6 +232,7 @@ const REFUSAL_TEXT = {
     evidence_unavailable: "Nothing was erased: this deployment's memory store cannot keep proof of an erase, so the erase was declined.",
     request_id_reused: 'Nothing was erased: this request id was already used for a different erase.',
     store_unreadable: 'Nothing was erased: part of the memory store could not be read, so the erase was declined before anything changed; the deployment operator needs to repair the store.',
+    personal_store_unjudged: renderMessage(msg('session.memoryErase.personalStoreUnjudged')),
 };
 const UNCONFIRMED_TEXT = {
     no_answer: 'Not confirmed: no answer came back from the engine, so the erase may or may not have happened.',
@@ -290,6 +292,7 @@ const REFUSAL_RETRY = {
     evidence_unavailable: 'needs_consent',
     request_id_reused: 'new_request_id',
     store_unreadable: 'needs_operator',
+    personal_store_unjudged: 'pointless',
 };
 export const SESSION_MEMORY_ERASE_REFUSAL_REASONS = Object.freeze(Object.keys(REFUSAL_TEXT));
 export const SESSION_MEMORY_ERASE_UNCONFIRMED_WHYS = Object.freeze(Object.keys(UNCONFIRMED_TEXT));
@@ -350,6 +353,8 @@ function bandOfCode(code) {
             return { refused: 'request_id_reused' };
         case 'memory.erasure_census_incomplete':
             return { refused: 'store_unreadable' };
+        case 'memory.erasure_store_unjudged':
+            return { refused: 'personal_store_unjudged' };
         case 'memory.target_outside_store':
             return { unconfirmed: 'store_link_outside' };
         case 'memory.scope_home_not_directory':

package/dist/sessionMemoryStatus.d.ts

@@ -1,4 +1,5 @@
 import type { SessionMemoryStatus, SessionMemoryStatusResponse } from '@sema-agent/sdk';
+import { type UiLanguage } from './env/uiLanguage.js';
 export interface MemoryStatusClientLike {
     sessions: {
         memoryStatus(sessionId: string, opts?: {
@@ -8,7 +9,17 @@ export interface MemoryStatusClientLike {
         } & SessionMemoryStatus>;
     };
 }
-export type MemoryStatusFacts = Omit<SessionMemoryStatusResponse, 'sessionId'>;
+export type MemoryStatusFacts = Omit<SessionMemoryStatusResponse, 'sessionId' | 'memorySync'> & {
+    readonly memorySync?: MemorySyncFacts;
+};
+export interface MemorySyncFacts {
+    readonly parked: readonly MemorySyncParkedFacts[];
+}
+export interface MemorySyncParkedFacts {
+    readonly scope: string;
+    readonly wayOut: string;
+}
+export declare const MEMORY_SYNC_WAY_OUT_DELETE_CURSOR: "delete_cursor";
 export type MemoryStatusVerdict = {
     readonly kind: 'ok';
     readonly sessionId: string;
@@ -44,4 +55,19 @@ export declare function readLastCapture(s: SessionMemoryStatus): LastCaptureRead
 export declare function readSessionMemoryStatus(client: MemoryStatusClientLike, sessionId: string, opts?: {
     signal?: AbortSignal;
 }): Promise<MemoryStatusVerdict>;
+export type MemorySyncParkingReading = {
+    readonly state: 'syncing';
+} | {
+    readonly state: 'parked';
+    readonly layers: readonly MemorySyncParkedLayerReading[];
+} | {
+    readonly state: 'not_reported';
+};
+export interface MemorySyncParkedLayerReading {
+    readonly scope: string;
+    readonly wayOut: string;
+    readonly deleteCursor: boolean;
+}
+export declare function readMemorySyncParking(facts: MemoryStatusFacts | null | undefined): MemorySyncParkingReading;
+export declare function memorySyncParkingNotice(reading: MemorySyncParkingReading, lang?: UiLanguage | (string & {})): string | undefined;
 export declare function readAutoConsolidationArmed(facts: MemoryStatusFacts | null | undefined): 'armed' | 'unarmed' | 'indeterminate';

package/dist/sessionMemoryStatus.js

@@ -1,5 +1,9 @@
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
+import { isUiLanguage } from './env/uiLanguage.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const MEMORY_SYNC_WAY_OUT_DELETE_CURSOR = 'delete_cursor';
+const MEMORY_SYNC_PARKED_READ_MAX = 256;
 export function classifyMemoryStatusFailure(e) {
     const rawCode = readThrownSlot(e, 'errorCode', 'data');
     const rawStatus = readThrownSlot(e, 'status', 'data');
@@ -64,6 +68,7 @@ export async function readSessionMemoryStatus(client, sessionId, opts) {
                     : {}),
                 ...(typeof o.lastCaptureAt === 'number' ? { lastCaptureAt: o.lastCaptureAt } : {}),
                 ...(typeof o.autoConsolidationArmed === 'boolean' ? { autoConsolidationArmed: o.autoConsolidationArmed } : {}),
+                ...memorySyncSpread(o),
             },
         };
     }
@@ -71,6 +76,118 @@ export async function readSessionMemoryStatus(client, sessionId, opts) {
         return classifyMemoryStatusFailure(e);
     }
 }
+function ownDataSlot(o, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        if (d === undefined)
+            return { ok: true, value: undefined };
+        return Object.hasOwn(d, 'value') ? { ok: true, value: d.value } : { ok: false };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function memorySyncFactsOf(raw) {
+    try {
+        if (!isPlainObject(raw))
+            return undefined;
+        const parkedSlot = ownDataSlot(raw, 'parked');
+        if (!parkedSlot.ok || !Array.isArray(parkedSlot.value))
+            return undefined;
+        const arr = parkedSlot.value;
+        const len = ownDataSlot(arr, 'length');
+        if (!len.ok || typeof len.value !== 'number' || !Number.isSafeInteger(len.value) || len.value < 0 || len.value > MEMORY_SYNC_PARKED_READ_MAX)
+            return undefined;
+        const parked = [];
+        for (let i = 0; i < len.value; i++) {
+            const el = ownDataSlot(arr, String(i));
+            if (!el.ok || !isPlainObject(el.value))
+                return undefined;
+            const scope = ownDataSlot(el.value, 'scope');
+            const wayOut = ownDataSlot(el.value, 'wayOut');
+            if (!scope.ok || !wayOut.ok || typeof scope.value !== 'string' || scope.value.length === 0 || typeof wayOut.value !== 'string' || wayOut.value.length === 0)
+                return undefined;
+            parked.push(Object.freeze({ scope: scope.value, wayOut: wayOut.value }));
+        }
+        return Object.freeze({ parked: Object.freeze(parked) });
+    }
+    catch {
+        return undefined;
+    }
+}
+function memorySyncSpread(o) {
+    const slot = ownDataSlot(o, 'memorySync');
+    if (!slot.ok || slot.value === undefined)
+        return {};
+    const facts = memorySyncFactsOf(slot.value);
+    return facts === undefined ? {} : { memorySync: facts };
+}
+export function readMemorySyncParking(facts) {
+    let sync;
+    try {
+        if (!isPlainObject(facts))
+            return Object.freeze({ state: 'not_reported' });
+        const slot = ownDataSlot(facts, 'memorySync');
+        sync = slot.ok ? memorySyncFactsOf(slot.value) : undefined;
+    }
+    catch {
+        sync = undefined;
+    }
+    if (sync === undefined)
+        return Object.freeze({ state: 'not_reported' });
+    if (sync.parked.length === 0)
+        return Object.freeze({ state: 'syncing' });
+    return Object.freeze({
+        state: 'parked',
+        layers: Object.freeze(sync.parked.map((p) => Object.freeze({ scope: p.scope, wayOut: p.wayOut, deleteCursor: p.wayOut === MEMORY_SYNC_WAY_OUT_DELETE_CURSOR }))),
+    });
+}
+const MEMORY_SYNC_SCOPE_NAME_MAX = 120;
+export function memorySyncParkingNotice(reading, lang) {
+    try {
+        if (typeof reading !== 'object' || reading === null)
+            return undefined;
+        const state = Object.getOwnPropertyDescriptor(reading, 'state');
+        if (state === undefined || !Object.hasOwn(state, 'value') || state.value !== 'parked')
+            return undefined;
+        const layersSlot = Object.getOwnPropertyDescriptor(reading, 'layers');
+        if (layersSlot === undefined || !Object.hasOwn(layersSlot, 'value') || !Array.isArray(layersSlot.value))
+            return undefined;
+        const raw = layersSlot.value;
+        const lenSlot = Object.getOwnPropertyDescriptor(raw, 'length');
+        const count = lenSlot?.value;
+        if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 1 || count > MEMORY_SYNC_PARKED_READ_MAX)
+            return undefined;
+        const scopes = [];
+        let named = true;
+        let allDeleteCursor = true;
+        for (let i = 0; i < count; i++) {
+            const el = Object.getOwnPropertyDescriptor(raw, String(i));
+            const layer = el !== undefined && Object.hasOwn(el, 'value') ? el.value : undefined;
+            if (typeof layer !== 'object' || layer === null)
+                return undefined;
+            const scope = Object.getOwnPropertyDescriptor(layer, 'scope');
+            const del = Object.getOwnPropertyDescriptor(layer, 'deleteCursor');
+            const s = scope !== undefined && Object.hasOwn(scope, 'value') ? scope.value : undefined;
+            if (typeof s !== 'string' || s.length === 0 || s.length > MEMORY_SYNC_SCOPE_NAME_MAX || /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(s))
+                named = false;
+            else
+                scopes.push(s);
+            if (del === undefined || !Object.hasOwn(del, 'value') || del.value !== true)
+                allDeleteCursor = false;
+        }
+        const wayOut = msg(allDeleteCursor ? 'session.memorySync.wayOut.deleteCursor' : 'session.memorySync.wayOut.unrecognized');
+        if (!named)
+            return renderMessage(msg(count === 1 ? 'session.memorySync.parkedUnnamed.one' : 'session.memorySync.parkedUnnamed.other', { count, wayOut }), isUiLanguage(lang) ? lang : undefined);
+        if (count === 1)
+            return renderMessage(msg('session.memorySync.parked.one', { scope: scopes[0] ?? '', wayOut }), isUiLanguage(lang) ? lang : undefined);
+        return renderMessage(msg('session.memorySync.parked.other', { count, scopes: scopes.join(lang === 'zh' ? '、' : ', '), wayOut }), isUiLanguage(lang) ? lang : undefined);
+    }
+    catch {
+        return undefined;
+    }
+}
 export function readAutoConsolidationArmed(facts) {
     if (typeof facts !== 'object' || facts === null)
         return 'indeterminate';

package/dist/sessionMemorySync.d.ts

@@ -0,0 +1,31 @@
+import { SDK_SESSION_MEMORY_UNOBSERVED_REASONS } from './generated/sdkFactTables.js';
+import { type UiLanguage } from './env/uiLanguage.js';
+type UnobservedReason = (typeof SDK_SESSION_MEMORY_UNOBSERVED_REASONS)[number];
+export type SessionMemorySyncReportReading = {
+    readonly scopes: readonly string[];
+} & ({
+    readonly layers: readonly object[];
+    readonly refused?: undefined;
+} | {
+    readonly refused: object;
+    readonly layers?: undefined;
+});
+export type SessionMemorySyncState = {
+    readonly kind: 'not_configured';
+    readonly report: SessionMemorySyncReportReading;
+} | {
+    readonly kind: 'reported';
+    readonly report: SessionMemorySyncReportReading;
+} | {
+    readonly kind: 'unobtainable';
+    readonly reason?: UnobservedReason;
+    readonly activeTaskId?: string;
+};
+export type SessionMemorySyncSettled = {
+    readonly report: {} | null | undefined;
+} | {
+    readonly error: {} | null | undefined;
+};
+export declare function sessionMemorySyncStateOf(settled: SessionMemorySyncSettled | null | undefined): SessionMemorySyncState | null;
+export declare function sessionMemorySyncNotice(state: SessionMemorySyncState | null | undefined, lang?: UiLanguage | (string & {})): string | undefined;
+export {};

package/dist/sessionMemorySync.js

@@ -0,0 +1,95 @@
+import { CONFLICT_SESSION_MEMORY_UNOBSERVED } from './engineErrorCodes.js';
+import { SDK_SESSION_MEMORY_UNOBSERVED_REASONS } from './generated/sdkFactTables.js';
+import { isUiLanguage } from './env/uiLanguage.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { slotReadOf, isSlotCarrier, readErrorString } from './wireFailureShape.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+const reasonOf = (v) => SDK_SESSION_MEMORY_UNOBSERVED_REASONS.find((w) => w === v);
+function scopesOf(report) {
+    const r = slotReadOf(report, 'scopes');
+    if (r.presence !== 'present' || !Array.isArray(r.value))
+        return undefined;
+    const out = [];
+    const len = r.value.length;
+    if (typeof len !== 'number' || !Number.isSafeInteger(len) || len < 0)
+        return undefined;
+    for (let i = 0; i < len; i++) {
+        const item = r.value[i];
+        if (typeof item !== 'string')
+            return undefined;
+        out.push(item);
+    }
+    return out;
+}
+export function sessionMemorySyncStateOf(settled) {
+    try {
+        if (typeof settled !== 'object' || settled === null)
+            return null;
+        const reportSlot = slotReadOf(settled, 'report');
+        const errorSlot = slotReadOf(settled, 'error');
+        if (reportSlot.presence === 'present' && errorSlot.presence === 'absent') {
+            const report = reportSlot.value;
+            if (typeof report !== 'object' || report === null || Array.isArray(report))
+                return null;
+            const scopes = scopesOf(report);
+            if (scopes === undefined)
+                return null;
+            const refused = slotReadOf(report, 'refused');
+            const layers = slotReadOf(report, 'layers');
+            if (refused.presence === 'unreadable' || layers.presence === 'unreadable')
+                return null;
+            const refusedArm = refused.presence === 'present';
+            if (refusedArm === (layers.presence === 'present'))
+                return null;
+            if (refusedArm ? typeof refused.value !== 'object' || refused.value === null || Array.isArray(refused.value) : !Array.isArray(layers.value))
+                return null;
+            const kind = scopes.length === 0 && !refusedArm ? 'not_configured' : 'reported';
+            return Object.freeze({ kind, report: report });
+        }
+        if (errorSlot.presence === 'present' && reportSlot.presence === 'absent') {
+            const err = errorSlot.value;
+            if (!isSlotCarrier(err))
+                return null;
+            if (effectiveWireErrorCode(err) !== CONFLICT_SESSION_MEMORY_UNOBSERVED)
+                return null;
+            const o = err;
+            const reason = reasonOf(readErrorString(o, 'reason'));
+            const active = readErrorString(o, 'activeTaskId');
+            return Object.freeze({
+                kind: 'unobtainable',
+                ...(reason !== undefined ? { reason } : {}),
+                ...(typeof active === 'string' && active !== '' ? { activeTaskId: active } : {}),
+            });
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+const UNOBTAINABLE_KEYS = Object.freeze({
+    no_settled_run: 'session.memorySyncTrigger.noSettledRun',
+    run_result_missing: 'session.memorySyncTrigger.runUnobserved',
+    run_result_unobserved: 'session.memorySyncTrigger.runUnobserved',
+    memory_not_mounted: 'session.memorySyncTrigger.memoryNotMounted',
+    no_leaf: 'session.memorySyncTrigger.noLeaf',
+});
+export function sessionMemorySyncNotice(state, lang) {
+    try {
+        if (typeof state !== 'object' || state === null)
+            return undefined;
+        const kind = slotReadOf(state, 'kind');
+        if (kind.presence !== 'present')
+            return undefined;
+        if (kind.value === 'not_configured')
+            return renderMessage(msg('session.memorySyncTrigger.notConfigured'), isUiLanguage(lang) ? lang : undefined);
+        if (kind.value !== 'unobtainable')
+            return undefined;
+        const reason = slotReadOf(state, 'reason');
+        const word = reason.presence === 'present' && typeof reason.value === 'string' ? reasonOf(reason.value) : undefined;
+        return renderMessage(msg(word !== undefined ? UNOBTAINABLE_KEYS[word] : 'session.memorySyncTrigger.unobtainable'), isUiLanguage(lang) ? lang : undefined);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/sessionRowTag.d.ts

@@ -20,5 +20,9 @@ export type SessionRowPatchRefusal = {
 } | {
     readonly kind: 'tag-unsupported';
 };
+export interface SessionRowUnreadable {
+    readonly errorCode?: string;
+}
+export declare function sessionRowUnreadableOf(row: object | null | undefined): SessionRowUnreadable | undefined;
 export declare function sessionRowTagOf(row: object | null | undefined): string | undefined;
 export declare function sessionRowPatchRefusalOf(error: {} | null | undefined, sent: Readonly<SessionRowPatchFields> | null | undefined): SessionRowPatchRefusal | null;

package/dist/sessionRowTag.js

@@ -8,6 +8,24 @@ function ownData(v, key) {
         return undefined;
     return guardedRead(() => readOwnDataValue(v, key));
 }
+export function sessionRowUnreadableOf(row) {
+    try {
+        const marker = ownData(row, 'unreadable');
+        if (!isPlainMarker(marker))
+            return undefined;
+        const code = ownData(marker, 'errorCode');
+        return Object.freeze(typeof code === 'string' && code.length > 0 ? { errorCode: code } : {});
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPlainMarker(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === null || (typeof proto === 'object' && Object.getPrototypeOf(proto) === null);
+}
 export function sessionRowTagOf(row) {
     const v = ownData(row, 'rowTag');
     return typeof v === 'string' && v.length > 0 ? v : undefined;

package/dist/settingsLayerAdmission.d.ts

@@ -1,4 +1,5 @@
 import type { HostSettingsLayer, WorkspaceTrustState } from './hostSettingsSource.js';
+export declare function layerAdmissionReading(trust: WorkspaceTrustState | 'unreadable'): WorkspaceTrustState;
 export declare function layerAdmissionWord(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): string;
 export declare function layerAdmitted(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): boolean;
 export declare function admittedLayers<L extends HostSettingsLayer>(layers: readonly L[], trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): readonly L[];

package/dist/settingsLayerAdmission.js

@@ -1,8 +1,11 @@
 import { SETTINGS_LAYER_ADMISSION } from './generated/settingsSchemaFns.js';
 const TRUST_UNREADABLE_READING = 'declined';
 const ADMITTED = 'admitted';
+export function layerAdmissionReading(trust) {
+    return trust === 'unreadable' ? TRUST_UNREADABLE_READING : trust;
+}
 function layerAdmissionOf(layer, trust, category, member) {
-    const reading = trust === 'unreadable' ? TRUST_UNREADABLE_READING : trust;
+    const reading = layerAdmissionReading(trust);
     return member === undefined ? SETTINGS_LAYER_ADMISSION(layer, reading, category) : SETTINGS_LAYER_ADMISSION(layer, reading, category, member);
 }
 export function layerAdmissionWord(layer, trust, category, member) {

package/dist/sseIdleTriage.d.ts

@@ -1,4 +1,5 @@
 import { type EnvLike } from './hostEnv.js';
+import { type RunNotFollowed } from './runFollow.js';
 export declare const SSE_HEARTBEAT_GRACE_ENV = "SEMA_SSE_HEARTBEAT_GRACE_MS";
 export declare const SSE_GRACE_MIN_MS = 5000;
 export declare const SSE_GRACE_MAX_MS = 600000;
@@ -7,9 +8,10 @@ export declare function resolveSseHeartbeatGraceMs(env?: EnvLike): number | unde
 export declare function markEngineAliveIdle<E extends Error>(err: E): E;
 export declare function engineAliveIdleElapsedMs(err: unknown): number | undefined;
 export declare function isSseIdleError(err: unknown): boolean;
+export declare function isStreamEndedWithoutTerminalError(err: {} | null | undefined): boolean;
 export declare function probeEngineAlive(baseUrl: string, timeoutMs?: number): Promise<boolean>;
 export declare function diagnoseSseIdleTear<T>(inner: AsyncGenerator<T>, baseUrl: string, signal?: AbortSignal): AsyncGenerator<T>;
 export declare function engineAliveIdleContent(elapsedMs: number, detach?: {
     detached: true;
     taskId?: string;
-}): string;
+}, notFollowed?: RunNotFollowed): string;

package/dist/sseIdleTriage.js

@@ -1,6 +1,8 @@
 import { hostEnv } from './hostEnv.js';
-import { SseIdleError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
+import { SseIdleError, StreamEndedWithoutTerminalError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
 import { readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { runNotFollowedNoticeRef } from './runFollow.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;
@@ -17,8 +19,12 @@ export function resolveSseHeartbeatGraceMs(env = hostEnv()) {
     return n;
 }
 export function markEngineAliveIdle(err) {
-    ;
-    err.semaTearVerdict = 'engine-alive-idle';
+    try {
+        ;
+        err.semaTearVerdict = 'engine-alive-idle';
+    }
+    catch {
+    }
     return err;
 }
 export function engineAliveIdleElapsedMs(err) {
@@ -32,6 +38,11 @@ export function isSseIdleError(err) {
         return true;
     return readThrownSlot(err, 'name', 'data') === 'SseIdleError';
 }
+export function isStreamEndedWithoutTerminalError(err) {
+    if (thrownIsInstanceOf(err, StreamEndedWithoutTerminalError))
+        return true;
+    return readThrownSlot(err, 'name', 'data') === 'StreamEndedWithoutTerminalError';
+}
 export async function probeEngineAlive(baseUrl, timeoutMs = 2_000) {
     return (await sdkProbeHealth(baseUrl, timeoutMs)).alive;
 }
@@ -46,8 +57,12 @@ export async function* diagnoseSseIdleTear(inner, baseUrl, signal) {
         throw err;
     }
 }
-export function engineAliveIdleContent(elapsedMs, detach) {
+export function engineAliveIdleContent(elapsedMs, detach, notFollowed) {
     const secs = Math.max(1, Math.round((elapsedMs > 0 ? elapsedMs : SDK_DEFAULT_GRACE_MS) / 1000));
+    if (notFollowed !== undefined && notFollowed !== null) {
+        const grace = msg('follow.notFollowed.idleGrace', { env: SSE_HEARTBEAT_GRACE_ENV, min: SSE_GRACE_MIN_MS, max: SSE_GRACE_MAX_MS, default: SDK_DEFAULT_GRACE_MS });
+        return renderMessage(msg('follow.notFollowed.idleTear', { secs, notice: runNotFollowedNoticeRef(notFollowed), grace }));
+    }
     const graceTail = `If your tasks legitimately go quiet this long (e.g. a long build), raise the idle grace: set ${SSE_HEARTBEAT_GRACE_ENV} ` +
         `(settings env, integer ms, ${SSE_GRACE_MIN_MS}-${SSE_GRACE_MAX_MS}; default ${SDK_DEFAULT_GRACE_MS}).`;
     if (detach?.detached) {

package/dist/subagent/engineSubagentTail.js

@@ -6,6 +6,7 @@ import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+import { readFrameTrueMark } from '../ownKey.js';
 function usableTailClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentStream']]);
 }
@@ -140,6 +141,7 @@ export function tailEngineSubagent(taskId, opts) {
                         ...(typeof d.toolName === 'string' ? { toolName: d.toolName } : {}),
                         ...(out !== undefined ? { output: out } : {}),
                         ...(d.isError === true ? { isError: true } : {}),
+                        ...(readFrameTrueMark(d, 'notExecuted') ? { notExecuted: true } : {}),
                     });
                 }
                 else if (t === 'task_settled') {

package/dist/subagentContentStore.d.ts

@@ -11,6 +11,7 @@ export type SubagentContentItem = {
     input: unknown;
     output?: string;
     isError?: boolean;
+    notExecuted?: true;
 } | {
     kind: 'echo';
     text: string;
@@ -31,6 +32,7 @@ export interface SubagentContentEvent {
     args?: unknown;
     output?: string | undefined;
     isError?: boolean | undefined;
+    notExecuted?: true | undefined;
 }
 export declare function coerceOutput(v: unknown): string | undefined;
 export declare function subagentContentEventOf(ev: {
@@ -82,6 +84,7 @@ export type SubagentViewSlot = {
     input: unknown;
     output?: string;
     isError?: boolean;
+    notExecuted?: true;
 };
 export declare function planSubagentViewSlots(taskId: string): SubagentViewSlot[];
 export declare function parentToolCallIdOf(taskId: string): string | undefined;

package/dist/subagentContentStore.js

@@ -1,4 +1,5 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
+import { readFrameTrueMark } from './ownKey.js';
 import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     return toolEndOutputText(v);
@@ -23,6 +24,7 @@ export function subagentContentEventOf(ev) {
         args: sub.args,
         output: coerceOutput(sub.output),
         isError: sub.isError,
+        notExecuted: readFrameTrueMark(sub, 'notExecuted') ? true : undefined,
     };
 }
 const MAX_ITEMS_PER_TASK = 200;
@@ -567,12 +569,17 @@ export function publishSubagentContentEvent(ev) {
                 const before = itemBytesOf(it);
                 const outBefore = it.output;
                 const errBefore = it.isError;
+                const notExecBefore = it.notExecuted;
                 it.output = ev.output ?? '';
                 it.isError = ev.isError === true;
+                if (ev.notExecuted === true)
+                    it.notExecuted = true;
+                else
+                    delete it.notExecuted;
                 const delta = itemBytesOf(it) - before;
                 s.itemBytes[at] = (s.itemBytes[at] ?? 0) + delta;
                 addBytes(s, delta);
-                stampPhase(s, it.id, 'end', ev.eventId, it.output !== outBefore || it.isError !== errBefore);
+                stampPhase(s, it.id, 'end', ev.eventId, it.output !== outBefore || it.isError !== errBefore || it.notExecuted !== notExecBefore);
                 break;
             }
             const synthId = id ?? `${ev.taskId}-tool-${s.items.length}`;
@@ -583,6 +590,7 @@ export function publishSubagentContentEvent(ev) {
                 input: ev.args ?? {},
                 output: ev.output ?? '',
                 isError: ev.isError === true,
+                ...(ev.notExecuted === true ? { notExecuted: true } : {}),
             });
             recordCut(s);
             stampPhase(s, synthId, 'end', ev.eventId, true);
@@ -626,6 +634,7 @@ export function planSubagentViewSlots(taskId) {
                 input: it.input,
                 ...(it.output !== undefined ? { output: it.output } : {}),
                 ...(it.isError === true ? { isError: true } : {}),
+                ...(it.notExecuted === true ? { notExecuted: true } : {}),
             });
         }
         else if (it.kind === 'text') {

package/dist/toolResult.js

@@ -28,7 +28,7 @@ export const PROTOCOL_MARKERS = {
     delegationTrailer: 'Verify this result before concluding. If it leaves more to do, continue or delegate again.',
     delegationTrailerFork: 'Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.',
     delegationFieldLine: /^(status|error|error_kind|observer|stats|worktree):(?: ([^\r\u2028\u2029\u0085]*))?/,
-    taskOutputLabel: /^TaskOutput\s+(\S+)$/,
+    taskOutputLabel: /^(?:TaskOutput|task)\s+(\S+)$/,
     taskOutputStatus: /^status:\s*(.+)$/m,
     taskOutputHeadSlots: /^(\r?\n)(?:(state: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?(?:(error: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?/,
     taskOutputResultNote: /^--- result \(([^)\n]*)\) ---/,