agl 43.3.0 → 43.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (71) hide show
  1. package/changelog.md +9 -0
  2. package/dist_serve/bundle.js +2 -2
  3. package/dist_serve/bundle.js.map +2 -2
  4. package/dist_ts/00_commitinfo_data.js +1 -1
  5. package/dist_ts/classes.authstore.d.ts +7 -0
  6. package/dist_ts/classes.authstore.js +9 -1
  7. package/dist_ts/classes.claudeharness.d.ts +13 -2
  8. package/dist_ts/classes.claudeharness.js +12 -5
  9. package/dist_ts/classes.controller.d.ts +27 -6
  10. package/dist_ts/classes.controller.js +136 -39
  11. package/dist_ts/classes.mcpcontrollerhost.js +4 -1
  12. package/dist_ts/classes.mcptools.js +6 -1
  13. package/dist_ts/classes.nativesessions.d.ts +12 -0
  14. package/dist_ts/classes.nativesessions.js +1 -1
  15. package/dist_ts/classes.workercallers.js +4 -2
  16. package/dist_ts/driver/classes.directreports.js +19 -19
  17. package/dist_ts/driver/classes.directreportstore.d.ts +8 -1
  18. package/dist_ts/driver/classes.directreportstore.js +20 -10
  19. package/dist_ts/fleet/classes.workers.d.ts +16 -0
  20. package/dist_ts/fleet/classes.workers.js +73 -39
  21. package/dist_ts/fleet/classes.workerstore.js +14 -8
  22. package/dist_ts/fleet/functions.workervalidation.js +10 -3
  23. package/dist_ts/fleet/interfaces.workers.d.ts +6 -2
  24. package/dist_ts/fleet/interfaces.workers.js +8 -4
  25. package/dist_ts/functions.deviceapi.d.ts +50 -3
  26. package/dist_ts/functions.deviceapi.js +174 -7
  27. package/dist_ts/functions.exactpersistence.d.ts +3 -0
  28. package/dist_ts/functions.exactpersistence.js +4 -0
  29. package/dist_ts/functions.mcpfleetworkertools.js +2 -2
  30. package/dist_ts/functions.ticketactor.d.ts +17 -1
  31. package/dist_ts/functions.ticketactor.js +55 -15
  32. package/dist_ts_interfaces/devices.d.ts +17 -4
  33. package/dist_ts_interfaces/devices.js +1 -1
  34. package/dist_ts_interfaces/fleetworkers.d.ts +32 -7
  35. package/dist_ts_interfaces/fleetworkers.js +19 -8
  36. package/dist_ts_interfaces/workercallers.d.ts +2 -0
  37. package/dist_ts_migration/classes.documentmigrationrunner.d.ts +14 -0
  38. package/dist_ts_migration/classes.documentmigrationrunner.js +20 -1
  39. package/dist_ts_migration/index.d.ts +1 -0
  40. package/dist_ts_migration/index.js +2 -1
  41. package/dist_ts_migration/v43_ticketactornames.d.ts +32 -0
  42. package/dist_ts_migration/v43_ticketactornames.js +236 -0
  43. package/package.json +1 -1
  44. package/readme.md +34 -3
  45. package/ts/00_commitinfo_data.ts +1 -1
  46. package/ts/classes.authstore.ts +10 -0
  47. package/ts/classes.claudeharness.ts +18 -4
  48. package/ts/classes.controller.ts +142 -40
  49. package/ts/classes.mcpcontrollerhost.ts +3 -0
  50. package/ts/classes.mcptools.ts +5 -0
  51. package/ts/classes.nativesessions.ts +13 -0
  52. package/ts/classes.workercallers.ts +3 -1
  53. package/ts/driver/classes.directreports.ts +18 -18
  54. package/ts/driver/classes.directreportstore.ts +20 -9
  55. package/ts/fleet/classes.workers.ts +66 -39
  56. package/ts/fleet/classes.workerstore.ts +11 -7
  57. package/ts/fleet/functions.workervalidation.ts +7 -2
  58. package/ts/fleet/interfaces.workers.ts +6 -2
  59. package/ts/functions.deviceapi.ts +227 -6
  60. package/ts/functions.exactpersistence.ts +5 -0
  61. package/ts/functions.mcpfleetworkertools.ts +1 -1
  62. package/ts/functions.ticketactor.ts +58 -14
  63. package/ts_interfaces/devices.schema.json +5 -2
  64. package/ts_interfaces/devices.ts +20 -4
  65. package/ts_interfaces/fleetworkers.ts +33 -7
  66. package/ts_interfaces/workercallers.ts +2 -0
  67. package/ts_migration/classes.documentmigrationrunner.ts +21 -0
  68. package/ts_migration/index.ts +1 -0
  69. package/ts_migration/v43_ticketactornames.ts +225 -0
  70. package/ts_web/00_commitinfo_data.ts +1 -1
  71. package/ts_web/elements.fleetworker.ts +4 -2
@@ -40,6 +40,7 @@ import {
40
40
  type TControllerInboxItem,
41
41
  type TControllerInboxWhere,
42
42
  type TControllerSessionFeedDelta,
43
+ type IFleetWorkerJob,
43
44
  } from '../ts_interfaces/index.js';
