agl 40.5.1 → 41.0.0

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_interfaces/workercallers.ts

@@ -6,6 +6,8 @@ export const workerCallerLaunchGenerationEnvironmentVariable = 'AGL_MCP_LAUNCH_G
 export interface IFleetWorkerCallerLaunchBase {
   launchId: string;
   projectId: string;
+  /** The fleet worker the launch identifies, `${projectId}:${name}`: a worker holds one current launch. */
+  workerId: string;
 }
 
 /**
@@ -27,11 +29,15 @@ export interface IFleetClaudeProcess {
   startTicks: string;
 }
 
-export type TFleetWorkerCallerBinding = IFleetWorkerCallerLaunchBase & {
+export type TFleetWorkerCallerBinding = Omit<IFleetWorkerCallerLaunchBase, 'workerId'> & {
   nativeSessionId: string;
   expectedBindingRevision: number;
 } & (
-  | { harnessId: 'claude'; claudeProcess: IFleetClaudeProcess }
+  /**
+   * A Claude launch binds to its background job and to the job's current process; a job whose process already exited
+   * binds without one, and the next process of the same job proves itself when its bridge enrolls.
+   */
+  | { harnessId: 'claude'; claudeJobId: string; claudeProcess?: IFleetClaudeProcess }
   | { harnessId: 'codex' }
 );
 
@@ -53,12 +59,34 @@ export interface IFleetWorkerCallerHooks {
     ticketSessionId: string;
   }>;
   getWorkerCallerStatus(launchId: string): IWorkerCallerReadiness;
-  revokeWorkerCaller(request: {
-    launchId: string;
+  /**
+   * Revokes one launch, or the current launch of a worker, also one the controller kept from before a restart. Every
+   * reason but `generation_change` revokes it for good: its kept binding is deleted with it.
+   */
+  revokeWorkerCaller(request: ({ launchId: string } | { workerId: string }) & {
     reason: 'failure' | 'stop' | 'replacement' | 'generation_change' | 'cancelled';
   }): Promise<void>;
 }
 
+/** The background job a Claude worker's launch is bound to, as the controller asks the fleet about it. */
+export interface IWorkerClaudeJobRequest {
+  workerId: string;
+  projectId: string;
+  nativeSessionId: string;
+  jobId: string;
+}
+
+/**
+ * What a fresh Claude inventory shows of that job: `running` in one process, `settled` without a process, `ended` for
+ * this worker (the worker is gone or archived, continues in another session, or the session continues as another job),
+ * or `unproven` when the registry or the inventory could not be read or did not list the session once.
+ */
+export type TWorkerClaudeJobObservation =
+  | { state: 'running'; process: IFleetClaudeProcess }
+  | { state: 'settled' }
+  | { state: 'ended'; reason: string }
+  | { state: 'unproven'; reason: string };
+
 export interface IWorkerCallerSubject {
   kind: 'worker_launch';
   launchId: string;

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'agl',
-  version: '40.5.1',
+  version: '41.0.0',
   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>`