@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/displayUntrusted.js

@@ -1099,6 +1099,69 @@ class InnerWordIndex {
         this.spanClose ??= codeSpanClose(this.text, this.plain);
         return this.spanClose[i] ?? -1;
     }
+    eventNext = null;
+    runEnd = null;
+    restFrom = null;
+    tailEnd = null;
+    bareEndFrom(k) {
+        const text = this.text;
+        const n = text.length;
+        if (this.eventNext === null || this.runEnd === null || this.restFrom === null) {
+            const ev = new Int32Array(n + 1).fill(n);
+            const run = new Int32Array(n + 1).fill(n);
+            for (let x = n - 1; x >= 0; x--) {
+                const ch = text.charAt(x);
+                const sep = ch === VIEW_SEPARATOR;
+                ev[x] = sep || isBareValueStop(ch) ? x : (ev[x + 1] ?? n);
+                run[x] = sep ? (run[x + 1] ?? n) : x;
+            }
+            this.eventNext = ev;
+            this.runEnd = run;
+            this.restFrom = new Int32Array(n + 1).fill(-1);
+        }
+        const ev = this.eventNext;
+        const run = this.runEnd;
+        const rest = this.restFrom;
+        const pendingRest = [];
+        let j = k;
+        let end;
+        for (;;) {
+            const x = ev[j] ?? n;
+            if (x >= n || text.charAt(x) !== VIEW_SEPARATOR) {
+                end = x;
+                break;
+            }
+            const p = run[x] ?? n;
+            if (credentialWordStartsNear(text, p, this.tokenInner)) {
+                end = x;
+                break;
+            }
+            const known = rest[p] ?? -1;
+            if (known !== -1) {
+                end = known;
+                break;
+            }
+            pendingRest.push(p);
+            j = p;
+        }
+        for (const p of pendingRest)
+            rest[p] = end;
+        return end;
+    }
+    closingTailEnd(t) {
+        if (this.tailEnd === null) {
+            const text = this.text;
+            const n = text.length;
+            const punct = new Int32Array(n + 1).fill(n);
+            for (let x = n - 1; x >= 0; x--)
+                punct[x] = TRAILING_PUNCTUATION.has(text.charAt(x)) ? (punct[x + 1] ?? n) : x;
+            const tail = new Int32Array(n + 1).fill(n);
+            for (let x = n - 1; x >= 0; x--)
+                tail[x] = text.charCodeAt(x) === 0x60 ? (tail[x + 1] ?? n) : (punct[x] ?? n);
+            this.tailEnd = tail;
+        }
+        return this.tailEnd[t] ?? this.text.length;
+    }
     next(q) {
         let best = null;
         for (const p of this.probes) {
@@ -1231,7 +1294,16 @@ function scanSecretValue(text, from, idx) {
     let cut = false;
     let j = i;
     const closingTick = idx === undefined ? -1 : idx.closingTickFrom(i);
-    while (j < text.length) {
+    if (idx !== undefined) {
+        const end0 = idx.bareEndFrom(i);
+        if (pending !== null && pending.start < end0 && innerWordFits(text, pending)) {
+            cut = true;
+            j = pending.start;
+        }
+        else
+            j = end0;
+    }
+    while (idx === undefined && j < text.length) {
         if (pending !== null && j >= pending.start) {
             if (j === pending.start && innerWordFits(text, pending)) {
                 cut = true;
@@ -1246,7 +1318,7 @@ function scanSecretValue(text, from, idx) {
             let p = j;
             while (p < text.length && text[p] === VIEW_SEPARATOR)
                 p++;
-            if (credentialWordStartsNear(text, p, idx?.tokenInner ?? true))
+            if (credentialWordStartsNear(text, p, true))
                 break;
             j = p;
             continue;
@@ -1255,13 +1327,8 @@ function scanSecretValue(text, from, idx) {
     }
     while (j > i && text[j - 1] === VIEW_SEPARATOR)
         j--;
-    if (closingTick > i && closingTick < j) {
-        let t = closingTick;
-        while (t < j && text.charCodeAt(t) === 0x60)
-            t++;
-        while (t < j && TRAILING_PUNCTUATION.has(text.charAt(t)))
-            t++;
-        if (t === j && text.charCodeAt(closingTick) === 0x60) {
+    if (idx !== undefined && closingTick > i && closingTick < j) {
+        if (idx.closingTailEnd(closingTick) >= j && text.charCodeAt(closingTick) === 0x60) {
             j = closingTick;
             while (j > i && text[j - 1] === VIEW_SEPARATOR)
                 j--;
@@ -2473,11 +2540,50 @@ function envSchemeWordReading(text, at) {
     }
     return k > e && ENV_ASSIGNMENT_AHEAD.test(text.slice(k, k + 256)) ? { end: e, beforeAssignment: true } : null;
 }
-function labelCandidates(S, pass, regions, out, blocks, outer = false) {
+const SCHEME_ADJACENT_SOURCE = String.raw `${SCHEME_LEFT_STRICT}(?<![/\\.@])(bearer|basic)(?=[A-Za-z0-9._~+/-])`;
+const SCHEME_ADJACENT_STRONG_MIN = 8;
+const SCHEME_ADJACENT_WEAK_MIN = 20;
+const SCHEME_ADJACENT_WINDOW = 96;
+function schemeAdjacentAccepted(scheme, win) {
+    if (ADDRESS_SCHEME_RE.test(win))
+        return true;
+    let w = 0;
+    while (w < win.length && isKeyWordChar(win.charCodeAt(w)))
+        w++;
+    if (w > 0 && isProseKnownLiteral(win.slice(0, w)))
+        return true;
+    const connector = (c) => c === 0x2d || c === 0x5f || c === 0x7e || c === 0x2b;
+    let h = 0;
+    while (h < win.length) {
+        const c = win.charCodeAt(h);
+        if (!(isAlnumCode(c) || connector(c) || c === 0x2e || c === 0x2f))
+            break;
+        h++;
+    }
+    const H = win.slice(0, h);
+    const head = H.charCodeAt(0);
+    if (head === 0x2e || head === 0x2f)
+        return false;
+    const upper = /[A-Z]/.test(H);
+    const digit = /[0-9]/.test(H);
+    if (H.length < (upper || digit ? SCHEME_ADJACENT_STRONG_MIN : SCHEME_ADJACENT_WEAK_MIN))
+        return false;
+    if (upper && digit && /[a-z]/.test(H))
+        return true;
+    const first = /^(?:[A-Z]?[a-z]+|[A-Z]+(?![a-z]))/.exec(connector(head) ? H.slice(1) : H);
+    if (first !== null && schemeFollowerReleased(scheme, first[0], false))
+        return false;
+    if (connector(head) || /^(?:[A-Z][a-z]+)+$/.test(H.split(/[-._~+\/]/, 1)[0] ?? ''))
+        return false;
+    return true;
+}
+function labelCandidates(S, pass, regions, out, blocks, mode = 'strict') {
     const text = S.text;
+    const outer = mode === 'outer';
+    const adjacent = mode === 'adjacent' && pass === 'scheme';
     const unitAt = (k) => S.unitAt(k);
     const strictSource = pass === 'label' ? SECRET_LABELLED_WORD.source : SECRET_SCHEME_WORD.source;
-    const re = new RegExp(outer ? (pass === 'label' ? LABEL_WORD_OUTER_SOURCE : SCHEME_WORD_OUTER_SOURCE) : strictSource, 'gi');
+    const re = new RegExp(adjacent ? SCHEME_ADJACENT_SOURCE : outer ? (pass === 'label' ? LABEL_WORD_OUTER_SOURCE : SCHEME_WORD_OUTER_SOURCE) : strictSource, 'gi');
     const strictAt = outer ? new RegExp(strictSource, 'iy') : null;
     const schemePass = pass !== 'label';
     const tokenPass = pass === 'token';
@@ -2744,6 +2850,8 @@ function labelCandidates(S, pass, regions, out, blocks, outer = false) {
             continue;
         if (schemePass && labelStartsAt(text, hit.index))
             continue;
+        if (adjacent && !schemeAdjacentAccepted(label, text.slice(hit.index + hit[0].length, hit.index + hit[0].length + SCHEME_ADJACENT_WINDOW)))
+            continue;
         let from = hit.index + hit[0].length;
         if (!schemePass && text.charCodeAt(from) === 0x3e && text.charCodeAt(from - 1) === 0x3d && labelQuotedAt(text, hit.index, hit[0].slice(label.length))) {
             let k = from + 1;
@@ -3102,6 +3210,9 @@ function longestAlnumRun(word) {
     }
     return best;
 }
+function isProseKnownLiteral(word) {
+    return SECRET_LITERAL_RE.test(word) && (longestAlnumRun(word) >= PROSE_LITERAL_MIN_RUN || shortLiteralTail(word));
+}
 const JWT_WORD = /^eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}$/;
 const PEM_BEGIN_SOURCE = `${PRIVATE_KEY_PEM_HEADER.source}(?: BLOCK)?-----`;
 const PEM_CASE_FLAGS = PRIVATE_KEY_PEM_HEADER.flags.includes('i') ? 'i' : '';
@@ -3569,7 +3680,7 @@ function proseLiteralEdits(text) {
             fileAt = fileUrlPositions(text);
         const localPath = prev === '\\' || prev === '.' || (slashSegment && fileAt != null && fileAt[i] === 1);
         const pathish = slashSegment || localPath;
-        if (!localPath && SECRET_LITERAL_RE.test(word) && (longestAlnumRun(word) >= PROSE_LITERAL_MIN_RUN || shortLiteralTail(word))) {
+        if (!localPath && isProseKnownLiteral(word)) {
             pushEdit(edits, text, i + escHead, end, REDACTED_SECRET);
         }
         else if (!localPath) {
@@ -4393,8 +4504,14 @@ function runLabelPasses(S, regions, cands, blocks) {
     labelCandidates(S, 'scheme', regions, cands, blocks);
     labelCandidates(S, 'token', regions, cands, blocks);
     labelCandidates(S, 'label', regions, cands, blocks);
-    labelCandidates(S, 'scheme', regions, cands, blocks, true);
-    labelCandidates(S, 'label', regions, cands, blocks, true);
+    labelCandidates(S, 'scheme', regions, cands, blocks, 'outer');
+    labelCandidates(S, 'label', regions, cands, blocks, 'outer');
+    emitRow('scheme-adjacent', (phases) => {
+        const adjacent = [];
+        labelCandidates(S, 'scheme', regions, adjacent, blocks, 'adjacent');
+        for (const c of adjacent)
+            cands.push({ ...c, phases });
+    });
 }
 function collectCandidates(text, o, nested) {
     const V = buildScanView(text, o);
@@ -4486,6 +4603,7 @@ const RULES_BY_VERSION = {
             form: { host: 'hooks.slack.com', trailingDot: true, pathKinds: ['services', 'workflows', 'triggers'], tailClass: 'A-Za-z0-9+/_-', minTailLength: 40 },
         },
     ],
+    '0.110.0': [{ id: 'scheme-adjacent', ticket: 'CC-1282', kind: 'generator' }],
 };
 const RULE_ROWS_ARE_GENERATORS = true;
 void RULE_ROWS_ARE_GENERATORS;
@@ -5118,6 +5236,12 @@ export function displayUntrusted(text, opts = {}) {
     const out = renderUntrusted(text, opts, null);
     return typeof out === 'string' ? out : out.tracked.text;
 }
+export function displayUntrustedCapped(text, max, opts = {}) {
+    const whole = displayUntrusted(text, opts);
+    if (typeof max !== 'number' || !Number.isFinite(max) || whole.length <= max)
+        return whole;
+    return `${displayUntrusted(text, { ...opts, max })}…`;
+}
 export function cleanUntrustedScalar(v) {
     return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false });
 }

package/dist/engineErrorCodes.d.ts

@@ -154,6 +154,9 @@ export declare const APPROVAL_EXPIRED: "approval.expired";
 export declare function runDeathVerdictNoteOf(code: string | undefined): string | undefined;
 export declare const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = "capability.operator_principals_required";
 export declare const COMPACT_NOT_RUNNING = "compact.not_running";
+export declare const INTERRUPT_NOTHING_IN_FLIGHT = "interrupt.nothing_in_flight";
+export declare const INTERRUPT_NOT_HELD = "interrupt.not_held";
+export declare const STEERING_NOT_RUNNING = "steering.not_running";
 export declare function isUnavailableFaceCode(code: string | undefined): boolean;
 export type OperatorGateRefusal = 'operator_only' | 'operators_unconfigured';
 export declare function operatorGateRefusalContent(cause: OperatorGateRefusal): string | undefined;

package/dist/engineErrorCodes.js

@@ -274,6 +274,9 @@ export function runDeathVerdictNoteOf(code) {
 }
 export const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = 'capability.operator_principals_required';
 export const COMPACT_NOT_RUNNING = 'compact.not_running';
+export const INTERRUPT_NOTHING_IN_FLIGHT = 'interrupt.nothing_in_flight';
+export const INTERRUPT_NOT_HELD = 'interrupt.not_held';
+export const STEERING_NOT_RUNNING = 'steering.not_running';
 export function isUnavailableFaceCode(code) {
     return typeof code === 'string' && (code.startsWith('capability.') || code.startsWith('feature.'));
 }

package/dist/engineHealthFacts.d.ts

@@ -1,4 +1,5 @@
 import type { HealthAuthKind } from '@sema-agent/sdk';
+import { type EngineHealthStoreDurability } from './storeDurabilityWord.js';
 export interface EngineHealthCenterFacts {
     readonly issuer?: string;
     readonly webBaseUrl?: string;
@@ -42,4 +43,23 @@ export interface EngineHealthFacts {
     readonly version?: string;
     readonly dataRoot?: string;
 }
+export type ModsDeploymentPackagesReading = {
+    readonly kind: 'present';
+    readonly count: number;
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function readModsDeploymentPackages(health: object | null | undefined): ModsDeploymentPackagesReading;
+export type EngineHealthStoreReading = {
+    readonly kind: 'reported';
+    readonly durability: EngineHealthStoreDurability;
+} | {
+    readonly kind: 'unreadable';
+    readonly word?: string;
+} | {
+    readonly kind: 'absent';
+};
+export declare function readEngineHealthStore(health: object | null | undefined): EngineHealthStoreReading;
 export declare function readEngineHealthFacts(health: object | null | undefined): EngineHealthFacts;

package/dist/engineHealthFacts.js

@@ -1,4 +1,5 @@
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
+import { readStoreDurability } from './storeDurabilityWord.js';
 const _healthFactsMatchSdk = [true, true, true, true, true, true, true, true, true, true];
 void _healthFactsMatchSdk;
 const ENGINE_SIGNAL_KEY = 'engineSignal';
@@ -117,6 +118,46 @@ function guarded(read) {
         return undefined;
     }
 }
+export function readModsDeploymentPackages(health) {
+    try {
+        if (!isObject(health))
+            return Object.freeze({ kind: 'unreadable' });
+        const mods = ownDataField(health, 'mods');
+        if (mods === undefined)
+            return Object.freeze({ kind: 'absent' });
+        if (!isObject(mods))
+            return Object.freeze({ kind: 'unreadable' });
+        const n = ownDataField(mods, 'deploymentPackages');
+        if (n === undefined)
+            return Object.freeze({ kind: 'absent' });
+        if (typeof n === 'number' && Number.isSafeInteger(n) && n >= 1)
+            return Object.freeze({ kind: 'present', count: n });
+        return Object.freeze({ kind: 'unreadable' });
+    }
+    catch {
+        return Object.freeze({ kind: 'unreadable' });
+    }
+}
+export function readEngineHealthStore(health) {
+    try {
+        if (!isObject(health))
+            return Object.freeze({ kind: 'unreadable' });
+        const store = ownDataField(health, 'store');
+        if (store === undefined)
+            return Object.freeze({ kind: 'absent' });
+        if (!isObject(store))
+            return Object.freeze({ kind: 'unreadable' });
+        const read = readStoreDurability(store);
+        if (read.kind === 'word')
+            return Object.freeze({ kind: 'reported', durability: read.durability });
+        if (read.kind === 'unrecognized')
+            return Object.freeze({ kind: 'unreadable', word: read.word });
+        return Object.freeze({ kind: 'unreadable' });
+    }
+    catch {
+        return Object.freeze({ kind: 'unreadable' });
+    }
+}
 export function readEngineHealthFacts(health) {
     if (!isObject(health))
         return Object.freeze({});

package/dist/engineHealthProbeVerdict.d.ts

@@ -0,0 +1,23 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import type { ProbeHealthResult } from '@sema-agent/sdk';
+export type HealthProbeUnansweredReason = 'timeout' | 'network';
+export type HealthProbeNotOkReason = 'http' | 'not_ok';
+export interface HealthProbeAnsweredNotOk {
+    readonly kind: 'answered_not_ok';
+    readonly reason: HealthProbeNotOkReason;
+    readonly http: number;
+    readonly status?: string;
+}
+export type HealthProbeVerdict = {
+    readonly kind: 'unanswered';
+    readonly reason: HealthProbeUnansweredReason;
+} | {
+    readonly kind: 'answered_ok';
+} | HealthProbeAnsweredNotOk;
+export interface TimedHealthAnswer {
+    readonly answer: HealthProbeAnsweredNotOk;
+    readonly atMs: number;
+}
+export declare function classifyHealthProbe(reading: ProbeHealthResult): HealthProbeVerdict | undefined;
+export declare function healthAnswerClause(verdict: HealthProbeVerdict, lang?: UiLanguage): string | undefined;
+export declare function latestSegmentHealthAnswer(segmentStartMs: number | undefined, ...seen: ReadonlyArray<TimedHealthAnswer | undefined>): HealthProbeAnsweredNotOk | undefined;

package/dist/engineHealthProbeVerdict.js

@@ -0,0 +1,115 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { slotReadOf } from './wireFailureShape.js';
+const UNANSWERED_REASONS = new Set(['timeout', 'network']);
+const NOT_OK_REASONS = new Set(['http', 'not_ok']);
+const REPORTED_STATUS_SHOWN_MAX = 64;
+function ownValue(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' ? r.value : undefined;
+}
+function isHttpCode(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 100 && v <= 599;
+}
+function shownStatusOf(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const shown = displayUntrusted(v, { max: REPORTED_STATUS_SHOWN_MAX });
+    return shown.trim() === '' ? undefined : shown;
+}
+function answeredNotOk(reason, http, status) {
+    return Object.freeze({ kind: 'answered_not_ok', reason, http, ...(status !== undefined ? { status } : {}) });
+}
+export function classifyHealthProbe(reading) {
+    try {
+        if (typeof reading !== 'object' || reading === null)
+            return undefined;
+        const alive = ownValue(reading, 'alive');
+        if (alive === true)
+            return Object.freeze({ kind: 'answered_ok' });
+        if (alive !== false)
+            return undefined;
+        const reason = ownValue(reading, 'reason');
+        if (typeof reason !== 'string')
+            return undefined;
+        if (UNANSWERED_REASONS.has(reason))
+            return Object.freeze({ kind: 'unanswered', reason: reason });
+        if (!NOT_OK_REASONS.has(reason))
+            return undefined;
+        const http = ownValue(reading, 'status');
+        if (!isHttpCode(http))
+            return undefined;
+        return answeredNotOk(reason, http, reason === 'not_ok' ? shownStatusOf(ownValue(reading, 'reportedStatus')) : undefined);
+    }
+    catch {
+        return undefined;
+    }
+}
+function answeredNotOkOf(v) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    if (ownValue(v, 'kind') !== 'answered_not_ok')
+        return undefined;
+    const reason = ownValue(v, 'reason');
+    const http = ownValue(v, 'http');
+    if (typeof reason !== 'string' || !NOT_OK_REASONS.has(reason) || !isHttpCode(http))
+        return undefined;
+    return answeredNotOk(reason, http, shownStatusOf(ownValue(v, 'status')));
+}
+export function healthAnswerClause(verdict, lang) {
+    try {
+        if (typeof verdict !== 'object' || verdict === null)
+            return undefined;
+        const kind = ownValue(verdict, 'kind');
+        if (kind === 'answered_ok')
+            return renderMessage(msg('localEngine.health.answer.ok'), lang);
+        if (kind === 'unanswered') {
+            const reason = ownValue(verdict, 'reason');
+            if (reason === 'timeout')
+                return renderMessage(msg('localEngine.health.answer.unansweredTimeout'), lang);
+            if (reason === 'network')
+                return renderMessage(msg('localEngine.health.answer.unansweredNetwork'), lang);
+            return undefined;
+        }
+        const nok = answeredNotOkOf(verdict);
+        if (nok === undefined)
+            return undefined;
+        return renderMessage(msg(nok.reason === 'not_ok' ? 'localEngine.health.answer.notOkStatus' : 'localEngine.health.answer.notOkHttp', { http: nok.http }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+function timedNotOkOf(s, start, bestAtMs) {
+    try {
+        if (typeof s !== 'object' || s === null)
+            return { kind: 'not_better' };
+        const atMs = ownValue(s, 'atMs');
+        if (typeof atMs !== 'number' || !Number.isFinite(atMs))
+            return { kind: 'not_better' };
+        if (start !== undefined && atMs < start)
+            return { kind: 'not_better' };
+        if (bestAtMs !== undefined && atMs <= bestAtMs)
+            return { kind: 'not_better' };
+        const answer = answeredNotOkOf(ownValue(s, 'answer'));
+        return answer === undefined ? { kind: 'not_better' } : { kind: 'better', entry: { atMs, answer } };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+export function latestSegmentHealthAnswer(segmentStartMs, ...seen) {
+    try {
+        const start = typeof segmentStartMs === 'number' && Number.isFinite(segmentStartMs) ? segmentStartMs : undefined;
+        let best;
+        for (const s of seen) {
+            const r = timedNotOkOf(s, start, best?.atMs);
+            if (r.kind === 'better')
+                best = r.entry;
+        }
+        return best?.answer;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/engineInlineTaskStats.d.ts

@@ -1,14 +1,15 @@
 import type { InlineTaskTick } from './seam.js';
 export interface EngineInlineTaskStats {
-    toolUses: number;
-    totalTokens: number;
-    durationMs: number;
+    toolUses?: number;
+    totalTokens?: number;
+    durationMs?: number;
     currentAction?: string;
     model?: string;
     done: boolean;
     isError: boolean;
 }
 export declare function publishEngineInlineTaskTick(cardId: string, tick: InlineTaskTick): void;
+export declare function publishEngineInlineTaskModel(cardId: string, model: string): void;
 export declare function settleEngineInlineTaskStats(cardId: string, isError: boolean): void;
 export declare function settleAllEngineInlineTaskStats(): void;
 export declare function getEngineInlineTaskStats(cardId: string): EngineInlineTaskStats | undefined;

package/dist/engineInlineTaskStats.js

@@ -13,7 +13,23 @@ export function publishEngineInlineTaskTick(cardId, tick) {
     const prev = statsByCardId.get(cardId);
     if (prev?.done)
         return;
-    statsByCardId.set(cardId, { ...tick, done: false, isError: false });
+    const { model: tickModel, ...counts } = tick;
+    const model = typeof tickModel === 'string' && tickModel.length > 0 ? tickModel : prev?.model;
+    statsByCardId.set(cardId, { ...counts, ...(model !== undefined ? { model } : {}), done: false, isError: false });
+    emit();
+}
+export function publishEngineInlineTaskModel(cardId, model) {
+    if (typeof model !== 'string' || model.length === 0)
+        return;
+    const prev = statsByCardId.get(cardId);
+    if (prev === undefined) {
+        statsByCardId.set(cardId, { model, done: false, isError: false });
+    }
+    else {
+        if (prev.model === model)
+            return;
+        statsByCardId.set(cardId, { ...prev, model });
+    }
     emit();
 }
 export function settleEngineInlineTaskStats(cardId, isError) {
@@ -40,7 +56,7 @@ export function getEngineInlineTaskStats(cardId) {
 export function getSoleLiveEngineInlineTaskStats() {
     let sole;
     for (const s of statsByCardId.values()) {
-        if (s.done)
+        if (s.done || s.toolUses === undefined)
             continue;
         if (sole !== undefined)
             return undefined;

package/dist/engineNoticeCodes.d.ts

@@ -394,6 +394,7 @@ export declare function classifierDenialLimitSentence(facts: Pick<ClassifierDeni
 export declare function taskLateApprovalSentence(facts: Pick<TaskLateApprovalFactsView, 'toolName'>, lang?: UiLanguage): string | undefined;
 export declare function taskHaltUnconsumedSentence(facts: Pick<TaskHaltUnconsumedFactsView, 'sessionId' | 'runId'>, lang?: UiLanguage): string | undefined;
 export declare function steeringParkedInputBlockedSentence(facts: Pick<SteeringParkedInputBlockedFactsView, 'sessionId' | 'runId'>, lang?: UiLanguage): string | undefined;
+export declare function modelCapabilityDowngradedSentence(facts: Pick<ModelCapabilityDowngradedFactsView, 'model' | 'capability' | 'status'>, lang?: UiLanguage): string | undefined;
 export declare function durableGateUnavailableSentence(facts: Pick<DurableGateUnavailableFactsView, 'source' | 'cause' | 'liveApprover' | 'liveQuestionFace'>, lang?: UiLanguage): string | undefined;
 export type DiscardedDeliveryPathWord = (typeof CORE_DISCARDED_DELIVERY_PATHS)[number];
 export interface DeliveryDiscardedFactsView {
@@ -403,6 +404,14 @@ export interface DeliveryDiscardedFactsView {
     path?: DiscardedDeliveryPathWord;
 }
 export declare function readDeliveryDiscarded(notice: {} | null | undefined): DeliveryDiscardedFactsView | undefined;
+export interface ModelCapabilityDowngradedFactsView {
+    model: string;
+    capability: string;
+    status: string;
+    sessionId: string;
+    runId: string;
+}
+export declare function readModelCapabilityDowngraded(notice: {} | null | undefined): ModelCapabilityDowngradedFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -444,6 +453,7 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'task.halt_unconsumed': typeof readTaskHaltUnconsumed;
     readonly 'steering.parked_input_blocked': typeof readSteeringParkedInputBlocked;
     readonly 'delegation.delivery_discarded': typeof readDeliveryDiscarded;
+    readonly 'model.capability_downgraded': typeof readModelCapabilityDowngraded;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;

package/dist/engineNoticeCodes.js

@@ -1,8 +1,8 @@
 import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
-import { displayUntrusted } from './displayUntrusted.js';
+import { displayUntrusted, displayUntrustedCapped } from './displayUntrusted.js';
 import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, CORE_USER_INPUT_UNDRAINED_FAMILIES, } from './generated/engineNoticeTables.js';
 import { CORE_APPROVAL_REMEDY_KINDS, CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DISCARDED_DELIVERY_PATHS, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
-import { msg, renderMessage } from './i18n/translate.js';
+import { msg, renderLanguageOf, renderMessage } from './i18n/translate.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
 import { inValueOf, slotReadOf } from './wireFailureShape.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
@@ -196,7 +196,6 @@ function readAskUnresolvableOf(notice) {
     };
 }
 export const DURABLE_MANDATE_SOURCES = CORE_DURABLE_MANDATE_SOURCES;
-const DURABLE_MANDATE_SOURCE_SET = new Set(DURABLE_MANDATE_SOURCES);
 export function readDurableGateUnavailable(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
@@ -213,7 +212,7 @@ export function readDurableGateUnavailable(notice) {
     const causeIn = o.cause;
     const sessionId = typeof sessionIdIn === 'string' && sessionIdIn.length > 0 ? sessionIdIn : undefined;
     const runId = typeof runIdIn === 'string' && runIdIn.length > 0 ? runIdIn : undefined;
-    const source = typeof sourceIn === 'string' && DURABLE_MANDATE_SOURCE_SET.has(sourceIn) ? sourceIn : undefined;
+    const source = typeof sourceIn === 'string' && sourceIn.length > 0 ? sourceIn : undefined;
     const cause = typeof causeIn === 'string' && causeIn.length > 0 ? causeIn : undefined;
     if (sessionId === undefined || runId === undefined || source === undefined || cause === undefined) {
         return undefined;
@@ -1417,14 +1416,14 @@ function shownName(v) {
 function shownText(v, max) {
     if (v === undefined)
         return undefined;
-    const s = displayUntrusted(v, { max });
+    const s = displayUntrustedCapped(v, max);
     return s.length > 0 ? s : undefined;
 }
 function wordLookup(table, word) {
     return Object.hasOwn(table, word) ? table[word] : undefined;
 }
 function joinSentences(parts, lang) {
-    return parts.filter((p) => p !== undefined && p.length > 0).join(lang === 'zh' ? '' : ' ');
+    return parts.filter((p) => p !== undefined && p.length > 0).join(renderLanguageOf(lang) === 'zh' ? '' : ' ');
 }
 export function memorySessionPollutedSentence(facts, lang) {
     try {
@@ -1658,6 +1657,21 @@ export function steeringParkedInputBlockedSentence(facts, lang) {
         return undefined;
     }
 }
+export function modelCapabilityDowngradedSentence(facts, lang) {
+    try {
+        const model = shownName(viewStr(facts, 'model'));
+        const capability = viewStr(facts, 'capability');
+        const status = viewStr(facts, 'status');
+        if (model === undefined || capability === undefined || status === undefined)
+            return undefined;
+        if (capability !== 'image' || status !== 'declared_off')
+            return undefined;
+        return renderMessage(msg('notice.model.capabilityDowngraded.image', { model }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
 const DURABLE_MANDATE_CLAUSE = Object.freeze({
     force_durable_gate: 'notice.durableGate.mandate.forceDurableGate',
     durable_approval: 'notice.durableGate.mandate.durableApproval',
@@ -1717,6 +1731,21 @@ function readDeliveryDiscardedOf(notice) {
     const path = typeof pathRaw === 'string' && DISCARDED_DELIVERY_PATH_SET.has(pathRaw) ? pathRaw : undefined;
     return { taskId, taskType, sessionId, ...(path !== undefined ? { path } : {}) };
 }
+export function readModelCapabilityDowngraded(notice) {
+    return guardedRead(notice, (n) => {
+        const o = userCodeDetail(n, 'model.capability_downgraded');
+        if (o === undefined)
+            return undefined;
+        const model = dataStr(o, 'model');
+        const capability = dataStr(o, 'capability');
+        const status = dataStr(o, 'status');
+        const sessionId = dataStr(o, 'sessionId');
+        const runId = dataStr(o, 'runId');
+        if (model === undefined || capability === undefined || status === undefined || sessionId === undefined || runId === undefined)
+            return undefined;
+        return { model, capability, status, sessionId, runId };
+    });
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -1758,6 +1787,7 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'task.halt_unconsumed': readTaskHaltUnconsumed,
     'steering.parked_input_blocked': readSteeringParkedInputBlocked,
     'delegation.delivery_discarded': readDeliveryDiscarded,
+    'model.capability_downgraded': readModelCapabilityDowngraded,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;