@kortix/ui 0.14.3 → 0.14.5

package/dist/session/panel/shared/derive-panels.d.ts

@@ -0,0 +1,81 @@
+/**
+ * What the agent MADE (Outputs) versus what it LOOKED AT (Context).
+ *
+ * Both are derived from the same ToolCallBlock[] the Progress list reads — Easy mode
+ * adds no data source, it only re-partitions what is already there.
+ *
+ * Classification is delegated to narration.ts wherever it already owns the
+ * answer (`familyForTool` for which tools write/read/browse the web,
+ * `createArtifactKind` for which image_gen/presentation_gen actions leave
+ * behind a real artifact to open versus a pure read/delete/listing) — this
+ * file must never re-derive that logic with its own second set of tool-name
+ * tables, or the two cards could disagree with what Progress just narrated
+ * for the same call.
+ */
+import { type ToolCallBlock } from '@kortix/sdk';
+export interface OutputItemBase {
+    callID: string;
+    name: string;
+    /** Human title from the show payload (W3). Display rule: `title ?? name`. */
+    title?: string;
+    description?: string;
+    /** Set only for latest-run items: first appearance vs a re-produced path (W11). */
+    fresh?: 'new' | 'updated';
+    /** The agent explicitly `show`ed this — a hand-over, so it ranks as a
+     *  deliverable regardless of extension. Set by `showOutputsOf`. */
+    shown?: boolean;
+}
+type ArtifactOutputItem = OutputItemBase & {
+    kind: 'file' | 'image' | 'video' | 'presentation';
+    path?: string;
+    url?: never;
+    /**
+     * The live deck's name, as `presentation_gen` knows it — the argument
+     * `usePresentationViewerStore.openPresentation(presentationName, sandboxUrl)`
+     * needs (W14's Present action). Only ever set from the `create` branch below
+     * (a real presentation_gen call), never from a `show`ed `.pptx` FILE: that's
+     * a static binary with no metadata.json/slide-html deck behind it for the
+     * fullscreen viewer to load, so Present must not offer it one.
+     */
+    presentationName?: string;
+};
+type AppOutputItem = OutputItemBase & {
+    kind: 'app';
+    path?: never;
+    /**
+     * The URL the thing is running at. When a user asks for a web page
+     * or a React app, the deliverable is not a file on disk — it's a server on a
+     * port. Outputs has to be able to hand them the *running thing*, or the one
+     * output they actually wanted is the one they can't reach.
+     */
+    url: string;
+    presentationName?: never;
+};
+export type OutputItem = ArtifactOutputItem | AppOutputItem;
+export interface ContextItem {
+    callID: string;
+    label: string;
+    kind: 'file' | 'web' | 'tool';
+    /** The real URL a `web` item points at — never rendered as the label
+     * itself, only as a title attribute / link target for the row. */
+    url?: string;
+    /** The real on-disk path a `file` item points at — set only for
+     * `kind: 'file'`. It is what lets the Context card open the file in the
+     * viewer. */
+    path?: string;
+    /** Every call behind a `tool` item, so the UI can show what the tool
+     * actually did (its real tool views) when the user opens the chip. */
+    calls?: ToolCallBlock[];
+}
+/** `s` without trailing `/`. A loop, not `/\/+$/`: that regex backtracks
+ *  quadratically on a long run of slashes (CodeQL js/polynomial-redos). */
+export declare function trimTrailingSlashes(s: string): string;
+export declare function deriveOutputs(calls: ToolCallBlock[], opts?: {
+    latestRun?: Set<string>;
+}): OutputItem[];
+export declare function deriveContext(calls: ToolCallBlock[]): {
+    files: ContextItem[];
+    web: ContextItem[];
+    tools: ContextItem[];
+};
+export {};

package/dist/session/panel/shared/derive-panels.js

