@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/promptBlockedCopy.js

@@ -4,7 +4,10 @@ import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD } from './rowKind.js';
 export { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD };
 const RUN_BLOCKED_REASONED = 'Run blocked';
 const RUN_BLOCKED_NO_REASON = 'Run blocked (the agent reported it cannot proceed)';
-const HOOK_WORDS_SHOWN_MAX = 1000;
+const WORDS_SHOWN_MAX = 1000;
+function shownWords(words) {
+    return displayUntrusted(words, { max: WORDS_SHOWN_MAX }).trim();
+}
 const CAUSE_CLAUSE = Object.freeze({
     crashed: 'the hook failed before it answered; the prompt was not submitted',
     timeout: 'the hook did not answer in time; the prompt was not submitted',
@@ -13,7 +16,7 @@ const CAUSE_CLAUSE = Object.freeze({
 function shownHookWords(words) {
     if (words === undefined)
         return undefined;
-    const shown = stripSystemReminderTagTokens(displayUntrusted(stripSystemReminderTagTokens(words), { max: HOOK_WORDS_SHOWN_MAX })).trim();
+    const shown = stripSystemReminderTagTokens(shownWords(stripSystemReminderTagTokens(words))).trim();
     return shown === '' ? undefined : shown;
 }
 export function runBlockedText(blocked) {
@@ -29,8 +32,10 @@ export function runBlockedText(blocked) {
     if (reason === undefined)
         return RUN_BLOCKED_NO_REASON;
     const unwrapped = unwrapSystemReminder(reason);
-    if (unwrapped === reason)
-        return `${RUN_BLOCKED_REASONED}: ${reason}`;
-    const body = stripSystemReminderTagTokens(unwrapped).trim();
-    return body === '' ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${body}`;
+    if (unwrapped === reason) {
+        const shown = shownWords(reason);
+        return shown === '' ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${shown}`;
+    }
+    const body = shownHookWords(unwrapped);
+    return body === undefined ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${body}`;
 }

package/dist/promptSuggestionBatch.d.ts

@@ -0,0 +1,7 @@
+export declare const SUGGESTION_BATCH_CAP = 8;
+export declare const SUGGESTION_CHARS_CAP = 200;
+export interface PromptSuggestionBatch {
+    readonly list: readonly string[];
+    readonly truncatedCount?: number;
+}
+export declare function promptSuggestionBatchOf(raw: {} | null | undefined): PromptSuggestionBatch | undefined;

package/dist/promptSuggestionBatch.js

@@ -0,0 +1,9 @@
+export const SUGGESTION_BATCH_CAP = 8;
+export const SUGGESTION_CHARS_CAP = 200;
+export function promptSuggestionBatchOf(raw) {
+    const filtered = (Array.isArray(raw) ? raw : []).filter((s) => typeof s === 'string' && s.trim().length > 0);
+    const list = filtered.slice(0, SUGGESTION_BATCH_CAP).map((s) => (s.length > SUGGESTION_CHARS_CAP ? `${s.slice(0, SUGGESTION_CHARS_CAP)}…` : s));
+    if (list.length === 0)
+        return undefined;
+    return { list, ...(filtered.length > list.length ? { truncatedCount: filtered.length - list.length } : {}) };
+}

package/dist/promptSuggestionsTail.d.ts

@@ -0,0 +1,39 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { LaneProof } from './seam.js';
+export declare const PROMPT_SUGGESTIONS_TAIL_MAX_ATTEMPTS = 6;
+export declare const PROMPT_SUGGESTIONS_TAIL_BUDGET_MS = 12000;
+export interface PromptSuggestionsTailEvent {
+    readonly kind: 'prompt_suggestions';
+    readonly laneProof: LaneProof;
+    readonly suggestions: readonly string[];
+}
+export type PromptSuggestionsStreamSeen = 'frame' | 'done' | 'cut';
+export interface PromptSuggestionsTailInput {
+    readonly runs: Pick<AgentClient['runs'], 'get'>;
+    readonly runId: string;
+    readonly sessionId?: string | undefined;
+    readonly requested: boolean;
+    readonly stream: PromptSuggestionsStreamSeen;
+    readonly baseUrl: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly sleep?: ((ms: number) => Promise<void>) | undefined;
+    readonly now?: (() => number) | undefined;
+}
+export type PromptSuggestionsTailOutcome = {
+    readonly kind: 'skipped';
+    readonly why: 'not_requested' | 'frame_on_stream' | 'settled_on_stream';
+} | {
+    readonly kind: 'settled';
+    readonly event?: PromptSuggestionsTailEvent;
+} | {
+    readonly kind: 'not_completed';
+    readonly attempts: number;
+} | {
+    readonly kind: 'gave_up';
+    readonly attempts: number;
+} | {
+    readonly kind: 'unavailable';
+    readonly attempts: number;
+};
+export declare function promptSuggestionsOnStream(baseUrl: string | undefined): boolean;
+export declare function followUpPromptSuggestions(input: PromptSuggestionsTailInput): Promise<PromptSuggestionsTailOutcome>;

package/dist/promptSuggestionsTail.js

@@ -0,0 +1,116 @@
+import { abortableSleep, requestDeadline } from './abortableSleep.js';
+import { engineCapString, engineCapValue } from './engineCapsCache.js';
+import { readOwnDataValue } from './ownKey.js';
+import { promptSuggestionBatchOf } from './promptSuggestionBatch.js';
+import { engineVersionTier } from './supportFloor.js';
+export const PROMPT_SUGGESTIONS_TAIL_MAX_ATTEMPTS = 6;
+export const PROMPT_SUGGESTIONS_TAIL_BUDGET_MS = 12_000;
+const RETRY_STEP_MS = 750;
+const RETRY_CAP_MS = 3_000;
+const ON_STREAM_SERVER_FLOOR = '7.149.0';
+const MAY_STILL_SUGGEST = Object.freeze(['completed', 'running']);
+export function promptSuggestionsOnStream(baseUrl) {
+    try {
+        const bit = engineCapValue(baseUrl, 'promptSuggestions');
+        if (bit.kind !== 'value' || bit.value !== true)
+            return false;
+        return engineVersionTier(engineCapString(baseUrl, 'version'), ON_STREAM_SERVER_FLOOR) === 'engine';
+    }
+    catch {
+        return false;
+    }
+}
+const freeze = (o) => Object.freeze(o);
+const own = (o, key) => {
+    try {
+        return typeof o === 'object' && o !== null ? readOwnDataValue(o, key) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+function eventOf(raw) {
+    const batch = promptSuggestionBatchOf(raw);
+    return batch === undefined ? undefined : freeze({ kind: 'prompt_suggestions', laneProof: freeze({ lane: 'main' }), suggestions: freeze([...batch.list]) });
+}
+function skipWhy(input) {
+    if (own(input, 'requested') !== true)
+        return 'not_requested';
+    const seen = own(input, 'stream');
+    if (seen === 'frame')
+        return 'frame_on_stream';
+    if (seen === 'done' && promptSuggestionsOnStream(own(input, 'baseUrl')))
+        return 'settled_on_stream';
+    return undefined;
+}
+export async function followUpPromptSuggestions(input) {
+    let attempts = 0;
+    try {
+        const why = skipWhy(input);
+        if (why !== undefined)
+            return freeze({ kind: 'skipped', why });
+        const runs = own(input, 'runs');
+        const runId = own(input, 'runId');
+        const get = typeof runs === 'object' && runs !== null ? runs.get : undefined;
+        if (typeof get !== 'function' || typeof runId !== 'string' || runId.length === 0)
+            return freeze({ kind: 'unavailable', attempts });
+        const sessionId = own(input, 'sessionId');
+        const signal = own(input, 'signal');
+        const sleepIn = own(input, 'sleep');
+        const nowIn = own(input, 'now');
+        const sleep = typeof sleepIn === 'function' ? sleepIn : (ms) => abortableSleep(ms, signal ?? new AbortController().signal);
+        const now = typeof nowIn === 'function' ? nowIn : Date.now;
+        const signalState = () => {
+            if (signal === undefined || signal === null)
+                return 'live';
+            try {
+                return signal.aborted === true ? 'aborted' : 'live';
+            }
+            catch {
+                return 'unreadable';
+            }
+        };
+        const t0 = now();
+        for (;;) {
+            if (signalState() !== 'live')
+                return freeze({ kind: 'unavailable', attempts });
+            const left = PROMPT_SUGGESTIONS_TAIL_BUDGET_MS - (now() - t0);
+            if (!(left > 0))
+                return freeze({ kind: 'gave_up', attempts });
+            attempts++;
+            const d = requestDeadline(left, signal);
+            let rec;
+            try {
+                rec = await d.race(Promise.resolve(get.call(runs, runId, {
+                    ...(typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {}),
+                    signal: d.signal,
+                })));
+            }
+            catch {
+                return freeze({ kind: d.expired() ? 'gave_up' : 'unavailable', attempts });
+            }
+            finally {
+                d.abort();
+            }
+            const suggestions = own(rec, 'suggestions');
+            if (Array.isArray(suggestions)) {
+                const event = eventOf(suggestions);
+                return freeze({ kind: 'settled', ...(event !== undefined ? { event } : {}) });
+            }
+            const status = own(rec, 'status');
+            if (typeof status === 'string' && !MAY_STILL_SUGGEST.includes(status))
+                return freeze({ kind: 'not_completed', attempts });
+            if (attempts >= PROMPT_SUGGESTIONS_TAIL_MAX_ATTEMPTS)
+                return freeze({ kind: 'gave_up', attempts });
+            const rest = PROMPT_SUGGESTIONS_TAIL_BUDGET_MS - (now() - t0);
+            if (!(rest > 0))
+                return freeze({ kind: 'gave_up', attempts });
+            if (signalState() !== 'live')
+                return freeze({ kind: 'unavailable', attempts });
+            await sleep(Math.min(RETRY_STEP_MS * attempts, RETRY_CAP_MS, rest));
+        }
+    }
+    catch {
+        return freeze({ kind: 'unavailable', attempts });
+    }
+}

package/dist/request/taskRequest.js

@@ -548,8 +548,12 @@ export function refilterHostSettings(request, fresh, lane) {
             }
         }
     }
-    if (Object.hasOwn(nextSettings, 'env')) {
-        const sentEnv = nextSettings.env;
+    const nowEnv = intake.carried.env;
+    const envUnwired = intake.dispositions['settings.env'] === 'unwired';
+    const envMaybeAdded = nowEnv !== undefined && !envUnwired && hostRefuseRowSeated('settings.env', lane, true);
+    const hasSentEnv = Object.hasOwn(nextSettings, 'env');
+    if (hasSentEnv || envMaybeAdded) {
+        const sentEnv = hasSentEnv ? nextSettings.env : {};
         if (!isPlainRecord(sentEnv))
             return unjudged();
         let names;
@@ -559,14 +563,14 @@ export function refilterHostSettings(request, fresh, lane) {
         catch {
             return unjudged();
         }
-        const nowEnv = intake.carried.env;
-        const envUnwired = intake.dispositions['settings.env'] === 'unwired';
         const sentKeys = Object.keys(sentEnv);
         const kept = sentKeys.filter((k) => names.includes(k) && (envUnwired || (nowEnv !== undefined && Object.hasOwn(nowEnv, k))));
-        if (kept.length !== sentKeys.length) {
+        const added = envMaybeAdded && nowEnv !== undefined ? names.filter((n) => !sentKeys.includes(n) && Object.hasOwn(nowEnv, n)) : [];
+        if (kept.length !== sentKeys.length || added.length > 0) {
             const { env: _sentEnv, ...restSettings } = nextSettings;
             void _sentEnv;
-            nextSettings = kept.length === 0 ? restSettings : { ...restSettings, env: Object.fromEntries(kept.map((k) => [k, sentEnv[k]])) };
+            const rows = [...kept.map((k) => [k, sentEnv[k]]), ...added.map((n) => [n, nowEnv?.[n]])];
+            nextSettings = rows.length === 0 ? restSettings : { ...restSettings, env: Object.fromEntries(rows) };
         }
     }
     if (nextSettings === settings)

package/dist/requestCoordinate.d.ts

@@ -0,0 +1 @@
+export declare function requestCoordinateText(root: string, segs: readonly (string | number)[], label?: (seg: string) => string): string;

package/dist/requestCoordinate.js

@@ -0,0 +1,13 @@
+const PLAIN_SEGMENT = /^[^.[\]"\s\p{Cc}]+$/u;
+export function requestCoordinateText(root, segs, label) {
+    let out = root;
+    for (const seg of segs) {
+        if (typeof seg === 'number') {
+            out += `[${seg}]`;
+            continue;
+        }
+        const shown = label === undefined ? seg : label(seg);
+        out += PLAIN_SEGMENT.test(shown) ? `.${shown}` : `[${JSON.stringify(shown)}]`;
+    }
+    return out;
+}

package/dist/rewindArchiveReading.js

@@ -2,9 +2,8 @@ import { createEngineCapReader } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 const CAPS_KEYS = {
     conversationAnchor: 'resumeAt',
-    forkRestore: 'rewindFiles',
+    restoreFiles: 'restoreFiles',
     codeOnly: 'rewindFilesTo',
-    restoreFilesEpoch: 'restoreFiles',
 };
 const _capsKeyPin = true;
 void _capsKeyPin;
@@ -22,12 +21,13 @@ export function projectRewindArchiveCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
+        const restoreFiles = bitOf(caps, CAPS_KEYS.restoreFiles);
         return {
             kind: 'present',
             conversationAnchor: bitOf(caps, CAPS_KEYS.conversationAnchor),
-            forkRestore: bitOf(caps, CAPS_KEYS.forkRestore),
+            forkRestore: restoreFiles,
             codeOnly: bitOf(caps, CAPS_KEYS.codeOnly),
-            restoreFilesEpoch: bitOf(caps, CAPS_KEYS.restoreFilesEpoch),
+            restoreFilesEpoch: restoreFiles,
         };
     }
     catch {

package/dist/runCancelContext.d.ts

@@ -31,9 +31,10 @@ export type RunAbortCause = {
 export declare const RUN_CANCELLED_CODE: "cancelled";
 export declare function classifyRunAbortCause(record: unknown): RunAbortCause;
 export type { AbortCause };
+export type AbortCauseWord = AbortCause | 'stall_verdict';
 export type AbortCauseReading = {
     readonly kind: 'known';
-    readonly cause: AbortCause;
+    readonly cause: AbortCauseWord;
 } | {
     readonly kind: 'unrecognized';
     readonly word: string;

package/dist/runCancelContext.js

@@ -100,6 +100,7 @@ const ABORT_CAUSE_SENTENCES = Object.freeze({
     ask_park_grace_exhausted: 'Aborted: the connection dropped while a question or approval was pending, and the run could not be parked for later resumption in time ' +
         '(cause ask_park_grace_exhausted) — not an engine error.',
     cancel_verb: 'Cancelled: a cancel request to the engine stopped this run (cause cancel_verb) — not an engine error.',
+    stall_verdict: 'Aborted: the server had already marked this run as stalled (its heartbeat lapsed), so this leg stopped itself (cause stall_verdict) — not an engine error.',
 });
 const ABORT_CAUSE_UNRECOGNIZED_SENTENCE = 'Aborted by the engine for a reason this client does not recognize — not an engine error.';
 function secondsText(ms) {

package/dist/runPermissionModeSwitch.js

@@ -1,6 +1,7 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readPermissionModeReceiptSegment } from './adapter/downstream/wiringManifestView.js';
 import { displayUntrusted } from './displayUntrusted.js';
+import { STEERING_NOT_RUNNING } from './engineErrorCodes.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, readOwnDataValue } from './ownKey.js';
@@ -8,7 +9,6 @@ import { permissionModeWriteAvailable } from './permissionModeWriteCapability.js
 import { permissionModeTitle } from './permissionWireCaps.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'))
@@ -79,7 +79,7 @@ function failureOutcomeOf(e) {
     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)
+        if (v.status === 409 && v.code === STEERING_NOT_RUNNING)
             return Object.freeze({ kind: 'not-running' });
         return Object.freeze({ kind: 'refused', status: v.status, ...(v.code !== undefined ? { errorCode: v.code } : {}) });
     }

package/dist/scenarioRefusal.js

@@ -1,23 +1,21 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
-import { readErrorRecord, readErrorString } from './wireFailureShape.js';
+import { liftLegacyRefusalFacts, readErrorString } from './wireFailureShape.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { msg, renderMessage } from './i18n/translate.js';
 const SCENARIO_REFUSAL_ERROR_MAX = 200;
-function detailBits(detail) {
-    if (detail === undefined)
-        return {};
+function scenarioBits(read) {
     let scenario;
     let source;
     try {
-        scenario = readOwnDataValue(detail, 'scenario');
+        scenario = read('scenario');
     }
     catch {
         scenario = undefined;
     }
     try {
-        source = readOwnDataValue(detail, 'source');
+        source = read('source');
     }
     catch {
         source = undefined;
@@ -42,20 +40,20 @@ export function scenarioRefusalOf(body) {
     try {
         if (!isPlainRecord(raw))
             return Object.freeze({});
-        const own = (key) => {
+        const ownOf = (o) => (key) => {
             try {
-                return readOwnDataValue(raw, key);
+                return readOwnDataValue(o, key);
             }
             catch {
                 return undefined;
             }
         };
-        const errorCode = own('errorCode');
-        const error = own('error');
-        const detail = own('detail');
+        const errorCode = ownOf(raw)('errorCode');
+        const error = ownOf(raw)('error');
+        const facts = liftLegacyRefusalFacts(SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, raw);
         let bits = {};
         try {
-            bits = detailBits(isPlainRecord(detail) ? detail : undefined);
+            bits = scenarioBits(ownOf(facts));
         }
         catch {
             bits = {};
@@ -80,7 +78,7 @@ export function scenarioRefusalFromError(err) {
         return Object.freeze({
             errorCode: SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
             ...(error !== undefined && error.length > 0 ? { error: capForDisplay(error, SCENARIO_REFUSAL_ERROR_MAX) } : {}),
-            ...detailBits(readErrorRecord(err, 'detail')),
+            ...scenarioBits((key) => readErrorString(err, key)),
         });
     }
     catch {

package/dist/scenarioSkills.js

@@ -49,24 +49,29 @@ export function scenarioSkillsOf(card) {
     }
 }
 const SCENARIO_SKILLS_CAPABILITY_KEY = 'scenarioSkills';
+const CAP_CONFIRMED = Object.freeze({ kind: 'confirmed' });
+const CAP_ABSENT = Object.freeze({ kind: 'absent' });
+const CAP_DECLINED = Object.freeze({ kind: 'declined' });
+const CAP_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const CAP_UNOBSERVED = Object.freeze({ kind: 'unobserved' });
 export function observedScenarioSkillsCapability(baseUrl) {
     try {
         const base = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
         const slot = engineCapValue(typeof base === 'string' ? base : undefined, SCENARIO_SKILLS_CAPABILITY_KEY);
         switch (slot.kind) {
             case 'unobserved':
-                return Object.freeze({ kind: 'unobserved' });
+                return CAP_UNOBSERVED;
             case 'not_reported':
-                return Object.freeze({ kind: 'absent' });
+                return CAP_ABSENT;
             case 'unreadable':
-                return Object.freeze({ kind: 'unreadable' });
+                return CAP_UNREADABLE;
             case 'null':
-                return Object.freeze({ kind: 'declined' });
+                return CAP_DECLINED;
             case 'value':
-                return slot.value === true ? Object.freeze({ kind: 'confirmed' }) : Object.freeze({ kind: 'declined' });
+                return slot.value === true ? CAP_CONFIRMED : CAP_DECLINED;
         }
     }
     catch {
-        return Object.freeze({ kind: 'unobserved' });
+        return CAP_UNOBSERVED;
     }
 }

package/dist/seam.d.ts

@@ -10,7 +10,8 @@ import type { ToolKillCause } from './toolResult.js';
 import type { HumanInputAttachmentView } from './ownKey.js';
 import type { SubagentAliasScope } from './subagentContentStore.js';
 import type { SessionBoxNoticeFacts } from './peerFrames.js';
-import type { TaskNotificationFields } from './notifications.js';
+import type { HostSettingNotice } from './hostTurnSettings.js';
+import type { ResupplyTruncatedSource, TaskNotificationFields } from './notifications.js';
 export interface AbortSignalLike {
     readonly aborted: boolean;
 }
@@ -167,7 +168,7 @@ export type ChromeEvent = {
 } | ({
     kind: 'run_cost_reconciled';
     laneProof: LaneProof;
-} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | CompactionStartedChromeEvent | SubagentStartedChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ResultReplayedChromeEvent | ToolParkedChromeEvent | SubagentAliasChromeEvent | SessionBoxNoticeChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent | ApprovalCompleteChromeEvent | SessionTitledChromeEvent | {
+} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | CompactionStartedChromeEvent | SubagentStartedChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ResultReplayedChromeEvent | ToolParkedChromeEvent | SubagentAliasChromeEvent | SessionBoxNoticeChromeEvent | ResupplyTruncatedChromeEvent | HostSettingNoticeChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent | ApprovalCompleteChromeEvent | SessionTitledChromeEvent | {
     kind: 'suspended_reopened';
     laneProof: LaneProof;
     reopen: Extract<SuspendedReopenReading, {
@@ -358,6 +359,19 @@ export interface SubagentAliasChromeEvent {
     seq?: number;
 }
 export type SessionBoxNoticeChromeEvent = SessionBoxNoticeChromeEnvelope & SessionBoxNoticeFacts;
+export interface ResupplyTruncatedChromeEvent {
+    kind: 'resupply_truncated';
+    laneProof: LaneProof;
+    source: ResupplyTruncatedSource;
+    taskId: string;
+    bytes: number;
+    droppedKeys: readonly string[];
+    text: string;
+}
+export type HostSettingNoticeChromeEvent = {
+    kind: 'host_setting_notice';
+    laneProof: LaneProof;
+} & HostSettingNotice;
 export interface SessionBoxNoticeChromeEnvelope {
     kind: 'session_box_notice';
     laneProof: LaneProof;

package/dist/seam.js

@@ -152,6 +152,16 @@ const CHROME_ARM_TABLE = {
             '渲 `text`(数据面英文)或按界面语言调 `sessionBoxNoticeSentence(本臂, lang)`;🔴 同一条通告有两个载体(转录行 + 本臂),接本臂的宿主按 `rowUuid` 把那一行摘掉、只渲一个;' +
             '`state` 是开集机读位,别回显、别按它猜句子;typed 正体缺席时本臂整个不发(不铸状态词)。',
     },
+    resupply_truncated: {
+        required: false,
+        duty: '可选:停驻补投帧只带了最小形的披露 —— 渲 `text`(数据面英文)或按界面语言调 `resupplyTruncatedSentence(本臂, lang)`,放在这条通知的转录行旁(task_notification)或完成通告旁(workflow_complete)。' +
+            '`droppedKeys` / `bytes` 是机读位,别拼进句子;披露位缺席(全形帧 / 老服务端)或坏形时本臂整个不发,不要自己据「摘要很短」推断截断。',
+    },
+    host_setting_notice: {
+        required: false,
+        duty: '可选:宿主自供设置项的一句通告(`hostTurnSettings()` 产物 `notices` 的一句;载荷 = `HostSettingNotice` 原样)。按 `plane` 呈现:`turn` 本回合系统行 / `session` 每会话每句一次 / ' +
+            '`diagnostic` 不渲只记;🔴 非终态:不是失败卡、不改回合状态;`key` / `cause` 缺席 = 这一句不挂某一行,不是坏形。铸口只有 `hostSettingNoticeEventsOf`,别手拼。',
+    },
     result_text_diverged: {
         required: false,
         duty: '可选:终帧正文与已上屏正文**互相都不是对方前缀**时的诚实披露。🔴 处置是把这一拍的转录行**改口**' +