@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/displayUntrusted.js

@@ -103,8 +103,8 @@ function valueIsWholeMarker(S, start, end, tokenInner = true) {
     return j >= end || !isKeyWordChar(text.charCodeAt(j)) || credentialWordStartsExactlyAt(text, j, tokenInner) || credentialPairAt(S, j);
 }
 const CREDENTIAL_NAME = /(?:(?:access|refresh|id|client|api|x[-_]api|session|auth)[-_]?)?(?:token|key|secret|password|authorization|credential)s?|bearer|basic/iy;
-const LABEL_SEPARATOR = /(?:\\*["'])?[\s\u115F\u1160\u3164\uFFA0\u2800]*[:=\uFF1A\uFF1D]/y;
-const SCHEME_SEPARATOR = /[\s:=\uFF1A\uFF1D\u115F\u1160\u3164\uFFA0\u2800]/y;
+const LABEL_SEPARATOR = /(?:\\*["'])?(?:[\s\u115F\u1160\u3164\uFFA0\u2800]|\\t)*[:=\uFF1A\uFF1D]/y;
+const SCHEME_SEPARATOR = /(?:[\s:=\uFF1A\uFF1D\u115F\u1160\u3164\uFFA0\u2800]|\\t)/y;
 function credentialPairAt(S, at) {
     const text = S.text;
     const re = new RegExp(CREDENTIAL_NAME.source, 'iy');
@@ -286,15 +286,22 @@ function pathCandidates(src, base, path, opaqueSegments, edits, soft) {
     for (const segment of path.split('/')) {
         const semi = segment.indexOf(';');
         const head = semi === -1 ? segment : segment.slice(0, semi);
-        if (opaqueSegments && isKnownSecretSegment(head)) {
+        if (opaqueSegments) {
             let a = 0;
             let b = head.length;
             while (a < b && !isKeyWordChar(head.charCodeAt(a)))
                 a++;
             while (b > a && !isKeyWordChar(head.charCodeAt(b - 1)))
                 b--;
-            if (b > a)
-                pushEdit(edits, src, pos + a, pos + b, REDACTED_SECRET);
+            if (isKnownSecretSegment(head)) {
+                if (b > a)
+                    pushEdit(edits, src, pos + a, pos + b, REDACTED_SECRET);
+            }
+            else if (b > a) {
+                const glued = gluedLiteralStart(head.slice(a, b));
+                if (glued > 0)
+                    pushEdit(edits, src, pos + a + glued, pos + b, REDACTED_SECRET);
+            }
         }
         if (semi !== -1) {
             let ppos = pos + semi + 1;
@@ -401,6 +408,7 @@ function urlCandidates(text, out, regions, unitPos = () => false, soft) {
             runStart--;
         if (runStart < end && !VALUE_BOUNDARY_TAIL.test(text.slice(start, runStart)))
             end = runStart;
+        end = trailingCloserEnd(text, start, mark + 3, end, unitPos);
         const tokenEdits = [];
         urlTokenCandidatesAt(text, start, end, tokenEdits, soft);
         editsToCandidates(tokenEdits, 'url', out, end);
@@ -420,6 +428,47 @@ function urlCandidates(text, out, regions, unitPos = () => false, soft) {
         mark = text.indexOf('://', end > mark + 3 ? end : mark + 3);
     }
 }
+function trailingCloserEnd(text, start, floor, end, unitPos) {
+    const opens = new Map();
+    const closes = new Map();
+    for (const [o, c] of BRACKET_PAIRS) {
+        opens.set(o, 0);
+        closes.set(c, 0);
+    }
+    for (let k = start; k < end; k++) {
+        if (unitPos(k))
+            continue;
+        const ch = text.charAt(k);
+        const o = opens.get(ch);
+        if (o !== undefined)
+            opens.set(ch, o + 1);
+        const c = closes.get(ch);
+        if (c !== undefined)
+            closes.set(ch, c + 1);
+    }
+    let e = end;
+    for (;;) {
+        if (e <= floor || unitPos(e - 1))
+            return e;
+        const ch = text.charAt(e - 1);
+        const c = closes.get(ch);
+        if (c === undefined)
+            return e;
+        let open = '';
+        for (const [o, cl] of BRACKET_PAIRS)
+            if (cl === ch)
+                open = o;
+        if (c <= (opens.get(open) ?? 0))
+            return e;
+        closes.set(ch, c - 1);
+        e--;
+        let runStart = e;
+        while (runStart > floor && TRAILING_PUNCTUATION.has(text.charAt(runStart - 1)))
+            runStart--;
+        if (runStart < e && !VALUE_BOUNDARY_TAIL.test(text.slice(start, runStart)))
+            e = runStart;
+    }
+}
 function atInAuthority(text, from) {
     for (let p = from; p < text.length; p++) {
         const ch = text.charAt(p);
@@ -763,9 +812,9 @@ const NAME_BLANK_RANGES = [
 const isNameBlank = (cp) => NAME_BLANK_RANGES.some(([a, b]) => cp >= a && cp <= b);
 const isFoldedBlank = (c) => isNameBlank(c) && isRegexSpace(c);
 const isUnicodeBlank = (c) => (c > 0x7f && isRegexSpace(c) && c !== 0xfeff) || isNameBlank(c);
-const SECRET_SCHEME_WORD = /(?:\b|(?<=\\[A-Za-z"']))(bearer|basic|token)[\s:=\uFF1A\uFF1D\u115F\u1160\u3164\uFFA0\u2800]+/gi;
+const SECRET_SCHEME_WORD = /(?:\b|(?<=\\[A-Za-z"']))(?!(?<=(?<!\\)\\)(?:bearer|basic|token)\\t)(bearer|basic|token)(?:[\s:=\uFF1A\uFF1D\u115F\u1160\u3164\uFFA0\u2800]|\\t)+/gi;
 const schemeWordIsInner = (word, tokenInner) => tokenInner || word.toLowerCase() !== 'token';
-const SECRET_LABELLED_WORD = /(?:\b|(?<=_)|(?<=\\[A-Za-z"']))((?:access[-_ ]?|refresh[-_ ]?|id[-_ ]?|client[-_ ]?|api[-_ ]?|x[-_]api[-_ ]?|session[-_ ]?|auth[-_ ]?)?(?:token|key|secret|password|authorization|credential)s?)(?:\\*["'])?[\s\u115F\u1160\u3164\uFFA0\u2800]*[:=\uFF1A\uFF1D][\s\u115F\u1160\u3164\uFFA0\u2800]*/gi;
+const SECRET_LABELLED_WORD = /(?:\b|(?<=_)|(?<=\\[A-Za-z"']))((?:access[-_ ]?|refresh[-_ ]?|id[-_ ]?|client[-_ ]?|api[-_ ]?|x[-_]api[-_ ]?|session[-_ ]?|auth[-_ ]?)?(?:token|key|secret|password|authorization|credential)s?)(?:\\*["'])?(?:[\s\u115F\u1160\u3164\uFFA0\u2800]|\\t)*[:=\uFF1A\uFF1D](?:[\s\u115F\u1160\u3164\uFFA0\u2800]|\\t)*/gi;
 const DIAGNOSTIC_VALUE_WORDS = new Set([
     'missing', 'required', 'invalid', 'expired', 'unauthorized', 'unauthenticated', 'authentication',
     'authorization', 'credential', 'credentials', 'unsupported', 'malformed', 'rejected', 'absent',
@@ -820,18 +869,67 @@ const AUTH_SCHEME_WORDS = new Set([
 const AUTH_SIGNATURE_SCHEME = /^[A-Z][A-Z0-9]*(?:-[A-Z0-9]+){2,}$/;
 const BARE_VALUE_STOP_CHARS = new Set([',', ';', '"', "'", '\\', '(', ')', '[', ']', '{', '}', '<', '>']);
 const isBareValueStop = (ch) => ch <= ' ' || BARE_VALUE_STOP_CHARS.has(ch);
+function isPlainAt(S, rawUnit, k) {
+    if (S.dropped(k) || S.painted(k) || S.unitAt(k) !== UNIT_NONE)
+        return false;
+    return rawUnit === null || rawUnit[S.rawStart(k)] !== 1;
+}
+function codeSpanClose(text, plain) {
+    const n = text.length;
+    const close = new Int32Array(n + 1).fill(-1);
+    let openLen = 0;
+    let spanFrom = -1;
+    let k = 0;
+    while (k < n) {
+        const c = text.charCodeAt(k);
+        if (c === 0x0a || c === 0x0d || c === 0x2028 || c === 0x2029) {
+            openLen = 0;
+            spanFrom = -1;
+            k++;
+            continue;
+        }
+        if (c !== 0x60 || !plain(k)) {
+            k++;
+            continue;
+        }
+        let e = k;
+        while (e < n && text.charCodeAt(e) === 0x60 && plain(e))
+            e++;
+        const len = e - k;
+        if (openLen === 0) {
+            openLen = len;
+            spanFrom = e;
+        }
+        else if (len === openLen) {
+            for (let x = spanFrom; x < k; x++)
+                close[x] = k;
+            openLen = 0;
+            spanFrom = -1;
+        }
+        k = e;
+    }
+    return close;
+}
+const BRACKET_PAIRS = new Map([['(', ')'], ['[', ']']]);
 class InnerWordIndex {
     text;
     tokenInner;
     probes;
-    constructor(text, tokenInner = true) {
+    plain;
+    spanClose = null;
+    constructor(text, tokenInner = true, plain = () => true) {
         this.text = text;
         this.tokenInner = tokenInner;
+        this.plain = plain;
         this.probes = [
             { re: new RegExp(SECRET_LABELLED_WORD.source, SECRET_LABELLED_WORD.flags), scheme: false, from: -1, hit: null },
             { re: new RegExp(SECRET_SCHEME_WORD.source, SECRET_SCHEME_WORD.flags), scheme: true, from: -1, hit: null },
         ];
     }
+    closingTickFrom(i) {
+        this.spanClose ??= codeSpanClose(this.text, this.plain);
+        return this.spanClose[i] ?? -1;
+    }
     next(q) {
         let best = null;
         for (const p of this.probes) {
@@ -857,6 +955,45 @@ class InnerWordIndex {
         return best;
     }
 }
+const WRAPPED_PLACEHOLDER = /^(?:[A-Z]{1,12}(?:_[A-Z]{1,12})*|[a-z]{1,12}(?:-[a-z]{1,12})*)$/;
+function wrappedValueAt(text, from, idx) {
+    let k = from;
+    while (k < text.length && text[k] === VIEW_SEPARATOR)
+        k++;
+    const close = BRACKET_PAIRS.get(text.charAt(k));
+    if (close === undefined || credentialWordStartsAt(text, k + 1, idx.tokenInner))
+        return null;
+    const inner = scanSecretValue(text, k + 1, idx);
+    if (inner === null || inner.start !== k + 1)
+        return null;
+    let c = inner.end;
+    while (c < text.length && text[c] === VIEW_SEPARATOR)
+        c++;
+    if (text.charAt(c) !== close || (close === ']' && text.charAt(c + 1) === '('))
+        return null;
+    return inner;
+}
+function tokenSchemeValueEnd(text, start, end, idx) {
+    if (withoutSeparators(text.slice(start, end)).toLowerCase() !== 'token')
+        return -1;
+    const re = new RegExp(SECRET_SCHEME_WORD.source, 'iy');
+    re.lastIndex = start;
+    const m = re.exec(text);
+    if (m === null || (m[1] ?? '').toLowerCase() !== 'token')
+        return -1;
+    const sepEnd = start + m[0].length;
+    if (/[\n\r\u2028\u2029:=\uFF1A\uFF1D]/.test(text.slice(start + (m[1] ?? '').length, sepEnd)))
+        return -1;
+    if (credentialWordStartsAt(text, sepEnd, idx.tokenInner))
+        return -1;
+    const iv = scanSecretValue(text, sepEnd, idx);
+    if (iv === null)
+        return -1;
+    const inner = withoutSeparators(text.slice(iv.start, iv.end));
+    if (schemeFollowerReleased('token', inner, false) || isDiagnosticWord(inner))
+        return -1;
+    return iv.end;
+}
 function innerWordFits(text, w) {
     for (let k = w.start; k <= w.sepAt && k < text.length; k++)
         if (isBareValueStop(text.charAt(k)))
@@ -912,6 +1049,7 @@ function scanSecretValue(text, from, idx) {
     let pending = cuttable ? idx.next(i + 1) : null;
     let cut = false;
     let j = i;
+    const closingTick = idx === undefined ? -1 : idx.closingTickFrom(i);
     while (j < text.length) {
         if (pending !== null && j >= pending.start) {
             if (j === pending.start && innerWordFits(text, pending)) {
@@ -936,6 +1074,18 @@ 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) {
+            j = closingTick;
+            while (j > i && text[j - 1] === VIEW_SEPARATOR)
+                j--;
+        }
+    }
     if (cut) {
         while (j > i && isCutDelimiter(text.charAt(j - 1))) {
             j--;
@@ -955,6 +1105,9 @@ function isDiagnosticValue(value, raw = value) {
         return true;
     if (ADDRESS_SCHEME_RE.test(raw))
         return true;
+    return isDiagnosticWord(value);
+}
+function isDiagnosticWord(value) {
     const bare = value.replace(/^\.+/, '').replace(/[.,;:!?)\]}'"]{0,8}$/, '').toLowerCase();
     return bare === '' || DIAGNOSTIC_VALUE_WORDS.has(bare);
 }
@@ -1014,6 +1167,26 @@ function isNamedNotValue(label, value) {
         return true;
     return isBacktickedCredentialName(value);
 }
+function schemeIsLabelValue(text, at) {
+    let k = at;
+    while (k > 0 && text[k - 1] === VIEW_SEPARATOR)
+        k--;
+    if (k > 0 && isQuoteChar(text.charAt(k - 1))) {
+        k--;
+        while (k > 0 && text.charCodeAt(k - 1) === 0x5c)
+            k--;
+    }
+    return k > 0 && labelEndsAt(text, k);
+}
+function labelQuotedAt(text, at, sep) {
+    const q = text.charAt(at - 1);
+    if (!isQuoteChar(q))
+        return false;
+    let k = 0;
+    while (sep.charCodeAt(k) === 0x5c)
+        k++;
+    return sep.charAt(k) === q;
+}
 function labelStartsAt(text, at) {
     const re = new RegExp(SECRET_LABELLED_WORD.source, 'iy');
     re.lastIndex = at;
@@ -1930,9 +2103,11 @@ function labelCandidates(S, pass, regions, out, blocks) {
     const re = pass === 'label' ? SECRET_LABELLED_WORD : SECRET_SCHEME_WORD;
     const schemePass = pass !== 'label';
     const tokenPass = pass === 'token';
-    const idx = new InnerWordIndex(text, tokenPass);
+    const rawUnitMap = blocks?.view.rawUnit ?? null;
+    const plainAt = (k) => isPlainAt(S, rawUnitMap, k);
+    const idx = new InnerWordIndex(text, tokenPass, plainAt);
     let listIdx = null;
-    const listIndex = () => (listIdx ??= new InnerWordIndex(text, idx.tokenInner));
+    const listIndex = () => (listIdx ??= new InnerWordIndex(text, idx.tokenInner, plainAt));
     let skipFrom = -1;
     let skipTo = -1;
     const flowBudget = { left: 4 * text.length + 4096, pairs: null };
@@ -2182,6 +2357,16 @@ function labelCandidates(S, pass, regions, out, blocks) {
         if (schemePass && labelStartsAt(text, hit.index))
             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;
+            while (k < text.length && isInlineBlank(text.charAt(k)))
+                k++;
+            let q = k;
+            while (text.charCodeAt(q) === 0x5c)
+                q++;
+            if (isQuoteChar(text.charAt(q)))
+                from = k;
+        }
         const colonSep = isColonSeparator(hit[0].slice((hit[1] ?? '').length));
         let bulletSkipped = false;
         for (;;) {
@@ -2244,6 +2429,16 @@ function labelCandidates(S, pass, regions, out, blocks) {
             }
         }
         let v0s = scanSecretValue(text, from, idx);
+        let wrapEnd = -1;
+        if (v0s === null) {
+            const w = wrappedValueAt(text, from, idx);
+            if (w !== null) {
+                if (WRAPPED_PLACEHOLDER.test(withoutSeparators(text.slice(w.start, w.end))))
+                    continue;
+                v0s = w;
+                wrapEnd = w.end;
+            }
+        }
         if (v0s === null) {
             let k = from;
             while (k < text.length && text[k] === VIEW_SEPARATOR)
@@ -2340,6 +2535,13 @@ function labelCandidates(S, pass, regions, out, blocks) {
             if (a !== -1)
                 v.end = a;
         }
+        if (wrapEnd !== -1 && v.end > wrapEnd)
+            v.end = wrapEnd;
+        if (!schemePass && !quoted && wrapEnd === -1 && !inQuery(v.start) && !/authorizations?$/i.test(label)) {
+            const ext = tokenSchemeValueEnd(text, v.start, v.end, idx);
+            if (ext > v.end)
+                v.end = ext;
+        }
         if (!quoted) {
             const trailing = trailingLabelStart(text, v.start, v.end, idx.tokenInner);
             if (trailing > 0 && innerWordHasValue(text, v.start + trailing, idx)) {
@@ -2402,6 +2604,11 @@ function labelCandidates(S, pass, regions, out, blocks) {
                 const trailing = trailingLabelStart(text, v.start, end, idx.tokenInner);
                 if (trailing !== -1)
                     end = v.start + trailing;
+                if (schemePass && schemeIsLabelValue(text, hit.index)) {
+                    push(v.start, Math.max(end, v.end), REDACTED_SECRET);
+                    re.lastIndex = quoted ? from : Math.max(end, v.end);
+                    continue;
+                }
                 if (gluedToSingleUnit(v.start, hit.index, unitAt) || userinfoHostHidden(text, v.start, unitAt)) {
                     const cut = trailing !== -1 ? end : Math.max(end, v.end);
                     const schemeHit = ADDRESS_SCHEME_RE.exec(text.slice(v.start, v.start + 20))?.[0] ?? '';
@@ -2799,6 +3006,90 @@ function authParamEdits(text) {
     }
     return edits;
 }
+const LITERAL_PROBE_WINDOW = 64;
+function gluedLiteralStart(word) {
+    const n = word.length;
+    if (n < PROSE_LITERAL_MIN_RUN + 2)
+        return 0;
+    const runFrom = new Int32Array(n + 1);
+    let best = 0;
+    let run = 0;
+    for (let k = n - 1; k >= 0; k--) {
+        if (isAlnumCode(word.charCodeAt(k))) {
+            run++;
+            if (run > best)
+                best = run;
+        }
+        else
+            run = 0;
+        runFrom[k] = best;
+    }
+    for (let k = 1; k < n; k++) {
+        const left = word.charCodeAt(k - 1);
+        if ((left !== 0x5f && left !== 0x2d) || !isAlnumCode(word.charCodeAt(k)))
+            continue;
+        if ((runFrom[k] ?? 0) < PROSE_LITERAL_MIN_RUN)
+            return 0;
+        if (SECRET_LITERAL_RE.test(word.slice(k, k + LITERAL_PROBE_WINDOW)))
+            return k;
+    }
+    return 0;
+}
+const OPAQUE_MIN_LENGTH = 24;
+const OPAQUE_MIN_ENTROPY = 3.5;
+const OPAQUE_MAX_AVG_SEGMENT = 2.5;
+const BASE64_FILE_SIGNATURES = ['iVBORw0KGgo', 'R0lGOD', 'UklGR', 'JVBERi0', 'UEsDB', 'H4sI', 'PHN2Zy', 'PD94bWwg', 'AAABAA'];
+const NON_SECRET_ID_PREFIXES = new Set(['toolu', 'srvtoolu', 'msg', 'msgbatch', 'req', 'file', 'chatcmpl', 'call', 'resp']);
+function isOpaqueWord(text, i, end) {
+    if (end - i < OPAQUE_MIN_LENGTH)
+        return false;
+    const prev = text.charAt(i - 1);
+    const next = text.charAt(end);
+    if (prev === '+' || prev === '@' || next === '+' || next === '/' || next === '=' || next === '@')
+        return false;
+    if (next === '.' && isKeyWordChar(text.charCodeAt(end + 1)))
+        return false;
+    if (text.slice(Math.max(0, i - 7), i).toLowerCase() === 'base64,')
+        return false;
+    const word = text.slice(i, end);
+    if (/^[0-9A-Fa-f_-]+$/.test(word) || /^sha(?:1|256|384|512)-/i.test(word))
+        return false;
+    if (BASE64_FILE_SIGNATURES.some((sig) => word.startsWith(sig)))
+        return false;
+    const typed = /^([a-z]+)[_-]/.exec(word);
+    if (typed !== null && NON_SECRET_ID_PREFIXES.has(typed[1] ?? ''))
+        return false;
+    let upper = false;
+    let lower = false;
+    let digit = false;
+    const counts = new Map();
+    for (let k = 0; k < word.length; k++) {
+        const c = word.charCodeAt(k);
+        if (c >= 0x41 && c <= 0x5a)
+            upper = true;
+        else if (c >= 0x61 && c <= 0x7a)
+            lower = true;
+        else if (c >= 0x30 && c <= 0x39)
+            digit = true;
+        counts.set(c, (counts.get(c) ?? 0) + 1);
+    }
+    if (!upper || !lower || !digit)
+        return false;
+    let entropy = 0;
+    for (const n of counts.values()) {
+        const p = n / word.length;
+        entropy -= p * Math.log2(p);
+    }
+    if (entropy < OPAQUE_MIN_ENTROPY)
+        return false;
+    let segments = 0;
+    let segmentChars = 0;
+    for (const m of word.matchAll(/[A-Z]?[a-z]+|[A-Z]+(?![a-z])|[0-9]+/g)) {
+        segments++;
+        segmentChars += m[0].length;
+    }
+    return segments > 0 && segmentChars / segments <= OPAQUE_MAX_AVG_SEGMENT;
+}
 function proseLiteralEdits(text) {
     const edits = [];
     let i = 0;
@@ -2833,6 +3124,13 @@ function proseLiteralEdits(text) {
         if (!pathish && SECRET_LITERAL_RE.test(word) && longestAlnumRun(word) >= PROSE_LITERAL_MIN_RUN) {
             pushEdit(edits, text, i, end, REDACTED_SECRET);
         }
+        else if (!pathish) {
+            const glued = gluedLiteralStart(word);
+            if (glued > 0)
+                pushEdit(edits, text, i + glued, end, REDACTED_SECRET);
+            else if (!hostSlot && isOpaqueWord(text, i, end))
+                pushEdit(edits, text, i, end, REDACTED_SECRET);
+        }
         i = end;
     }
     return edits;
@@ -4081,6 +4379,10 @@ export function displayUntrusted(text, opts = {}) {
     const out = renderUntrusted(text, opts, null);
     return typeof out === 'string' ? out : out.text;
 }
+export function quoteUntrustedForSentence(text, max) {
+    const shown = displayUntrusted(text, { max, blanks: true, escapeBackslashes: true });
+    return shown.trim() === '' ? undefined : `"${shown.replace(/"/g, '\\"')}"`;
+}
 export function displayUntrustedMarks(text, opts = {}) {
     const ledger = { cps: [], lens: [] };
     const out = renderUntrusted(text, opts, ledger);
@@ -4088,4 +4390,4 @@ export function displayUntrustedMarks(text, opts = {}) {
         return { text: out, marks: [] };
     return { text: out.text, marks: collectMarks(out, ledger) };
 }
-const isQuoteChar = (c) => c.charCodeAt(0) === 0x22 || c.charCodeAt(0) === 0x27 || (c === '' && /`/.test(c));
+const isQuoteChar = (c) => c.charCodeAt(0) === 0x22 || c.charCodeAt(0) === 0x27;

package/dist/engineAgentAbsence.d.ts

@@ -1,5 +1,5 @@
 import { type EngineAgentPanelAbsence, type EngineAgentPanelCycleIdentity, type EngineAgentPanelEvent } from './engineAgentPanelStore.js';
-import type { RunTerminalStatus } from './runTerminal.js';
+import type { CcTaskTerminalStatus } from './terminalStatuses.js';
 export declare const ENGINE_AGENT_ABSENT_ROW_TEXT = "engine no longer reports this agent \u00B7 it may still be running";
 export declare const ENGINE_AGENT_ABSENCE_TTL_MS: number;
 export type EngineAgentAbsenceMark = Readonly<Pick<EngineAgentPanelAbsence, 'lastSeenAtMs' | 'absentForMs'>>;
@@ -48,7 +48,7 @@ export interface EngineAgentAbsenceReapOptions {
 }
 export declare function reapEngineAgentAbsentRows(rows: Readonly<Record<string, EngineAgentAbsenceReapRow | null | undefined>>, opts: EngineAgentAbsenceReapOptions): EngineAgentAbsenceReap;
 export declare function engineAgentAbsenceDroppedLine(label: string, ttlMs?: number, removeReason?: string | null): string;
-export declare function engineAgentTerminalAfterDropLine(label: string, status: RunTerminalStatus, hasReport: boolean): string;
+export declare function engineAgentTerminalAfterDropLine(label: string, status: CcTaskTerminalStatus, hasReport: boolean): string;
 export interface EngineAgentRegistryRowView {
     readonly id: string;
     readonly type: string;

package/dist/engineAgentPanelStore.d.ts

@@ -1,3 +1,7 @@
+import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS, type EnginePanelTaskIdentity, type PanelDelta } from './panelReduce.js';
+import type { EngineAgentPanelCycleIdentity } from './cycleOrder.js';
+export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
+export type { EngineAgentPanelCycleIdentity, EnginePanelTaskIdentity };
 export type EngineAgentPanelEvent = {
     kind: 'tick';
     taskId: string;
@@ -45,33 +49,19 @@ export declare const PANEL_TOOLUSES_LANE_POLICY: Readonly<Record<'tick' | 'fleet
 export declare function markEnginePanelTaskResident(taskId: string): void;
 export declare function clearEnginePanelTaskResident(taskId: string): void;
 export declare function isEnginePanelTaskResident(taskId: string): boolean;
-type Listener = (ev: EngineAgentPanelEvent) => void;
-export declare function isNewEngineAgentPanelCycle(prev: EngineAgentPanelCycleIdentity | null | undefined, next: EngineAgentPanelCycleIdentity | null | undefined): boolean;
-export interface EngineAgentPanelCycleIdentity {
-    readonly cycleSeq?: number;
-    readonly startedAt?: number;
-}
-export declare function isStaleEngineAgentPanelEnd(end: EngineAgentPanelCycleIdentity | null | undefined, current: EngineAgentPanelCycleIdentity | null | undefined): boolean;
-export declare const MAX_HELD_WIRE_TICK_BEATS = 16;
-export interface EnginePanelTaskIdentity {
-    readonly taskId: string;
-    readonly origin: 'fleet-row' | 'wire';
-    readonly cycleSeq?: number;
-    readonly startedAt?: number;
-}
 export declare function resolveEnginePanelTaskId(wireTaskId: string, parentToolCallId?: string): EnginePanelTaskIdentity;
 export declare function clearEnginePanelTaskResidentByWire(wireTaskId: string, cycle?: EngineAgentPanelCycleIdentity): void;
 export declare function __resetEngineAgentPanelIdentityForTests(): void;
+export declare function __resetEnginePanelStateForTests(): void;
 export declare function publishEngineAgentPanelEvent(ev: EngineAgentPanelEvent): void;
-export declare function subscribeEngineAgentPanel(fn: Listener): () => void;
+export declare function subscribeEngineAgentPanel(fn: (ev: EngineAgentPanelEvent) => void): () => void;
+export declare function subscribeEnginePanelRows(fn: (delta: PanelDelta) => void): () => void;
 export interface EngineAgentPanelAbsence {
     taskId: string;
     lastSeenAtMs: number;
     absentForMs: number;
     wireTaskId?: string;
 }
-type AbsenceListener = (ev: EngineAgentPanelAbsence) => void;
 export declare function publishEngineAgentPanelAbsence(ev: EngineAgentPanelAbsence): void;
-export declare function subscribeEngineAgentPanelAbsence(fn: AbsenceListener): () => void;
+export declare function subscribeEngineAgentPanelAbsence(fn: (ev: EngineAgentPanelAbsence) => void): () => void;
 export declare function __resetEngineAgentPanelAbsenceForTests(): void;
-export {};