@@ -0,0 +1,475 @@
+/**
+ * What the agent MADE (Outputs) versus what it LOOKED AT (Context).
+ *
+ * Both are derived from the same ToolCallBlock[] the Progress list reads — Easy mode
+ * adds no data source, it only re-partitions what is already there.
+ *
+ * Classification is delegated to narration.ts wherever it already owns the
+ * answer (`familyForTool` for which tools write/read/browse the web,
+ * `createArtifactKind` for which image_gen/presentation_gen actions leave
+ * behind a real artifact to open versus a pure read/delete/listing) — this
+ * file must never re-derive that logic with its own second set of tool-name
+ * tables, or the two cards could disagree with what Progress just narrated
+ * for the same call.
+ */
+import { toWorkspaceRelative } from '../../../internal/files/runtime-files.js';
+import { parseImageOutput } from '../../media/image-output-path.js';
+import { parsePresentationOutput } from '@kortix/sdk';
+import { humanizeSearchQuery } from '@kortix/sdk';
+import { looksLikeHtml, parseWebSearchOutput, wsDomain, } from '@kortix/sdk';
+import { getToolPrimaryArg, normalizeName } from '../../tool/tool-meta.js';
+import { extractReadableHtml } from '../../../_vendor/kortix-shared.js';
+import { contextLabelForTool, createArtifactKind, familyForTool, narrationToolName as humanizeToolName, } from '@kortix/sdk';
+import { toolCallMetadata, toolKind } from '@kortix/sdk';
+function filePathOf(call) {
+    const input = inputOf(call);
+    const p = input.filePath ?? input.file_path ?? input.path;
+    return typeof p === 'string' && p ? p : undefined;
+}
+/** `s` without trailing `/`. A loop, not `/\/+$/`: that regex backtracks
+ *  quadratically on a long run of slashes (CodeQL js/polynomial-redos). */
+export function trimTrailingSlashes(s) {
+    let end = s.length;
+    while (end > 0 && s.charCodeAt(end - 1) === 47)
+        end -= 1;
+    return s.slice(0, end);
+}
+/** Last path segment, tolerant of both `/` and `\` separators. */
+function basename(p) {
+    const cleaned = trimTrailingSlashes(p.replace(/\\/g, '/'));
+    const idx = cleaned.lastIndexOf('/');
+    return idx >= 0 ? cleaned.slice(idx + 1) : cleaned;
+}
+/** One dedup key per real file: slashes normalized, workspace-relative, so an
+ * absolute write and a relative patch of the same file can never be two rows. */
+function outputPathKey(path) {
+    const cleaned = path.replace(/\\/g, '/').replace(/^\.\//, '');
+    return toWorkspaceRelative(cleaned);
+}
+function truncate(s, max = 60) {
+    const trimmed = s.replace(/\s+/g, ' ').trim();
+    return trimmed.length > max ? trimmed.slice(0, max - 1) + '…' : trimmed;
+}
+/** A call's arguments as an object. A pending call that still streams its
+ * arguments as text has none yet, as a v1 part's `state.input` had none. */
+function inputOf(call) {
+    const input = call.input;
+    return typeof input === 'object' && input !== null && !Array.isArray(input)
+        ? input
+        : {};
+}
+/** A completed call's output text as the tool returned it, without the
+ * bash-only tag stripping `partOutput` (tool/shared/infrastructure.tsx) does —
+ * image_gen/presentation_gen output is a flat JSON payload, never bash's
+ * tagged output. */
+function rawOutputOf(call) {
+    if (call.status !== 'complete')
+        return '';
+    let text = '';
+    for (const item of call.result?.content ?? [])
+        if (item.type === 'text')
+            text += item.text;
+    return text;
+}
+/**
+ * apply_patch's INPUT is an opaque patch blob — no filename lives there.
+ * The per-file paths only exist in its OUTPUT metadata (`toolCallMetadata(call).files`),
+ * the exact shape ApplyPatchTool itself renders from (see PatchFileLite). One
+ * call can touch several files, so this returns one OutputItem per file
+ * actually changed — never a single item named after the tool. Deletions are
+ * skipped: there is nothing left for the user to open.
+ */
+function applyPatchOutputs(call) {
+    const raw = toolCallMetadata(call).files;
+    if (!Array.isArray(raw))
+        return [];
+    const items = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const file = entry;
+        if (file.type === 'delete')
+            continue;
+        const relativePath = typeof file.relativePath === 'string' ? file.relativePath : '';
+        const filePath = typeof file.filePath === 'string' ? file.filePath : '';
+        const path = relativePath || filePath;
+        if (!path)
+            continue;
+        const name = basename(path);
+        if (!name)
+            continue;
+        items.push({ callID: call.call_id, name, path: filePath || path, kind: 'file' });
+    }
+    return items;
+}
+/**
+ * The real artifact name (and path, if known) for image_gen / presentation_gen
+ * calls — never `humanizeToolName(call.name)` ("Image Gen"/"Presentation Gen").
+ * Both components resolve their real name the same way: parse the tool's
+ * OUTPUT payload (parseImageOutput / parsePresentationOutput), falling back to
+ * the request's own input fields, and only then to a truthful generic noun.
+ */
+function createArtifactName(call) {
+    const t = normalizeName(call.name);
+    const input = inputOf(call);
+    if (t === 'image_gen') {
+        const { imagePath } = parseImageOutput(rawOutputOf(call));
+        if (imagePath) {
+            const name = basename(imagePath);
+            if (name)
+                return { name, path: imagePath };
+        }
+        const prompt = typeof input.prompt === 'string' ? input.prompt : '';
+        return { name: prompt ? truncate(prompt) : 'Image' };
+    }
+    if (t === 'presentation_gen') {
+        const parsed = parsePresentationOutput(rawOutputOf(call));
+        const presentationName = parsed?.presentation_name ||
+            (typeof input.presentation_name === 'string' ? input.presentation_name : '');
+        const slideTitle = parsed?.slide_title || (typeof input.slide_title === 'string' ? input.slide_title : '');
+        const path = parsed?.presentation_path;
+        if (presentationName && slideTitle)
+            return { name: `${presentationName}: ${slideTitle}`, path };
+        if (presentationName)
+            return { name: presentationName, path };
+        if (slideTitle)
+            return { name: slideTitle, path };
+        return { name: 'Presentation', path };
+    }
+    // video_gen / show / show_user — unchanged behavior.
+    return { name: getToolPrimaryArg(call) || humanizeToolName(call.name) };
+}
+export function deriveOutputs(calls, opts) {
+    const out = [];
+    // key → index into `out`. Later occurrences of a key REPLACE the row in
+    // place (last-write-wins): a file rewritten in run 5 is the run-5 file, and
+    // showing its run-1 identity was a lie about what the user would open.
+    const seen = new Map();
+    const keyOf = (item) => item.url ?? (item.path ? outputPathKey(item.path) : item.name);
+    const push = (item) => {
+        const key = keyOf(item);
+        const existing = seen.get(key);
+        const isLatest = opts?.latestRun?.has(item.callID) ?? false;
+        if (existing === undefined) {
+            if (isLatest)
+                item.fresh = 'new';
+            seen.set(key, out.length);
+            out.push(item);
+            return;
+        }
+        // Re-produced. The later item wins; if the re-production happened in the
+        // latest run it reads as an update, otherwise it stays unmarked history.
+        if (isLatest)
+            item.fresh = 'updated';
+        out[existing] = item;
+    };
+    for (const call of calls) {
+        // A call that errored produced nothing — surfacing it here would
+        // advertise a file/image/presentation that doesn't exist, and clicking
+        // it would fire `requestFileOpen` on a path that was never written. A
+        // call still 'running'/'pending' hasn't produced anything YET either —
+        // an artifact only exists once the call actually completes.
+        if (call.status !== 'complete')
+            continue;
+        const family = familyForTool(call.name);
+        if (family === 'hidden')
+            continue;
+        if (family === 'edit') {
+            // apply_patch has no name in its input at all — its per-file paths
+            // live only in output metadata, and one call can produce several files.
+            if (toolKind(call.name) === 'apply_patch') {
+                for (const item of applyPatchOutputs(call))
+                    push(item);
+                continue;
+            }
+            // write / edit / morph_edit — a file the agent wrote.
+            const path = filePathOf(call);
+            const name = getToolPrimaryArg(call);
+            if (!name)
+                continue;
+            push({ callID: call.call_id, name, path, kind: 'file' });
+            continue;
+        }
+        if (family === 'create') {
+            // `show` is the agent HANDING OVER what it produced — a running site, a
+            // spreadsheet, a deck. `createArtifactKind` returns null for it, rightly:
+            // showing a file isn't *making* one, and narration must never claim it
+            // did. But Outputs asks a different question — "is there something here I
+            // can open?" — and for a shown artifact the answer is plainly yes.
+            //
+            // One `show` can hand over SEVERAL things at once (the chat renders them
+            // as a carousel), so this yields a list, not a single item. That is the
+            // whole reason a run that produced a CSV, an XLSX, a DOCX, a PPTX and a
+            // PDF in one show showed *none* of them: the payload had no top-level
+            // path, only `items[]`.
+            const shown = showOutputsOf(call);
+            if (shown.length > 0) {
+                for (const item of shown)
+                    push(item);
+                continue;
+            }
+            // image_gen / video_gen / presentation_gen — ask narration.ts's own action
+            // tables whether this specific call made anything, rather than assuming
+            // every call to these tool names did.
+            const kind = createArtifactKind(call);
+            if (!kind)
+                continue;
+            const { name, path } = createArtifactName(call);
+            const presentationName = kind === 'presentation'
+                ? parsePresentationOutput(rawOutputOf(call))?.presentation_name
+                : undefined;
+            push({ callID: call.call_id, name, path, kind, presentationName });
+        }
+    }
+    return out;
+}
+const IMAGE_EXT = /\.(png|jpe?g|gif|webp|svg|avif|heic|bmp)$/i;
+const VIDEO_EXT = /\.(mp4|mov|webm|avi|mkv)$/i;
+const DECK_EXT = /\.(pptx?|key)$/i;
+/** A single shown thing → the row it becomes, or null if there's nothing to open. */
+function showPayloadToOutput(payload, callID) {
+    const url = typeof payload.url === 'string' ? payload.url.trim() : '';
+    if (url && /^https?:\/\//i.test(url)) {
+        return { ...appOutput(url, payload.title, payload.description, callID), shown: true };
+    }
+    const path = typeof payload.path === 'string' ? payload.path.trim() : '';
+    // No path and no URL: a string, an inline chunk of text, an error message.
+    // Real, but not a thing you can open — and a row you can't click is worse
+    // than no row.
+    if (!path)
+        return null;
+    const name = basename(path) || path;
+    const title = typeof payload.title === 'string' && payload.title.trim() ? payload.title.trim() : undefined;
+    const description = typeof payload.description === 'string' && payload.description.trim()
+        ? payload.description.trim()
+        : undefined;
+    // The kind drives the row's glyph AND which renderer opens: a sheet must open
+    // as a grid, not as a wall of text.
+    const kind = IMAGE_EXT.test(name)
+        ? 'image'
+        : VIDEO_EXT.test(name)
+            ? 'video'
+            : DECK_EXT.test(name)
+                ? 'presentation'
+                : 'file';
+    return { callID, name, title, description, path, kind, shown: true };
+}
+/**
+ * Everything a single `show` call hands over.
+ *
+ * `show` is how the agent says "here is what you asked for", and it's the only
+ * signal we get for files it produced with a *script* rather than by writing
+ * them directly — a `.pdf` from pandoc, an `.xlsx` from python, a `.csv` from a
+ * query. Those are never `write` calls, so without this they sit on disk and
+ * appear nowhere.
+ *
+ * Crucially, ONE show can carry MANY things: the agent generates five files and
+ * shows them together (the chat renders that as a carousel). The payload then
+ * has no top-level `path` at all — only `items[]` — which is exactly why a run
+ * that produced a CSV, XLSX, DOCX, PPTX and PDF surfaced none of them.
+ */
+function showOutputsOf(call) {
+    const tool = normalizeName(call.name);
+    if (tool !== 'show' && tool !== 'show_user')
+        return [];
+    const input = inputOf(call);
+    const items = parseShowItems(input.items);
+    if (items.length > 0) {
+        return items
+            .map((item) => showPayloadToOutput(item ?? {}, call.call_id))
+            .filter((item) => item !== null);
+    }
+    const single = showPayloadToOutput(input, call.call_id);
+    return single ? [single] : [];
+}
+/**
+ * `items` reaches us as EITHER an array or a JSON string — the model serializes
+ * it, and nothing downstream normalizes that before it lands in the call's `input`.
+ * `ShowTool` handles both (`typeof raw === 'string' ? JSON.parse(raw) : raw`),
+ * which is why the chat rendered all five files perfectly while Outputs showed
+ * none of them: an `Array.isArray` check sees a string and quietly moves on.
+ */
+function parseShowItems(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (typeof raw !== 'string')
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        // Half-streamed or malformed JSON. Show nothing rather than throw and take
+        // the whole panel down with it.
+        return [];
+    }
+}
+/**
+ * A running app, if this call is handing one over.
+ *
+ * Named for the user's word, not the machine's: they asked for "a landing page"
+ * or "a dashboard", and what they get back is a thing they can open. The port
+ * number is the fallback name, never the first choice — `localhost:3000` means
+ * nothing to someone who has never run a server.
+ */
+function appOutput(url, rawTitle, rawDescription, callID) {
+    const title = typeof rawTitle === 'string' ? rawTitle.trim() : '';
+    const description = typeof rawDescription === 'string' && rawDescription.trim() ? rawDescription.trim() : undefined;
+    let fallback = url;
+    try {
+        const parsed = new URL(url);
+        fallback = parsed.port ? `${parsed.hostname}:${parsed.port}` : parsed.hostname;
+    }
+    catch {
+        // A URL we can't parse still opens fine — just show it as-is.
+    }
+    return {
+        callID,
+        name: title || fallback,
+        title: title || undefined,
+        description,
+        kind: 'app',
+        url,
+    };
+}
+/**
+ * Collapse protocol/`www.`/trailing-slash differences so the same page
+ * fetched two different ways (http vs https, with vs without `www.`, with
+ * vs without a trailing slash) normalizes to one dedup key. Never shown to
+ * the user — `web[].label` is always a title or a domain (see `webSourceOf`).
+ */
+function normalizeUrl(raw) {
+    return trimTrailingSlashes(raw
+        .trim()
+        .replace(/^[a-z][a-z0-9+.-]*:\/\//i, '')
+        .replace(/^www\./i, '')
+        .toLowerCase());
+}
+/** A page title extracted from a `web_fetch`/`webfetch` call's own HTML
+ * output, reusing the exact same parsing WebFetchTool itself uses — never a
+ * second, divergent HTML-sniffing implementation. `undefined` for non-HTML
+ * output (plain text/markdown fetches carry no separate title). */
+function titleFromFetchOutput(call) {
+    const output = rawOutputOf(call);
+    const input = inputOf(call);
+    const format = typeof input.format === 'string' ? input.format : '';
+    const isHtml = format === 'html' || (!format && looksLikeHtml(output));
+    if (!isHtml || !output)
+        return undefined;
+    return extractReadableHtml(output).title || undefined;
+}
+/**
+ * The real-world pages a `web`-family call is "about" — the identities
+ * `deriveContext` dedups on and the truthful labels it shows.
+ *
+ * - `web_fetch`/`scrape_webpage`-style calls target one URL (`input.url`).
+ * - `web_search`-style calls have no URL of their own; their OUTPUT is the
+ *   search-results payload, and EVERY parsed result is a page the search
+ *   surfaced — returning only the first is how "searched 10 sources" used to
+ *   collapse to one context entry. A search whose exact result the agent
+ *   later fetches still dedups: both resolve to the same normalized key.
+ * - A search with no parseable result falls back to its query text.
+ */
+function webSourcesOf(call) {
+    const input = inputOf(call);
+    if (toolKind(call.name) === 'web_search') {
+        const results = [];
+        for (const parsed of parseWebSearchOutput(rawOutputOf(call))) {
+            for (const source of parsed.sources) {
+                if (source.url)
+                    results.push(source);
+            }
+        }
+        if (results.length > 0) {
+            return results.map((r) => ({ url: r.url, label: r.title || wsDomain(r.url) }));
+        }
+        // No results to name it with, so the query itself is the label — which
+        // means it has to be readable. Models write engine syntax (`site:x foo`);
+        // see `humanizeSearchQuery`.
+        const query = humanizeSearchQuery(typeof input.query === 'string' ? input.query : '');
+        return query ? [{ url: '', label: query }] : [];
+    }
+    // web_fetch / webfetch / scrape_webpage / scrapewebpage — identified by
+    // the page it targeted. The label is the real page title when the fetch's
+    // own output is parseable HTML; otherwise the domain — never the raw URL.
+    const url = typeof input.url === 'string' ? input.url : '';
+    if (!url)
+        return [];
+    return [{ url, label: titleFromFetchOutput(call) || wsDomain(url) }];
+}
+export function deriveContext(calls) {
+    const files = [];
+    const web = [];
+    const tools = [];
+    const seenFiles = new Set();
+    const seenWeb = new Set();
+    const seenTools = new Map();
+    for (const call of calls) {
+        // A failed call didn't successfully look at anything — it must not
+        // surface as something the agent inspected either (a failed read never
+        // actually saw the file's contents, a failed fetch never saw the page).
+        if (call.status === 'error')
+            continue;
+        const family = familyForTool(call.name);
+        if (family === 'hidden')
+            continue; // context-engine bookkeeping — never shown
+        if (toolKind(call.name) === 'read') {
+            const path = filePathOf(call) ?? getToolPrimaryArg(call);
+            if (!path || seenFiles.has(path))
+                continue;
+            seenFiles.add(path);
+            files.push({
+                callID: call.call_id,
+                label: getToolPrimaryArg(call) || path,
+                kind: 'file',
+                path,
+            });
+            continue;
+        }
+        // A write is something the agent MADE, not something it looked at —
+        // Outputs owns it, not Context, even though it also "touches" a file.
+        // `create` (image_gen/video_gen/presentation_gen/show/show_user) is the
+        // same story — an image/video/presentation/result the agent produced —
+        // so it gets the exact same treatment, or it double-counts: once in
+        // Outputs, again here as e.g. "Image Gen".
+        if (family === 'edit' || family === 'create')
+            continue;
+        if (family === 'web') {
+            for (const source of webSourcesOf(call)) {
+                // Dedup by the normalized URL when one is known (a search that
+                // surfaced the exact page a later fetch visited collapses here);
+                // otherwise fall back to the label itself (a bare query has no URL).
+                const key = source.url ? normalizeUrl(source.url) : `q:${source.label}`;
+                if (seenWeb.has(key))
+                    continue;
+                seenWeb.add(key);
+                web.push({
+                    callID: call.call_id,
+                    label: source.label,
+                    kind: 'web',
+                    url: source.url || undefined,
+                });
+            }
+            continue;
+        }
+        // Everything else is recorded once, by name, as "a tool that was used".
+        // Every call to that tool rides along on `calls` so the UI can show what
+        // the tool actually did when the user asks — one chip, all its calls.
+        //
+        // The name comes from `contextLabelForTool`, not `humanizeToolName`: a
+        // family whose tools have several spellings (memory / memory_search /
+        // get_mem / mem_search / ltm_search) must fold into ONE row, and the
+        // by-label `seenTools` map below is what folds it — so the fold is only
+        // as good as the label. `narration.ts` owns that mapping, keyed on family.
+        const label = contextLabelForTool(call.name);
+        const seen = seenTools.get(label);
+        if (seen) {
+            (seen.calls ??= []).push(call);
+            continue;
+        }
+        const item = { callID: call.call_id, label, kind: 'tool', calls: [call] };
+        seenTools.set(label, item);
+        tools.push(item);
+    }
+    return { files, web, tools };
+}

package/dist/session/panel/shared/latest-run.d.ts

@@ -0,0 +1,9 @@
+/**
+ * "The latest run" = everything at and after the LAST user message. Every card
+ * in the panel derives from the whole thread's calls; this slice is what lets
+ * them say which of it is fresh — new outputs first, honest per-run duration —
+ * without changing what they include.
+ */
+import type { SessionLogMessage } from '@kortix/sdk';
+export declare function latestRunMessages(messages: SessionLogMessage[] | undefined): SessionLogMessage[];
+export declare function latestRunCallIds(messages: SessionLogMessage[] | undefined): Set<string>;

package/dist/session/panel/shared/latest-run.js

@@ -0,0 +1,22 @@
+/**
+ * "The latest run" = everything at and after the LAST user message. Every card
+ * in the panel derives from the whole thread's calls; this slice is what lets
+ * them say which of it is fresh — new outputs first, honest per-run duration —
+ * without changing what they include.
+ */
+import { collectAllToolCalls } from './collect-tool-parts.js';
+export function latestRunMessages(messages) {
+    if (!messages || messages.length === 0)
+        return [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === 'user')
+            return messages.slice(i);
+    }
+    return messages;
+}
+export function latestRunCallIds(messages) {
+    const ids = new Set();
+    for (const call of collectAllToolCalls(latestRunMessages(messages)))
+        ids.add(call.call_id);
+    return ids;
+}

