@sema-agent/client-core 0.108.0 → 0.110.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;

package/dist/engineAgentAbsence.d.ts

@@ -56,6 +56,7 @@ export interface EngineAgentRegistryRowView {
     readonly description?: string;
     readonly createdAt?: number;
     readonly sessionId?: string;
+    readonly retained?: true;
 }
 export type EngineAgentRegistryUnavailableWhy = 'no_list_face' | 'capability_unknown' | 'route_absent' | 'ownership_required' | 'read_failed';
 export type EngineAgentRegistryListing = {
@@ -75,6 +76,7 @@ export interface EngineAgentRegistryReadingOptions {
     readonly sessionId?: string;
 }
 export declare function engineAgentRegistryReadingOf(listing: EngineAgentRegistryListing | null | undefined, registryKey: string | null | undefined, opts?: EngineAgentRegistryReadingOptions | null): EngineAgentRegistryReading;
+export declare function localEngineSessionShellsOf(listings: readonly (EngineAgentRegistryListing | null | undefined)[]): number | 'unknown';
 export interface EngineAgentRegistryMissingRow {
     readonly id: string;
     readonly status: string;

package/dist/engineAgentAbsence.js

@@ -214,6 +214,34 @@ function readingFromRecord(rec, registryKey, opts) {
     const single = ownOpt(opts, 'singleReplica');
     return single.given && single.value === true && REGISTRY_AGENT_HANDLE_RE.test(registryKey) ? 'not_listed' : 'unknown';
 }
+const SESSION_SHELL_TYPES = new Set(Object.keys({ background_bash: true, monitor: true }));
+export function localEngineSessionShellsOf(listings) {
+    try {
+        if (!Array.isArray(listings))
+            return 'unknown';
+        let count = 0;
+        for (let i = 0; i < listings.length; i++) {
+            if (!Object.hasOwn(listings, i))
+                return 'unknown';
+            const rec = registryListingProvenanceOf(listings[i]);
+            if (rec === undefined || rec.superseded || rec.rawRowCount >= REGISTRY_LIST_LIMIT)
+                return 'unknown';
+            for (const r of rec.rows) {
+                if (!SESSION_SHELL_TYPES.has(r.type) || r.retained === true)
+                    continue;
+                const reading = registryStatusReading(r.status);
+                if (reading === 'unknown')
+                    return 'unknown';
+                if (reading === 'running')
+                    count++;
+            }
+        }
+        return count;
+    }
+    catch {
+        return 'unknown';
+    }
+}
 function keySetOf(v) {
     if (v instanceof Set)
         return (k) => v.has(k);

package/dist/engineErrorCodes.d.ts

@@ -49,6 +49,10 @@ export declare const ATTACHMENT_BUNDLE_SEED_FIXED = "attachment.bundle_seed_fixe
 export declare const ATTACHMENT_BOUND_ELSEWHERE = "attachment.bound_elsewhere";
 export declare const CONFLICT_SESSION_MEMORY_UNOBSERVED = "conflict.session_memory_unobserved";
 export declare const CONFLICT_SESSION_ARCHIVE_STAMPED = "conflict.session_archive_stamped";
+export declare const REQUEST_ENV_CREDENTIAL_REFUSED = "request.env_credential_refused";
+export declare const CONFLICT_SESSION_ID_RETIRED = "conflict.session_id_retired";
+export declare const LIMIT_RATE_EXCEEDED = "limit.rate_exceeded";
+export declare const RATE_EXCEEDED_RUN_CONCURRENCY_CAP = "run_concurrency_cap";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
 export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";
@@ -150,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

@@ -73,6 +73,10 @@ export const ATTACHMENT_BUNDLE_SEED_FIXED = 'attachment.bundle_seed_fixed';
 export const ATTACHMENT_BOUND_ELSEWHERE = 'attachment.bound_elsewhere';
 export const CONFLICT_SESSION_MEMORY_UNOBSERVED = 'conflict.session_memory_unobserved';
 export const CONFLICT_SESSION_ARCHIVE_STAMPED = 'conflict.session_archive_stamped';
+export const REQUEST_ENV_CREDENTIAL_REFUSED = 'request.env_credential_refused';
+export const CONFLICT_SESSION_ID_RETIRED = 'conflict.session_id_retired';
+export const LIMIT_RATE_EXCEEDED = 'limit.rate_exceeded';
+export const RATE_EXCEEDED_RUN_CONCURRENCY_CAP = 'run_concurrency_cap';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
 export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';
@@ -270,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

@@ -8,6 +8,7 @@ export interface EngineHealthAuthFacts {
     readonly required: boolean;
     readonly kinds: readonly (HealthAuthKind | (string & {}))[];
     readonly identityAttach: 'available' | 'unavailable';
+    readonly serviceTokenActsForDeployment?: boolean;
 }
 export interface EngineHealthDrainingFacts {
     readonly actionId: string;
@@ -17,6 +18,19 @@ export interface EngineHealthDrainingFacts {
 export interface EngineHealthLeaseFacts {
     readonly lingerMs: number;
     readonly tickMs: number;
+    readonly firstAttach?: EngineHealthFirstAttachFacts;
+}
+export interface EngineHealthFirstAttachFacts {
+    readonly windowMs: number;
+    readonly since: number;
+    readonly attachedAt: number | null;
+}
+export interface EngineHealthInflightFacts {
+    readonly total: number;
+    readonly http?: number;
+    readonly leader?: number;
+    readonly sessionResident?: number;
+    readonly backgroundAgents?: number;
 }
 export interface EngineHealthFacts {
     readonly center?: EngineHealthCenterFacts;
@@ -24,5 +38,17 @@ export interface EngineHealthFacts {
     readonly operator?: 'present' | 'absent';
     readonly draining?: EngineHealthDrainingFacts;
     readonly engineLease?: EngineHealthLeaseFacts;
+    readonly inflight?: EngineHealthInflightFacts;
+    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 declare function readEngineHealthFacts(health: object | null | undefined): EngineHealthFacts;

package/dist/engineHealthFacts.js

@@ -1,5 +1,5 @@
-import { readOwnDataValue } from './ownKey.js';
-const _healthFactsMatchSdk = [true, true, true, true, true, true];
+import { ownDataField, readOwnDataValue } from './ownKey.js';
+const _healthFactsMatchSdk = [true, true, true, true, true, true, true, true, true, true];
 void _healthFactsMatchSdk;
 const ENGINE_SIGNAL_KEY = 'engineSignal';
 function isObject(v) {
@@ -51,7 +51,10 @@ function authOf(raw) {
             return undefined;
         kinds.push(word);
     }
-    return Object.freeze({ required, kinds: Object.freeze(kinds), identityAttach });
+    const actsRaw = readOwnDataValue(raw, 'serviceTokenActsForDeployment');
+    if (actsRaw !== undefined && typeof actsRaw !== 'boolean')
+        return undefined;
+    return Object.freeze({ required, kinds: Object.freeze(kinds), identityAttach, ...(typeof actsRaw === 'boolean' ? { serviceTokenActsForDeployment: actsRaw } : {}) });
 }
 function drainingOf(health) {
     const signal = readOwnDataValue(health, ENGINE_SIGNAL_KEY);
@@ -67,6 +70,17 @@ function drainingOf(health) {
         return undefined;
     return Object.freeze({ actionId, since, deadlineAt });
 }
+function firstAttachOf(raw) {
+    if (!isObject(raw))
+        return undefined;
+    const windowMs = epochMs(readOwnDataValue(raw, 'windowMs'));
+    const since = epochMs(readOwnDataValue(raw, 'since'));
+    const attachedRaw = readOwnDataValue(raw, 'attachedAt');
+    const attachedAt = attachedRaw === null ? null : epochMs(attachedRaw);
+    if (windowMs === undefined || since === undefined || attachedAt === undefined)
+        return undefined;
+    return Object.freeze({ windowMs, since, attachedAt });
+}
 function leaseOf(raw) {
     if (!isObject(raw))
         return undefined;
@@ -74,7 +88,26 @@ function leaseOf(raw) {
     const tickMs = epochMs(readOwnDataValue(raw, 'tickMs'));
     if (lingerMs === undefined || tickMs === undefined)
         return undefined;
-    return Object.freeze({ lingerMs, tickMs });
+    const firstRaw = readOwnDataValue(raw, 'firstAttach');
+    const firstAttach = firstRaw === undefined ? undefined : firstAttachOf(firstRaw);
+    if (firstRaw !== undefined && firstAttach === undefined)
+        return undefined;
+    return Object.freeze({ lingerMs, tickMs, ...(firstAttach !== undefined ? { firstAttach } : {}) });
+}
+function inflightOf(health) {
+    const total = epochMs(readOwnDataValue(health, 'inflight'));
+    if (total === undefined)
+        return undefined;
+    const raw = guarded(() => readOwnDataValue(health, 'inflightBreakdown'));
+    const parts = {};
+    if (isObject(raw)) {
+        for (const key of ['http', 'leader', 'sessionResident', 'backgroundAgents']) {
+            const v = guarded(() => epochMs(readOwnDataValue(raw, key)));
+            if (v !== undefined)
+                parts[key] = v;
+        }
+    }
+    return Object.freeze({ total, ...parts });
 }
 function guarded(read) {
     try {
@@ -84,6 +117,26 @@ 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 readEngineHealthFacts(health) {
     if (!isObject(health))
         return Object.freeze({});
@@ -93,11 +146,17 @@ export function readEngineHealthFacts(health) {
     const operator = operatorRaw === 'present' || operatorRaw === 'absent' ? operatorRaw : undefined;
     const draining = guarded(() => drainingOf(health));
     const engineLease = guarded(() => leaseOf(readOwnDataValue(health, 'engineLease')));
+    const inflight = guarded(() => inflightOf(health));
+    const version = guarded(() => nonEmptyString(readOwnDataValue(health, 'version')));
+    const dataRoot = guarded(() => nonEmptyString(readOwnDataValue(health, 'dataRoot')));
     return Object.freeze({
         ...(center !== undefined ? { center } : {}),
         ...(auth !== undefined ? { auth } : {}),
         ...(operator !== undefined ? { operator } : {}),
         ...(draining !== undefined ? { draining } : {}),
         ...(engineLease !== undefined ? { engineLease } : {}),
+        ...(inflight !== undefined ? { inflight } : {}),
+        ...(version !== undefined ? { version } : {}),
+        ...(dataRoot !== undefined ? { dataRoot } : {}),
     });
 }

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;