@ours.network/fleet 1.1.0-nightly.24 → 1.1.0-nightly.26

package/dist/owner-channel/channel.js

@@ -15,10 +15,11 @@ import { ACP_CANCEL_DEADLINE_EXCEEDED, CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED
 import { VERSION } from '../version.js';
 import { renderMarkdownFailure, renderMarkdownResult, roomStatus, taskStatus, } from '../rooms-tasks/markdown.js';
 import { dispatchOwnerCommand, fleetCliOps, isOwnerCommandText, } from './commands.js';
-import { FleetCommandAuditStore, lifecycleEventDigestBasis, renderFleetLifecycleEvent, } from '../fleet-command-audit.js';
+import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCommandAuditStore, lifecycleEventDigestBasis, renderFleetLifecycleEvent, setFleetAuditLifecycleCheckpoint, } from '../fleet-command-audit.js';
 import { OURS_BOUND_ELSEWHERE, OursSdkClient, oursErrorCode, } from './ours-client.js';
 import { ownerNotices, } from './notices.js';
 import { DuplicateSendError, OwnerAuthorizationState, OwnerChannelState, OwnerConversationState, } from './state.js';
+import { FleetLifecycleOutbox } from './lifecycle-outbox.js';
 import { OwnerTaskState, ownerTaskAuditId, ownerTaskDigest, } from './tasks.js';
 import { AttachmentRecoveryState, admitAttachments, cleanupAttachmentRoot, parseIncomingAttachments, parseRetrievedAttachments, prepareAttachmentDirectory, recoveredAttachment, removeRequestDirectory, safeField, validateAttachmentSelection, validateAttachmentRelaySelection, writeRecoveredAttachment, } from './attachments.js';
 import { acquireOwnerBinderLease, OWNER_BIND_HANDOFF_TIMEOUT_MS, } from './binder.js';
@@ -112,6 +113,7 @@ export class OwnerChannel {
     fleetOps;
     prepareRestart;
     commandAudits;
+    lifecycleOutbox;
     constructor(options) {
         this.options = options;
         this.client = options.client ?? new OursSdkClient(options.env, line => options.log(`[${options.role}] owner channel ${line}`));
@@ -128,6 +130,7 @@ export class OwnerChannel {
         });
         this.state = new OwnerChannelState(join(options.stateDir, '.owner-channel-state.json'));
         this.commandAudits = new FleetCommandAuditStore(join(options.stateDir, '.owner-channel-command-audit.json'));
+        this.lifecycleOutbox = new FleetLifecycleOutbox(join(options.stateDir, '.owner-channel-lifecycle-outbox.json'));
         this.authorizations = new OwnerAuthorizationState(join(options.stateDir, '.owner-channel-owners.json'), options.config.owners);
         this.conversations = new OwnerConversationState(join(options.stateDir, '.owner-channel-conversations.json'));
         this.tasks = new OwnerTaskState(join(options.stateDir, '.owner-channel-tasks.json'));
@@ -153,6 +156,8 @@ export class OwnerChannel {
             options.log(`[${options.role}] owner message recovery state corrupt; message intake disabled`);
         if (!this.attachmentRecovery.integrity())
             options.log(`[${options.role}] owner attachment recovery state corrupt; attachments disabled`);
+        if (!this.lifecycleOutbox.integrity().ok)
+            options.log(`[${options.role}] owner lifecycle outbox corrupt; lifecycle delivery disabled`);
     }
     async start() {
         this.stopping = false;
@@ -200,6 +205,7 @@ export class OwnerChannel {
         this.startedOnce = true;
         this.ready = true;
         await this.flushPendingFleetCommandAudits();
+        await this.flushPendingFleetLifecycle();
         // Do not make role startup wait for an old owner request to finish a turn.
         // watchLoop itself drains before every establishment, including this first
         // one, so there is no drain-to-tip race.
@@ -275,6 +281,37 @@ export class OwnerChannel {
                 ...(event.configuration ? { configuration: event.configuration } : {}) }), `fleet-spawn\0${event.creationActionId}`, 0);
         });
     }