package/dist/session/panel/shared/output-priority.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The order a person cares about — not the order the machine made things in.
+ *
+ * A run that produces a report generates the report AND the dozen files it took
+ * to build it. Chronological order buries the answer under the scaffolding:
+ * someone asks for their profile as a PDF and the panel opens with `globals.css`,
+ * `layout.tsx`, `Navbar.tsx`. Every one of those rows is truthful and none of
+ * them is what the user came for.
+ *
+ * So user-facing document kinds lead — the spreadsheet, the write-up, the deck,
+ * the page — media follows, source code goes last. Nothing is hidden — hiding
+ * would be a lie about what the agent did — but the thing they asked for is the
+ * thing they see first, and the first row is always safe to click.
+ */
+import type { OutputItem } from './derive-panels.js';
+export declare function outputRank(output: Pick<OutputItem, 'name' | 'kind' | 'shown'>): number;
+/** Scaffolding: the making-of, not the thing — ranks in the last bucket and
+ *  folds behind the "N more" row whenever a real deliverable exists. */
+export declare function isScaffoldingOutput(output: Pick<OutputItem, 'name' | 'kind' | 'shown'>): boolean;
+/** The kind a person recognizes — the row's right-hand whisper. Never an
+ * extension, never a path (W3). */
+export declare function deliverableKindLabel(output: Pick<OutputItem, 'name' | 'kind'>): string;
+/**
+ * Sort by what the user came for. Stable: files of equal rank keep the order the
+ * agent produced them in, so a run that wrote ten components still reads as the
+ * sequence it happened in.
+ */
+export declare function sortOutputs(outputs: OutputItem[]): OutputItem[];
+/**
+ * THE deliverable — the one thing worth presenting unprompted when a run
+ * finishes (W2). The run that just finished owns the payoff: a fresh
+ * deliverable always beats a higher-ranked stale one, or finishing a quick
+ * .docx would auto-open last week's report.pdf. Within each freshness group,
+ * a live app beats every file (it's the thing the user asked for by name) and
+ * files fall back to the same order the Outputs card shows. Stale-only input
+ * still returns something — the chip-consume path may run after freshness
+ * context is gone. Null when nothing is actually openable — auto-presenting a
+ * dead row would open a detail that can't render anything.
+ */
+export declare function selectPrimaryDeliverable(apps: OutputItem[], files: OutputItem[]): OutputItem | null;