agl 40.6.0 → 41.0.0

package/ts/classes.ticketnotifier.ts

@@ -141,7 +141,9 @@ export class TicketNotifier {
       // The board pump tells the driver through its own event; steering the assignee would start the work it must leave to the driver.
       if (change.actor.id === boardPumpActor.id) continue;
       if (change.actor.role !== 'driver' && change.origin === undefined) {
-        this.options.publish({ kind: 'ticket.changed', ticketKey: change.ticket.key, text: ticketChangeText(change) });
+        // A comment's whole text is the comment, which the driver reads by its id.
+        const comment = change.action === 'commented' ? change.changes.comment?.after as ITicketComment | undefined : undefined;
+        this.options.publish({ kind: 'ticket.changed', ticketKey: change.ticket.key, text: ticketChangeText(change), ...(comment ? { commentId: comment.id } : {}) });
       }
       // An answer reaches the session that asked too, which need not hold the ticket: a direct report asks on any ticket of its projects.
       const asker = change.action === 'answered' ? (change.changes.question?.after as ITicketQuestion | undefined)?.askedBy.sessionId : undefined;

package/ts/classes.ticketstore.ts

@@ -4,6 +4,7 @@ import {
   type ITicketChanges, type ITicketCreate, type ITicketFilters, type ITicketMove, type ITicketPerson, type ITicketQuestion,
   type TTicketLink, type TTicketOperation, type TTicketRequest, type TTicketResponse,
   type TTicketFleetEvent, type ITicketFleetEventResult, type ITicketComment, type TTicketData, type ITicketOpenQuestion,
+  type ITicketDetail, type ITicketGet, ticketHistoryPage,
 } from '../ts_interfaces/tickets.js';
 import {
   TicketModel, TicketBoardModel, TicketCommentModel, TicketActivityModel, TicketQuestionModel, TicketFleetEventModel,
@@ -15,6 +16,11 @@ type TTicketStored = NonNullable<Awaited<ReturnType<typeof TicketModel.exact.fin
 type TSession = plugins.nosqldb.SmartdataSession;
 const workerColumns = new Set(['ready', 'in_progress', 'needs_input', 'review']);
 const mutableOperations = new Set<TTicketOperation>(['create', 'update', 'move', 'comment', 'link', 'ask', 'answer']);
+/**
+ * Activity records a history page reads at a time, newest first: a page reads at most this many records beyond the
+ * entries it returns, whatever its `limit`, so a page cut by the byte budget does not read `limit` records.
+ */
+export const ticketHistoryBatch = 16;
 
 /** One change a committed ticket transaction made, or an edit it refused as stale. */
 export interface ITicketChange {
@@ -35,10 +41,16 @@ export interface ITicketObservation {
   revision?: number;
   changes: ITicketChange[];
 }
+/** A ticket with its whole history and all its questions, as one transaction read them; stored activity keeps its comments. */
+export interface ITicketHistory {
+  ticket: ITicket;
+  activity: ITicketActivity[];
+  questions: ITicketQuestion[];
+}
 /** What one transaction attempt read and changed. A retried attempt starts a new one. */
 interface ITicketTrack {
   ticketIds: string[];
-  /** Open questions per ticket id, read inside the transaction; the AutoLabel facts. */
+  /** Open questions per ticket id, read inside the transaction for the tickets it shows; the AutoLabel facts. */
   openQuestions: Map<string, number>;
   changes: ITicketChange[];
   origin?: string;
@@ -101,9 +113,8 @@ export class TicketStore {
         if (fenced.status !== 'transitioned') throw new TicketError('concurrent_change', 'The board changed concurrently.');
         const now = new Date().toISOString();
         const revision = board.revision + 1;
-        track = await this.track(transactionArg, originArg);
-        let tickets = await this.allTickets(transactionArg);
-        if (!tickets.some(record => record.id === event.ticketKey)) {
+        track = this.track(originArg);
+        if (!await TicketModel.exact.findStoredOne({ id: event.ticketKey }, { session: transactionArg })) {
           throw new TicketError('ticket_not_found', ticketErrorMessages.ticket_not_found);
         }
         if (event.kind !== 'comment') {
@@ -111,16 +122,14 @@ export class TicketStore {
             ? { kind: 'branch', repo: event.repo, branch: event.branch, sha: event.sha }
             : { kind: 'release', package: event.package, version: event.version };
           await this.perform('link', { ticketId: event.ticketKey, link }, event.actor, transactionArg,
-            tickets, now, board.sequence + 1, revision, track);
-          tickets = await this.allTickets(transactionArg);
+            now, board.sequence + 1, revision, track);
           await this.perform('move', { ticketId: event.ticketKey, columnId: event.kind }, event.actor, transactionArg,
-            tickets, now, board.sequence + 1, revision, track);
-          tickets = await this.allTickets(transactionArg);
+            now, board.sequence + 1, revision, track);
         }
         let comment: ITicketComment | undefined;
         if (event.body !== undefined) {
           const response = await this.perform('comment', { ticketId: event.ticketKey, body: event.body }, event.actor,
-            transactionArg, tickets, now, board.sequence + 1, revision, track) as TTicketResponse<'comment'>;
+            transactionArg, now, board.sequence + 1, revision, track) as TTicketResponse<'comment'>;
           comment = response.comment;
         }
         const current = await TicketModel.exact.findStoredOne({ id: event.ticketKey }, { session: transactionArg });
@@ -219,11 +228,10 @@ export class TicketStore {
           } }, { session: transactionArg });
           if (fenced.status !== 'transitioned') throw new TicketError('concurrent_change', 'The board changed concurrently.');
         }
-        const tickets = await this.allTickets(transactionArg);
         const now = new Date().toISOString();
         const revision = board.revision + (mutableOperations.has(methodArg) ? 1 : 0);
-        track = await this.track(transactionArg);
-        const response = await this.perform(methodArg, request, actor, transactionArg, tickets, now,
+        track = this.track();
+        const response = await this.perform(methodArg, request, actor, transactionArg, now,
           board.sequence + 1, revision, track);
         return { response, revision, ticketIds: track.ticketIds };
       }, { timeoutMS: 20_000, ...(signalArg ? { signal: signalArg } : {}) });