+    notifyFleetLifecycle(presentations) {
+        const run = this.managementTail.then(async () => {
+            // Acceptance is durable before delivery. A detached worker may exit
+            // while the Owner channel is reconnecting; startup/recovery flushes the
+            // pending event through the existing exactly-once send ledger.
+            this.lifecycleOutbox.enqueue(presentations);
+            if (this.ready && !this.stopping)
+                await this.flushPendingFleetLifecycle();
+        });
+        this.managementTail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async flushPendingFleetLifecycle() {
+        for (const entry of this.lifecycleOutbox.pending()) {
+            try {
+                await this.sendProactiveMessage(renderFleetLifecycleEvent(entry.presentation), `fleet-lifecycle\0${lifecycleEventDigestBasis(entry.presentation)}`, 0);
+                this.lifecycleOutbox.finish(entry.digest, 'delivered');
+            }
+            catch (error) {
+                if (error instanceof DuplicateSendError) {
+                    this.lifecycleOutbox.finish(entry.digest, error.status === 'delivered' ? 'delivered' : 'uncertain');
+                    this.options.log(`[${this.options.role}] duplicate Fleet lifecycle event suppressed`);
+                    continue;
+                }
+                // If the send crossed the uncertain boundary, the proactive ledger
+                // will refuse it on the next flush. A pre-send outage stays pending.
+                this.logError('pending Fleet lifecycle delivery deferred', error);
+                return;
+            }
+        }
+    }
     beginFleetCommandAudit(requestId, argv) {
         const run = this.managementTail.then(async () => {
             let attempt = this.commandAudits.begin(requestId, this.options.role, argv);
@@ -396,6 +433,7 @@ export class OwnerChannel {
                 if (superseded())
                     throw new Error('owner recovery epoch superseded');
                 this.ready = true;
+                await this.flushPendingFleetLifecycle();
                 this.watchTask = this.watchLoop(watchGeneration);
             }
             catch (error) {
@@ -1235,6 +1273,19 @@ export class OwnerChannel {
      * agent itself can execute /force-restart, /model, or any other command.
      */
     async handleCommand(sender, text, wireId) {
+        const provisioningCommand = async (run) => {
+            beginFleetAuditCollection();
+            setFleetAuditLifecycleCheckpoint(events => this.notifyFleetLifecycle(events));
+            try {
+                return await run();
+            }
+            finally {
+                setFleetAuditLifecycleCheckpoint(undefined);
+                const remaining = consumeFleetAuditCollection().presentations;
+                if (remaining?.length)
+                    await this.notifyFleetLifecycle(remaining);
+            }
+        };
         const ctx = {
             authenticatedCid: sender.id,
             role: this.options.role,
@@ -1257,13 +1308,44 @@ export class OwnerChannel {
             recoverRoom: roomId => this.recoverRoomFromOwner(sender, roomId, wireId),
             terminalTask: (taskId, kind, outcome) => this.terminalTaskFromOwner(sender, taskId, kind, outcome, wireId),
             recoverTask: taskId => this.recoverTaskFromOwner(sender, taskId, wireId),
-            createTask: input => new TaskRoomApplicationService(this.options.configPath).createTask({
-                ...input,
-                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
+            createTask: input => provisioningCommand(async () => {
+                const service = new TaskRoomApplicationService(this.options.configPath);
+                const task = await service.createTask({
+                    ...input,
+                    actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
+                });
+                if (!input.backlog && !input.noRoom && task.room_id) {
+                    const outcome = service.taskProvisioningOutcome(task.task_id);
+                    if (outcome.kind === 'in_progress' && !outcome.next_action)
+                        await this.fleetOps.provisionTask(task.task_id);
+                }
+                return task;
             }),
-            startTask: taskId => new TaskRoomApplicationService(this.options.configPath).startTask({
-                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+            startTask: taskId => provisioningCommand(async () => {
+                const service = new TaskRoomApplicationService(this.options.configPath);
+                const task = await service.startTask({
+                    actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+                });
+                // A zero-duration observation repairs a ready notice after a crash or
+                // duplicate start without extending the start command's existing wait.
+                const outcome = await service.awaitTaskProvisioning({
+                    actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
+                    taskId: task.task_id, waitMs: 0,
+                });
+                if (outcome.kind === 'in_progress' && !outcome.next_action)
+                    await this.fleetOps.provisionTask(task.task_id);
+                return outcome;
             }),
+            awaitTask: taskId => provisioningCommand(async () => {
+                const service = new TaskRoomApplicationService(this.options.configPath);
+                const initial = service.taskProvisioningOutcome(taskId);
+                if (initial.kind === 'in_progress')
+                    await this.fleetOps.provisionTask(taskId);
+                return service.awaitTaskProvisioning({
+                    actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+                });
+            }),
+            taskProvisioningOutcome: taskId => new TaskRoomApplicationService(this.options.configPath).taskProvisioningOutcome(taskId),
             listTasks: filter => new TaskRoomApplicationService(this.options.configPath).listTasks(filter),
             groupedTasks: filter => new TaskRoomApplicationService(this.options.configPath).groupedTasks(filter),
             listTaskLists: () => new TaskRoomApplicationService(this.options.configPath).listTaskLists(),
@@ -1294,9 +1376,9 @@ export class OwnerChannel {
             getRoomQuery: id => new TaskRoomApplicationService(this.options.configPath).getRoomDetail(id),
             listTemplateQueries: () => new TaskRoomApplicationService(this.options.configPath).listTemplates(),
             getTemplateQuery: name => new TaskRoomApplicationService(this.options.configPath).getTemplate(name),
-            createRoom: input => new TaskRoomApplicationService(this.options.configPath).createRoom({
+            createRoom: input => provisioningCommand(() => new TaskRoomApplicationService(this.options.configPath).createRoom({
                 ...input, actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
-            }),
+            })),
             recentEvents: limit => this.options.session.eventsSince(0).slice(-limit),
             readWorklogTail: maxChars => this.readWorklogTail(maxChars),
             reply: async (replyText) => { await this.send(sender.id, replyText, wireId); },

package/dist/owner-channel/commands.d.ts

@@ -1,7 +1,7 @@
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
 import type { RoomOrchestrationRecord, TaskOutcome, TaskRecord, TaskTerminalIntent, TaskListRecord } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
-import type { CreateRoomRequest, CreateTaskRequest, TaskRoomApplicationService } from '../application/task-room-service.js';
+import type { CreateRoomRequest, CreateTaskRequest, TaskProvisioningOutcome, TaskRoomApplicationService } from '../application/task-room-service.js';
 import type { TaskState } from '../rooms-tasks/types.js';
 /**
  * Fleet-level effects a deterministic owner command may trigger. Production
@@ -19,6 +19,9 @@ export interface OwnerFleetOps {
     settleTask(taskId: string): Promise<void>;
     /** Settle an accepted task deletion outside the caller role's supervisor lifecycle. */
     settleTaskDeletion(taskId: string): Promise<void>;
+    /** Continue an accepted provisioning saga until convergence. */
+    provisionTask(taskId: string): Promise<void>;
+    /** Explicit recovery may also route terminal and deletion intents. */
     recoverTask(taskId: string): Promise<void>;
 }
 /**
@@ -58,7 +61,9 @@ export interface OwnerCommandContext {
     terminalTask(taskId: string, kind: TaskTerminalIntent['kind'], outcome?: TaskOutcome): Promise<void>;
     recoverTask(taskId: string): Promise<void>;
     createTask(input: Omit<CreateTaskRequest, 'actor'>): Promise<TaskRecord>;
-    startTask(taskId: string): Promise<TaskRecord>;
+    startTask(taskId: string): Promise<TaskProvisioningOutcome | TaskRecord>;
+    awaitTask?(taskId: string): Promise<TaskProvisioningOutcome>;
+    taskProvisioningOutcome?(taskId: string): TaskProvisioningOutcome;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
         list?: string;

package/dist/owner-channel/commands.js

@@ -106,6 +106,24 @@ const taskAction = (title, task, fields = []) => renderMarkdownResult({
         ...fields,
     ],
 });
+const taskProvisioningAction = (outcome) => {
+    if (outcome.kind === 'failed')
+        return renderMarkdownFailure({
+            kind: 'state', subject: `/task await ${outcome.task.task_id}`,
+            detail: outcome.blocker ?? 'Provisioning reached a terminal failure.',
+            action: outcome.next_action ?? `Run /task recover ${outcome.task.task_id}.`,
+        });
+    return taskAction(outcome.kind === 'ready' ? 'Room provisioning complete'
+        : outcome.next_action ? 'Room provisioning needs attention' : 'Room provisioning continues', outcome.task, [
+        ...(outcome.room ? [{ label: 'Room', value: `${outcome.room.room_id} — ${outcome.room.room_name}` }] : []),
+        ...(outcome.launch.template ? [{ label: 'Template', value: outcome.launch.template, kind: 'code' }] : []),
+        { label: 'Members', value: `${outcome.members.active}/${outcome.members.expected} active; ${outcome.members.launched}/${outcome.members.expected} launched` },
+        ...(outcome.blocker ? [{ label: 'Blocker', value: outcome.blocker }] : []),
+        ...(outcome.next_action ? [{ label: 'Next action', value: outcome.next_action }] : []),
+        ...(outcome.kind === 'in_progress'
+            ? [{ label: 'Await', value: `/task await ${outcome.task.task_id}`, kind: 'code' }] : []),
+    ]);
+};
 const roomAction = (title, room, fields = []) => renderMarkdownResult({
     icon: '🏠', title,
     fields: [
@@ -319,6 +337,12 @@ export const ownerCommands = [
                             title: titleParts.join(' '), origin: { type: 'owner_channel' },
                             backlog, template, noRoom, brief: trailingLines, list,
                         });
+                        const provisioning = !backlog && !noRoom && t.room_id
+                            ? ctx.taskProvisioningOutcome?.(t.task_id) : undefined;
+                        if (provisioning) {
+                            await ctx.reply(taskProvisioningAction(provisioning));
+                            break;
+                        }
                         await ctx.reply(taskAction('Task created', t, [
                             { label: 'Title', value: t.title },
                             ...(template ? [{ label: 'Template', value: template, kind: 'code' }] : []),
@@ -419,8 +443,17 @@ export const ownerCommands = [
                     case 'start': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task start <id>');
-                        const t = await ctx.startTask(rest[0]);
-                        await ctx.reply(taskAction('Task started', t));
+                        const started = await ctx.startTask(rest[0]);
+                        await ctx.reply('kind' in started
+                            ? taskProvisioningAction(started) : taskAction('Task started', started));
+                        break;
+                    }
+                    case 'await': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task await <id>');
+                        if (!ctx.awaitTask)
+                            throw new Error('task await is unavailable');
+                        await ctx.reply(taskProvisioningAction(await ctx.awaitTask(rest[0])));
                         break;
                     }
                     case 'block': {
@@ -731,6 +764,7 @@ export function fleetCliOps(role, configPath) {
         closeRoom: roomId => launchFleetWorker(['room', '_delete', roomId], `room-delete-${roomId}`, configPath),
         settleTask: taskId => launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath),
         settleTaskDeletion: taskId => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, configPath),
+        provisionTask: taskId => launchFleetWorker(['task', '_provision', taskId], `task-provision-${taskId}`, configPath),
         recoverTask: taskId => launchFleetWorker(['task', '_recover', taskId], `task-recover-${taskId}`, configPath),
     };
 }

package/dist/owner-channel/lifecycle-outbox.d.ts

@@ -0,0 +1,24 @@
+import { type FleetAuditPresentation } from '../fleet-command-audit.js';
+type LifecycleDelivery = 'pending' | 'delivered' | 'uncertain';
+interface LifecycleOutboxEntry {
+    digest: string;
+    presentation: FleetAuditPresentation;
+    delivery: LifecycleDelivery;
+}
+/** Durable lifecycle acceptance queue; plaintext is limited to validated concise presentations. */
+export declare class FleetLifecycleOutbox {
+    private readonly path;
+    private entries;
+    private corruptReason?;
+    constructor(path: string);
+    integrity(): {
+        ok: boolean;
+        error?: string;
+    };
+    enqueue(presentations: FleetAuditPresentation[]): void;
+    pending(): readonly LifecycleOutboxEntry[];
+    finish(digest: string, delivery: Exclude<LifecycleDelivery, 'pending'>): void;
+    private assertHealthy;
+    private persist;
+}
+export {};

package/dist/owner-channel/lifecycle-outbox.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, readFileSync } from 'node:fs';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { lifecycleEventDigestBasis, validateFleetAuditPresentations, } from '../fleet-command-audit.js';
+const DIGEST = /^[a-f0-9]{64}$/u;
+const LIMIT = 5_000;
+/** Durable lifecycle acceptance queue; plaintext is limited to validated concise presentations. */
+export class FleetLifecycleOutbox {
+    path;
+    entries = [];
+    corruptReason;
+    constructor(path) {
+        this.path = path;
+        if (!existsSync(path))
+            return;
+        try {
+            const value = JSON.parse(readFileSync(path, 'utf8'));
+            if (value.version !== 1 || !Array.isArray(value.entries) || value.entries.length > LIMIT)
+                throw new Error('invalid lifecycle outbox');
+            const digests = new Set();
+            for (const entry of value.entries) {
+                validateFleetAuditPresentations([entry?.presentation]);
+                if (!DIGEST.test(entry.digest)
+                    || !['pending', 'delivered', 'uncertain'].includes(entry.delivery)
+                    || digests.has(entry.digest))
+                    throw new Error('invalid lifecycle outbox entry');
+                digests.add(entry.digest);
+            }
+            this.entries = structuredClone(value.entries);
+            chmodSync(path, 0o600);
+        }
+        catch {
+            this.corruptReason = 'invalid persisted Fleet lifecycle outbox';
+            this.entries = [];
+            try {
+                chmodSync(path, 0o600);
+            }
+            catch { /* remain fail-closed */ }
+        }
+    }
+    integrity() {
+        return this.corruptReason ? { ok: false, error: this.corruptReason } : { ok: true };
+    }
+    enqueue(presentations) {
+        this.assertHealthy();
+        validateFleetAuditPresentations(presentations);
+        let changed = false;
+        for (const presentation of presentations) {
+            const digest = createHash('sha256').update(lifecycleEventDigestBasis(presentation)).digest('hex');
+            if (this.entries.some(entry => entry.digest === digest))
+                continue;
+            if (this.entries.length >= LIMIT) {
+                const settled = this.entries.findIndex(entry => entry.delivery !== 'pending');
+                if (settled < 0)
+                    throw new Error(`Fleet lifecycle outbox is limited to ${LIMIT} pending events`);
+                this.entries.splice(settled, 1);
+            }
+            this.entries.push({ digest, presentation: structuredClone(presentation), delivery: 'pending' });
+            changed = true;
+        }
+        if (changed)
+            this.persist();
+    }
+    pending() {
+        this.assertHealthy();
+        return this.entries.filter(entry => entry.delivery === 'pending').map(entry => structuredClone(entry));
+    }
+    finish(digest, delivery) {
+        this.assertHealthy();
+        const entry = this.entries.find(candidate => candidate.digest === digest);
+        if (!entry)
+            throw new Error('unknown Fleet lifecycle outbox entry');
+        if (entry.delivery === delivery)
+            return;
+        if (entry.delivery !== 'pending')
+            throw new Error('conflicting Fleet lifecycle delivery state');
+        entry.delivery = delivery;
+        this.persist();
+    }
+    assertHealthy() {
+        if (this.corruptReason)
+            throw new Error(this.corruptReason);
+    }
+    persist() {
+        replaceFileAtomically(this.path, `${JSON.stringify({ version: 1, entries: this.entries })}\n`, 0o600);
+    }
+}

package/dist/preset-migration.d.ts

@@ -31,7 +31,7 @@ interface MigrationHooks {
     beforeLockClaim?: () => void;
     beforeRoleDefaultPublish?: () => void;
 }
-/** Explicit adoption of exact packaged revision-3/4 role defaults; customized files are never changed. */
+/** Explicit adoption of exact known packaged role defaults; customized files are never changed. */
 export declare function migratePackagedRoleDefaults(configuration: string, options?: {
     write?: boolean;
 }, hooks?: MigrationHooks): RoleDefaultMigrationResult;

package/dist/preset-migration.js

@@ -51,7 +51,23 @@ const V4_ROLE_DEFAULT_FINGERPRINTS = Object.freeze({
 const V4_GENERATED_ROLE_DEFAULT_FINGERPRINTS = Object.freeze({
     'agent_templates/LocalCoordinator.yaml': 'cb7c83a835dde9d45bac42cadce2f196f561d2460321c690cdef435f7076f97f',
 });
-const V5_ROLE_DEFAULTS = new Set([
+const V5_ROLE_DEFAULT_FINGERPRINTS = Object.freeze({
+    'roles/LocalCoordinator.yaml': '52714be635060adca2bc7fe99c27c3184be6c78e3874a77e61a2fb135bac1278',
+    'roles/Developer.yaml': '04278f325c366035e82d8e7f4aff72badb297eaf2fb5afae38a28a5aaf9260c9',
+    'roles/Critic.yaml': 'bcb96c84534ca6fc466a8ee63f679785d347ed1cdf223efcc36ca5ed4ca7f3de',
+    'agent_templates/LocalCoordinator.yaml': 'c59980ab7d94dad4d4961ba308cf62342291d8f1c57cf2faf900e80136fa2e7d',
+    'agent_templates/Developer.yaml': '36f1d010a9c8591ae5ba422ef1ac26335b9f7f3382b6b8532844df754a56287e',
+    'agent_templates/Critic.yaml': '7025b842e260a9c91ebc64dd3a11162a82b025b287457c6cb6f6c8964b38cdfd',
+    'room_templates/single.yaml': '61051917b1f4f53a13687cc69d3f9ad98f1b02558f82b236b22aac942850395f',
+    'room_templates/pair.yaml': 'a20b2145fa84e5d61266385e629892734b98fc61be9d0c7647c3778ec1bb40a8',
+    'room_templates/team.yaml': 'c455f54a1f86106bfac7192299130dabfb91fa6179d2dedcc0573a384a902411',
+});
+const V5_GENERATED_ROLE_DEFAULT_FINGERPRINTS = Object.freeze({
+    'agent_templates/LocalCoordinator.yaml': 'cb7c83a835dde9d45bac42cadce2f196f561d2460321c690cdef435f7076f97f',
+    'agent_templates/Developer.yaml': 'fdd953aab72d042e62780dd273598745aae59521b39edf4876d7676bb7189c83',
+    'agent_templates/Critic.yaml': '3e98a28f17876061cfadf984351aa59fdbe19629e514eff52c74546545c64a91',
+});
+const CURRENT_ROLE_DEFAULTS = new Set([
     'roles/Coordinator.yaml', 'roles/LocalCoordinator.yaml', 'roles/Developer.yaml', 'roles/Critic.yaml',
     'agent_templates/LocalCoordinator.yaml', 'agent_templates/Developer.yaml', 'agent_templates/Critic.yaml',
     'room_templates/single.yaml', 'room_templates/pair.yaml', 'room_templates/team.yaml',
@@ -152,7 +168,7 @@ function validateRoleDefaultMigration(stageManifest) {
                 throw new Error(`Room Template '${template.name}' references missing Agent Template '${member.agent_template}'`);
     }
 }
-/** Explicit adoption of exact packaged revision-3/4 role defaults; customized files are never changed. */
+/** Explicit adoption of exact known packaged role defaults; customized files are never changed. */
 export function migratePackagedRoleDefaults(configuration, options = {}, hooks = {}) {
     const configPath = resolve(configuration);
     const root = splitRootFor(configPath);
@@ -176,6 +192,7 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
         const known = new Set([
             ...Object.keys(V3_ROLE_DEFAULT_FINGERPRINTS),
             ...Object.keys(V4_ROLE_DEFAULT_FINGERPRINTS),
+            ...Object.keys(V5_ROLE_DEFAULT_FINGERPRINTS),
         ]);
         for (const relative of known) {
             const path = join(root, relative);
@@ -187,14 +204,16 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
                 V3_GENERATED_ROLE_DEFAULT_FINGERPRINTS[relative],
                 V4_ROLE_DEFAULT_FINGERPRINTS[relative],
                 V4_GENERATED_ROLE_DEFAULT_FINGERPRINTS[relative],
+                V5_ROLE_DEFAULT_FINGERPRINTS[relative],
+                V5_GENERATED_ROLE_DEFAULT_FINGERPRINTS[relative],
             ].some(expected => expected !== undefined && actual === expected);
             if (recognized)
-                (V5_ROLE_DEFAULTS.has(relative) ? replacements : removals).push(path);
+                (CURRENT_ROLE_DEFAULTS.has(relative) ? replacements : removals).push(path);
             else
                 preserved.push(path);
         }
         const additions = [];
-        for (const relative of V5_ROLE_DEFAULTS) {
+        for (const relative of CURRENT_ROLE_DEFAULTS) {
             const path = join(root, relative);
             if (!existsSync(path))
                 additions.push(path);