agl 40.5.1 → 41.0.0

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/classes.workercallerbindings.ts

@@ -0,0 +1,147 @@
+import * as plugins from './plugins.js';
+import type { IWorkerBridgeCommand, IWorkerProcessSnapshot } from './functions.workerprocessproof.js';
+
+/** The Claude process a kept binding was last proved against: its PID, start and the digest of its whole snapshot. */
+export interface IWorkerCallerBindingProcess {
+  pid: number;
+  startTicks: string;
+  snapshotDigest: string;
+}
+
+/**
+ * What the controller keeps of a fleet Claude worker's current caller launch, so a restarted controller proves the
+ * worker's bridge again instead of forgetting it. Never a credential, never the launch id or generation themselves:
+ * the overlay holds those, and a bridge presents them; the record keeps their digests to find and check the launch.
+ */
+export interface IWorkerCallerBindingDocument {
+  /** The fleet worker's id: a worker keeps one binding, its current launch's. */
+  id: string;
+  projectId: string;
+  harnessId: 'claude';
+  /** SHA-256 digests (base64url) of the launch id and of its generation. */
+  launchDigest: string;
+  generationDigest: string;
+  /** The bridge command approved when the launch was prepared, and the Claude Code executable it was proved against. */
+  command: IWorkerBridgeCommand;
+  claudeExecutable: string;
+  revision: number;
+  /** Once bound: the background job, its session, and the job's process when one was proved. */
+  binding?: { nativeSessionId: string; jobId: string; process?: IWorkerCallerBindingProcess };
+  updateId: string;
+}
+export type TWorkerCallerBindingRecord = Omit<IWorkerCallerBindingDocument, 'updateId'>;
+
+/** Where the controller keeps the bindings of fleet Claude launches. */
+export interface IWorkerCallerBindingStore {
+  /** The binding kept for the launch whose id has the digest `launchDigestArg`. */
+  find(launchDigestArg: string): Promise<TWorkerCallerBindingRecord | undefined>;
+  /** Keeps `recordArg` as its worker's binding; another launch's binding of the worker is replaced. */
+  save(recordArg: TWorkerCallerBindingRecord): Promise<void>;
+  /** Deletes the worker's binding; with `launchDigestArg`, only while it is that launch's. */
+  delete(workerIdArg: string, launchDigestArg?: string): Promise<void>;
+}
+
+export const workerCallerDigest = (valueArg: string): string => plugins.crypto.createHash('sha256').update(valueArg).digest('base64url');
+export const workerProcessSnapshotDigest = (snapshotArg: IWorkerProcessSnapshot): string => workerCallerDigest(JSON.stringify([
+  snapshotArg.pid, snapshotArg.parentPid, snapshotArg.startTicks, snapshotArg.executable, snapshotArg.arguments]));
+
+const digest = plugins.z.string().regex(/^[A-Za-z0-9_-]{43}$/u);
+const absolutePath = plugins.z.string().min(2).max(4096).refine((valueArg) => plugins.path.isAbsolute(valueArg) && !valueArg.includes('\0'));
+const documentSchema = plugins.z.object({
+  id: plugins.z.string().min(3).max(1024), projectId: plugins.z.string().regex(/^[A-Za-z0-9_.:-]{1,256}$/u),
+  harnessId: plugins.z.literal('claude'), launchDigest: digest, generationDigest: digest,
+  command: plugins.z.object({ executable: absolutePath, entry: absolutePath,
+    arguments: plugins.z.array(plugins.z.string().max(4096)).max(64) }).strict(),
+  claudeExecutable: absolutePath, revision: plugins.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  binding: plugins.z.object({ nativeSessionId: plugins.z.string().uuid(), jobId: plugins.z.string().regex(/^[A-Za-z0-9_.:-]{1,256}$/u),
+    process: plugins.z.object({ pid: plugins.z.number().int().min(2), startTicks: plugins.z.string().regex(/^\d{1,32}$/u),
+      snapshotDigest: digest }).strict().optional() }).strict().optional(),
+  updateId: plugins.z.string().uuid(),
+}).strict();
+
+@plugins.nosqldb.namedIndex({ name: 'worker_caller_launch', key: { launchDigest: 1 }, options: { unique: true } })
+@plugins.nosqldb.managed({ collectionName: 'agl_worker_caller_bindings' })
+@plugins.nosqldb.exactPersistence({ assertDocument: (input: unknown) => {
+  const doc = documentSchema.parse(input);
+  if (!doc.id.startsWith(`${doc.projectId}:`)) throw new Error('Worker caller binding identity mismatch.');
+  if (doc.binding && doc.revision < 1) throw new Error('Worker caller binding revision mismatch.');
+} })
+export class WorkerCallerBindingModel extends plugins.nosqldb.SmartDataDbDoc<WorkerCallerBindingModel, IWorkerCallerBindingDocument> {
+  declare static exact: plugins.nosqldb.TExact<WorkerCallerBindingModel>;
+  @plugins.nosqldb.unI() public id!: string;
+  @plugins.nosqldb.svDb() public projectId!: string;
+  @plugins.nosqldb.svDb() public harnessId!: 'claude';
+  @plugins.nosqldb.svDb() public launchDigest!: string;
+  @plugins.nosqldb.svDb() public generationDigest!: string;
+  @plugins.nosqldb.svDb() public command!: IWorkerBridgeCommand;
+  @plugins.nosqldb.svDb() public claudeExecutable!: string;
+  @plugins.nosqldb.svDb() public revision!: number;
+  @plugins.nosqldb.svDb() public binding?: IWorkerCallerBindingDocument['binding'];
+  @plugins.nosqldb.svDb() public updateId!: string;
+}
+
+const ambiguous = (errorArg: unknown): boolean => errorArg instanceof plugins.nosqldb.SmartdataExactPersistenceError && errorArg.code === 'ambiguous_write';
+const record = (documentArg: IWorkerCallerBindingDocument): TWorkerCallerBindingRecord => {
+  const { updateId: _updateId, ...rest } = structuredClone(documentArg);
+  return rest;
+};
+
+/** The kept bindings in the controller's store; the auth store owns the model manager and database. Writes run one at a time. */
+export class WorkerCallerBindingStore implements IWorkerCallerBindingStore {
+  private mutationTail: Promise<void> = Promise.resolve();
+
+  public async find(launchDigestArg: string): Promise<TWorkerCallerBindingRecord | undefined> {
+    const stored = await WorkerCallerBindingModel.exact.findStoredOne({ launchDigest: launchDigestArg });
+    return stored ? record(WorkerCallerBindingModel.exact.toPersisted(stored)) : undefined;
+  }
+
+  public save(recordArg: TWorkerCallerBindingRecord): Promise<void> {
+    return this.mutate(async () => {
+      const candidate: IWorkerCallerBindingDocument = { ...structuredClone(recordArg), updateId: plugins.crypto.randomUUID() };
+      const stored = await WorkerCallerBindingModel.exact.findStoredOne({ id: candidate.id });
+      try {
+        if (stored) {
+          const current = WorkerCallerBindingModel.exact.toPersisted(stored);
+          if (current.launchDigest === candidate.launchDigest) {
+            // A launch's binding only gains or renews its job; it is never unbound again.
+            if (current.binding && !candidate.binding) throw new Error('A kept worker caller binding cannot lose its job.');
+            const result = await WorkerCallerBindingModel.exact.transition({ current: stored, change: (model) => { Object.assign(model, candidate); } });
+            if (result.status !== 'transitioned') throw new Error('The kept worker caller binding changed concurrently.');
+            return;
+          }
+          const deleted = await WorkerCallerBindingModel.exact.delete({ current: stored });
+          if (deleted.status !== 'deleted') throw new Error('The kept worker caller binding changed concurrently.');
+        }
+        const inserted = await WorkerCallerBindingModel.exact.insert(candidate);
+        if (WorkerCallerBindingModel.exact.toPersisted(inserted.document).updateId !== candidate.updateId) {
+          throw new Error('Another worker caller binding holds this launch.');
+        }
+      } catch (error) {
+        if (!ambiguous(error)) throw error;
+        const after = await WorkerCallerBindingModel.exact.findStoredOne({ id: candidate.id });
+        if (!after || WorkerCallerBindingModel.exact.toPersisted(after).updateId !== candidate.updateId) {
+          throw new Error('Keeping the worker caller binding has an uncertain outcome.', { cause: error });
+        }
+      }
+    });
+  }
+
+  public delete(workerIdArg: string, launchDigestArg?: string): Promise<void> {
+    return this.mutate(async () => {
+      const stored = await WorkerCallerBindingModel.exact.findStoredOne({ id: workerIdArg });
+      if (!stored || launchDigestArg !== undefined && WorkerCallerBindingModel.exact.toPersisted(stored).launchDigest !== launchDigestArg) return;
+      try {
+        const result = await WorkerCallerBindingModel.exact.delete({ current: stored });
+        if (result.status !== 'deleted') throw new Error('The kept worker caller binding changed concurrently.');
+      } catch (error) {
+        if (!ambiguous(error) || await WorkerCallerBindingModel.exact.findStoredOne({ id: workerIdArg })) throw error;
+      }
+    });
+  }
+
+  private mutate(operationArg: () => Promise<void>): Promise<void> {
+    const task = this.mutationTail.then(operationArg);
+    this.mutationTail = task.then(() => undefined, () => undefined);
+    return task;
+  }
+}