@sema-agent/client-core 0.104.0 → 0.105.0

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/steering.d.ts

@@ -11,6 +11,7 @@ export interface EngineTaskStatusAttachment {
     status: 'pending' | 'running' | 'completed' | 'failed' | 'killed' | 'parked';
     description: string;
     deltaSummary: null;
+    read?: string;
 }
 export type SteeringRenderable = SteeringInjectedAttachment | EngineTaskStatusAttachment;
 export declare function steeringLabel(source: string): string;

package/dist/steering.js

@@ -25,37 +25,45 @@ const PHRASE_TO_STATUS = [
     ['failed', 'failed'],
     ['killed', 'killed'],
 ];
+const BACKGROUND_TASK_LINE = new RegExp('^- \\[([^\\]]+)\\] Task "([\\s\\S]*)" (' +
+    PHRASE_TO_STATUS.map(([phrase]) => phrase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|') +
+    ')(?: — ((?:(?!" )[\\s\\S])*))?$');
 function parseBackgroundTaskLine(line) {
-    const trimmed = line.trim();
-    for (const [phrase, status] of PHRASE_TO_STATUS) {
-        const suffix = `" ${phrase}`;
-        if (!trimmed.endsWith(suffix))
-            continue;
-        const head = trimmed.slice(0, trimmed.length - suffix.length);
-        const m = /^- \[([^\]]+)\] Task "([\s\S]*)$/.exec(head);
-        if (!m)
-            return null;
-        const taskId = m[1];
-        const description = m[2];
-        if (taskId === undefined || description === undefined)
-            return null;
-        return {
-            type: 'task_status',
-            taskId,
-            taskType: 'local_bash',
-            status,
-            description,
-            deltaSummary: null,
-        };
+    const m = BACKGROUND_TASK_LINE.exec(line.trim());
+    if (!m)
+        return null;
+    const taskId = m[1];
+    const description = m[2];
+    const status = PHRASE_TO_STATUS.find(([phrase]) => phrase === m[3])?.[1];
+    if (taskId === undefined || description === undefined || status === undefined)
+        return null;
+    const read = m[4];
+    return {
+        type: 'task_status',
+        taskId,
+        taskType: 'local_bash',
+        status,
+        description,
+        deltaSummary: null,
+        ...(read !== undefined ? { read } : {}),
+    };
+}
+function rowBoundariesTrusted(lines) {
+    let last = lines.length - 1;
+    while (last >= 0 && (lines[last] ?? '').trim() === '')
+        last--;
+    for (let i = 0; i < last; i++) {
+        if (/^- \[[^\]]+\] Task "[^"]*$/.test((lines[i] ?? '').trim()))
+            return false;
     }
-    return null;
+    return true;
 }
 export function steeringInjectedToAttachments(source, preview) {
     if (source === 'background_tasks') {
-        const tasks = preview
-            .split('\n')
-            .map(parseBackgroundTaskLine)
-            .filter((t) => t !== null);
+        const lines = preview.split('\n');
+        const tasks = rowBoundariesTrusted(lines)
+            ? lines.map(parseBackgroundTaskLine).filter((t) => t !== null)
+            : [];
         if (tasks.length > 0)
             return tasks;
     }

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/turnFailurePresentation.d.ts

@@ -4,10 +4,13 @@ import { type LiveModelCatalog } from './liveModelCatalog.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 export type TurnFailureCategory = 'auth' | 'billing' | 'rate_limited' | 'invalid_request' | 'capability_unavailable' | 'timeout' | 'server_error' | 'connection_lost' | 'parked' | 'internal';
 export declare const TURN_FAILURE_CATEGORIES: readonly TurnFailureCategory[];
-export interface TurnFailureRetry {
+export type TurnFailureRetry = {
     readonly offer: boolean;
     readonly basis: 'wire' | 'category';
-}
+} | {
+    readonly offer: false;
+    readonly basis: 'not_followed';
+};
 export interface TurnFailurePresentation {
     readonly category: TurnFailureCategory;
     readonly kind: TurnWireErrorVerdict['kind'];