44
45
  import {
45
46
  deviceLabelMaximumCharacters,
@@ -117,6 +118,12 @@ import { AglProxyOutdatedError, AglProxyRefusedError, AglProxyUnavailableError }
117
118
  import { TicketError, ticketBoardNarrows, ticketFilter, type ITicketBoardNarrowing, type TTicketErrorCode } from './classes.ticketstore.js';
118
119
  import { assertTicketRequest } from './functions.ticketvalidation.js';
119
120
  import { ticketColumns, ticketAutoLabels, type ticketErrorMessages } from '../ts_interfaces/tickets.js';
121
+ import type { TAuthErrorCode } from './interfaces.auth.js';
122
+ import { configurationErrorCodes, type TConfigurationErrorCode } from './configuration/classes.configurationerror.js';
123
+ import type { ControllerElicitationReplyError } from './functions.elicitation.js';
124
+ import type { FleetNativeTurnError } from './fleet/interfaces.workers.js';
125
+ import type { TClaudeDispatchRefusal } from './classes.claudeharness.js';
126
+ import type { INativeSessionFailedErrorData } from './classes.nativesessions.js';
120
127
 
121
128
  /*
122
129
  * The device API's requests and projections: what a device may ask, checked before anything is read, and the reduced
@@ -145,7 +152,7 @@ export const deviceRelayedEventTypes: ReadonlySet<TControllerEventType> = new Se
145
152
  ]);
146
153
 
147
154
  /** Every refusal code of the device contract, once: what a device request may be refused with as it is. */
148
- const deviceRefusalCodes: ReadonlySet<string> = new Set([...Object.keys({
155
+ export const deviceRefusalCodes: ReadonlySet<string> = new Set([...Object.keys({
149
156
  device_unknown: true,
150
157
  device_pairing_invalid: true,
151
158
  device_pairing_unavailable: true,
@@ -163,8 +170,192 @@ const deviceRefusalCodes: ReadonlySet<string> = new Set([...Object.keys({
163
170
  invalid_request: true,
164
171
  controller_unavailable: true,
165
172
  operation_limit: true,
173
+ concurrent_change: true,
174
+ outcome_unknown: true,
175
+ controller_failed: true,
166
176
  } satisfies Record<Exclude<TDeviceRefusalCode, TDeviceTicketRefusalCode>, true>), ...deviceTicketRefusalCodes]);
167
177
 
178
+ /**
179
+ * Every code the controller refuses a device's request with before the device error translation: the codes of the
180
+ * typed errors `asTypedResponseError` passes on as their own (the auth store's, the configuration authority's, an
181
+ * elicitation reply's, a native Codex turn's), the codes it gives the others (`controller_operation_failed` for a fault
182
+ * under a failure journal reference), and the codes the browser's shared functions a device runs refuse with (session
183
+ * reads and sends, native sessions, answers, direct children).
184
+ */
185
+ export type TControllerRefusalCode =
186
+ | TAuthErrorCode
187
+ | TConfigurationErrorCode
188
+ | ControllerElicitationReplyError['code']
189
+ | FleetNativeTurnError['code']
190
+ | typeof controllerOperationFailedErrorCode
191
+ | 'concurrent_change'
192
+ | 'operation_limit'
193
+ | 'session_not_found'
194
+ | 'outcome_unknown'
195
+ | 'flex_not_ready'
196
+ | 'flex_operation_failed'
197
+ | 'flex_projection_not_found'
198
+ | 'flex_projection_cursor_invalid'
199
+ | 'flex_projection_invalid'
200
+ | 'controller_unavailable'
201
+ | 'invalid_request'
202
+ | 'rate_limited'
203
+ | 'session_read_only'
204
+ | 'project_not_found'
205
+ | 'harness_unavailable'
206
+ | 'native_session_failed'
207
+ | 'not_found'
208
+ | 'child_scope_invalid'
209
+ | 'model_not_found'
210
+ | 'model_harness_mismatch'
211
+ | 'attachments_unsupported'
212
+ | 'message_rate_limited';
213
+
214
+ /** A controller refusal's device code, by its code alone or, where its data says more, by its data. */
215
+ type TDeviceRefusalOf = TDeviceRefusalCode | ((errorDataArg: Readonly<Record<string, unknown>>) => TDeviceRefusalCode);
216
+
217
+ /** A native send Claude Code refused before it went out because it was busy: nothing was sent, so read again. */
218
+ const deviceClaudeDispatchRefusals: Readonly<Record<TClaudeDispatchRefusal, TDeviceRefusalCode>> = {
219
+ // The conversation still works on a turn: another change to the same session runs.
220
+ busy: 'concurrent_change',
221
+ // As many Claude Code conversations work as the host runs: the controller's operation limit.
222
+ capacity: 'operation_limit',
223
+ };
224
+
225
+ /**
226
+ * A failed native session operation in the device contract: unless it says nothing reached the session (`refused`), the
227
+ * send or answer may have happened; a refusal a busy conversation or host caused is that state, any other a fault.
228
+ */
229
+ const deviceNativeSessionFailure = (errorDataArg: Readonly<Partial<Record<keyof INativeSessionFailedErrorData, unknown>>>): TDeviceRefusalCode => {
230
+ if (errorDataArg.outcome !== 'refused') return 'outcome_unknown';
231
+ const refusal = errorDataArg.refusal;
232
+ return typeof refusal === 'string' && Object.hasOwn(deviceClaudeDispatchRefusals, refusal)
233
+ ? deviceClaudeDispatchRefusals[refusal as TClaudeDispatchRefusal] : 'controller_failed';
234
+ };
235
+
236
+ /**
237
+ * How every controller code outside the device contract reaches a device: the one table the device error translation
238
+ * reads, so the compiler names every code a new controller refusal adds before a device can meet it. A state of the
239
+ * controller is `controller_unavailable`; a race AGL lost before it acted `concurrent_change`; a dispatch that may have
240
+ * happened `outcome_unknown`; a session the device can no longer reach `session_not_found`; a refusal the owner resolves
241
+ * in the browser `session_read_only`; and a fault, or a refusal of a request no device makes, `controller_failed` with
242
+ * the failure journal's reference.
243
+ */
244
+ export const deviceControllerRefusals: Readonly<Record<Exclude<TControllerRefusalCode, TDeviceRefusalCode>, TDeviceRefusalOf>> = {
245
+ // The auth store and the audit trail every device operation writes.
246
+ not_initialized: 'controller_unavailable',
247
+ config_mismatch: 'controller_failed',
248
+ setup_unavailable: 'controller_failed',
249
+ setup_invalid: 'controller_failed',
250
+ setup_expired: 'controller_failed',
251
+ ceremony_limit: 'controller_failed',
252
+ ceremony_invalid: 'controller_failed',
253
+ ceremony_replayed: 'controller_failed',
254
+ ceremony_expired: 'controller_failed',
255
+ origin_mismatch: 'controller_failed',
256
+ peer_mismatch: 'controller_failed',
257
+ verification_failed: 'controller_failed',
258
+ credential_not_found: 'controller_failed',
259
+ // A write whose commit AGL could not confirm.
260
+ ambiguous_write: 'outcome_unknown',
261
+ counter_conflict: 'controller_failed',
262
+ // A project that went away under the session a device names.
263
+ invalid_project: 'session_not_found',
264
+ invalid_resource: 'controller_failed',
265
+ invalid_settings: 'controller_failed',
266
+ temp_password_invalid: 'controller_failed',
267
+ temp_password_limit: 'controller_failed',
268
+ // The configuration authority the driver, the direct reports and the deploy monitor read.
269
+ invalid_argument: 'controller_failed',
270
+ conflict: 'concurrent_change',
271
+ // A prompt answered or withdrawn meanwhile (a native session's, an elicitation's), or a configuration record gone.
272
+ not_found: 'concurrent_change',
273
+ unsupported: 'controller_failed',
274
+ unbound: 'controller_unavailable',
275
+ unauthorized: 'controller_failed',
276
+ unavailable: 'controller_unavailable',
277
+ // A Codex turn that ended, or that another client runs, before the message reached it: nothing was sent.
278
+ turn_ended: 'concurrent_change',
279
+ delivery_unsupported: 'concurrent_change',
280
+ controller_operation_failed: 'controller_failed',
281
+ // The Flex harness: starting or recovering is a state; a page cursor it no longer knows is the device's to drop.
282
+ flex_not_ready: 'controller_unavailable',
283
+ flex_operation_failed: 'controller_failed',
284
+ flex_projection_not_found: 'session_not_found',
285
+ flex_projection_cursor_invalid: 'invalid_request',
286
+ flex_projection_invalid: 'controller_failed',
287
+ project_not_found: 'session_not_found',
288
+ harness_unavailable: 'controller_unavailable',
289
+ // A native session's failure says whether a send or an answer may have happened; without that, it may have.
290
+ native_session_failed: deviceNativeSessionFailure,
291
+ child_scope_invalid: 'session_not_found',
292
+ model_not_found: 'session_read_only',
293
+ model_harness_mismatch: 'session_read_only',
294
+ attachments_unsupported: 'session_read_only',
295
+ message_rate_limited: 'rate_limited',
296
+ };
297
+
298
+ /**
299
+ * The controller codes whose message may carry a raw cause (a socket path, a spawn error, a dependency's own text): a
300
+ * native session's failure, an unavailable harness's diagnostic, and the configuration authority's refusals. A device
301
+ * gets the sentence of the device code they map to instead (`deviceRefusalSentences`); the cause stays in the log.
302
+ */
303
+ const deviceRawTextCodes: ReadonlySet<string> = new Set<TControllerRefusalCode>(['native_session_failed', 'harness_unavailable', ...configurationErrorCodes]);
304
+
305
+ /** What a device reads for `outcome_unknown` in place of a message that may carry a raw cause. */
306
+ const deviceOutcomeUnknownSentence = 'The request may have taken effect. Read again to learn whether it did before sending it again.';
307
+
308
+ /** The device's own sentence for a refusal whose controller message may carry a raw cause. */
309
+ const deviceRefusalSentences: Readonly<Partial<Record<TDeviceRefusalCode, string>>> = {
310
+ outcome_unknown: deviceOutcomeUnknownSentence,
311
+ concurrent_change: 'Something else changed this at the same time, and nothing was done. Read it again, then decide.',
312
+ operation_limit: 'The controller is busy. Try again once current work has finished.',
313
+ controller_unavailable: 'The controller cannot do this now. Try again later.',
314
+ // Only for a refusal of `deviceRawTextCodes`, which says the message did not go out.
315
+ direct_report_failed: 'The direct report did not take the message.',
316
+ };
317
+
318
+ /** What a device reads for `controller_failed`: the cause is the failure journal's, under the reference beside it. */
319
+ const deviceControllerFailedSentence = 'The controller operation failed.';
320
+
321
+ /** A controller refusal's code in the device contract: as it is where the contract has it, else by the table. */
322
+ const deviceRefusalCodeOf = (codeArg: unknown, errorDataArg: Readonly<Record<string, unknown>>): TDeviceRefusalCode | undefined => {
323
+ if (typeof codeArg !== 'string') return undefined;
324
+ if (deviceRefusalCodes.has(codeArg)) return codeArg as TDeviceRefusalCode;
325
+ if (!Object.hasOwn(deviceControllerRefusals, codeArg)) return undefined;
326
+ const refusal = deviceControllerRefusals[codeArg as keyof typeof deviceControllerRefusals];
327
+ return typeof refusal === 'function' ? refusal(errorDataArg) : refusal;
328
+ };
329
+
330
+ /**
331
+ * The device error translation: the refusal a device receives for the typed refusal `typedArg` the controller answers
332
+ * `causeArg` with, always a code of the device contract. A contract code passes as it is; every other code maps through
333
+ * `deviceControllerRefusals`, with the controller's message, or the device code's own sentence where that message may
334
+ * carry a raw cause (`deviceRawTextCodes`). A fault, and a code the table does not know, is `controller_failed` with one
335
+ * fixed sentence and the failure journal's reference: the controller's own when it kept the cause, else one recorded
336
+ * here for `methodArg`.
337
+ */
338
+ export const deviceContractError = (
339
+ typedArg: plugins.typedrequest.TypedResponseError,
340
+ causeArg: unknown,
341
+ methodArg: string,
342
+ ): plugins.typedrequest.TypedResponseError => {
343
+ const errorData: Readonly<Record<string, unknown>> = typeof typedArg.errorData === 'object' && typedArg.errorData !== null
344
+ ? typedArg.errorData as Record<string, unknown> : {};
345
+ const code = deviceRefusalCodeOf(errorData.code, errorData);
346
+ if (code !== undefined && code !== 'controller_failed') {
347
+ if (code === errorData.code) return typedArg;
348
+ return deviceRefusal(code, typeof errorData.code === 'string' && deviceRawTextCodes.has(errorData.code)
349
+ ? deviceRefusalSentences[code] ?? 'AGL refused the request.' : typedArg.errorText);
350
+ }
351
+ let reference = errorData.reference;
352
+ if (typeof reference !== 'string') {
353
+ reference = controllerFailureJournal.record({ operation: methodArg, cause: causeArg });
354
+ console.error(`A device's ${methodArg} failed (ref ${reference}):`, causeArg);
355
+ }
356
+ return new plugins.typedrequest.TypedResponseError(deviceControllerFailedSentence, { code: 'controller_failed' satisfies TDeviceRefusalCode, reference });
357
+ };
358
+
168
359
  /** The code a typed refusal carries, if any. */
169
360
  const typedResponseErrorCode = (errorArg: unknown): unknown => (
170
361
  errorArg instanceof plugins.typedrequest.TypedResponseError ? (errorArg.errorData as { code?: unknown } | undefined)?.code : undefined
@@ -202,7 +393,9 @@ export const serveDeviceDriver = async <T>(operationArg: () => Promise<T>): Prom
202
393
  * A failure of the owner's message to a direct report, in the device contract: another Codex client's turn is
203
394
  * `direct_report_busy` (a device reads no turn to name), the agent message rate `rate_limited` (final, as for every
204
395
  * device request), and every other refusal outside the contract `direct_report_failed` with its text and the failure
205
- * journal's reference, where AGL kept the cause. Other failures are answered as `serveDirectReport` answers them.
396
+ * journal's reference, where AGL kept the cause; a refusal whose message may carry a raw cause (`deviceRawTextCodes`)
397
+ * reads `deviceRefusalSentences.direct_report_failed` instead, its message kept in the failure journal. Other failures
398
+ * are answered as `serveDirectReport` answers them.
206
399
  */
207
400
  export const deviceDirectReportMessageRefusal = (errorArg: unknown): unknown => {
208
401
  if (!(errorArg instanceof plugins.typedrequest.TypedResponseError)) return errorArg;
@@ -212,19 +405,47 @@ export const deviceDirectReportMessageRefusal = (errorArg: unknown): unknown =>
212
405
  }
213
406
  if (code === 'message_rate_limited') return deviceRefusal('rate_limited', errorArg.errorText);
214
407
  if (typeof code === 'string' && deviceRefusalCodes.has(code)) return errorArg;
408
+ // A message that may have reached the report is never `direct_report_failed`, which says it took none.
409
+ if (deviceRefusalCodeOf(code, errorArg.errorData as Readonly<Record<string, unknown>>) === 'outcome_unknown') {
410
+ return deviceContractError(errorArg, errorArg, 'device.directreport.message');
411
+ }
412
+ if (typeof code === 'string' && deviceRawTextCodes.has(code)) {
413
+ const reference = controllerFailureJournal.record({ operation: 'device.directreport.message', cause: errorArg });
414
+ console.error(`A device's direct report message failed (ref ${reference}):`, errorArg);
415
+ return new plugins.typedrequest.TypedResponseError(`${deviceRefusalSentences.direct_report_failed} (ref ${reference})`,
416
+ { code: 'direct_report_failed' satisfies TDeviceRefusalCode });
417
+ }
215
418
  const reference = code === controllerOperationFailedErrorCode ? (errorArg.errorData as { reference?: unknown }).reference : undefined;
216
419
  return deviceRefusal('direct_report_failed', `${errorArg.errorText}${typeof reference === 'string' ? ` (ref ${reference})` : ''}`.slice(0, 4096));
217
420
  };
218
421
 
422
+ /**
423
+ * A device's refusal of its message to a direct report whose fleet job failed. A job that may have delivered the
424
+ * message (`IFleetWorkerJob.errorOutcome` other than `refused`: the steer failed after its dispatch, or nothing proves
425
+ * it did not) is `outcome_unknown`, which a client never sends again on its own, never `direct_report_failed`, which
426
+ * says the report took no message. A job that sent nothing is `direct_report_failed`: a refusal the fleet wrote itself
427
+ * (`errorCode`) with its text, any other with the controller's generic sentence. Where the device does not read the
428
+ * job's error, the failure journal keeps it under the reference the message ends with, as the Driver view shows it.
429
+ */
430
+ export const deviceDirectReportJobRefusal = (jobArg: IFleetWorkerJob): plugins.typedrequest.TypedResponseError => {
431
+ const delivered = jobArg.errorOutcome !== 'refused';
432
+ if (!delivered && jobArg.errorCode !== undefined && jobArg.error !== undefined) return deviceRefusal('direct_report_failed', jobArg.error.slice(0, 4096));
433
+ const cause = jobArg.error ?? 'The fleet job failed without an error.';
434
+ const reference = controllerFailureJournal.record({ operation: 'device.directreport.message', cause });
435
+ console.error(`A device's direct report message failed in fleet job ${jobArg.id} (ref ${reference}):`, cause);
436
+ return delivered ? deviceRefusal('outcome_unknown', `${deviceOutcomeUnknownSentence} (ref ${reference})`)
437
+ : deviceRefusal('direct_report_failed', `${deviceControllerFailedSentence} (ref ${reference})`);
438
+ };
439
+
219
440
  /**
220
441
  * How the ticket store's refusals outside `ticketErrorMessages` reach a device: a concurrent change the transaction lost
221
- * wrote nothing and reads as the board having changed meanwhile; a commit whose outcome is unknown is a state of the
222
- * controller (AGL-1670 gives it a code of its own, which a client never resends); a fleet event's conflict and an owner
223
- * capability the controller could not verify answer no device request.
442
+ * wrote nothing and reads as the board having changed meanwhile; a commit whose outcome is unknown may have happened,
443
+ * which a client never resends but reads the ticket again to learn; a fleet event's conflict and an owner capability the
444
+ * controller could not verify answer no device request.
224
445
  */
225
446
  const deviceTicketStoreRefusals: Readonly<Record<Exclude<TTicketErrorCode, keyof typeof ticketErrorMessages>, TDeviceRefusalCode>> = {
226
447
  concurrent_change: 'ticket_revision_conflict',
227
- outcome_unknown: 'controller_unavailable',
448
+ outcome_unknown: 'outcome_unknown',
228
449
  ticket_fleet_event_conflict: 'invalid_request',
229
450
  unauthorized: 'invalid_request',
230
451
  };
@@ -0,0 +1,5 @@
1
+ import * as plugins from './plugins.js';
2
+
3
+ /** Whether an error is the persistence client's exact-write error of this code (`SmartdataExactPersistenceError`). */
4
+ export const exactError = (errorArg: unknown, codeArg: plugins.nosqldb.TExactPersistenceErrorCode): boolean =>
5
+ errorArg instanceof plugins.nosqldb.SmartdataExactPersistenceError && errorArg.code === codeArg;
@@ -16,7 +16,7 @@ const descriptions: Record<TFleetWorkerAction, string> = {
16
16
  list: 'List this owner\'s fleet workers as summaries, newest first, in pages of limit (1-100, default 50): identity, ticket, state, native id, cwd, the native status, newest turn outcome and native wait last observed, and fence flags (an unresolved dispatch with its action and since, a lost or reconfirmed dispatch, a recorded error). total, fenced and failed (recorded errors and failed turn outcomes) count the whole filtered set, so a page never hides a fence. Continue with nextCursor and the same filter (archived, ticketKey, state, harness); a cursor of another filter or one after a worker no longer held as it was is refused. view full returns every full record unpaged; fleet_worker_get returns one worker whole.',
17
17
  get: 'Read one of this owner\'s fleet workers, archived ones included, by name or id: its full record (dispatch fence, lost, reconfirmed and re-bind resolutions with their attribution and proof, error) and the native status, turn outcome and start, native wait and excerpt the controller last observed.',
18
18
  status: 'Read a fleet operation job (the handle a fleet_worker_* action returns), not a host job. Jobs are transient; bindings and unresolved dispatches survive restart. Inspect unknown native outcomes before retrying.',
19
- 'job-wait': 'Wait until a fleet operation job (the handle a fleet_worker_* action returns, not a host job) succeeds or fails, or timeoutMs (at most 240000) passes; timedOut tells which. Waiting, a timeout or an abandoned wait never cancels the job. A job the controller no longer holds (jobs end with a controller restart or eviction) is JOB_UNAVAILABLE, not failed: read the worker with fleet_worker_get.',
19
+ 'job-wait': 'Wait until a fleet operation job (the handle a fleet_worker_* action returns, not a host job) succeeds or fails, or timeoutMs (at most 240000) passes; timedOut tells which. Waiting, a timeout or an abandoned wait never cancels the job. A job the controller no longer holds (jobs end with a controller restart or eviction) is JOB_UNAVAILABLE, not failed: read the worker with fleet_worker_get. A failed job\'s errorOutcome is refused when nothing reached a native session, unknown when it may have (a steer may have been delivered): never repeat an unknown one before reading the worker.',
20
20
  'native-message': 'Reach a Claude Code background job that no fleet worker binds with an attributed message, through Claude Code itself, as the browser\'s native session send does: a settled (done, blocked or stopped) job is woken with it (`claude --bg --resume <id> <text>`), a running one takes it in its inbox through Claude Code\'s own SendMessage, accepted and queued there, not yet read. nativeId is the full session id or a unique prefix of at least 8 characters; an ambiguous prefix is refused. A running job without a session name of its own (none, or one another running session shares), a failed or held job, a fleet worker\'s session and a project conversation are refused with their reason. The message arrives behind the same attribution header as session_message, naming the sender label and the local owner capability, never as the job\'s user. It holds no dispatch fence, writes no ticket comment and does not observe the turn that reads it; the receipt (delivery native-wake or native-inbox) names the command that adopts the job as a fleet worker. Returns a job handle; an unknown outcome is never retried.',
21
21
  watch: 'Read the one bounded fleet event stream: worker turn endings, reports during turns, reaped Claude worker observations, release outcomes, and host load. Continue with the returned epoch/cursor; reset explicitly signals restart or retained-history gaps.',
22
22
  };
@@ -1,20 +1,64 @@
1
- import type { IControllerMcpCaller } from '../ts_interfaces/mcprequests.js';
1
+ import type { TControllerSessionHarnessId } from '../ts_interfaces/interfaces.js';
2
+ import type { IControllerMcpCaller, TControllerMcpSubject } from '../ts_interfaces/mcprequests.js';
2
3
  import { ticketErrorMessages, type ITicketActor } from '../ts_interfaces/tickets.js';
3
4
  import { TicketError } from './classes.ticketstore.js';
4
5
 
5
- export const ticketActorFromCaller = (callerArg: IControllerMcpCaller): ITicketActor => {
6
- const subject = callerArg.subject;
7
- if (subject.kind === 'anonymous') throw new TicketError('ticket_identity_required', ticketErrorMessages.ticket_identity_required);
8
- if (subject.kind === 'worker_launch') return { id: subject.sessionIdentityId,
9
- name: subject.ticketSessionId, sessionId: subject.ticketSessionId, kind: subject.harnessId, role: 'worker' };
10
- if (subject.kind === 'session') {
11
- const sessionId = `${subject.sessionId.harnessId}:${subject.sessionId.nativeId}`;
12
- return { id: subject.sessionIdentityId, name: sessionId, sessionId,
13
- kind: subject.sessionId.harnessId === 'codex' ? 'codex' : 'worker', role: 'worker' };
6
+ /**
7
+ * What a ticket calls a session no direct report or fleet worker names: its harness's label, never its session id. A
8
+ * new harness does not compile until it has one.
9
+ */
10
+ export const ticketSessionLabels: Readonly<Record<TControllerSessionHarnessId, string>> = {
11
+ claude: 'Claude Code session',
12
+ codex: 'Codex session',
13
+ opencode: 'OpenCode session',
14
+ flex: 'Flex session',
15
+ };
16
+ /** What a ticket calls the OpenCode runtime's caller: one server per controller, never one session (AGL-1686). */
17
+ export const ticketOpenCodeRuntimeName = 'OpenCode';
18
+
19
+ /** The native session an MCP caller acts in, as tickets name it (`harness:nativeId`); none for a caller without one. */
20
+ export const ticketCallerSessionId = (callerArg: IControllerMcpCaller): string | undefined => {
21
+ const subject: TControllerMcpSubject = callerArg.subject;
22
+ switch (subject.kind) {
23
+ case 'worker_launch': return subject.ticketSessionId;
24
+ case 'session': return `${subject.sessionId.harnessId}:${subject.sessionId.nativeId}`;
25
+ case 'terminal': return subject.agentSessionId === undefined ? undefined : `claude:${subject.agentSessionId}`;
26
+ case 'runtime':
27
+ case 'anonymous': return undefined;
28
+ default: {
29
+ const exhaustive: never = subject;
30
+ throw new Error(`Unknown MCP caller subject ${(exhaustive as { kind: string }).kind}.`);
31
+ }
14
32
  }
15
- if (subject.kind === 'terminal' && subject.agentSessionId) {
16
- const sessionId = `claude:${subject.agentSessionId}`;
17
- return { id: sessionId, name: sessionId, sessionId, kind: 'claude', role: 'worker' };
33
+ };
34
+
35
+ /**
36
+ * The actor a ticket records for an MCP caller. It is named by its role, never by a session id (AGL-1686): the active
37
+ * direct report whose session the caller acts in (`reportNameArg`, which the caller resolves once through
38
+ * `DirectReports.reportOf` with `ticketCallerSessionId`), else the fleet worker's name, else its harness's label; the
39
+ * OpenCode runtime is "OpenCode". `id` and `sessionId` identify the actor; the name is display only.
40
+ */
41
+ export const ticketActorFromCaller = (callerArg: IControllerMcpCaller, reportNameArg?: string): ITicketActor => {
42
+ const subject: TControllerMcpSubject = callerArg.subject;
43
+ switch (subject.kind) {
44
+ case 'anonymous': throw new TicketError('ticket_identity_required', ticketErrorMessages.ticket_identity_required);
45
+ case 'worker_launch': return { id: subject.sessionIdentityId, name: reportNameArg ?? subject.workerName,
46
+ sessionId: subject.ticketSessionId, kind: subject.harnessId, role: 'worker' };
47
+ case 'session': {
48
+ const sessionId = `${subject.sessionId.harnessId}:${subject.sessionId.nativeId}`;
49
+ return { id: subject.sessionIdentityId, name: reportNameArg ?? ticketSessionLabels[subject.sessionId.harnessId], sessionId,
50
+ kind: subject.sessionId.harnessId === 'codex' ? 'codex' : 'worker', role: 'worker' };
51
+ }
52
+ case 'terminal': {
53
+ // A terminal without an agent session acts in no session.
54
+ if (subject.agentSessionId === undefined) return { id: callerArg.auditPeerId, name: 'terminal', kind: 'worker', role: 'worker' };
55
+ const sessionId = `claude:${subject.agentSessionId}`;
56
+ return { id: sessionId, name: reportNameArg ?? ticketSessionLabels.claude, sessionId, kind: 'claude', role: 'worker' };
57
+ }
58
+ case 'runtime': return { id: callerArg.auditPeerId, name: ticketOpenCodeRuntimeName, kind: 'worker', role: 'worker' };
59
+ default: {
60
+ const exhaustive: never = subject;
61
+ throw new Error(`Unknown MCP caller subject ${(exhaustive as { kind: string }).kind}.`);
62
+ }
18
63
  }
19
- return { id: callerArg.auditPeerId, name: subject.kind, kind: 'worker', role: 'worker' };
20
64
  };
@@ -4098,9 +4098,12 @@
4098
4098
  "rate_limited",
4099
4099
  "invalid_request",
4100
4100
  "controller_unavailable",
4101
- "operation_limit"
4101
+ "operation_limit",
4102
+ "concurrent_change",
4103
+ "outcome_unknown",
4104
+ "controller_failed"
4102
4105
  ],
4103
- "description": "Why AGL refused a device request, as `error.data.code`: `device_unknown`: no such device is paired (any more): forget the pairing; `device_pairing_invalid`: the code is unknown, used or expired; `device_pairing_unavailable`: the controller has no public origin, so nothing can pair with it; `device_limit`: the controller holds its maximum of devices; `device_already_paired`: this key is paired already; `device_proof_invalid`: the signature does not verify; `device_challenge_invalid`: no live nonce of this connection for this device; `device_authentication_required`: the connection is not authenticated as a device; `session_not_found`: the session feed lists no such session (or, for a `childSessionId`, the session has no such direct child that runs); `session_read_only`: AGL does not write to the session (another process runs it, a fleet worker owns it); the ticket store's own refusals, `deviceTicketRefusalCodes`, each with the store's reason (since 1.3; these four since 1.2): `ticket_not_found`, `ticket_question_not_found`: no such ticket, or no such question on it; `ticket_question_answered`: the question already has a different answer; a second answer is refused; `ticket_answer_invalid`: the answer chooses options the question does not have, more than one where it takes one, or text where it takes none; `driver_absent`: the host has no driver session; the owner starts the driver in the browser, a device never does (since 1.3); `direct_report_failed`: the direct report took no message, or AGL could not confirm it did: it is not an active report, it is a Claude Code session the fleet does not run, or its fleet job or Codex server failed; the message says why (since 1.3); `direct_report_busy`: the report's Codex thread runs a turn another Codex client started, which a device does not steer; nothing was sent: send it again once that turn ended (since 1.3); `rate_limited`, `invalid_request`, `controller_unavailable` and `operation_limit` as for any client. In this device protocol version (1.0) AGL sends no retry hint with a refusal (no `retry` beside the error, no retry timing in `error.data`), and `rate_limited` is final: a client never resends the refused request on its own; it shows the refusal, and the user may try again."
4106
+ "description": "Why AGL refused a device request, as `error.data.code`: `device_unknown`: no such device is paired (any more): forget the pairing; `device_pairing_invalid`: the code is unknown, used or expired; `device_pairing_unavailable`: the controller has no public origin, so nothing can pair with it; `device_limit`: the controller holds its maximum of devices; `device_already_paired`: this key is paired already; `device_proof_invalid`: the signature does not verify; `device_challenge_invalid`: no live nonce of this connection for this device; `device_authentication_required`: the connection is not authenticated as a device; `session_not_found`: the session feed lists no such session (or, for a `childSessionId`, the session has no such direct child that runs); `session_read_only`: AGL does not write to the session for a device now: another process runs it, a fleet worker owns it, or it needs the owner in the browser first (its model is no longer available, or a stopped message holds files its connection cannot read); the message says which; the ticket store's own refusals, `deviceTicketRefusalCodes`, each with the store's reason (since 1.3; these four since 1.2): `ticket_not_found`, `ticket_question_not_found`: no such ticket, or no such question on it; `ticket_question_answered`: the question already has a different answer; a second answer is refused; `ticket_answer_invalid`: the answer chooses options the question does not have, more than one where it takes one, or text where it takes none; `driver_absent`: the host has no driver session; the owner starts the driver in the browser, a device never does (since 1.3); `direct_report_failed`: the direct report took no message, or AGL could not confirm it did: it is not an active report, it is a Claude Code session the fleet does not run, or its fleet job or Codex server failed; the message says why (since 1.3); a message AGL dispatched without learning whether it arrived is `outcome_unknown`; `direct_report_busy`: the report's Codex thread runs a turn another Codex client started, which a device does not steer; nothing was sent: send it again once that turn ended (since 1.3); `rate_limited`, `invalid_request`, `controller_unavailable` and `operation_limit` as for any client; `concurrent_change`: another change to the same session or record ran at the same time (a turn another client runs, a session being archived or deleted, a prompt answered meanwhile), and AGL did not carry the request out: read again, then decide (since 1.3); `outcome_unknown`: AGL dispatched the request, or may have, and cannot tell whether it took effect: it may have happened. A client never resends it on its own; it reads the session, the driver or the ticket again to learn the outcome, and the user decides (since 1.3; `device.session.send` and `device.ticket.answer` sent it before as it was); `controller_failed`: AGL failed the request; the message is always \"The controller operation failed.\", and AGL keeps the cause in its failure journal under `error.data.reference`, which the owner's browser shows (since 1.3; a device got the browser's `controller_operation_failed` before). The set is closed: every refusal of every device method is one of these codes, whatever the controller refused it with, and a client may treat any other code as `controller_failed`. In this device protocol version (1.0) AGL sends no retry hint with a refusal (no `retry` beside the error, no retry timing in `error.data`), and `rate_limited` is final: a client never resends the refused request on its own; it shows the refusal, and the user may try again."
4104
4107
  },
4105
4108
  "TDeviceReportWorkerStatus": {
4106
4109
  "type": "string",
@@ -103,7 +103,9 @@ export type TDeviceTicketRefusalCode = (typeof deviceTicketRefusalCodes)[number]
103
103
  * `device_authentication_required`: the connection is not authenticated as a device;
104
104
  * `session_not_found`: the session feed lists no such session (or, for a `childSessionId`, the session has no such
105
105
  * direct child that runs);
106
- * `session_read_only`: AGL does not write to the session (another process runs it, a fleet worker owns it);
106
+ * `session_read_only`: AGL does not write to the session for a device now: another process runs it, a fleet worker owns
107
+ * it, or it needs the owner in the browser first (its model is no longer available, or a stopped message holds files its
108
+ * connection cannot read); the message says which;
107
109
  * the ticket store's own refusals, `deviceTicketRefusalCodes`, each with the store's reason (since 1.3; these four since
108
110
  * 1.2): `ticket_not_found`, `ticket_question_not_found`: no such ticket, or no such question on it;
109
111
  * `ticket_question_answered`: the question already has a different answer; a second answer is refused;
@@ -113,10 +115,21 @@ export type TDeviceTicketRefusalCode = (typeof deviceTicketRefusalCodes)[number]
113
115
  * (since 1.3);
114
116
  * `direct_report_failed`: the direct report took no message, or AGL could not confirm it did: it is not an active
115
117
  * report, it is a Claude Code session the fleet does not run, or its fleet job or Codex server failed; the message says
116
- * why (since 1.3);
118
+ * why (since 1.3); a message AGL dispatched without learning whether it arrived is `outcome_unknown`;
117
119
  * `direct_report_busy`: the report's Codex thread runs a turn another Codex client started, which a device does not
118
120
  * steer; nothing was sent: send it again once that turn ended (since 1.3);
119
- * `rate_limited`, `invalid_request`, `controller_unavailable` and `operation_limit` as for any client.
121
+ * `rate_limited`, `invalid_request`, `controller_unavailable` and `operation_limit` as for any client;
122
+ * `concurrent_change`: another change to the same session or record ran at the same time (a turn another client runs,
123
+ * a session being archived or deleted, a prompt answered meanwhile), and AGL did not carry the request out: read again,
124
+ * then decide (since 1.3);
125
+ * `outcome_unknown`: AGL dispatched the request, or may have, and cannot tell whether it took effect: it may have
126
+ * happened. A client never resends it on its own; it reads the session, the driver or the ticket again to learn the
127
+ * outcome, and the user decides (since 1.3; `device.session.send` and `device.ticket.answer` sent it before as it was);
128
+ * `controller_failed`: AGL failed the request; the message is always "The controller operation failed.", and AGL keeps
129
+ * the cause in its failure journal under `error.data.reference`, which the owner's browser shows (since 1.3; a device got
130
+ * the browser's `controller_operation_failed` before).
131
+ * The set is closed: every refusal of every device method is one of these codes, whatever the controller refused it
132
+ * with, and a client may treat any other code as `controller_failed`.
120
133
  * In this device protocol version (1.0) AGL sends no retry hint with a refusal (no `retry` beside the error, no retry
121
134
  * timing in `error.data`), and `rate_limited` is final: a client never resends the refused request on its own; it shows
122
135
  * the refusal, and the user may try again.
@@ -139,7 +152,10 @@ export type TDeviceRefusalCode =
139
152
  | 'rate_limited'
140
153
  | 'invalid_request'
141
154
  | 'controller_unavailable'
142
- | 'operation_limit';
155
+ | 'operation_limit'
156
+ | 'concurrent_change'
157
+ | 'outcome_unknown'
158
+ | 'controller_failed';
143
159
 
144
160
  /** The harness a session runs on. */
145
161
  export type TDeviceHarness = 'claude' | 'codex' | 'flex' | 'opencode';
@@ -264,14 +264,23 @@ export interface IFleetWorkerSummaryPage {
264
264
  nextCursor?: string;
265
265
  }
266
266
  /**
267
- * The refusals of the fleet worker reads, passed to the caller with their message: `job_unavailable`, the controller
268
- * holds no such job of the owner (jobs are transient: a controller restart or eviction drops them; read the worker
269
- * with `fleet_worker_get`); `worker_not_found`, the owner has no worker of that name or id; `list_cursor_mismatch`, the
270
- * cursor belongs to another filter; `list_cursor_stale`, the worker the cursor continues after is no longer held as
271
- * it was; `list_cursor_invalid`, the cursor is not one a summary list returned (a `limit` or `cursor` with the full view is
272
- * refused by request validation instead).
267
+ * The fleet's own refusals, whose text AGL writes, passed to the caller with their message, thrown or as a failed job's
268
+ * `errorCode`. Of the worker reads: `job_unavailable`, the controller holds no such job of the owner (jobs are
269
+ * transient: a controller restart or eviction drops them; read the worker with `fleet_worker_get`); `worker_not_found`,
270
+ * the owner has no worker of that name or id; `list_cursor_mismatch`, the cursor belongs to another filter;
271
+ * `list_cursor_stale`, the worker the cursor continues after is no longer held as it was; `list_cursor_invalid`, the
272
+ * cursor is not one a summary list returned (a `limit` or `cursor` with the full view is refused by request validation
273
+ * instead). Of the jobs, the relaunch and the dispatch fences, by what the caller does next: `fleet_unavailable`, the
274
+ * fleet admits no job now (it is closing, holds its most jobs, or cannot prove its own process); try again later;
275
+ * `worker_fenced`, the worker's dispatch fence stands in the way (an unresolved or running dispatch, one resolved as
276
+ * lost, a reconfirmation without its ticket comment, a fence or record another job changed, no native session yet);
277
+ * inspect the worker before acting again; `worker_archived`, the worker is archived; `ticket_mismatch`, the worker is
278
+ * bound to another ticket; `worker_conflict`, the request does not fit what the fleet holds (the name is taken, the
279
+ * session is bound already, the harness has no relaunch or native sessions, the profile is not configured, the
280
+ * directory is none, the session cannot be adopted as that identity); change the request.
273
281
  */
274
- export const fleetWorkerErrorCodes = ['job_unavailable', 'worker_not_found', 'list_cursor_mismatch', 'list_cursor_stale', 'list_cursor_invalid'] as const;
282
+ export const fleetWorkerErrorCodes = ['job_unavailable', 'worker_not_found', 'list_cursor_mismatch', 'list_cursor_stale', 'list_cursor_invalid',
283
+ 'fleet_unavailable', 'worker_fenced', 'worker_archived', 'ticket_mismatch', 'worker_conflict'] as const;
275
284
  export type TFleetWorkerErrorCode = (typeof fleetWorkerErrorCodes)[number];
276
285
  export type TFleetWorkerRequest<T extends TFleetWorkerAction> = IFleetWorkerRequests[T];
277
286
  export interface IFleetWorkerJob {
@@ -284,8 +293,25 @@ export interface IFleetWorkerJob {
284
293
  ticketSync?: IFleetTicketSync;
285
294
  /** What a `native-message` job delivered. */
286
295
  nativeMessage?: IFleetNativeMessageReceipt;
296
+ /** Why the job failed, as its error said: the fleet's own refusal, or a dependency's text (a harness's output). */
287
297
  error?: string;
298
+ /**
299
+ * Set on a failed job exactly when the fleet refused it itself (`fleetWorkerErrorCodes`): then `error` is AGL's own
300
+ * text, which the Driver view and a device show. Without it, `error` may be a dependency's output.
301
+ */
302
+ errorCode?: TFleetWorkerErrorCode;
303
+ /**
304
+ * Set on a failed job: whether what it dispatched may have reached a native session, in the words of a failed native
305
+ * send (`native_session_failed`'s `outcome`). `refused`: the job failed before anything reached a native session,
306
+ * proved by a refusal before its first dispatch or by a dispatch that sent nothing: nothing was sent. `unknown`: it
307
+ * may have (a steer may have been delivered), which is every failure without that proof; read the worker before acting
308
+ * again and never send it again on your own. A failed job without it, from an older controller, is `unknown`.
309
+ */
310
+ errorOutcome?: TFleetWorkerErrorOutcome;
288
311
  }
312
+ /** How far a failed fleet worker job got (`IFleetWorkerJob.errorOutcome`). */
313
+ export const fleetWorkerErrorOutcomes = ['refused', 'unknown'] as const;
314
+ export type TFleetWorkerErrorOutcome = (typeof fleetWorkerErrorOutcomes)[number];
289
315
  /**
290
316
  * A message to a Claude Code background job no fleet worker binds: a native wake of a settled job (`native-wake`) or a
291
317
  * message into a running job's inbox through Claude Code's own SendMessage (`native-inbox`, accepted and queued, not
@@ -97,6 +97,8 @@ export interface IWorkerCallerSubject {
97
97
  nativeSessionId: string;
98
98
  sessionIdentityId: string;
99
99
  ticketSessionId: string;
100
+ /** The fleet worker's name: what a ticket calls the worker, unless it is an active direct report. */
101
+ workerName: string;
100
102
  }
101
103
 
102
104
  export type TWorkerCallerEnrollment = { bridgePid: number } & (
@@ -14,6 +14,7 @@ import { ClaudeGatewayRetirementV38Migration } from './v38_claudegatewayretireme
14
14
  import { TicketOwnerPrincipalV38Migration } from './v38_ticketownerprincipal.js';
15
15
  import { TicketClosedColumnV41Migration } from './v41_ticketclosedcolumn.js';
16
16
  import { TicketLinkReposV41Migration } from './v41_ticketlinkrepos.js';
17
+ import { TicketActorNamesV43Migration } from './v43_ticketactornames.js';
17
18
  import type { IControllerIssuerIdentity } from '../ts/interfaces.identity.js';
18
19
 
19
20
  interface IDocumentMigration {
@@ -54,6 +55,18 @@ export class PostDatabaseDocumentMigrationRunner {
54
55
  ).run();
55
56
  }
56
57
 
58
+ /**
59
+ * The ticket migrations of a controller start, in their order; a new one goes last. v38 gives owner assignments the
60
+ * store's principal, v41 moves tickets released by hand without a release link to closed, and v43 names ticket actors
61
+ * by their role (AGL-1686). Answers the keys v41 moved and those whose revision v43 moved.
62
+ */
63
+ public async runTicketStart(principalIdArg: string): Promise<{ closed: string[]; renamed: string[] }> {
64
+ await this.runTicketOwnerPrincipal(principalIdArg);
65
+ const closed = await this.runTicketClosedColumn();
66
+ const renamed = await this.runTicketActorNames();
67
+ return { closed, renamed };
68
+ }
69
+
57
70
  public async runTicketOwnerPrincipal(principalIdArg: string): Promise<void> {
58
71
  await new TicketOwnerPrincipalV38Migration(this.database, principalIdArg).run();
59
72
  }
@@ -63,6 +76,14 @@ export class PostDatabaseDocumentMigrationRunner {
63
76
  return await new TicketClosedColumnV41Migration(this.database).run();
64
77
  }
65
78
 
79
+ /**
80
+ * AGL-1686: once, every person and actor a ticket stores under its session id is named by its harness's label, and the
81
+ * OpenCode runtime's `runtime` actor "OpenCode"; answers the keys whose revision it moved.
82
+ */
83
+ public async runTicketActorNames(): Promise<string[]> {
84
+ return await new TicketActorNamesV43Migration(this.database).run();
85
+ }
86
+
66
87
  /**
67
88
  * AGL-909: once, links and release plans name each repository `resolveArg` resolves as `org/name`; answers the keys it
68
89
  * changed. With no repository discovered (`discoveredArg` 0) it waits for a later start.
@@ -28,4 +28,5 @@ export * from './v39_flexpublicheadpointers.js';
28
28
  export * from './v41_ticketmigrationmarkers.js';
29
29
  export * from './v41_ticketclosedcolumn.js';
30
30
  export * from './v41_ticketlinkrepos.js';
31
+ export * from './v43_ticketactornames.js';
31
32
  export * from './v43_flexpostharnessmigrationmarkers.js';