@sema-agent/client-core 0.104.1 → 0.105.0

package/dist/runPermissionModeSwitch.js

@@ -0,0 +1,135 @@
+import { atMostOnceVerdictOf } from './atMostOnce.js';
+import { readPermissionModeReceiptSegment } from './adapter/downstream/wiringManifestView.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { SDK_PERMISSION_MODE_ADMISSION_FOLDS, SDK_PERMISSION_MODE_PERSIST_MISSES } from './generated/sdkFactTables.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { ownDataField } from './ownKey.js';
+import { permissionModeWriteAvailable } from './permissionModeWriteCapability.js';
+import { isDisplayableWireCode } from './wireFailureShape.js';
+export const PERMISSION_MODE_SWITCH_RESULT_KEYS = Object.freeze(['taskId', 'sessionId', 'status', 'permissionMode', 'admission', 'persisted', 'persistMiss']);
+const NOT_RUNNING_CODE = 'steering.not_running';
+const PRE_SWITCH_CORRUPT_CODE = 'corrupt';
+function guardedSlot(o, key) {
+    if (o === null || (typeof o !== 'object' && typeof o !== 'function'))
+        return undefined;
+    try {
+        return o[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+const unavailable = () => Object.freeze({ kind: 'unavailable' });
+const unreadableAnswer = () => Object.freeze({ kind: 'unconfirmed', why: 'unreadable-answer' });
+function admissionOf(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const requested = ownDataField(raw, 'requested');
+    const admitted = ownDataField(raw, 'admitted');
+    const foldedBy = ownDataField(raw, 'foldedBy');
+    if (typeof requested !== 'string' || requested === '' || typeof admitted !== 'string' || admitted === '')
+        return undefined;
+    const fold = SDK_PERMISSION_MODE_ADMISSION_FOLDS.find((w) => w === foldedBy);
+    return fold === undefined ? undefined : Object.freeze({ requested, admitted, foldedBy: fold });
+}
+function switchOutcomeOf(taskId, sent, body) {
+    try {
+        if (body === null || typeof body !== 'object' || Array.isArray(body))
+            return unreadableAnswer();
+        const keys = PERMISSION_MODE_SWITCH_RESULT_KEYS;
+        for (const k of Reflect.ownKeys(body))
+            if (typeof k !== 'string' || !keys.includes(k))
+                return unreadableAnswer();
+        if (ownDataField(body, 'taskId') !== taskId)
+            return unreadableAnswer();
+        const sessionId = ownDataField(body, 'sessionId');
+        if (typeof sessionId !== 'string' || sessionId === '' || ownDataField(body, 'status') !== 'running')
+            return unreadableAnswer();
+        const permissionMode = readPermissionModeReceiptSegment(body, 'permissionMode');
+        if (permissionMode === undefined)
+            return unreadableAnswer();
+        const admissionRaw = ownDataField(body, 'admission');
+        const admission = admissionRaw === undefined ? undefined : admissionOf(admissionRaw);
+        if (admissionRaw !== undefined && admission === undefined)
+            return unreadableAnswer();
+        const asked = admission !== undefined ? admission.requested : permissionMode.requested;
+        if (asked !== undefined && asked !== sent)
+            return unreadableAnswer();
+        if (admission !== undefined && permissionMode.requested !== undefined && permissionMode.requested !== admission.admitted)
+            return unreadableAnswer();
+        const persisted = ownDataField(body, 'persisted');
+        const persistMiss = ownDataField(body, 'persistMiss');
+        const base = { kind: 'switched', taskId, sessionId, permissionMode, ...(admission !== undefined ? { admission } : {}) };
+        if (persisted === true && persistMiss === undefined)
+            return Object.freeze({ ...base, persisted: true });
+        const miss = persisted === false ? SDK_PERMISSION_MODE_PERSIST_MISSES.find((w) => w === persistMiss) : undefined;
+        return miss === undefined ? unreadableAnswer() : Object.freeze({ ...base, persisted: false, persistMiss: miss });
+    }
+    catch {
+        return unreadableAnswer();
+    }
+}
+function failureOutcomeOf(e) {
+    const v = atMostOnceVerdictOf(e);
+    if (v.status === 501)
+        return unavailable();
+    if (v.delivery === 'rejected' && v.status !== undefined) {
+        if (v.status === 404)
+            return Object.freeze({ kind: 'not-found' });
+        if (v.status === 409 && v.code === NOT_RUNNING_CODE)
+            return Object.freeze({ kind: 'not-running' });
+        return Object.freeze({ kind: 'refused', status: v.status, ...(v.code !== undefined ? { errorCode: v.code } : {}) });
+    }
+    if (v.status === 500 && v.code === PRE_SWITCH_CORRUPT_CODE)
+        return Object.freeze({ kind: 'refused', status: 500, errorCode: v.code });
+    return v.status !== undefined
+        ? Object.freeze({ kind: 'unconfirmed', why: 'server-error', status: v.status })
+        : Object.freeze({ kind: 'unconfirmed', why: 'transport' });
+}
+export async function setRunPermissionMode(runs, taskId, mode, opts = {}) {
+    if (!permissionModeWriteAvailable(guardedSlot(opts, 'permissionModeWrite')))
+        return unavailable();
+    const verb = guardedSlot(runs, 'setPermissionMode');
+    if (typeof verb !== 'function')
+        return unavailable();
+    const sessionId = guardedSlot(opts, 'sessionId');
+    const signal = guardedSlot(opts, 'signal');
+    const callOpts = {
+        ...(typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {}),
+        ...(signal !== undefined && signal !== null ? { signal: signal } : {}),
+    };
+    let body;
+    try {
+        body = await verb.call(runs, taskId, mode, callOpts);
+    }
+    catch (e) {
+        return failureOutcomeOf(e);
+    }
+    return switchOutcomeOf(taskId, mode, body);
+}
+export function runPermissionModeSwitchLine(outcome, lang) {
+    switch (outcome.kind) {
+        case 'switched': {
+            const mode = displayUntrusted(outcome.permissionMode.effective, { max: 64 });
+            const reason = outcome.admission !== undefined
+                ? msg(outcome.admission.foldedBy === 'entry_floor' ? 'session.permissionModeSwitch.reason.entryFloor' : 'session.permissionModeSwitch.reason.disableAutoMode')
+                : outcome.permissionMode.foldedBy !== undefined
+                    ? msg('session.permissionModeSwitch.reason.engine')
+                    : undefined;
+            const line = renderMessage(reason === undefined ? msg('session.permissionModeSwitch.applied', { mode }) : msg('session.permissionModeSwitch.folded', { mode, reason }), lang);
+            return outcome.persisted ? line : renderMessage(msg('session.permissionModeSwitch.notPersisted', { line }), lang);
+        }
+        case 'not-running':
+            return renderMessage(msg('session.permissionModeSwitch.notRunning'), lang);
+        case 'not-found':
+            return renderMessage(msg('session.permissionModeSwitch.notFound'), lang);
+        case 'refused':
+            return outcome.errorCode !== undefined && isDisplayableWireCode(outcome.errorCode)
+                ? renderMessage(msg('session.permissionModeSwitch.refusedWithCode', { status: String(outcome.status), code: outcome.errorCode }), lang)
+                : renderMessage(msg('session.permissionModeSwitch.refused', { status: String(outcome.status) }), lang);
+        case 'unconfirmed':
+            return renderMessage(msg('session.permissionModeSwitch.unconfirmed'), lang);
+        case 'unavailable':
+            return renderMessage(msg('session.permissionModeSwitch.unavailable'), lang);
+    }
+}

package/dist/runReattachPolicy.d.ts

@@ -1,3 +1,4 @@
+import { type RunNotFollowed } from './runFollow.js';
 export declare const REATTACH_MAX_TRIES = 5;
 export interface ReattachBudget {
     readonly tries: number;
@@ -5,27 +6,34 @@ export interface ReattachBudget {
     readonly drainingTotal: number;
 }
 export declare const REATTACH_BUDGET_FRESH: ReattachBudget;
+export declare const REATTACH_BUDGET_NONE: ReattachBudget;
 export type ReattachEvent = {
     readonly cause: 'connection_lost';
-    readonly hasRunId: boolean;
+    readonly runId?: string;
     readonly error?: object;
 } | {
     readonly cause: 'stream_cap';
-    readonly hasRunId: boolean;
+    readonly runId?: string;
 } | {
     readonly cause: 'stream_draining';
-    readonly hasRunId: boolean;
+    readonly runId?: string;
     readonly frame: object;
     readonly madeProgress?: boolean;
+} | {
+    readonly cause: 'stream_draining';
+    readonly runId?: string;
+    readonly ladder: 'exhausted';
 };
-export type ReattachGiveUp = 'no_run_id' | 'budget_exhausted' | 'bad_input';
+export type ReattachDrainingEvent = Extract<ReattachEvent, {
+    readonly cause: 'stream_draining';
+}>;
 export type ReattachDecision = {
     readonly action: 'reattach';
     readonly afterMs: number;
     readonly budget: ReattachBudget;
 } | {
     readonly action: 'give_up';
-    readonly reason: ReattachGiveUp;
     readonly budget: ReattachBudget;
+    readonly notFollowed: RunNotFollowed<'reattach_exhausted' | 'no_run_id' | 'bad_input'>;
 };
 export declare function runReattachPolicy(budget: ReattachBudget, event: ReattachEvent): ReattachDecision;

package/dist/runReattachPolicy.js

@@ -1,46 +1,81 @@
 import { STREAM_DRAINING_RECONNECT_MAX, drainingRetryDelayMs, isPreStreamDrainingReject } from './wireErrorTriage.js';
 import { drainingLegStep } from './streamDrainingLegs.js';
+import { mintRunNotFollowed } from './runFollow.js';
 export const REATTACH_MAX_TRIES = 5;
 const DRAINING_TOTAL_MAX = REATTACH_MAX_TRIES * STREAM_DRAINING_RECONNECT_MAX;
 export const REATTACH_BUDGET_FRESH = Object.freeze({ tries: 0, drainingStreak: 0, drainingTotal: 0 });
+export const REATTACH_BUDGET_NONE = Object.freeze({ tries: REATTACH_MAX_TRIES, drainingStreak: 0, drainingTotal: DRAINING_TOTAL_MAX });
 const isCount = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
-const giveUp = (reason, budget) => Object.freeze({ action: 'give_up', reason, budget });
+const giveUp = (notFollowed, budget) => Object.freeze({ action: 'give_up', budget, notFollowed });
 const reattach = (afterMs, tries, drainingStreak, drainingTotal) => Object.freeze({ action: 'reattach', afterMs, budget: Object.freeze({ tries, drainingStreak, drainingTotal }) });
 export function runReattachPolicy(budget, event) {
+    let handle;
     try {
-        if (typeof budget !== 'object' || budget === null || !isCount(budget.tries) || !isCount(budget.drainingStreak) || !isCount(budget.drainingTotal))
-            return giveUp('bad_input', REATTACH_BUDGET_FRESH);
-        if (typeof event !== 'object' || event === null || typeof event.hasRunId !== 'boolean')
-            return giveUp('bad_input', budget);
-        if (!event.hasRunId)
-            return giveUp('no_run_id', budget);
+        const eventOk = typeof event === 'object' && event !== null;
+        const runId = eventOk ? event.runId : undefined;
+        handle = typeof runId === 'string' && runId !== '' ? runId : undefined;
+        const budgetOk = typeof budget === 'object' && budget !== null && isCount(budget.tries) && isCount(budget.drainingStreak) && isCount(budget.drainingTotal);
+        const keep = budgetOk ? budget : REATTACH_BUDGET_FRESH;
+        if (!eventOk)
+            return giveUp(mintRunNotFollowed('bad_input'), keep);
+        const bad = () => giveUp(mintRunNotFollowed('bad_input', handle), keep);
+        if (!budgetOk)
+            return bad();
+        const cause = event.cause;
+        if (cause !== 'connection_lost' && cause !== 'stream_cap' && cause !== 'stream_draining')
+            return bad();
+        let draining;
+        if (cause === 'stream_draining') {
+            const ladder = event.ladder;
+            const frame = event.frame;
+            if ((ladder === undefined) === (frame === undefined))
+                return bad();
+            if (ladder !== undefined) {
+                if (ladder !== 'exhausted')
+                    return bad();
+                draining = { ladder: true };
+            }
+            else {
+                const madeProgress = event.madeProgress;
+                const streak = madeProgress === true ? 0 : budget.drainingStreak;
+                const st = drainingLegStep(streak, frame);
+                if ('giveUp' in st.decision && st.decision.giveUp === 'not_draining_end')
+                    return bad();
+                draining = { step: st };
+            }
+        }
+        if (runId === undefined)
+            return giveUp(mintRunNotFollowed('no_run_id'), keep);
+        if (handle === undefined)
+            return bad();
+        const exhausted = (brk) => giveUp(mintRunNotFollowed('reattach_exhausted', handle, brk), budget);
         const { tries, drainingStreak, drainingTotal } = budget;
-        if (event.cause === 'connection_lost') {
+        if (cause === 'connection_lost') {
             if (tries >= REATTACH_MAX_TRIES)
-                return giveUp('budget_exhausted', budget);
+                return exhausted(cause);
+            const error = event.error;
             const next = tries + 1;
-            const afterMs = isPreStreamDrainingReject(event.error) ? drainingRetryDelayMs(event.error, next - 1) : 1000 * next;
+            const afterMs = isPreStreamDrainingReject(error) ? drainingRetryDelayMs(error, next - 1) : 1000 * next;
             return reattach(afterMs, next, 0, drainingTotal);
         }
-        if (event.cause === 'stream_cap') {
+        if (cause === 'stream_cap') {
             if (tries >= REATTACH_MAX_TRIES)
-                return giveUp('budget_exhausted', budget);
+                return exhausted(cause);
             return reattach(0, tries + 1, 0, drainingTotal);
         }
-        if (event.cause === 'stream_draining') {
-            const streak = event.madeProgress === true ? 0 : drainingStreak;
-            const { decision, streak: nextStreak } = drainingLegStep(streak, event.frame);
-            if ('reconnectAfterMs' in decision && drainingTotal < DRAINING_TOTAL_MAX)
-                return reattach(decision.reconnectAfterMs, tries, nextStreak, drainingTotal + 1);
-            if ('giveUp' in decision && decision.giveUp === 'not_draining_end')
-                return giveUp('bad_input', budget);
+        if (draining === undefined || 'ladder' in draining) {
             if (tries >= REATTACH_MAX_TRIES)
-                return giveUp('budget_exhausted', budget);
-            return reattach(0, tries + 1, nextStreak, drainingTotal);
+                return exhausted(cause);
+            return reattach(0, tries + 1, drainingStreak, drainingTotal);
         }
-        return giveUp('bad_input', budget);
+        const { decision, streak: nextStreak } = draining.step;
+        if ('reconnectAfterMs' in decision && drainingTotal < DRAINING_TOTAL_MAX)
+            return reattach(decision.reconnectAfterMs, tries, nextStreak, drainingTotal + 1);
+        if (tries >= REATTACH_MAX_TRIES)
+            return exhausted(cause);
+        return reattach(0, tries + 1, nextStreak, drainingTotal);
     }
     catch {
-        return giveUp('bad_input', REATTACH_BUDGET_FRESH);
+        return giveUp(mintRunNotFollowed('bad_input', handle), REATTACH_BUDGET_FRESH);
     }
 }

package/dist/seam.d.ts

@@ -5,6 +5,7 @@ import type { WiringManifestAutoMode, WiringManifestModelGate, WiringManifestMcp
 import type { ToolRosterView, ToolRosterDeltaView, WiringManifestHandsView } from './toolRoster.js';
 import type { WiringManifestFleetView } from './adapter/downstream/wiringManifestView.js';
 import type { SuspendedReopenReading } from './hitl/suspendedReopen.js';
+import type { PlanReviewCardFacts } from './planReviewCardFacts.js';
 import type { ToolKillCause } from './toolResult.js';
 import type { HumanInputAttachmentView } from './ownKey.js';
 import type { TaskNotificationFields } from './notifications.js';
@@ -117,6 +118,7 @@ export type ChromeEvent = {
     summary: string;
     message: string;
     notification: Readonly<TaskNotificationFields>;
+    diagnostics?: string;
 } | {
     kind: 'task_ledger_sync';
     laneProof: LaneProof;
@@ -159,6 +161,7 @@ export type ChromeEvent = {
     kind: 'plan_review_park';
     laneProof: LaneProof;
     result: unknown;
+    planReview?: PlanReviewCardFacts;
 } | ({
     kind: 'run_cost_reconciled';
     laneProof: LaneProof;

package/dist/seam.js

@@ -32,7 +32,7 @@ const CHROME_ARM_TABLE = {
             '🔴 `usageMissing` 在场时同行 usage 是**下界**,渲「≥」不渲已知账;' +
             '🔴 终帧的 `_sema_nested_usage_by_task` 是同一份账的**收口快照**,两者**不相加**(本臂是增量、那是合计)',
     },
-    plan_review_park: { required: true, duty: '弹 plan 审批卡(fail-soft,不挡后续终态帧)' },
+    plan_review_park: { required: true, duty: '弹 plan 审批卡(fail-soft,不挡后续终态帧);卡事实 `planReview` 在场时按它出选项与原因句(只有 shown 给批准档)' },
     run_cost_reconciled: {
         required: false,
         duty: '可选:终局成本对账(own / nested / compaction 三段 + reconciled = own + nested)。' +

package/dist/seatContract.js

@@ -1254,6 +1254,7 @@ const SUBAGENT_CONTENT_SHAPE = shapeRule("subagent content", {
     args: optF({ label: "passthrough", test: () => true }),
     output: optF(R_STR),
     isError: optF(R_BOOL),
+    notExecuted: optF(R_TRUE),
 });
 export function readSeatSubagentContent(event) {
     try {

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/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') {