agl 40.6.0 → 41.0.1

package/ts/functions.workerprocessproof.ts

@@ -142,15 +142,26 @@ const processOwnsLoopbackConnection = async (connectionArg: IWorkerCallerConnect
   return matches.length === 1 && await processOwnsInode(pidArg, matches[0][9]);
 };
 
+/**
+ * The arguments after its `cli.js` entry that an upgrade re-executes an `agl mcp` bridge of the controller on
+ * `controllerPortArg` with (`AglMcpReexecCoordinator`): the port pins the next image to its handover record's.
+ * A bridge proof accepts exactly these besides the approved command's own.
+ */
+export const aglMcpReexecArguments = (controllerPortArg: number): string[] => ['mcp', '--port', String(controllerPortArg)];
+
 /**
  * The bridge process `bridgePidArg`, proved to hold the caller's end of the direct loopback connection and to run the
  * approved command, whatever its parent. The command is the one recorded when the launch was prepared: an upgrade
- * installs AGL under another path, and a command whose files are gone is refused as such.
+ * installs AGL under another path, and a command whose files are gone is refused as such. Its arguments are the
+ * approved ones or, once an upgrade re-executed the bridge in place, `aglMcpReexecArguments` for `controllerPortArg`,
+ * the port this controller is configured with, never one the bridge names: the connection proof already shows that
+ * the bridge talks to this controller.
  */
 export const readWorkerBridge = async (
   connectionArg: IWorkerCallerConnection | undefined,
   bridgePidArg: number,
   commandArg: IWorkerBridgeCommand,
+  controllerPortArg: number,
 ): Promise<IWorkerProcessSnapshot> => {
   for (const file of [commandArg.executable, commandArg.entry]) {
     let resolved: string;
@@ -165,8 +176,10 @@ export const readWorkerBridge = async (
   }
   const bridge = await readWorkerProcessSnapshot(bridgePidArg);
   const entry = await plugins.fs.promises.realpath(bridge.arguments[1] ?? '');
+  const argumentsTail = bridge.arguments.slice(2);
   if (bridge.executable !== commandArg.executable || entry !== commandArg.entry
-    || !plugins.util.isDeepStrictEqual(bridge.arguments.slice(2), commandArg.arguments)) {
+    || (!plugins.util.isDeepStrictEqual(argumentsTail, commandArg.arguments)
+      && !plugins.util.isDeepStrictEqual(argumentsTail, aglMcpReexecArguments(controllerPortArg)))) {
     throw new WorkerCallerProofError('Worker bridge does not match the approved launch.');
   }
   return bridge;
@@ -177,8 +190,9 @@ export const verifyWorkerBridge = async (
   bridgePidArg: number,
   commandArg: IWorkerBridgeCommand,
   parentArg: IWorkerProcessSnapshot,
+  controllerPortArg: number,
 ): Promise<IWorkerProcessSnapshot> => {
-  const bridge = await readWorkerBridge(connectionArg, bridgePidArg, commandArg);
+  const bridge = await readWorkerBridge(connectionArg, bridgePidArg, commandArg, controllerPortArg);
   if (bridge.parentPid !== parentArg.pid) throw new WorkerCallerProofError('Worker bridge does not match the approved launch.');
   if (!workerSnapshotsEqual(parentArg, await readWorkerProcessSnapshot(parentArg.pid))
     || !workerSnapshotsEqual(bridge, await readWorkerProcessSnapshot(bridge.pid))) {

package/ts/interfaces.flexipc.ts

@@ -23,6 +23,7 @@ import {
 type TFlexCreateSessionOptions = plugins.flexharness.IFlexCreateSessionOptions;
 type TFlexMessage = plugins.flexharness.IFlexMessage;
 type TFlexMessagePage = plugins.flexharness.IFlexMessagePage;
+type TFlexMessageMetadataPage = plugins.flexharness.IFlexMessageMetadataPage;
 type TFlexPermissionRequest = plugins.flexharness.IFlexPermissionRequest;
 export type TFlexPromptQueueEntry = plugins.flexharness.IFlexPromptQueueEntry;
 type TFlexPromptOptions = plugins.flexharness.IFlexPromptOptions;
@@ -67,7 +68,7 @@ export type TFlexTurnReversionCaptureInspectionV2 =
 export type TFlexTurnReversionApplyInspection =
   plugins.flexharness.IFlexTurnReversionApplyInspection;
 
-export const flexIpcProtocolVersion = 38 as const;
+export const flexIpcProtocolVersion = 39 as const;
 /**
  * The installation's own Flex runs, which belong to no project: the configuration projection's adapting run, and
  * Session Intelligence over a session outside every project.
@@ -307,6 +308,8 @@ export interface IFlexDriverRequest {
 export interface IFlexDriverResolution {
   instructions: string;
   notes: string;
+  /** The revision of the session scratchpad that holds the notes; names them as the driver's pinned context. */
+  notesRevision: number;
 }
 export const flexDriverToolNamePattern = /^[a-z][a-z0-9_]{0,63}$/u;
 export const flexDriverToolInputMaxBytes = 2 * 1024 * 1024;
@@ -363,7 +366,7 @@ export interface IFlexHostRequestMap {
     request: IFlexTurnReversionReleaseRequest;
     response: { released: true };
   };
-  /** The controller-owned driver session's instructions and notes; null for every other session. */
+  /** The controller-owned driver session's instructions and notes with their revision; null for every other session. */
   'driver.resolve': {
     request: IFlexDriverRequest;
     response: { driver: IFlexDriverResolution | null };
@@ -836,6 +839,14 @@ export interface IFlexRequestMap {
     request: { scopeId: string; sessionId: string; limit?: number; before?: string; includeUndone?: boolean };
     response: TFlexMessagePage;
   };
+  /**
+   * The same pages with each message's identity and state only (no parts, model, usage or error):
+   * a whole transcript is scanned without reading its text or tool output.
+   */
+  'message.metadata.page': {
+    request: { scopeId: string; sessionId: string; limit?: number; before?: string; includeUndone?: boolean };
+    response: TFlexMessageMetadataPage;
+  };
   'message.get': {
     request: { scopeId: string; sessionId: string; messageId: string; includeUndone?: boolean };
     response: TFlexMessage;
@@ -1358,6 +1369,7 @@ export const readOnlyFlexRequestMethods: ReadonlySet<TFlexRequestMethod> = new S
   'session.reversion.info',
   'slash.list',
   'message.page',
+  'message.metadata.page',
   'message.get',
   'prompt.get',
   'prompt.list',
@@ -1387,6 +1399,7 @@ const requestMethods: ReadonlySet<string> = new Set<TFlexRequestMethod>([
   'slash.list',
   'slash.execute',
   'message.page',
+  'message.metadata.page',
   'message.get',
   'prompt.start',
   'prompt.continue',
@@ -1919,28 +1932,22 @@ const isFlexModelLimit = (valueArg: unknown): valueArg is TFlexModelLimit => (
   isFlexPlainObject(valueArg) && plugins.flexModels.isModelLimitInfo(valueArg)
 );
 
-export const isFlexPublicMessage = (valueArg: unknown): valueArg is TFlexMessage =>
-  isFlexPlainObject(valueArg)
-  && hasFlexExactKeys(
-    valueArg,
-    ['messageId', 'sessionId', 'runId', 'role', 'status', 'createdAt', 'parts'],
-    ['completedAt', 'model', 'usage', 'error', 'limit', 'rejectedPermissionId', 'steerId', 'cacheWarm', 'promptId', 'keptInContext', 'undone'],
-  )
-  && isIdentifier(valueArg.messageId)
+const flexMessageIdentityKeys = ['messageId', 'sessionId', 'runId', 'role', 'status', 'createdAt'] as const;
+const flexMessageOptionalIdentityKeys = ['completedAt', 'steerId', 'promptId', 'keptInContext', 'undone', 'cacheWarm'] as const;
+const flexMessageKeys = [...flexMessageIdentityKeys, 'parts'] as const;
+const flexMessageOptionalKeys = [
+  ...flexMessageOptionalIdentityKeys, 'model', 'usage', 'error', 'limit', 'rejectedPermissionId',
+] as const;
+
+/** The identity and state a transcript message and its metadata share (`TFlexMessageMetadata`). */
+const hasFlexMessageIdentity = (valueArg: Record<string, unknown>): boolean =>
+  isIdentifier(valueArg.messageId)
   && isIdentifier(valueArg.sessionId)
   && isIdentifier(valueArg.runId)
   && ['user', 'assistant'].includes(String(valueArg.role))
   && ['streaming', 'completed', 'failed', 'cancelled'].includes(String(valueArg.status))
   && isIsoDate(valueArg.createdAt)
   && (valueArg.completedAt === undefined || isIsoDate(valueArg.completedAt))
-  && Array.isArray(valueArg.parts)
-  && valueArg.parts.length <= 2000
-  && valueArg.parts.every((partArg) => isMessagePart(partArg))
-  && (valueArg.model === undefined || isModelIdentity(valueArg.model))
-  && (valueArg.usage === undefined || isUsage(valueArg.usage))
-  && (valueArg.error === undefined || isBoundedString(valueArg.error, 2048))
-  && (valueArg.limit === undefined || isFlexModelLimit(valueArg.limit))
-  && (valueArg.rejectedPermissionId === undefined || isIdentifier(valueArg.rejectedPermissionId))
   && (valueArg.steerId === undefined || (valueArg.role === 'user' && isIdentifier(valueArg.steerId)))
   && (valueArg.promptId === undefined || (valueArg.role === 'user' && isBoundedString(valueArg.promptId, 512)))
   && !(valueArg.promptId !== undefined && valueArg.steerId !== undefined)
@@ -1949,6 +1956,25 @@ export const isFlexPublicMessage = (valueArg: unknown): valueArg is TFlexMessage
   && (valueArg.undone === undefined || valueArg.undone === true)
   && (valueArg.cacheWarm === undefined || valueArg.cacheWarm === true);
 
+export const isFlexPublicMessage = (valueArg: unknown): valueArg is TFlexMessage =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, flexMessageKeys, flexMessageOptionalKeys)
+  && hasFlexMessageIdentity(valueArg)
+  && Array.isArray(valueArg.parts)
+  && valueArg.parts.length <= 2000
+  && valueArg.parts.every((partArg) => isMessagePart(partArg))
+  && (valueArg.model === undefined || isModelIdentity(valueArg.model))
+  && (valueArg.usage === undefined || isUsage(valueArg.usage))
+  && (valueArg.error === undefined || isBoundedString(valueArg.error, 2048))
+  && (valueArg.limit === undefined || isFlexModelLimit(valueArg.limit))
+  && (valueArg.rejectedPermissionId === undefined || isIdentifier(valueArg.rejectedPermissionId));
+
+/** A transcript message's identity and state as `message.metadata.page` carries it: no content. */
+export const isFlexMessageMetadata = (valueArg: unknown): valueArg is plugins.flexharness.TFlexMessageMetadata =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, flexMessageIdentityKeys, flexMessageOptionalIdentityKeys)
+  && hasFlexMessageIdentity(valueArg);
+
 export const isFlexPublicSession = (valueArg: unknown): valueArg is TFlexSession => {
   if (
     !isFlexPlainObject(valueArg)
@@ -2573,6 +2599,7 @@ export const isFlexRequestPayload = <TMethod extends TFlexRequestMethod>(
         && isScopeAndSession(valueArg)
         && isUpdateSessionOptions(valueArg.options);
     case 'message.page':
+    case 'message.metadata.page':
       return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'], ['limit', 'before', 'includeUndone'])
         && isScopeAndSession(valueArg)
         && (valueArg.limit === undefined
@@ -3118,10 +3145,11 @@ export const isFlexHostResponseResult = <TMethod extends TFlexHostRequestMethod>
     if (!hasFlexExactKeys(valueArg, ['driver'])) return false;
     const driver = valueArg.driver;
     return driver === null || (isFlexPlainObject(driver)
-      && hasFlexExactKeys(driver, ['instructions', 'notes'])
+      && hasFlexExactKeys(driver, ['instructions', 'notes', 'notesRevision'])
       && isBoundedString(driver.instructions, 64 * 1024)
       && isBoundedString(driver.notes, 128 * 1024, true)
-      && driver.notes.length <= 32_768);
+      && driver.notes.length <= 32_768
+      && isNonNegativeInteger(driver.notesRevision));
   }
   if (methodArg === 'driver.tool') {
     if (Object.hasOwn(valueArg, 'error')) {
@@ -3441,11 +3469,12 @@ export const isFlexResponseResult = <TMethod extends TFlexRequestMethod>(
     case 'slash.execute':
       return isSlashExecutionResult(valueArg);
     case 'message.page':
+    case 'message.metadata.page':
       return isFlexPlainObject(valueArg)
         && hasFlexExactKeys(valueArg, ['messages', 'startIndex'], ['nextCursor'])
         && Array.isArray(valueArg.messages) && valueArg.messages.length <= 50
         && Number.isSafeInteger(valueArg.startIndex) && (valueArg.startIndex as number) >= 0
-        && valueArg.messages.every(isFlexPublicMessage)
+        && valueArg.messages.every(methodArg === 'message.page' ? isFlexPublicMessage : isFlexMessageMetadata)
         && (valueArg.nextCursor === undefined || isBoundedString(valueArg.nextCursor, 4096));
     case 'message.get':
       return isFlexPublicMessage(valueArg);

package/ts_interfaces/fleetworkers.ts

@@ -228,6 +228,12 @@ export interface IFleetEvent {
   /** The native session (`harness:nativeId`) a ticket notice addressed. */
   sessionId?: string;
   reportId?: string;
+  /**
+   * The comment on `ticketKey` that holds this event's whole text, by the id the ticket board returned: a worker's report
+   * the fleet commented (`worker.report.mid_turn`, `worker.turn.ended`), the board pump's stall notice, a commented
+   * `ticket.changed`. Read it with `ticket_get` and `commentId`. Absent when no comment holds the text.
+   */
+  commentId?: string;
   turnId?: string;
   status?: string;
   text?: string;

package/ts_interfaces/interfaces.ts

@@ -5,7 +5,7 @@ import type {
   TControllerBrowserPaintAvailability,
   TControllerBrowserPaintTermination,
 } from './browserpaint.js';
-export const controllerProtocolVersion = 45 as const;
+export const controllerProtocolVersion = 46 as const;
 export const controllerUpgradeManagementVersion = 2 as const;
 export const controllerPackageName = 'agl' as const;
 /** The systemd user unit `agl service install` writes; a controller it runs reports it in its status. */

package/ts_interfaces/requests.tickets.ts

@@ -1,7 +1,7 @@
 import type * as plugins from './plugins.js';
 import type {
-  ITicket, ITicketActivity, ITicketAnswer, ITicketAsk, ITicketBoard, ITicketChanges, ITicketComment, ITicketCreate,
-  ITicketFilters, ITicketMove, ITicketQuestion, TTicketLink, TTicketOperation, TTicketReferenceContent, TTicketRequest,
+  ITicket, ITicketAnswer, ITicketAsk, ITicketBoard, ITicketChanges, ITicketComment, ITicketCreate,
+  ITicketDetail, ITicketFilters, ITicketGet, ITicketMove, ITicketQuestion, TTicketLink, TTicketOperation, TTicketReferenceContent, TTicketRequest,
   TTicketResponse,
 } from './tickets.js';
 
@@ -61,15 +61,18 @@ export interface IReq_ControllerMcpTicketSearch extends plugins.typedrequestInte
   response: { tickets: ITicket[] };
 }
 /**
- * Reads a ticket by its `AGL-<n>` key, with its Markdown comments, source, links, questions and
- * their answers, and its complete activity log.
+ * Reads a ticket by its `AGL-<n>` key with its source, links, all its questions and their answers,
+ * and the newest page of its history (up to `limit` entries, default 50, at most 500, within 256 KiB), oldest first: the
+ * activity entries and the Markdown comments they name, a `commented` entry naming its comment by
+ * id. `historyBefore` is present while older history exists; pass it as `before` for the next page.
+ * `commentId` reads that one comment instead (`comments: [it]`, `activity: []`), without `before` or `limit`.
  */
 export interface IReq_ControllerMcpTicketGet extends plugins.typedrequestInterfaces.implementsTR<
   TControllerMcpTicketRequest<'get'>, IReq_ControllerMcpTicketGet
 > {
   method: 'agl.mcp.ticket.get';
-  request: { ticketId: string } & { ownerToken?: string };
-  response: { ticket: ITicket; comments: ITicketComment[]; activity: ITicketActivity[]; questions: ITicketQuestion[] };
+  request: ITicketGet & { ownerToken?: string };
+  response: ITicketDetail;
 }
 /** Reads a ticket's comments. */
 export interface IReq_ControllerMcpTicketComments extends plugins.typedrequestInterfaces.implementsTR<

package/ts_interfaces/tickets.ts

@@ -200,6 +200,36 @@ export interface ITicketCreate {
   attachments?: ITicketAttachment[];
 }
 export interface ITicketMove { ticketId: string; columnId: TTicketColumn; beforeTicketId?: string; }
+/**
+ * How many history entries one `get` returns unless it names `limit`, the most it may name, and the bytes a page holds
+ * at most (its entries plus the comments they name, serialized; a page holds at least one entry). The budget wins over `limit`.
+ */
+export const ticketHistoryPage = { default: 50, maximum: 500, bytes: 256 * 1024 } as const;
+/** A ticket and one page of its history: the newest entries, or those older than the entry `before` names, within `ticketHistoryPage`. */
+export interface ITicketGet {
+  ticketId: string;
+  /** An activity id, as `historyBefore` returned it: the page holds only older entries. */
+  before?: string;
+  /** Entries on the page, 1 to 500 (`ticketHistoryPage.maximum`); 50 (`ticketHistoryPage.default`) when absent. */
+  limit?: number;
+  /**
+   * One comment of this ticket, by the id an activity entry or a fleet event names: the response holds the ticket, its
+   * questions and that comment alone (`comments: [it]`, `activity: []`, no `historyBefore`). Excludes `before` and `limit`.
+   */
+  commentId?: string;
+}
+/**
+ * A ticket, all its questions and one page of its history, oldest first. `activity` is the page; `comments` are the
+ * comments its `commented` entries name, whose `changes.comment` holds only `{ after: { id } }` here (the stored
+ * entry keeps the whole comment). `historyBefore` is present while older entries exist: pass it as `before`.
+ */
+export interface ITicketDetail {
+  ticket: ITicket;
+  comments: ITicketComment[];
+  activity: ITicketActivity[];
+  questions: ITicketQuestion[];
+  historyBefore?: string;
+}
 export interface ITicketBoard {
   revision: number;
   columns: { id: TTicketColumn; title: string; done?: boolean }[];
@@ -211,7 +241,7 @@ export interface ITicketOperations {
   list: { request: ITicketFilters; response: { tickets: ITicket[] } };
   board: { request: ITicketFilters; response: ITicketBoard };
   search: { request: { query: string; label?: string }; response: { tickets: ITicket[] } };
-  get: { request: { ticketId: string }; response: { ticket: ITicket; comments: ITicketComment[]; activity: ITicketActivity[]; questions: ITicketQuestion[] } };
+  get: { request: ITicketGet; response: ITicketDetail };
   comments: { request: { ticketId: string }; response: { comments: ITicketComment[] } };
   create: { request: ITicketCreate; response: { ticket: ITicket } };
   update: { request: { ticketId: string; expectedRevision: number; changes: ITicketChanges }; response: { ticket: ITicket } };
@@ -259,6 +289,7 @@ export const ticketErrorMessages = {
   ticket_ask_forbidden: 'Workers may ask questions only on tickets assigned to their verified session.',
   ticket_answer_forbidden: 'Only the owner or the driver may answer ticket questions.',
   ticket_question_not_found: 'The requested question does not exist on this ticket.',
+  ticket_comment_not_found: 'The requested comment does not exist on this ticket.',
   ticket_question_answered: 'The question already has a different answer; a second answer is refused. Ask a new question instead.',
   ticket_answer_invalid: 'An answer chooses existing option ids (one unless multiSelect) and/or gives free text where the question allows it.',
 } as const;

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'agl',
-  version: '40.6.0',
+  version: '41.0.1',
   description: 'Agent Gateway Layer for OpenCode, FlexHarness, and Codex sessions'
 }

package/ts_web/elements.harnesscontrollerapp.ts

@@ -941,10 +941,13 @@ const modelHarnessId = (choiceArg: interfaces.TControllerModelChoice): TBrowserS
 /** How long after asking for a restart this page expects its connection to drop; still connected, AGL did not restart. */
 const restartCheckMs = 20_000;
 
+/** A model as a harness's own row names it, without the harness: "openai/gpt-5.6-sol". */
+const modelChoiceName = (choiceArg: interfaces.TControllerModelChoice): string => `${choiceArg.providerID}/${choiceArg.modelID}`;
+
 const modelOptionLabel = (choiceArg: interfaces.TControllerModelChoice): string => {
   return [
     sessionHarnessLabel(modelHarnessId(choiceArg)),
-    `${choiceArg.providerID}/${choiceArg.modelID}`,
+    modelChoiceName(choiceArg),
   ].join(' · ');
 };
 
@@ -18816,16 +18819,23 @@ ${entry.detail.stack}`}</pre>`}
 
   /** General as the controller's confirmed settings and this browser's own choices have it. */
   private generalSettingsView(): IGeneralSettingsView {
+    // Each row belongs to one harness, so it names a model without the harness.
+    const modelName = (modelStringArg: string): string => {
+      const choice = this.modelChoicesByString.get(modelStringArg);
+      return choice ? modelChoiceName(choice) : modelStringArg;
+    };
     return {
       defaults: (['opencode', 'flex', 'codex', 'claude'] as const).map((harnessIdArg) => {
         const name = sessionHarnessLabel(harnessIdArg);
         const model = this.defaultModelStrings[harnessIdArg];
         const unavailable = this.unavailableDefaultModels[harnessIdArg];
         // Flex has no default of its own: without one AGL can name, its composer asks for a model.
-        const runningDefault = this.composerDefaultModelStrings[harnessIdArg]
-          || (harnessIdArg === 'flex' ? '' : `${name}'s own default`);
+        const composerDefault = this.composerDefaultModelStrings[harnessIdArg];
+        const runningDefault = composerDefault
+          ? modelName(composerDefault)
+          : harnessIdArg === 'flex' ? '' : `${name}'s own default`;
         const note = unavailable
-          ? `The saved default ${modelOptionLabel(unavailable)} is no longer offered. ${runningDefault
+          ? `The saved default ${modelChoiceName(unavailable)} is no longer offered. ${runningDefault
             ? `New conversations run on ${runningDefault}.`
             : 'New Flex conversations need an account and model chosen in the composer.'}`
           : harnessIdArg === 'flex' && !model ? 'Without a default, Flex\'s composer asks for an account and a model.' : '';
@@ -18834,7 +18844,7 @@ ${entry.detail.stack}`}</pre>`}
           name,
           models: [
             { key: '', label: harnessIdArg === 'flex' ? 'Ask in the composer' : `${name}'s own default` },
-            ...this.modelOptionsForHarness(harnessIdArg).map((optionArg) => ({ key: optionArg, label: optionArg })),
+            ...this.modelOptionsForHarness(harnessIdArg).map((optionArg) => ({ key: optionArg, label: modelName(optionArg) })),
           ],
           model,
           efforts: this.settingsEffortDropdownOptions(model)
@@ -18854,9 +18864,10 @@ ${entry.detail.stack}`}</pre>`}
       gpu: this.browserGpu,
       activeGpu: this.activeBrowserGpu,
       presentation: this.browserPresentation,
-      paintState: this.activeBrowserPaint
-        ? describeBrowserPaintAvailability(this.activeBrowserPaint)
-        : 'No browser runtime is running.',
+      // Said only while Paint cannot be used: an available Paint needs no sentence.
+      paintState: !this.activeBrowserPaint
+        ? 'No browser runtime is running.'
+        : this.activeBrowserPaint.state === 'available' ? '' : describeBrowserPaintAvailability(this.activeBrowserPaint),
       paintRearm: this.activeBrowserPaint?.state === 'unavailable'
         && this.activeBrowserPaint.reason !== 'descriptor-missing'
         && this.activeBrowserPaint.reason !== 'unsupported-platform'

package/ts_web/elements.ticketboard.ts

@@ -250,6 +250,20 @@ export class AglTicketBoard extends plugins.deesElement.DeesElement {
       ?? { id: personArg.id, name: personArg.name };
   }
 
+  /** A ticket's whole history: `get` returns it a page at a time, newest first, so this reads back to the first entry. */
+  private async history(ticketIdArg: string, signalArg?: AbortSignal): Promise<Omit<interfaces.ITicketDetail, 'historyBefore'>> {
+    const pages: interfaces.ITicketDetail[] = [];
+    let before: string | undefined;
+    do {
+      const page = await this.fire('get', { ticketId: ticketIdArg, limit: interfaces.ticketHistoryPage.maximum,
+        ...(before === undefined ? {} : { before }) }, signalArg);
+      pages.unshift(page);
+      before = page.historyBefore;
+    } while (before !== undefined);
+    const { ticket, questions } = pages.at(-1)!;
+    return { ticket, questions, comments: pages.flatMap((pageArg) => pageArg.comments), activity: pages.flatMap((pageArg) => pageArg.activity) };
+  }
+
   /** Tickets as the kanban shows them, remembering whom they name. */
   private shown(ticketsArg: interfaces.ITicket[]): IKanbanTicket[] {
     for (const ticket of ticketsArg) {
@@ -274,12 +288,10 @@ export class AglTicketBoard extends plugins.deesElement.DeesElement {
     searchTickets: async (queryArg, signalArg) => this.shown((await this.fire('search', { query: queryArg }, signalArg)).tickets),
     // The discussion is the comments and the questions; the kanban orders them by when they were written.
     loadComments: async (ticketIdArg, signalArg) => {
-      const { comments, questions } = await this.fire('get', { ticketId: ticketIdArg }, signalArg);
+      const { comments, questions } = await this.history(ticketIdArg, signalArg);
       return [...comments.map(kanbanComment), ...questions.map(kanbanQuestion)];
     },
-    loadActivity: async (ticketIdArg, signalArg) => (
-      (await this.fire('get', { ticketId: ticketIdArg }, signalArg)).activity.map(kanbanActivity)
-    ),
+    loadActivity: async (ticketIdArg, signalArg) => (await this.history(ticketIdArg, signalArg)).activity.map(kanbanActivity),
     addComment: async (inputArg) => this.change(async () => (
       kanbanComment((await this.fire('comment', { ticketId: inputArg.ticketId, body: inputArg.body })).comment)
     )),

package/ts_web/settings.general.ts

@@ -36,7 +36,7 @@ export interface IGeneralSettingsView {
   gpu: 'enabled' | 'disabled';
   activeGpu: 'enabled' | 'disabled';
   presentation: interfaces.TControllerBrowserPresentation;
-  /** What the runtime says of Paint, or that no browser runtime runs. */
+  /** Why Paint cannot be used now, or that no browser runtime runs; empty while Paint is available. */
   paintState: string;
   /** Paint's integrity retries stopped and can be started again. */
   paintRearm: boolean;
@@ -90,10 +90,15 @@ export const renderGeneralSettings = (
         leading: html`<mp-harness-mark .harness=${rowArg.harnessId}></mp-harness-mark>`,
         label: rowArg.name,
         ...(rowArg.note ? { description: rowArg.note } : {}),
-        control: html`<mp-model-picker class="settingsDefault" data-harness=${rowArg.harnessId} style="width: min(340px, 100%);"
+        // One folded button per row (model · effort), as wide as it says and at most a share of a narrow screen;
+        // it opens the model and the effort in a speech bubble. A saved default no longer offered gives it the
+        // warning tone.
+        control: html`<mp-model-picker class="settingsDefault" data-harness=${rowArg.harnessId} fold="always"
+          style="max-width: min(360px, 45vw);" .label=${`Default model for ${rowArg.name}`}
+          .warning=${rowArg.noteIsWarning ? rowArg.note : ''}
           .models=${rowArg.models} .model=${rowArg.model} .efforts=${rowArg.efforts} .effort=${rowArg.effort}
           .effortDisabledReason=${rowArg.effortDisabledReason} .modelPlaceholder=${'Choose a model'}
-          .modelLabel=${`${rowArg.name} default model`} .effortLabel=${`${rowArg.name} reasoning effort`}
+          .modelLabel=${'Model'} .effortLabel=${'Reasoning effort'}
           @mp-model-change=${(eventArg: CustomEvent<TMpModelChoice>) => actionsArg.setDefault(rowArg.harnessId, eventArg.detail)}
         ></mp-model-picker>`,
       })),
@@ -161,7 +166,8 @@ export const renderGeneralSettings = (
         {
           key: 'presentation',
           label: 'New browser views show',
-          description: `Paint draws the page as vector scenes in this tab; Video streams it. Each view can switch on its own. ${viewArg.paintState}`,
+          description: `Paint draws the page as vector scenes in this tab; Video streams it. Each view can switch on its own.${
+            viewArg.paintState ? ` ${viewArg.paintState}` : ''}`,
           control: html`
             ${viewArg.paintRearm
               ? html`<dees-button class="settingsBrowserPaintRearm" size="sm" text="Retry Paint" @clicked=${() => actionsArg.rearmPaint()}></dees-button>`