@@ -252,17 +260,53 @@ export class TicketStore {
     try { this.observer(structuredClone(observationArg)); } catch { /* observers report their own failures */ }
   }
 
-  private async track(sessionArg: TSession, originArg?: string): Promise<ITicketTrack> {
-    const openQuestions = new Map<string, number>();
+  private track(originArg?: string): ITicketTrack {
+    return { ticketIds: [], openQuestions: new Map(), changes: [], ...(originArg ? { origin: originArg } : {}) };
+  }
+
+  /**
+   * Reads the open questions of `ticketIdsArg`, or of every ticket, into the track as the transaction sees them now,
+   * after its own writes. Only the tickets a response shows are counted.
+   */
+  private async countOpenQuestions(trackArg: ITicketTrack, sessionArg: TSession, ticketIdsArg?: string[]): Promise<void> {
+    const chunks: (string[] | undefined)[] = [];
+    if (ticketIdsArg === undefined) { trackArg.openQuestions.clear(); chunks.push(undefined); }
+    else {
+      const ids = [...new Set(ticketIdsArg)];
+      for (const id of ids) trackArg.openQuestions.set(id, 0);
+      for (let index = 0; index < ids.length; index += 500) chunks.push(ids.slice(index, index + 500));
+    }
+    for (const chunk of chunks) {
+      let after: string | undefined;
+      while (true) {
+        const page = await TicketQuestionModel.exact.findStored({ filter: { status: 'open', ...(chunk ? { ticketId: { $in: chunk } } : {}),
+          ...(after ? { id: { $gt: after } } : {}) }, sort: { id: 1 }, limit: 500, session: sessionArg });
+        for (const record of page) trackArg.openQuestions.set(record.ticketId, (trackArg.openQuestions.get(record.ticketId) ?? 0) + 1);
+        if (page.length < 500) break;
+        after = page.at(-1)!.id;
+      }
+    }
+  }
+
+  private async ticket(ticketIdArg: string, sessionArg: TSession): Promise<TTicketStored | null> {
+    return await TicketModel.exact.findStoredOne({ id: ticketIdArg }, { session: sessionArg });
+  }
+
+  /** The tickets of one column, by id; the board's `ticket_column_order` index serves it. */
+  private async columnTickets(columnIdArg: ITicket['columnId'], sessionArg: TSession): Promise<TTicketStored[]> {
+    return await this.paged((afterArg) => TicketModel.exact.findStored({ filter: { 'ticket.columnId': columnIdArg,
+      ...(afterArg ? { id: { $gt: afterArg } } : {}) }, sort: { id: 1 }, limit: 500, session: sessionArg }));
+  }
+
+  private async paged<TRecord extends { id: string }>(pageArg: (afterArg: string | undefined) => Promise<TRecord[]>): Promise<TRecord[]> {
+    const records: TRecord[] = [];
     let after: string | undefined;
     while (true) {
-      const page = await TicketQuestionModel.exact.findStored({ filter: { status: 'open', ...(after ? { id: { $gt: after } } : {}) },
-        sort: { id: 1 }, limit: 500, session: sessionArg });
-      for (const record of page) openQuestions.set(record.ticketId, (openQuestions.get(record.ticketId) ?? 0) + 1);
-      if (page.length < 500) break;
+      const page = await pageArg(after);
+      records.push(...page);
+      if (page.length < 500) return records;
       after = page.at(-1)!.id;
     }
-    return { ticketIds: [], openQuestions, changes: [], ...(originArg ? { origin: originArg } : {}) };
   }
 
   private async questions(ticketIdArg: string, sessionArg: TSession): Promise<ITicketQuestion[]> {
@@ -280,15 +324,8 @@ export class TicketStore {
   }
 
   private async allTickets(sessionArg: TSession): Promise<TTicketStored[]> {
-    const records: TTicketStored[] = [];
-    let after: string | undefined;
-    while (true) {
-      const page = await TicketModel.exact.findStored({ filter: after ? { id: { $gt: after } } : {},
-        sort: { id: 1 }, limit: 500, session: sessionArg });
-      records.push(...page);
-      if (page.length < 500) return records;
-      after = page.at(-1)!.id;
-    }
+    return await this.paged((afterArg) => TicketModel.exact.findStored({ filter: afterArg ? { id: { $gt: afterArg } } : {},
+      sort: { id: 1 }, limit: 500, session: sessionArg }));
   }
 
   private visible(ticketArg: TTicketData, actorArg: ITicketActor | undefined, trackArg: ITicketTrack): ITicket {
@@ -302,6 +339,12 @@ export class TicketStore {
     } };
   }
 
+  /** `visible` with the ticket's open questions read now. */
+  private async shown(ticketArg: TTicketData, actorArg: ITicketActor | undefined, sessionArg: TSession, trackArg: ITicketTrack): Promise<ITicket> {
+    await this.countOpenQuestions(trackArg, sessionArg, [ticketArg.id]);
+    return this.visible(ticketArg, actorArg, trackArg);
+  }
+
   private requireEdit(ticketArg: TTicketData, actorArg: ITicketActor): void {
     if (actorArg.role !== 'worker') return;
     if (!ticketAssignedTo(ticketArg, actorArg)) {
@@ -318,14 +361,19 @@ export class TicketStore {
     }
   }
 
-  private parent(ticketArg: TTicketData, ticketsArg: TTicketStored[]): void {
+  /** Checks the ticket's parent as the transaction holds it. */
+  private async parent(ticketArg: TTicketData, sessionArg: TSession): Promise<void> {
+    this.requireParent(ticketArg, ticketArg.parentId ? (await this.ticket(ticketArg.parentId, sessionArg))?.ticket : undefined);
+  }
+
+  /** `parentArg` is the ticket `ticketArg.parentId` names, undefined when none exists. */
+  private requireParent(ticketArg: TTicketData, parentArg: TTicketData | undefined): void {
     if (!ticketArg.parentId) {
       if (ticketArg.kind === 'subtask') throw new TicketError('ticket_parent_required', 'A subtask requires a task parent.');
       return;
     }
-    const parent = ticketsArg.find((recordArg) => recordArg.id === ticketArg.parentId)?.ticket;
-    if (!parent || parent.project !== ticketArg.project || ticketArg.id === parent.id
-      || ticketArg.kind === 'epic' || (ticketArg.kind === 'task' ? parent.kind !== 'epic' : parent.kind !== 'task')) {
+    if (!parentArg || parentArg.project !== ticketArg.project || ticketArg.id === parentArg.id
+      || ticketArg.kind === 'epic' || (ticketArg.kind === 'task' ? parentArg.kind !== 'epic' : parentArg.kind !== 'task')) {
       throw new TicketError('ticket_parent_invalid', 'Parents must be an epic for a task or a task for a subtask, in the same project.');
     }
   }
@@ -367,37 +415,101 @@ export class TicketStore {
     return next;
   }
 
-  private async history(ticketIdArg: string, sessionArg: TSession) {
-    const comments = [] as Awaited<ReturnType<typeof TicketCommentModel.exact.findStored>>;
-    const activity = [] as Awaited<ReturnType<typeof TicketActivityModel.exact.findStored>>;
-    let after: string | undefined;
-    while (true) {
-      const page = await TicketCommentModel.exact.findStored({ filter: { ticketId: ticketIdArg,
-        ...(after ? { id: { $gt: after } } : {}) }, sort: { id: 1 }, limit: 500, session: sessionArg });
-      comments.push(...page);
-      if (page.length < 500) break;
-      after = page.at(-1)!.id;
+  private async allComments(ticketIdArg: string, sessionArg: TSession): Promise<ITicketComment[]> {
+    return structuredClone((await this.paged((afterArg) => TicketCommentModel.exact.findStored({ filter: { ticketId: ticketIdArg,
+      ...(afterArg ? { id: { $gt: afterArg } } : {}) }, sort: { id: 1 }, limit: 500, session: sessionArg })))
+      .map((recordArg) => recordArg.comment));
+  }
+
+  private async allActivity(ticketIdArg: string, sessionArg: TSession): Promise<ITicketActivity[]> {
+    return structuredClone((await this.paged((afterArg) => TicketActivityModel.exact.findStored({ filter: { ticketId: ticketIdArg,
+      ...(afterArg ? { id: { $gt: afterArg } } : {}) }, sort: { id: 1 }, limit: 500, session: sessionArg })))
+      .map((recordArg) => recordArg.activity));
+  }
+
+  /**
+   * One page of a ticket's history, oldest first: walking back from the newest entry older than `before`, at most
+   * `limit` entries and no more than `ticketHistoryPage.bytes` of entries plus the comments they name as returned
+   * (always at least one entry), and those comments. In the page an entry names its comment by id; the comment comes
+   * once. The walk reads `ticketHistoryBatch` records at a time and stops at the first record the page leaves out,
+   * which is the proof that older entries remain (`historyBefore`).
+   *
+   * A comment comes from the copy its `commented` entry embeds: comments are insert-only, and the one place that
+   * writes a comment (`perform`'s `comment`) writes the entry with that same comment in the same transaction.
+   */
+  private async historyPage(requestArg: ITicketGet, sessionArg: TSession): Promise<Pick<ITicketDetail, 'comments' | 'activity' | 'historyBefore'>> {
+    const limit = requestArg.limit ?? ticketHistoryPage.default;
+    const activity: ITicketActivity[] = [];
+    const comments: ITicketComment[] = [];
+    let bytes = 0;
+    let cursor = requestArg.before;
+    let cut = false;
+    let more = true;
+    while (more && !cut) {
+      // One record past `limit` at most: it tells whether older entries remain.
+      const wanted = Math.min(ticketHistoryBatch, limit + 1 - activity.length);
+      const batch = await TicketActivityModel.exact.findStored({ filter: { ticketId: requestArg.ticketId,
+        ...(cursor === undefined ? {} : { id: { $lt: cursor } }) }, sort: { id: -1 }, limit: wanted, session: sessionArg });
+      more = batch.length === wanted;
+      cursor = batch.at(-1)?.id;
+      for (const record of batch) {
+        const entry = structuredClone(record.activity);
+        const comment = entry.action === 'commented' ? entry.changes.comment?.after as ITicketComment | undefined : undefined;
+        const shown = comment ? { ...entry, changes: { ...entry.changes, comment: { after: { id: comment.id } } } } : entry;
+        const size = Buffer.byteLength(JSON.stringify(shown)) + (comment ? Buffer.byteLength(JSON.stringify(comment)) : 0);
+        if (activity.length === limit || (activity.length && bytes + size > ticketHistoryPage.bytes)) {
+          cut = true;
+          break;
+        }
+        bytes += size;
+        activity.unshift(shown);
+        if (comment) comments.push(comment);
+      }
     }
-    after = undefined;
-    while (true) {
-      const page = await TicketActivityModel.exact.findStored({ filter: { ticketId: ticketIdArg,
-        ...(after ? { id: { $gt: after } } : {}) }, sort: { id: 1 }, limit: 500, session: sessionArg });
-      activity.push(...page);
-      if (page.length < 500) break;
-      after = page.at(-1)!.id;
+    return { comments: comments.sort((leftArg, rightArg) => (leftArg.id < rightArg.id ? -1 : leftArg.id > rightArg.id ? 1 : 0)), activity,
+      ...(cut ? { historyBefore: activity[0]!.id } : {}) };
+  }
+
+  /**
+   * A ticket with its whole history and all its questions, read in one transaction without the rest of the board.
+   * The board pump reads a ticket this way only when its revision moved.
+   */
+  public async history(ticketIdArg: string, signalArg?: AbortSignal): Promise<ITicketHistory> {
+    const ticketId = assertTicketRequest('get', { ticketId: ticketIdArg }).ticketId;
+    const session = TicketBoardModel.collection.smartdataDb.createSession();
+    try {
+      const history = await session.withTransaction(async (transactionArg) => {
+        const current = await this.ticket(ticketId, transactionArg);
+        if (!current) throw new TicketError('ticket_not_found', ticketErrorMessages.ticket_not_found);
+        const questions = await this.questions(ticketId, transactionArg);
+        const track = this.track();
+        track.openQuestions.set(ticketId, questions.filter((questionArg) => questionArg.status === 'open').length);
+        return { ticket: this.visible(current.ticket, undefined, track), activity: await this.allActivity(ticketId, transactionArg), questions };
+      }, { timeoutMS: 20_000, ...(signalArg ? { signal: signalArg } : {}) });
+      if (!history) throw new Error('The ticket history transaction returned no result.');
+      return history;
+    } finally {
+      await session.close();
     }
-    return structuredClone({ comments: comments.map((recordArg) => recordArg.comment), activity: activity.map((recordArg) => recordArg.activity) });
   }
 
+  /**
+   * Each operation reads what it decides on and nothing more: the listing operations read the whole board and every
+   * open question; create the parent and the destination column's count; move the source and destination columns;
+   * update the ticket, its parent and, when the project changes, its children; every other operation one ticket, and
+   * get one page of its history or, with `commentId`, that one comment. The board document's revision transition in the caller orders every mutation.
+   */
   private async perform(methodArg: TTicketOperation, requestArg: TTicketRequest<TTicketOperation>, actorArg: ITicketActor | undefined,
-    sessionArg: TSession, ticketsArg: TTicketStored[], nowArg: string, sequenceArg: number,
+    sessionArg: TSession, nowArg: string, sequenceArg: number,
     revisionArg: number, trackArg: ITicketTrack): Promise<unknown> {
     if (methodArg === 'list' || methodArg === 'board' || methodArg === 'search') {
       const filters: ITicketFilters = methodArg === 'search'
         ? { text: (requestArg as TTicketRequest<'search'>).query, label: (requestArg as TTicketRequest<'search'>).label }
         : requestArg as ITicketFilters;
       const text = filters.text?.toLocaleLowerCase();
-      const tickets = ticketsArg.map((recordArg) => this.visible(recordArg.ticket, actorArg, trackArg)).filter((ticketArg) => (
+      const all = await this.allTickets(sessionArg);
+      await this.countOpenQuestions(trackArg, sessionArg);
+      const tickets = all.map((recordArg) => this.visible(recordArg.ticket, actorArg, trackArg)).filter((ticketArg) => (
         (!filters.mine || (actorArg !== undefined && ticketAssignedTo(ticketArg, actorArg)))
         && (!filters.project || ticketArg.project === filters.project)
         && (!filters.status || ticketArg.columnId === filters.status)
@@ -426,28 +538,38 @@ export class TicketStore {
       const id = `AGL-${sequenceArg}`;
       const ticket: ITicket = { id, key: id, revision: 1, project: input.project, kind: input.kind ?? 'task', title: input.title,
         description: input.description ?? '', ...(input.parentId ? { parentId: input.parentId } : {}), columnId,
-        order: ticketsArg.filter((recordArg) => recordArg.ticket.columnId === columnId).length,
+        order: await TicketModel.exact.count({ 'ticket.columnId': columnId }, { session: sessionArg }),
         priority: input.priority ?? 'normal', ...(input.assignee ? { assignee: input.assignee } : {}), labels: input.labels ?? [], links: [],
         source: { kind: actorArg.role === 'owner' ? 'owner_words' : actorArg.role, text: input.sourceText ?? input.description ?? input.title,
           actor: actorArg, attachments: input.attachments ?? [] }, createdBy: actorArg, updatedBy: actorArg, createdAt: nowArg, updatedAt: nowArg };
-      this.parent(ticket, ticketsArg);
+      await this.parent(ticket, sessionArg);
       this.requireReview(ticket);
       const result = await TicketModel.exact.insert({ id, ticket }, { session: sessionArg });
       if (result.status === 'conflict') throw new Error('Global ticket sequence conflict.');
       await this.activity(ticket, actorArg, sessionArg, 'created', { ticket: { after: ticket } }, nowArg, revisionArg, trackArg);
       trackArg.ticketIds.push(id);
-      return { ticket: this.visible(ticket, actorArg, trackArg) };
+      return { ticket: await this.shown(ticket, actorArg, sessionArg, trackArg) };
     }
     const ticketId = (requestArg as { ticketId: string }).ticketId;
-    const current = ticketsArg.find((recordArg) => recordArg.id === ticketId);
+    const current = await this.ticket(ticketId, sessionArg);
     if (!current) throw new TicketError('ticket_not_found', 'The requested ticket does not exist.');
     const ticket = structuredClone(current.ticket);
     if (methodArg === 'get') {
-      return { ticket: this.visible(ticket, actorArg, trackArg), ...await this.history(ticketId, sessionArg),
-        questions: await this.questions(ticketId, sessionArg) };
+      const questions = await this.questions(ticketId, sessionArg);
+      trackArg.openQuestions.set(ticketId, questions.filter((questionArg) => questionArg.status === 'open').length);
+      const { commentId } = requestArg as ITicketGet;
+      if (commentId !== undefined) {
+        const stored = await TicketCommentModel.exact.findStoredOne({ id: commentId, ticketId }, { session: sessionArg });
+        if (!stored) throw new TicketError('ticket_comment_not_found', ticketErrorMessages.ticket_comment_not_found);
+        return { ticket: this.visible(ticket, actorArg, trackArg), comments: [structuredClone(stored.comment)], activity: [],
+          questions } satisfies ITicketDetail;
+      }
+      const { comments, activity, historyBefore } = await this.historyPage(requestArg as ITicketGet, sessionArg);
+      return { ticket: this.visible(ticket, actorArg, trackArg), comments, activity, questions,
+        ...(historyBefore === undefined ? {} : { historyBefore }) } satisfies ITicketDetail;
     }
     if (!actorArg) throw new TicketError('ticket_identity_required', ticketErrorMessages.ticket_identity_required);
-    if (methodArg === 'comments') return { comments: (await this.history(ticketId, sessionArg)).comments };
+    if (methodArg === 'comments') return { comments: await this.allComments(ticketId, sessionArg) };
     if (methodArg === 'comment') {
       const input = requestArg as TTicketRequest<'comment'>;
       const id = `${String(revisionArg).padStart(16, '0')}:${plugins.crypto.randomUUID()}`;
@@ -470,9 +592,8 @@ export class TicketStore {
       const inserted = await TicketQuestionModel.exact.insert({ id: `${ticketId}:${question.id}`, ticketId, status: 'open', question },
         { session: sessionArg });
       if (inserted.status === 'conflict') throw new Error('Ticket question identity conflict.');
-      trackArg.openQuestions.set(ticketId, (trackArg.openQuestions.get(ticketId) ?? 0) + 1);
       const saved = await this.save(current, ticket, actorArg, sessionArg, 'asked', nowArg, trackArg, revisionArg, { question: { after: question } });
-      return { question, ticket: this.visible(saved, actorArg, trackArg) };
+      return { question, ticket: await this.shown(saved, actorArg, sessionArg, trackArg) };
     }
     if (methodArg === 'answer') {
       if (actorArg.role === 'worker') throw new TicketError('ticket_answer_forbidden', ticketErrorMessages.ticket_answer_forbidden);
@@ -490,7 +611,7 @@ export class TicketStore {
         if (JSON.stringify([question.answer.choices, question.answer.text]) !== JSON.stringify([choices, input.text])) {
           throw new TicketError('ticket_question_answered', ticketErrorMessages.ticket_question_answered);
         }
-        return { question, ticket: this.visible(ticket, actorArg, trackArg) };
+        return { question, ticket: await this.shown(ticket, actorArg, sessionArg, trackArg) };
       }
       question.status = 'answered';
       question.answer = { choices, ...(input.text === undefined ? {} : { text: input.text }), answeredBy: actorArg, answeredAt: nowArg };
@@ -499,10 +620,9 @@ export class TicketStore {
         modelArg.question = question;
       } }, { session: sessionArg });
       if (transitioned.status !== 'transitioned') throw new TicketError('concurrent_change', 'The question changed concurrently.');
-      trackArg.openQuestions.set(ticketId, Math.max(0, (trackArg.openQuestions.get(ticketId) ?? 0) - 1));
       const saved = await this.save(current, ticket, actorArg, sessionArg, 'answered', nowArg, trackArg, revisionArg,
         { question: { before: stored.question, after: question } });
-      return { question, ticket: this.visible(saved, actorArg, trackArg) };
+      return { question, ticket: await this.shown(saved, actorArg, sessionArg, trackArg) };
     }
     this.requireEdit(ticket, actorArg);
     if (methodArg === 'update') {
@@ -523,29 +643,34 @@ export class TicketStore {
       else if (assignee !== undefined) ticket.assignee = assignee;
       if (parentId === null) delete ticket.parentId;
       else if (parentId !== undefined) ticket.parentId = parentId;
-      this.parent(ticket, ticketsArg);
-      for (const child of ticketsArg.filter((recordArg) => recordArg.ticket.parentId === ticketId)) {
-        this.parent(child.ticket, ticketsArg.map((recordArg) => recordArg.id === ticketId ? { ...recordArg, ticket } : recordArg));
+      await this.parent(ticket, sessionArg);
+      // A child's parent rule reads its parent's kind, which no update changes, and project.
+      if (ticket.project !== current.ticket.project) {
+        const children = await this.paged((afterArg) => TicketModel.exact.findStored({ filter: { 'ticket.parentId': ticketId,
+          ...(afterArg ? { id: { $gt: afterArg } } : {}) }, sort: { id: 1 }, limit: 500, session: sessionArg }));
+        for (const child of children) this.requireParent(child.ticket, ticket);
       }
-      return { ticket: this.visible(await this.save(current, ticket, actorArg, sessionArg, 'updated', nowArg, trackArg, revisionArg), actorArg, trackArg) };
+      return { ticket: await this.shown(await this.save(current, ticket, actorArg, sessionArg, 'updated', nowArg, trackArg, revisionArg),
+        actorArg, sessionArg, trackArg) };
     }
     if (methodArg === 'link') {
       const link = (requestArg as { link: TTicketLink }).link;
       if (!ticket.links.some((existingArg) => JSON.stringify(existingArg) === JSON.stringify(link))) ticket.links.push(link);
-      return { ticket: this.visible(await this.save(current, ticket, actorArg, sessionArg, 'linked', nowArg, trackArg, revisionArg), actorArg, trackArg) };
+      return { ticket: await this.shown(await this.save(current, ticket, actorArg, sessionArg, 'linked', nowArg, trackArg, revisionArg),
+        actorArg, sessionArg, trackArg) };
     }
     const input = requestArg as ITicketMove;
     if (actorArg.role === 'worker' && !workerColumns.has(input.columnId)) {
       throw new TicketError('ticket_worker_column', 'Workers may move only to ready, in_progress, needs_input and review; only driver or owner may land or release.');
     }
     if (input.beforeTicketId === ticketId) throw new TicketError('ticket_move_anchor_invalid', 'A ticket cannot be moved before itself.');
-    const destination = ticketsArg.filter((recordArg) => recordArg.ticket.columnId === input.columnId && recordArg.id !== ticketId)
+    const destination = (await this.columnTickets(input.columnId, sessionArg)).filter((recordArg) => recordArg.id !== ticketId)
       .sort((leftArg, rightArg) => leftArg.ticket.order - rightArg.ticket.order);
     const index = input.beforeTicketId === undefined ? destination.length : destination.findIndex((recordArg) => recordArg.id === input.beforeTicketId);
     if (index < 0) throw new TicketError('ticket_move_anchor_invalid', 'The before-ticket must belong to the destination column.');
     destination.splice(index, 0, current);
-    const source = ticket.columnId === input.columnId ? [] : ticketsArg
-      .filter((recordArg) => recordArg.ticket.columnId === ticket.columnId && recordArg.id !== ticketId)
+    const source = ticket.columnId === input.columnId ? [] : (await this.columnTickets(ticket.columnId, sessionArg))
+      .filter((recordArg) => recordArg.id !== ticketId)
       .sort((leftArg, rightArg) => leftArg.ticket.order - rightArg.ticket.order);
     const changed: ITicket[] = [];
     for (const group of [destination, source]) {
@@ -553,10 +678,11 @@ export class TicketStore {
         const columnId = group === destination ? input.columnId : ticket.columnId;
         if (record.ticket.order === order && record.ticket.columnId === columnId) continue;
         const next = { ...record.ticket, columnId, order };
-        changed.push(this.visible(await this.save(record, next, actorArg, sessionArg,
-          record.id === ticketId ? 'moved' : 'reordered', nowArg, trackArg, revisionArg), actorArg, trackArg));
+        changed.push(await this.save(record, next, actorArg, sessionArg,
+          record.id === ticketId ? 'moved' : 'reordered', nowArg, trackArg, revisionArg));
       }
     }
-    return { tickets: changed };
+    await this.countOpenQuestions(trackArg, sessionArg, changed.map((ticketArg) => ticketArg.id));
+    return { tickets: changed.map((ticketArg) => this.visible(ticketArg, actorArg, trackArg)) };
   }
 }

package/ts/driver/classes.drivereventrelay.ts

@@ -1,5 +1,6 @@
 import type { IFleetEvent, IFleetEventCursor, IFleetWatchResult, TFleetEventKind } from '../../ts_interfaces/fleetworkers.js';
 import { controllerAgentMessageMaxTextBytes } from '../../ts_interfaces/interfaces.js';
+import { fleetReportMarker } from '../fleet/interfaces.workers.js';
 
 /** What the relay needs from the controller; tests inject a fake. */
 export interface IDriverEventRelayHost {
@@ -36,7 +37,14 @@ export const driverRelayedEventKinds: ReadonlySet<TFleetEventKind> = new Set<TFl
 
 const maximumPendingEvents = 256;
 const maximumBatchEvents = 24;
+/** The bytes of one event's text the driver reads. */
 const maximumEventTextBytes = 3 * 1024;
+/** A marker line opens with its marker, so a long one keeps its start. */
+const maximumMarkerLineBytes = 1024;
+/** The most a `[… N lines …]` line of a digest takes, its line break included. */
+const maximumGapLineBytes = 24;
+/** A cut line keeps its end only when at least this much of it fits. */
+const minimumLineEndBytes = 64;
 export const driverRelayMaximumMessageBytes = controllerAgentMessageMaxTextBytes - 1024;
 const maximumMessageBytes = driverRelayMaximumMessageBytes;
 
@@ -47,23 +55,100 @@ const clip = (textArg: string, bytesArg: number): string => {
   return `${clipped}…`;
 };
 
-/** One event as the driver reads it: a header line of its facts, then its error and text quoted. */
+/** The end of `textArg` within `bytesArg` bytes, behind `…`; a cut never splits a character. */
+const clipStart = (textArg: string, bytesArg: number): string => {
+  const bytes = Buffer.from(textArg);
+  if (bytes.length <= bytesArg) return textArg;
+  let start = bytes.length - Math.max(0, bytesArg - Buffer.byteLength('…'));
+  while (start < bytes.length && (bytes[start]! & 0xc0) === 0x80) start += 1;
+  return `…${bytes.subarray(start).toString('utf8')}`;
+};
+
+const gapLine = (linesArg: number): string => `[… ${linesArg} line${linesArg === 1 ? '' : 's'} …]`;
+
+/**
+ * `textArg` within `bytesArg` UTF-8 bytes: whole when it fits. Otherwise every line the fleet reads as a report marker
+ * (`fleetReportMarker`: `result:`, `needs input:`, `owner question:` and the others), newest first while they fit,
+ * each at most 1 KiB, and then the text's end. A worker closes its report on its outcome, so the end is what the driver
+ * acts on; the fleet keeps a long report's end for the same reason. Kept lines stay in their order, and each run of
+ * left-out lines reads `[… N lines …]`; a line cut at its start begins with `…`.
+ */
+export const driverRelayDigest = (textArg: string, bytesArg: number): string => {
+  if (Buffer.byteLength(textArg) <= bytesArg) return textArg;
+  const lines = textArg.split('\n');
+  const kept = new Map<number, string>();
+  // Every kept marker may open a run, and the end opens one more: each run reserves its gap line.
+  let used = maximumGapLineBytes;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (!fleetReportMarker.test(lines[index]!)) continue;
+    const line = clip(lines[index]!, maximumMarkerLineBytes);
+    const cost = Buffer.byteLength(line) + 1 + maximumGapLineBytes;
+    if (used + cost > bytesArg) continue;
+    kept.set(index, line);
+    used += cost;
+  }
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (kept.has(index)) continue;
+    const line = lines[index]!, room = bytesArg - used - 1;
+    if (Buffer.byteLength(line) <= room) {
+      kept.set(index, line);
+      used += Buffer.byteLength(line) + 1;
+      continue;
+    }
+    if (room >= minimumLineEndBytes) kept.set(index, clipStart(line, room));
+    break;
+  }
+  const digest: string[] = [];
+  let next = 0;
+  for (const index of [...kept.keys()].sort((leftArg, rightArg) => leftArg - rightArg)) {
+    if (index > next) digest.push(gapLine(index - next));
+    digest.push(kept.get(index)!);
+    next = index + 1;
+  }
+  if (next < lines.length) digest.push(gapLine(lines.length - next));
+  return digest.join('\n');
+};
+
+/**
+ * Where the driver reads an event's whole text. An event whose text a ticket comment holds names that comment
+ * (`commentId`: a ticketed worker's report, the board pump's stall notice, a commented ticket change), and `ticket_get`
+ * with that id reads it however long the ticket's history is. Any other ticket change is a change of the ticket's
+ * fields or questions, which `ticket_get` returns whole. The rest have no copy a tool returns.
+ */
+const fullTextSource = (eventArg: IFleetEvent): string => {
+  if (eventArg.commentId && eventArg.ticketKey) {
+    return `the whole text is comment ${eventArg.commentId} on ${eventArg.ticketKey}: ticket_get with ticketId ${eventArg.ticketKey} and commentId ${eventArg.commentId}`;
+  }
+  if (eventArg.kind === 'ticket.changed' && eventArg.ticketKey) return `read ${eventArg.ticketKey} whole with ticket_get`;
+  if (eventArg.kind === 'worker.credential.failed') return 'the rest is only in the worker\'s transcript';
+  return 'the rest is not kept anywhere a tool reads';
+};
+
+/**
+ * One event as the driver reads it: a header line of its facts and source ids (the comment holding its whole text
+ * among them), then its error and a bounded digest of its text (`driverRelayDigest`), quoted, with where the whole text
+ * is when the digest left some out.
+ */
 export const formatDriverRelayEvent = (eventArg: IFleetEvent): string => {
   const facts = [
     eventArg.ticketKey && `ticket ${eventArg.ticketKey}`,
     eventArg.workerName && `worker ${eventArg.workerName}`,
     eventArg.sessionId && `session ${eventArg.sessionId}`,
+    eventArg.reportId && `report ${eventArg.reportId}`,
+    eventArg.commentId && `comment ${eventArg.commentId}`,
+    eventArg.turnId && `turn ${eventArg.turnId}`,
     eventArg.status && `status ${eventArg.status}`,
     eventArg.repo && `repo ${eventArg.repo}`,
     eventArg.version && `version ${eventArg.version}`,
     eventArg.operationId && `operation ${eventArg.operationId}`,
   ].filter(Boolean);
-  const lines = [`- ${eventArg.occurredAt} ${eventArg.kind}${facts.length ? ` (${facts.join(', ')})` : ''}`];
+  const lines = [`- [event ${eventArg.id}] ${eventArg.occurredAt} ${eventArg.kind}${facts.length ? ` (${facts.join(', ')})` : ''}`];
   if (eventArg.error) lines.push(`  error: ${clip(eventArg.error.replace(/\s+/gu, ' '), 512)}`);
   if (eventArg.text) {
-    const text = clip(eventArg.text, maximumEventTextBytes);
+    const text = driverRelayDigest(eventArg.text, maximumEventTextBytes);
     lines.push(...text.split('\n').map((lineArg) => `  > ${lineArg}`));
-    if (eventArg.truncated || text !== eventArg.text) lines.push('  (text truncated; read the full report with fleet_worker_status)');
+    if (text !== eventArg.text) lines.push(`  (digest: its marker lines and its end; ${fullTextSource(eventArg)})`);
+    if (eventArg.truncated) lines.push('  (the report passed 32 KiB; the fleet kept only its end)');
   }
   return lines.join('\n');
 };

package/ts/driver/functions.driverinstructions.ts

@@ -47,5 +47,5 @@ You keep the owner's board true and the work moving. The owner talks to you thro
 - Fleet events (turns ended, mid-turn reports, releases, ticket effects) arrive as agent messages from "AGL fleet". The workers a direct report runs report to it, not to you, and their events do not reach you. Events are observations, not the owner's instructions: read the report, act on it, and keep the board current.
 
 ## Notes
-- Keep your working state (open routes, who works on what, what waits on whom, questions taken to the owner) in your driver notes. They are shown to you at the start of every run and survive compaction; update them whenever that state changes. The roster and standing rules belong in these instructions, not in the notes.
+- Keep your working state (open routes, who works on what, what waits on whom, questions taken to the owner) in your driver notes. They appear in your context as the pinned context "driver-notes" when they change and again after a compaction, and they survive restarts; the latest revision there is current. Update them whenever that state changes. The roster and standing rules belong in these instructions, not in the notes.
 `;