@nxisai/agent-harness 0.7.0 → 0.8.0

package/src/harness/records.ts

@@ -0,0 +1,237 @@
+/**
+ * The records a read tool returned, and what each one says as plain facts.
+ *
+ * A typed-retrieval result reaches the harness in many wrappings: structured
+ * content, JSON text, or the whole response serialized again by an extension
+ * in the loop. {@link extractRecords} digs the record list out of any of them.
+ * {@link recordFacts} then reads one schema.org record into the facts a
+ * person compares businesses by: whether it is open now, its rating, what it
+ * does, what reviewers said. Those facts are what a recommendation may cite,
+ * and nothing else.
+ *
+ * @module
+ */
+import type { ModelContextToolResponse } from '../types.js';
+
+type Obj = Record<string, unknown>;
+
+const isObj = (v: unknown): v is Obj => !!v && typeof v === 'object' && !Array.isArray(v);
+
+/**
+ * The records in a read tool's response, wherever they are.
+ *
+ * @param res - The response, or its text.
+ * @returns The records, as the server sent them; empty when there are none.
+ */
+export function extractRecords(res: ModelContextToolResponse | string | null | undefined): Obj[] {
+  const sources: unknown[] = [];
+  // Every candidate payload, unwrapping response envelopes: structured
+  // content and each text part, parsed as JSON, possibly encoded twice.
+  const visit = (raw: unknown, depth = 0): void => {
+    if (raw == null || depth > 5) return;
+    if (typeof raw === 'string') {
+      const t = raw.trim();
+      if (!t) return;
+      try {
+        visit(JSON.parse(t), depth + 1);
+      } catch {
+        // Plain text: nothing to extract.
+      }
+      return;
+    }
+    if (typeof raw !== 'object') return;
+    sources.push(raw);
+    const v = raw as Obj;
+    if (v.structuredContent != null) visit(v.structuredContent, depth + 1);
+    if (Array.isArray(v.content)) {
+      for (const c of v.content) if (isObj(c)) visit(c.text, depth + 1);
+    }
+  };
+  visit(res);
+  for (const data of sources) {
+    const items = itemsFrom(data);
+    if (items.length) return items;
+  }
+  return [];
+}
+
+/** The record array within one parsed payload. */
+function itemsFrom(data: unknown): Obj[] {
+  const objs = (arr: unknown[]) => arr.filter(isObj);
+  if (Array.isArray(data)) return objs(data);
+  if (!isObj(data)) return [];
+  for (const key of ['results', 'types', 'items', 'entities', 'data']) {
+    if (Array.isArray(data[key])) return objs(data[key] as unknown[]);
+  }
+  if (isObj(data.result)) return [data.result];
+  if (data['@id'] != null || data['@type'] != null || data.name != null) return [data];
+  return [];
+}
+
+// ── Opening hours ───────────────────────────────────────────────────────────
+
+const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const SHORT: Record<string, number> = { su: 0, mo: 1, tu: 2, we: 3, th: 4, fr: 5, sa: 6 };
+
+/** Minutes after midnight: "07:30" → 450. */
+function minutes(hhmm: unknown): number | null {
+  const m = String(hhmm ?? '').match(/^(\d{1,2}):(\d{2})/);
+  return m ? Number(m[1]) * 60 + Number(m[2]) : null;
+}
+
+/** "7am", "5:30pm", "noon". */
+function clock(mins: number): string {
+  const h = Math.floor(mins / 60) % 24;
+  const m = mins % 60;
+  if (h === 12 && m === 0) return 'noon';
+  const suffix = h < 12 ? 'am' : 'pm';
+  const h12 = h % 12 || 12;
+  return m ? `${h12}:${String(m).padStart(2, '0')}${suffix}` : `${h12}${suffix}`;
+}
+
+/** Each day's opening spans, [opens, closes] in minutes; index 0 is Sunday. */
+function weekOf(entity: Obj): [number, number][][] | null {
+  const week: [number, number][][] = DAYS.map(() => []);
+  let any = false;
+  const spec = entity.openingHoursSpecification;
+  for (const s of Array.isArray(spec) ? spec : spec ? [spec] : []) {
+    if (!isObj(s)) continue;
+    const opens = minutes(s.opens);
+    const closes = minutes(s.closes);
+    if (opens === null || closes === null) continue;
+    const days = Array.isArray(s.dayOfWeek) ? s.dayOfWeek : [s.dayOfWeek];
+    for (const d of days) {
+      const i = DAYS.findIndex((name) => String(d ?? '').replace(/^.*[/#]/, '').toLowerCase() === name.toLowerCase());
+      if (i >= 0) {
+        week[i].push([opens, closes]);
+        any = true;
+      }
+    }
+  }
+  // The compact form: "Mo-Fr 07:00-17:00", "Sa 08:00-13:00", "Mo-Su 00:00-23:59".
+  const compact = entity.openingHours;
+  for (const line of Array.isArray(compact) ? compact : compact ? String(compact).split(/[;,](?=\s*[A-Z][a-z])/) : []) {
+    const m = String(line).trim().match(/^([A-Za-z]{2})(?:-([A-Za-z]{2}))?\s+(\d{1,2}:\d{2})-(\d{1,2}:\d{2})$/);
+    if (!m) continue;
+    const from = SHORT[m[1].toLowerCase()];
+    const to = m[2] ? SHORT[m[2].toLowerCase()] : from;
+    if (from === undefined || to === undefined) continue;
+    for (let d = from; ; d = (d + 1) % 7) {
+      week[d].push([minutes(m[3])!, minutes(m[4])!]);
+      any = true;
+      if (d === to) break;
+    }
+  }
+  return any ? week : null;
+}
+
+/** Whether a business is open at a time, and how a visitor should read it. */
+export interface OpenStatus {
+  open: boolean;
+  /** "Open now · 24/7", "Open now · until 5pm", "Opens 7am", "Opens Mon 7am". */
+  label: string;
+  /** Open every hour of every day. */
+  always: boolean;
+}
+
+/**
+ * Whether a record's business is open at `now`, read from its opening hours.
+ *
+ * @returns Null when the record states no hours this can read.
+ */
+export function openStatus(entity: Obj, now: Date = new Date()): OpenStatus | null {
+  const week = weekOf(entity);
+  if (!week) return null;
+  const always = week.every((spans) => spans.some(([o, c]) => o === 0 && c >= 23 * 60 + 59));
+  if (always) return { open: true, label: 'Open now · 24/7', always: true };
+  const day = now.getDay();
+  const at = now.getHours() * 60 + now.getMinutes();
+  const current = week[day].find(([o, c]) => at >= o && at < c);
+  if (current) return { open: true, label: `Open now · until ${clock(current[1])}`, always: false };
+  // The next opening, today later or on a following day.
+  for (let ahead = 0; ahead < 7; ahead++) {
+    const d = (day + ahead) % 7;
+    const next = week[d].filter(([o]) => ahead > 0 || o > at).sort((a, b) => a[0] - b[0])[0];
+    if (!next) continue;
+    // Today or tomorrow reads as a time alone; further off, with the day.
+    return { open: false, label: ahead <= 1 ? `Opens ${clock(next[0])}` : `Opens ${DAYS[d].slice(0, 3)} ${clock(next[0])}`, always: false };
+  }
+  return { open: false, label: 'Closed', always: false };
+}
+
+// ── Facts ───────────────────────────────────────────────────────────────────
+
+/** One record, as the facts a visitor compares by. */
+export interface RecordFacts {
+  /** Its `@id`, else its name: what a pick refers to. */
+  key: string;
+  name: string;
+  type?: string;
+  status?: OpenStatus;
+  rating?: number;
+  reviewCount?: number;
+  phone?: string;
+  /** Services it offers, by name, with their one-line descriptions. */
+  services: { name: string; description?: string }[];
+  /** What it says it specializes in. */
+  knows: string[];
+  description?: string;
+  /** What reviewers wrote, with who wrote it. */
+  reviews: { text: string; author?: string }[];
+  /** The year it was founded. */
+  since?: number;
+  /** ZIP codes or places it serves. */
+  area: string[];
+}
+
+const str = (v: unknown): string => (v == null ? '' : String(Array.isArray(v) ? v[0] : v)).trim();
+const list = (v: unknown): unknown[] => (Array.isArray(v) ? v : v == null ? [] : [v]);
+
+/** A schema.org record as plain facts. */
+export function recordFacts(entity: Obj, now: Date = new Date()): RecordFacts {
+  const name = str(entity.name ?? entity.title ?? entity.headline) || 'This result';
+  const rating = isObj(entity.aggregateRating) ? Number(entity.aggregateRating.ratingValue) : NaN;
+  const count = isObj(entity.aggregateRating) ? Number(entity.aggregateRating.reviewCount ?? entity.aggregateRating.ratingCount) : NaN;
+  const services = list(entity.makesOffer)
+    .map((o) => (isObj(o) && isObj(o.itemOffered) ? o.itemOffered : isObj(o) ? o : null))
+    .filter(isObj)
+    .map((s) => ({ name: str(s.name), description: str(s.description) || undefined }))
+    .filter((s) => s.name);
+  const reviews = list(entity.review)
+    .filter(isObj)
+    .map((r) => ({ text: str(r.reviewBody ?? r.description), author: isObj(r.author) ? str(r.author.name) || undefined : str(r.author) || undefined }))
+    .filter((r) => r.text);
+  const founded = str(entity.foundingDate).match(/^(\d{4})/);
+  const status = openStatus(entity, now) ?? undefined;
+  return {
+    key: str(entity['@id']) || name,
+    name,
+    type: str(entity['@type']).replace(/^.*[/#]/, '') || undefined,
+    ...(status ? { status } : {}),
+    ...(Number.isFinite(rating) ? { rating } : {}),
+    ...(Number.isFinite(count) ? { reviewCount: count } : {}),
+    ...(str(entity.telephone) ? { phone: str(entity.telephone) } : {}),
+    services,
+    knows: list(entity.knowsAbout).map(str).filter(Boolean),
+    ...(str(entity.description) ? { description: str(entity.description) } : {}),
+    reviews,
+    ...(founded ? { since: Number(founded[1]) } : {}),
+    area: list(entity.areaServed).map((a) => (isObj(a) ? str(a.name ?? a.postalCode) : str(a))).filter(Boolean),
+  };
+}
+
+/** The facts as lines a model reads, and a recommendation is checked against. */
+export function factLines(f: RecordFacts): string[] {
+  const lines: string[] = [];
+  if (f.type) lines.push(f.type);
+  if (f.status) lines.push(f.status.label);
+  if (f.rating !== undefined) lines.push(`Rated ${f.rating}${f.reviewCount !== undefined ? ` from ${f.reviewCount} reviews` : ''}`);
+  if (f.since) lines.push(`In business since ${f.since}`);
+  if (f.services.length) lines.push(`Services: ${f.services.map((s) => (s.description ? `${s.name} (${s.description})` : s.name)).join('; ')}`);
+  if (f.knows.length) lines.push(`Specializes in: ${f.knows.join(', ')}`);
+  if (f.description) lines.push(f.description);
+  for (const r of f.reviews.slice(0, 2)) lines.push(`Review: "${r.text}"${r.author ? ` (${r.author})` : ''}`);
+  if (f.area.length) lines.push(`Serves: ${f.area.join(', ')}`);
+  if (f.phone) lines.push(`Phone: ${f.phone}`);
+  return lines;
+}

package/src/harness/renderer.ts

@@ -13,6 +13,7 @@ import type { ModelContextToolInfo, ModelContextToolResponse } from '../types.js
 import type { ClarificationPlan } from './plan.js';
 import type { Resolution, Slot } from './slots.js';
 import type { AgentStep } from './steps.js';
+import type { ResultPick } from './recommend.js';
 
 /** One tool call and its response, for renderers that show their work. */
 export interface TraceEntry {
@@ -81,6 +82,16 @@ export interface StreamingBubble {
   finalize(text: string): void;
 }
 
+/** What the harness adds to a search's results. */
+export interface ResultsExtra {
+  /**
+   * The record the model recommends, with reasons the record backs. Absent
+   * when there was one result, the model gave no backed reason, or
+   * recommendations are off: show the results as a list.
+   */
+  pick?: ResultPick;
+}
+
 /** A write tool with every value resolved, awaiting a human press. */
 export interface ConfirmRequest {
   /** The tool about to be called. */
@@ -162,7 +173,7 @@ export interface HarnessRenderer {
   confirm(req: ConfirmRequest): void;
 
   /** A read tool returned records. */
-  results(tool: ModelContextToolInfo, res: ModelContextToolResponse): void;
+  results(tool: ModelContextToolInfo, res: ModelContextToolResponse, extra?: ResultsExtra): void;
   /** A write tool succeeded. */
   detail(tool: ModelContextToolInfo, values: Record<string, unknown>, text: string): void;
   /** A tool failed, or returned something that cannot be rendered. */

package/src/harness/tools/action-tools.ts

@@ -520,6 +520,24 @@ export function formOptions(tool: ModelContextToolInfo, values: Record<string, u
   return out;
 }
 
+/**
+ * The site forms that can be sent to a business, by its name: the site tools
+ * on this page whose choices include it.
+ *
+ * @returns Each form's tool name and what it is called ("quote form").
+ */
+export function formsFor(name: string): { tool: string; noun: string }[] {
+  const wanted = name.trim().toLowerCase();
+  if (!wanted) return [];
+  const out: { tool: string; noun: string }[] = [];
+  for (const [toolName, t] of built) {
+    if (t.choices?.some((c) => c.toLowerCase() === wanted)) {
+      out.push({ tool: toolName, noun: withoutSiteSuffix(toolName).replace(/[_-]+/g, ' ').trim().toLowerCase() });
+    }
+  }
+  return out;
+}
+
 /** An option that only asks to choose: "Select…", "Choose a service…". */
 export const isPlaceholder = (value: string): boolean => /^\s*(select|choose|pick)\b/i.test(value) || /…\s*$|\.\.\.\s*$/.test(value);
 

package/src/harness/tools/site-pages.ts

@@ -194,7 +194,7 @@ export function pageForEntity(entity: Obj, pages: SitePage[], origin: string): S
 /**
  * The page an id formed from it names, or null.
  *
- * nxis-sdn-api forms a page entity's id as the page URL plus a fragment, so the page is the id with
+ * The NxisAI index forms a page entity's id as the page URL plus a fragment, so the page is the id with
  * the fragment removed.
  */
 function pageOfId(id: string | undefined, origin: string): string | null {

package/src/index.ts

@@ -60,6 +60,7 @@ export type {
   HarnessRenderer,
   AskRequest,
   ConfirmRequest,
+  ResultsExtra,
   StreamingBubble,
 } from './harness/renderer.js';
 
@@ -172,6 +173,8 @@ export {
 } from './harness/tools/pending-action.js';
 export type { PendingAction, PendingVisit } from './harness/tools/pending-action.js';
 export { findEmbeddedAction, loadSiteActions, parseAction, type EmbeddedActionQuery } from './harness/tools/site-actions.js';
+export { extractRecords, openStatus, recordFacts, factLines, type OpenStatus, type RecordFacts } from './harness/records.js';
+export { recommend, grounded, RECOMMEND_TOOL, type ResultPick, type RecommendRequest } from './harness/recommend.js';
 export type { ConnectResult, ConnectOptions, SiteActionsOptions } from './harness/tools/source.js';
 export type { BridgeOptions } from './harness/tools/bridge.js';
 

package/src/ui/agent-fullscreen.ts

@@ -43,6 +43,7 @@ import { connectTools } from '../harness/tools/source.js';
 import {
   chooserOf,
   formOptions,
+  formsFor,
   handoffFor,
   isSiteTool,
   withoutSiteSuffix,
@@ -59,6 +60,9 @@ import {
   type ActionItem,
   type ActionStep,
 } from './action-card.js';
+import { resultsAnswer, RESULTS_ANSWER_CSS, type AnswerCard } from './result-pick.js';
+import { extractRecords, openStatus, recordFacts } from '../harness/records.js';
+import type { ResultPick } from '../harness/recommend.js';
 import { resumePendingAction } from '../harness/tools/resume.js';
 import { savePendingVisit, setConversationSource, takePendingVisit } from '../harness/tools/pending-action.js';
 import { pageForEntity, type SitePage } from '../harness/tools/site-pages.js';
@@ -329,6 +333,14 @@ interface ResultCard {
   id?: string;
   /** The page on this site the record came from, when it can be told. */
   page?: { url: string; label: string };
+  /** The rating and how many reviews it rests on. */
+  stars?: number;
+  reviews?: number;
+  /** Open or closed when the search ran: "Open now · 24/7", "Opens 7am". */
+  status?: { open: boolean; label: string };
+  phone?: string;
+  /** What the record states, short, for comparing it. */
+  facts?: string[];
 }
 
 type ThreadItem =
@@ -337,7 +349,7 @@ type ThreadItem =
   | { kind: 'trace'; name: string; args: Record<string, unknown>; text: string; isError: boolean; count?: number }
   | { kind: 'route'; agent: string; via: string }
   | { kind: 'detail'; title: string; note: string; rows: DetailRow[] }
-  | { kind: 'results'; title: string; note: string; cards: ResultCard[] }
+  | { kind: 'results'; title: string; note: string; cards: ResultCard[]; pick?: ResultPick }
   | { kind: 'metrics'; rounds: MetricsRound[] }
   | { kind: 'form' }
   /** A turn the person called off. Kept so the thread explains its own gap. */
@@ -1646,9 +1658,9 @@ class NxisAgentFullscreen extends HTMLElement {
       ask: (req) => (this._usesCard(req.tool) ? this._cardAsk(req) : this._renderAsk(req)),
       confirm: (req) => (this._usesCard(req.tool) ? this._cardConfirm(req) : this._renderConfirm(req)),
       left: (tool, destination) => this._cardLeft(tool, destination),
-      results: (tool, res) => {
+      results: (tool, res, extra) => {
         const conv = this._active();
-        const item = this._buildResultsItem(tool, res);
+        const item = this._buildResultsItem(tool, res, extra?.pick);
         // A read that answers in words — "you are on the home page", "already open" — has no records
         // to draw, and an empty result card reading "No results found." contradicts the answer it
         // just gave. Say what it said.
@@ -2582,61 +2594,9 @@ class NxisAgentFullscreen extends HTMLElement {
    * return the first that yields records. Shapes covered: query → results[],
    * list_types → types[], get → result{}, or a bare entity/array. */
   private _extractItems(res: ModelContextToolResponse | string | null): Record<string, unknown>[] {
-    const sources: unknown[] = [];
-    // Collect every candidate payload, recursively unwrapping tool-response
-    // envelopes. `res` can be an object, a JSON string, or (with a WebMCP browser
-    // extension in the loop) the whole `{content, structuredContent}` envelope
-    // serialized to a string, possibly more than once. Diving into both
-    // `structuredContent` and each `content[].text` covers all of them.
-    const visit = (raw: unknown, depth = 0): void => {
-      if (raw == null || depth > 5) return;
-      const val: unknown = raw;
-      if (typeof val === 'string') {
-        const t = val.trim();
-        if (!t) return;
-        let parsed: unknown;
-        try {
-          parsed = JSON.parse(t);
-        } catch {
-          return; // plain (non-JSON) text — nothing to extract
-        }
-        // Parsed value may itself be an object/array OR another JSON string
-        // (double-encoded); recurse either way.
-        return visit(parsed, depth + 1);
-      }
-      if (!val || typeof val !== 'object') return;
-      sources.push(val);
-      const v = val as Record<string, unknown>;
-      if (v.structuredContent != null) visit(v.structuredContent, depth + 1);
-      if (Array.isArray(v.content)) {
-        for (const c of v.content) {
-          if (c && typeof c === 'object') visit((c as Record<string, unknown>).text, depth + 1);
-        }
-      }
-    };
-    visit(res);
-
-    for (const data of sources) {
-      const items = this._itemsFrom(data);
-      if (items.length) return items;
-    }
-    console.warn('[nxis-mcp] no items extracted from tool result', { sourcesTried: sources.length, res });
-    return [];
-  }
-
-  /** Find the record array within one parsed payload. */
-  private _itemsFrom(data: unknown): Record<string, unknown>[] {
-    const objs = (arr: unknown[]) =>
-      arr.filter((x) => x && typeof x === 'object') as Record<string, unknown>[];
-    if (Array.isArray(data)) return objs(data);
-    if (!data || typeof data !== 'object') return [];
-    const d = data as Record<string, unknown>;
-    for (const key of ['results', 'types', 'items', 'entities', 'data']) {
-      if (Array.isArray(d[key])) return objs(d[key] as unknown[]);
-    }
-    if (d.result && typeof d.result === 'object') return [d.result as Record<string, unknown>];
-    if (d['@id'] != null || d['@type'] != null || d.name != null) return [d];
-    return [];
+    const items = extractRecords(res);
+    if (!items.length) console.warn('[nxis-mcp] no items extracted from tool result', { res });
+    return items;
   }
 
   /** Build a display card from a single record (a JSON-LD entity or a type row). */
@@ -2704,19 +2664,82 @@ class NxisAgentFullscreen extends HTMLElement {
     const id = entity['@id'] != null ? str(entity['@id']) : undefined;
     const found = pageForEntity(entity, this._sitePages, location.origin);
     const page = found ? { url: found.url, label: found.name } : undefined;
-    return { title, type, rating, emergency, sub, rows, id, ...(page ? { page } : {}) };
+
+    // What the answer view compares by, beyond the rating and hours its heading already shows.
+    const facts = recordFacts(entity);
+    const status = openStatus(entity) ?? undefined;
+    const lines = [
+      facts.services.length ? facts.services.slice(0, 3).map((x) => x.name).join(', ') : facts.knows.slice(0, 3).join(', '),
+      facts.since ? `In business since ${facts.since}` : '',
+      facts.reviews[0] ? `\u201c${facts.reviews[0].text}\u201d${facts.reviews[0].author ? ` \u2014 ${facts.reviews[0].author}` : ''}` : '',
+    ].filter((l): l is string => !!l);
+    return {
+      title,
+      type,
+      rating,
+      emergency,
+      sub,
+      rows,
+      id,
+      ...(page ? { page } : {}),
+      ...(facts.rating !== undefined ? { stars: facts.rating } : {}),
+      ...(facts.reviewCount !== undefined ? { reviews: facts.reviewCount } : {}),
+      ...(status ? { status: { open: status.open, label: status.label } } : {}),
+      ...(facts.phone ? { phone: facts.phone } : {}),
+      facts: lines,
+    };
   }
 
   private _buildResultsItem(
     tool: ModelContextToolInfo,
     res: ModelContextToolResponse,
+    pick?: ResultPick,
   ): Extract<ThreadItem, { kind: 'results' }> {
     const items = this._extractItems(res);
     const cards = items.slice(0, 12).map((e) => this._entityCard(e));
     const note = !cards.length
       ? 'No results found.'
       : `${cards.length} result${cards.length === 1 ? '' : 's'}`;
-    return { kind: 'results', title: humanize(tool.name), note, cards };
+    return { kind: 'results', title: humanize(tool.name), note, cards, ...(pick && pick.index < cards.length ? { pick } : {}) };
+  }
+
+  /**
+   * Results as an answer: the recommended pick with its reasons and the others
+   * to compare, or a short list that opens per result. Records of things
+   * only: a listing of types or counts keeps the plain cards.
+   */
+  private _answerEl(item: Extract<ThreadItem, { kind: 'results' }>): HTMLElement | null {
+    // Records of things: a pick, or at least one result with a rating, hours, a phone or a page.
+    // A sparse record beside them (an index entry with only a name) still shows, by name.
+    const things = item.cards.filter((c) => c.stars !== undefined || c.status || c.phone || c.page);
+    if (!item.pick && !things.length) return null;
+    const cards: AnswerCard[] = item.cards.map((c) => {
+      const form = formsFor(c.title)[0];
+      const quote = form && /quote/.test(form.noun);
+      return {
+        title: c.title,
+        stars: c.stars,
+        reviews: c.reviews,
+        status: c.status,
+        phone: c.phone,
+        page: c.page,
+        facts: c.facts ?? [],
+        ...(form
+          ? {
+              form: quote
+                ? { label: 'Get a quote', message: `Get a quote from ${c.title}` }
+                : { label: `Use their ${form.noun}`, message: `Start the ${form.noun} for ${c.title}` },
+            }
+          : {}),
+      };
+    });
+    return resultsAnswer(cards, item.pick, {
+      ask: (text) => {
+        if (this._turnActive) return;
+        this._els.input.value = text;
+        void this._onSend();
+      },
+    });
   }
 
   /** Feature-card pattern: tinted icon chip, tags, tight Manrope headline, one
@@ -2777,9 +2800,12 @@ class NxisAgentFullscreen extends HTMLElement {
    * surface; a2ui="a2ui-results" opts this element back into it for comparison.
    */
   private _resultsEl(item: Extract<ThreadItem, { kind: 'results' }>): HTMLElement {
-    return this.getAttribute('a2ui') === 'a2ui-results'
-      ? this._resultsElA2ui(item)
-      : this._resultsElLegacy(item);
+    if (this.getAttribute('a2ui') === 'a2ui-results') return this._resultsElA2ui(item);
+    if (!this._classicPrompts && item.cards.length) {
+      const answer = this._answerEl(item);
+      if (answer) return answer;
+    }
+    return this._resultsElLegacy(item);
   }
 
   private _resultsElLegacy(item: Extract<ThreadItem, { kind: 'results' }>): HTMLElement {
@@ -4099,6 +4125,9 @@ class NxisAgentFullscreen extends HTMLElement {
       /* The action card: forms and handoffs as one message. */
       ${ACTION_CARD_CSS}
 
+      /* Search results as an answer: a pick and why, or a short list. */
+      ${RESULTS_ANSWER_CSS}
+
       /* App-icon tile: chevron centered in a 56px tile, Soft Gray, hairline. */
       .launcher {
         position: fixed; right: 20px; bottom: 20px; z-index: 9998;