ai-foreman 1.7.24 → 1.7.26

package/dist/tickets/groupReset.js

@@ -94,107 +94,111 @@ export function resolveTicketResetSelection(projectDir, requested, options = {},
 }
 export function applyResolvedTicketReset(projectDir, selection, actor = "user", now = new Date(), hooks = {}) {
     const opened = open(projectDir);
-    const { config, paths, definitions, db } = opened;
-    const workflow = new WorkflowDb(projectDir);
-    const resetId = hooks.resetId ?? randomUUID();
-    const current = new Map(definitions.map((definition) => [definition.id, definition]));
-    const groupCatalog = db.listTicketGroups();
-    const snapshots = new Map(groupCatalog.flatMap((group) => group.members.map((member) => [member.ticketId, member.snapshot])));
-    const states = db.getAllStates();
-    const selectedIds = new Set(selection.ticketIds);
-    const currentRelatedRuns = recoverableBuildRuns(projectDir, now)
-        .filter((run) => run.tickets.some((ticketId) => selectedIds.has(ticketId)))
-        .map((run) => ({ runId: run.runId, status: run.status, tickets: [...run.tickets] }));
-    const comparable = { ...selection, relatedRuns: currentRelatedRuns };
-    delete comparable.inputFingerprint;
-    const actualFingerprint = selectionFingerprint(comparable, current, states, snapshots, groupCatalog);
-    if (actualFingerprint !== selection.inputFingerprint) {
-        db.close();
-        workflow.close();
-        throw new Error("ticket/group/reset inputs changed after preview; no reset was applied—preview the exact selection again");
-    }
-    const restore = selection.definitionRestorations.filter((item) => item.restore);
-    const restored = restore.map((item) => item.ticketId);
-    const restoredSet = new Set(restored);
-    const restoredDefinitions = restore.map((item) => snapshots.get(item.ticketId)?.definition);
-    if (restoredDefinitions.some((item) => !item)) {
-        db.close();
-        workflow.close();
-        throw new Error("a selected definition snapshot became unavailable");
-    }
-    const nextDefinitions = [...definitions, ...restoredDefinitions.filter((definition) => !current.has(definition.id))].sort((a, b) => a.order - b.order);
-    const definitionIssues = validateTicketDefs(nextDefinitions);
-    if (definitionIssues.length) {
-        db.close();
-        workflow.close();
-        throw new Error(`restored ticket definitions are invalid: ${definitionIssues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
-    }
-    const resettable = selection.ticketIds.filter((ticketId) => current.has(ticketId) || restoredSet.has(ticketId));
-    const ignoredMissing = selection.ticketIds.filter((ticketId) => !current.has(ticketId) && !restoredSet.has(ticketId));
-    if (resettable.length === 0 && restored.length === 0) {
-        db.close();
-        workflow.close();
-        return { resetId, tickets: [], restored: [], ignoredMissing };
-    }
-    const stageDir = join(projectDir, ".rafi", "reset-stage", resetId);
-    const stagedDefinitions = join(stageDir, "tickets.yaml");
-    const stagedProgress = join(stageDir, "progress.md");
-    const definitionsBefore = existsSync(paths.tickets) ? readFileSync(paths.tickets) : undefined;
-    const progressBefore = existsSync(paths.progressDoc) ? readFileSync(paths.progressDoc) : undefined;
-    const oldStates = new Map([...new Set([...resettable, ...restored])].map((ticketId) => [ticketId, db.getState(ticketId)]));
-    const oldRecent = db.getRecentCompleted().filter((row) => resettable.includes(row.ticket_id));
-    const eventIds = [];
-    const run = workflow.createRun({ kind: "recovery", checkpoint: "group-reset-intent", originalWork: selection, remainingWork: { tickets: resettable }, state: { resetId } }, now);
-    const publication = workflow.beginPublication(run.runId, { operation: "group-ticket-reset", resetId, selection, stagedDefinitions, stagedProgress, definitionsTarget: paths.tickets, progressTarget: paths.progressDoc }, { definitions: digest(definitionsBefore), progress: digest(progressBefore) }, now);
+    const { config, paths, db } = opened;
+    let workflowHandle;
     try {
-        const stamp = now.toISOString();
-        db.transaction(() => {
-            for (const definition of restoredDefinitions)
-                if (!db.getState(definition.id))
-                    db.upsertState(definition.id, pristineTicketState(definition.id, stamp, actor), stamp);
-            for (const row of selection.previewRows) {
-                if (!resettable.includes(row.ticketId)) {
-                    eventIds.push(db.insertEvent({ timestamp: stamp, actor, ticket_id: row.ticketId, event_type: "ticket_reset_skipped_missing", old_status: row.status, new_status: row.status, summary: `Skipped missing definition ${row.ticketId}`, validation: null, evidence: null, payload_json: JSON.stringify({ reset_id: resetId, input_fingerprint: selection.inputFingerprint }) }));
-                    continue;
-                }
-                const old = db.getState(row.ticketId)?.status ?? row.status;
-                db.upsertState(row.ticketId, pristineTicketState(row.ticketId, stamp, actor), stamp);
-                db.deleteRecentCompleted(row.ticketId);
-                eventIds.push(db.insertEvent({ timestamp: stamp, actor, ticket_id: row.ticketId, event_type: "ticket_reset", old_status: old, new_status: "planned", summary: `Reset ${row.ticketId} from approved immutable selection`, validation: null, evidence: null, payload_json: JSON.stringify({ reset_id: resetId, groups: selection.groups.map((group) => group.id), restored_definition: restoredSet.has(row.ticketId), input_fingerprint: selection.inputFingerprint }) }));
+        const workflow = workflowHandle = new WorkflowDb(projectDir);
+        const resetId = hooks.resetId ?? randomUUID();
+        return workflow.withTrackerMutationAuthority(() => {
+            const definitions = loadTickets(paths.tickets);
+            const current = new Map(definitions.map((definition) => [definition.id, definition]));
+            const groupCatalog = db.listTicketGroups();
+            const snapshots = new Map(groupCatalog.flatMap((group) => group.members.map((member) => [member.ticketId, member.snapshot])));
+            const states = db.getAllStates();
+            const selectedIds = new Set(selection.ticketIds);
+            const currentRelatedRuns = recoverableBuildRuns(projectDir, now)
+                .filter((run) => run.tickets.some((ticketId) => selectedIds.has(ticketId)))
+                .map((run) => ({ runId: run.runId, status: run.status, tickets: [...run.tickets] }));
+            const comparable = { ...selection, relatedRuns: currentRelatedRuns };
+            delete comparable.inputFingerprint;
+            const actualFingerprint = selectionFingerprint(comparable, current, states, snapshots, groupCatalog);
+            if (actualFingerprint !== selection.inputFingerprint) {
+                throw new Error("ticket/group/reset inputs changed after preview; no reset was applied—preview the exact selection again");
+            }
+            const restore = selection.definitionRestorations.filter((item) => item.restore);
+            const restored = restore.map((item) => item.ticketId);
+            const restoredSet = new Set(restored);
+            const restoredDefinitions = restore.map((item) => snapshots.get(item.ticketId)?.definition);
+            if (restoredDefinitions.some((item) => !item)) {
+                throw new Error("a selected definition snapshot became unavailable");
+            }
+            const nextDefinitions = [...definitions, ...restoredDefinitions.filter((definition) => !current.has(definition.id))].sort((a, b) => a.order - b.order);
+            const definitionIssues = validateTicketDefs(nextDefinitions);
+            if (definitionIssues.length) {
+                throw new Error(`restored ticket definitions are invalid: ${definitionIssues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+            }
+            const resettable = selection.ticketIds.filter((ticketId) => current.has(ticketId) || restoredSet.has(ticketId));
+            const ignoredMissing = selection.ticketIds.filter((ticketId) => !current.has(ticketId) && !restoredSet.has(ticketId));
+            if (resettable.length === 0 && restored.length === 0) {
+                return { resetId, tickets: [], restored: [], ignoredMissing };
+            }
+            const stageDir = join(projectDir, ".rafi", "reset-stage", resetId);
+            const stagedDefinitions = join(stageDir, "tickets.yaml");
+            const stagedProgress = join(stageDir, "progress.md");
+            const definitionsBefore = existsSync(paths.tickets) ? readFileSync(paths.tickets) : undefined;
+            const progressBefore = existsSync(paths.progressDoc) ? readFileSync(paths.progressDoc) : undefined;
+            const oldStates = new Map([...new Set([...resettable, ...restored])].map((ticketId) => [ticketId, db.getState(ticketId)]));
+            const oldRecent = db.getRecentCompleted().filter((row) => resettable.includes(row.ticket_id));
+            const eventIds = [];
+            const run = workflow.createRun({ kind: "recovery", checkpoint: "group-reset-intent", originalWork: selection, remainingWork: { tickets: resettable }, state: { resetId } }, now);
+            let publication;
+            try {
+                publication = workflow.beginPublication(run.runId, { operation: "group-ticket-reset", resetId, selection, stagedDefinitions, stagedProgress, definitionsTarget: paths.tickets, progressTarget: paths.progressDoc }, { definitions: digest(definitionsBefore), progress: digest(progressBefore) }, now);
+                const stamp = now.toISOString();
+                db.transaction(() => {
+                    for (const definition of restoredDefinitions)
+                        if (!db.getState(definition.id))
+                            db.upsertState(definition.id, pristineTicketState(definition.id, stamp, actor), stamp);
+                    for (const row of selection.previewRows) {
+                        if (!resettable.includes(row.ticketId)) {
+                            eventIds.push(db.insertEvent({ timestamp: stamp, actor, ticket_id: row.ticketId, event_type: "ticket_reset_skipped_missing", old_status: row.status, new_status: row.status, summary: `Skipped missing definition ${row.ticketId}`, validation: null, evidence: null, payload_json: JSON.stringify({ reset_id: resetId, input_fingerprint: selection.inputFingerprint }) }));
+                            continue;
+                        }
+                        const old = db.getState(row.ticketId)?.status ?? row.status;
+                        db.upsertState(row.ticketId, pristineTicketState(row.ticketId, stamp, actor), stamp);
+                        db.deleteRecentCompleted(row.ticketId);
+                        eventIds.push(db.insertEvent({ timestamp: stamp, actor, ticket_id: row.ticketId, event_type: "ticket_reset", old_status: old, new_status: "planned", summary: `Reset ${row.ticketId} from approved immutable selection`, validation: null, evidence: null, payload_json: JSON.stringify({ reset_id: resetId, groups: selection.groups.map((group) => group.id), restored_definition: restoredSet.has(row.ticketId), input_fingerprint: selection.inputFingerprint }) }));
+                    }
+                });
+                mkdirSync(stageDir, { recursive: true });
+                writeFileSync(stagedDefinitions, stringify({ tickets: nextDefinitions }, { lineWidth: 120 }), "utf8");
+                writeFileSync(stagedProgress, renderProgressDoc({ config, projectDir, ticketDefs: nextDefinitions, states: db.getAllStates(), db, now: stamp }), "utf8");
+                workflow.updatePublication(publication.transactionId, "staged", now);
+                workflow.updatePublication(publication.transactionId, "tracker_committed", now);
+                hooks.beforePublish?.();
+                atomicCopy(stagedDefinitions, paths.tickets);
+                writeProgressDoc(paths.progressDoc, readFileSync(stagedProgress, "utf8"), true);
+                workflow.updatePublication(publication.transactionId, "published", now);
+                workflow.updatePublication(publication.transactionId, "committed", now);
+                workflow.transition(run.runId, { status: "completed", checkpoint: "group-reset-committed", remainingWork: {}, state: { resetId, tickets: resettable, restored, ignoredMissing } }, now);
+                rmSync(stageDir, { recursive: true, force: true });
+                return { resetId, tickets: resettable, restored, ignoredMissing };
+            }
+            catch (error) {
+                db.transaction(() => {
+                    db.deleteEvents(eventIds);
+                    for (const [ticketId, state] of oldStates)
+                        state ? db.upsertState(ticketId, state, state.updated_at) : db.deleteState(ticketId);
+                    for (const row of oldRecent)
+                        db.upsertRecentCompleted(row);
+                });
+                restoreFile(paths.tickets, definitionsBefore);
+                restoreFile(paths.progressDoc, progressBefore);
+                if (publication)
+                    workflow.updatePublication(publication.transactionId, "rolled_back", now);
+                workflow.transition(run.runId, { status: "failed", checkpoint: "group-reset-rolled-back", state: { resetId, error: error instanceof Error ? error.message : String(error) } }, now);
+                rmSync(stageDir, { recursive: true, force: true });
+                throw error;
             }
         });
-        mkdirSync(stageDir, { recursive: true });
-        writeFileSync(stagedDefinitions, stringify({ tickets: nextDefinitions }, { lineWidth: 120 }), "utf8");
-        writeFileSync(stagedProgress, renderProgressDoc({ config, projectDir, ticketDefs: nextDefinitions, states: db.getAllStates(), db, now: stamp }), "utf8");
-        workflow.updatePublication(publication.transactionId, "staged", now);
-        workflow.updatePublication(publication.transactionId, "tracker_committed", now);
-        hooks.beforePublish?.();
-        atomicCopy(stagedDefinitions, paths.tickets);
-        writeProgressDoc(paths.progressDoc, readFileSync(stagedProgress, "utf8"), true);
-        workflow.updatePublication(publication.transactionId, "published", now);
-        workflow.updatePublication(publication.transactionId, "committed", now);
-        workflow.transition(run.runId, { status: "completed", checkpoint: "group-reset-committed", remainingWork: {}, state: { resetId, tickets: resettable, restored, ignoredMissing } }, now);
-        rmSync(stageDir, { recursive: true, force: true });
-        return { resetId, tickets: resettable, restored, ignoredMissing };
-    }
-    catch (error) {
-        db.transaction(() => {
-            db.deleteEvents(eventIds);
-            for (const [ticketId, state] of oldStates)
-                state ? db.upsertState(ticketId, state, state.updated_at) : db.deleteState(ticketId);
-            for (const row of oldRecent)
-                db.upsertRecentCompleted(row);
-        });
-        restoreFile(paths.tickets, definitionsBefore);
-        restoreFile(paths.progressDoc, progressBefore);
-        workflow.updatePublication(publication.transactionId, "rolled_back", now);
-        workflow.transition(run.runId, { status: "failed", checkpoint: "group-reset-rolled-back", state: { resetId, error: error instanceof Error ? error.message : String(error) } }, now);
-        rmSync(stageDir, { recursive: true, force: true });
-        throw error;
     }
     finally {
-        db.close();
-        workflow.close();
+        try {
+            workflowHandle?.close();
+        }
+        finally {
+            db.close();
+        }
     }
 }
 function selectGroups(groups, requested) {

package/dist/tickets/reset.js

@@ -61,82 +61,93 @@ export function resetTickets(projectDir, target, actor = "user", now = new Date(
     if (ids.length === 0)
         return { resetId: randomUUID(), tickets: [] };
     const { config, paths, tickets, db } = open(projectDir);
-    const workflow = new WorkflowDb(projectDir);
-    const resetId = hooks.resetId ?? randomUUID();
-    if (ids.every((id) => db.getTicketEvents(id).some((event) => event.event_type === "ticket_reset" && event.payload_json?.includes(resetId)))) {
-        workflow.close();
-        db.close();
-        return { resetId, tickets: ids };
-    }
-    const stagePath = join(projectDir, ".rafi", "reset-stage", resetId, "progress.md");
-    const oldStates = new Map(ids.map((id) => [id, db.getState(id)]));
-    const oldRecentCompleted = db.getRecentCompleted().filter((row) => ids.includes(row.ticket_id));
-    const insertedEventIds = [];
-    const progressBefore = existsSync(paths.progressDoc) ? readFileSync(paths.progressDoc) : undefined;
-    const run = workflow.createRun({
-        kind: "recovery",
-        checkpoint: "ticket-reset-intent",
-        originalWork: { resetId, scope: preview.scope, tickets: ids, states: Object.fromEntries(oldStates) },
-        remainingWork: { tickets: ids },
-        state: { operation: "ticket-reset", progressDigest: digest(progressBefore) },
-    }, now);
-    const publication = workflow.beginPublication(run.runId, { operation: "ticket-reset", resetId, tickets: ids, stagePath, targetPath: paths.progressDoc }, { progressDigest: digest(progressBefore) }, now);
+    let workflowHandle;
     try {
-        const stamp = now.toISOString();
-        db.transaction(() => {
-            for (const row of preview.tickets) {
-                db.upsertState(row.id, pristineTicketState(row.id, stamp, actor), stamp);
-                db.deleteRecentCompleted(row.id);
-                insertedEventIds.push(db.insertEvent({
-                    timestamp: stamp,
-                    actor,
-                    ticket_id: row.id,
-                    event_type: "ticket_reset",
-                    old_status: row.status,
-                    new_status: "planned",
-                    summary: `Reset ${row.id} to pristine active state`,
-                    validation: null,
-                    evidence: null,
-                    payload_json: JSON.stringify({ reset_id: resetId, scope: preview.scope, cleared: row.cleared }),
-                }));
+        const workflow = workflowHandle = new WorkflowDb(projectDir);
+        const resetId = hooks.resetId ?? randomUUID();
+        if (ids.every((id) => db.getTicketEvents(id).some((event) => event.event_type === "ticket_reset" && event.payload_json?.includes(resetId)))) {
+            return { resetId, tickets: ids };
+        }
+        return workflow.withTrackerMutationAuthority(() => {
+            if (JSON.stringify(loadTickets(paths.tickets)) !== JSON.stringify(tickets))
+                throw new Error("Ticket definitions changed before reset authority was acquired; preview again");
+            const stagePath = join(projectDir, ".rafi", "reset-stage", resetId, "progress.md");
+            const oldStates = new Map(ids.map((id) => [id, db.getState(id)]));
+            const oldRecentCompleted = db.getRecentCompleted().filter((row) => ids.includes(row.ticket_id));
+            const insertedEventIds = [];
+            const progressBefore = existsSync(paths.progressDoc) ? readFileSync(paths.progressDoc) : undefined;
+            const run = workflow.createRun({
+                kind: "recovery",
+                checkpoint: "ticket-reset-intent",
+                originalWork: { resetId, scope: preview.scope, tickets: ids, states: Object.fromEntries(oldStates) },
+                remainingWork: { tickets: ids },
+                state: { operation: "ticket-reset", progressDigest: digest(progressBefore) },
+            }, now);
+            let publication;
+            try {
+                publication = workflow.beginPublication(run.runId, { operation: "ticket-reset", resetId, tickets: ids, stagePath, targetPath: paths.progressDoc }, { progressDigest: digest(progressBefore) }, now);
+                const stamp = now.toISOString();
+                db.transaction(() => {
+                    for (const row of preview.tickets) {
+                        db.upsertState(row.id, pristineTicketState(row.id, stamp, actor), stamp);
+                        db.deleteRecentCompleted(row.id);
+                        insertedEventIds.push(db.insertEvent({
+                            timestamp: stamp,
+                            actor,
+                            ticket_id: row.id,
+                            event_type: "ticket_reset",
+                            old_status: oldStates.get(row.id)?.status ?? row.status,
+                            new_status: "planned",
+                            summary: `Reset ${row.id} to pristine active state`,
+                            validation: null,
+                            evidence: null,
+                            payload_json: JSON.stringify({ reset_id: resetId, scope: preview.scope, cleared: row.cleared }),
+                        }));
+                    }
+                });
+                mkdirSync(dirname(stagePath), { recursive: true });
+                writeFileSync(stagePath, renderProgressDoc({ config, projectDir, ticketDefs: tickets, states: db.getAllStates(), db, now: stamp }), "utf8");
+                workflow.updatePublication(publication.transactionId, "staged", now);
+                workflow.updatePublication(publication.transactionId, "tracker_committed", now);
+                hooks.beforePublish?.();
+                writeProgressDoc(paths.progressDoc, readFileSync(stagePath, "utf8"), true);
+                workflow.updatePublication(publication.transactionId, "published", now);
+                workflow.updatePublication(publication.transactionId, "committed", now);
+                workflow.transition(run.runId, { status: "completed", checkpoint: "ticket-reset-committed", remainingWork: {}, state: { operation: "ticket-reset", resetId, tickets: ids } }, now);
+                rmSync(dirname(stagePath), { recursive: true, force: true });
+                return { resetId, tickets: ids };
             }
-        });
-        mkdirSync(dirname(stagePath), { recursive: true });
-        writeFileSync(stagePath, renderProgressDoc({ config, projectDir, ticketDefs: tickets, states: db.getAllStates(), db, now: stamp }), "utf8");
-        workflow.updatePublication(publication.transactionId, "staged", now);
-        workflow.updatePublication(publication.transactionId, "tracker_committed", now);
-        hooks.beforePublish?.();
-        writeProgressDoc(paths.progressDoc, readFileSync(stagePath, "utf8"), true);
-        workflow.updatePublication(publication.transactionId, "published", now);
-        workflow.updatePublication(publication.transactionId, "committed", now);
-        workflow.transition(run.runId, { status: "completed", checkpoint: "ticket-reset-committed", remainingWork: {}, state: { operation: "ticket-reset", resetId, tickets: ids } }, now);
-        rmSync(dirname(stagePath), { recursive: true, force: true });
-        return { resetId, tickets: ids };
-    }
-    catch (error) {
-        db.transaction(() => {
-            db.deleteEvents(insertedEventIds);
-            for (const [id, state] of oldStates) {
-                if (state)
-                    db.upsertState(id, state, state.updated_at);
+            catch (error) {
+                db.transaction(() => {
+                    db.deleteEvents(insertedEventIds);
+                    for (const [id, state] of oldStates) {
+                        if (state)
+                            db.upsertState(id, state, state.updated_at);
+                        else
+                            db.deleteState(id);
+                    }
+                    for (const row of oldRecentCompleted)
+                        db.upsertRecentCompleted(row);
+                });
+                if (progressBefore)
+                    writeProgressDoc(paths.progressDoc, progressBefore.toString("utf8"), true);
                 else
-                    db.deleteState(id);
+                    rmSync(paths.progressDoc, { force: true });
+                rmSync(dirname(stagePath), { recursive: true, force: true });
+                if (publication)
+                    workflow.updatePublication(publication.transactionId, "rolled_back", now);
+                workflow.transition(run.runId, { status: "failed", checkpoint: "ticket-reset-rolled-back", state: { operation: "ticket-reset", resetId, error: error instanceof Error ? error.message : String(error) } }, now);
+                throw error;
             }
-            for (const row of oldRecentCompleted)
-                db.upsertRecentCompleted(row);
         });
-        if (progressBefore)
-            writeProgressDoc(paths.progressDoc, progressBefore.toString("utf8"), true);
-        else
-            rmSync(paths.progressDoc, { force: true });
-        rmSync(dirname(stagePath), { recursive: true, force: true });
-        workflow.updatePublication(publication.transactionId, "rolled_back", now);
-        workflow.transition(run.runId, { status: "failed", checkpoint: "ticket-reset-rolled-back", state: { operation: "ticket-reset", resetId, error: error instanceof Error ? error.message : String(error) } }, now);
-        throw error;
     }
     finally {
-        workflow.close();
-        db.close();
+        try {
+            workflowHandle?.close();
+        }
+        finally {
+            db.close();
+        }
     }
 }
 /** Finish or roll back a reset publication left incomplete by process interruption. */

package/dist/workflowDb.d.ts

@@ -201,7 +201,6 @@ export interface QaReportRecordV2 {
     createdAt: string;
     updatedAt: string;
 }
-/** Authoritative persistence for every resumable workflow in a project. */
 export declare class WorkflowDb {
     readonly projectDir: string;
     private readonly readinessAccess?;
@@ -212,6 +211,7 @@ export declare class WorkflowDb {
     private coordinatorTransition;
     private lineageTransition;
     private workAuthority;
+    private readonly createdRecoveryIntents;
     constructor(projectDir: string, path?: string, readinessAccess?: {
         probeId: string;
     } | {
@@ -254,6 +254,9 @@ export declare class WorkflowDb {
     /** Atomic local changes only; never await provider or filesystem work here. */
     atomic<T>(work: () => T): T;
     buildAdmission(): BuildAdmission | undefined;
+    /** Short synchronous tracker mutations share the build fence without retiring
+     * provider receipts or granting authority to resume implementation. */
+    withTrackerMutationAuthority<T>(work: () => T): T;
     private assertNoLegacyBuildOwner;
     private assertExecutionProtocol;
     acquireBuildAdmission(runId: string, phase: BuildAdmission["phase"]): BuildAdmission;
@@ -270,6 +273,10 @@ export declare class WorkflowDb {
     acknowledgeBuildLaunchChild(authority: BuildAdmission, token: string, pid: number): void;
     reconcileBuildLaunches(runId: string, original?: BuildAdmission): "retired" | "claimed" | "unknown";
     buildLaunch(token: string): BuildLaunch | undefined;
+    /** A supervisor's waiting exit may represent a successful partial QA boundary.
+     * Require this launch's clean worker exit and verified cleanup, never just QA. */
+    successfulPartialQaRecovery(runId: string, ticketId: string, launchToken: string): boolean;
+    waitForSuccessfulPartialQaRecovery(runId: string, ticketId: string, launchToken: string): Promise<boolean>;
     preparationSuccessor(runId: string): string;
     reservePreparationRetry(predecessor: string, args: string[], expectedStartArgs?: string): {
         runId: string;
@@ -310,6 +317,9 @@ export declare class WorkflowDb {
         state?: Record<string, unknown>;
         legacy?: boolean;
     }, now?: Date): WorkflowRunSnapshot;
+    /** Record failure of an intent this connection just created, before recovery
+     * authority was acquired. This cannot write build execution or publications. */
+    pauseOwnStartOverIntent(runId: string, error: unknown): void;
     getRun(runId: string): WorkflowRunSnapshot | undefined;
     /** Publication intents are immutable; mutable tracker snapshots are not approval evidence. */
     approvedPopulationDefinitions(): unknown[];
@@ -347,6 +357,7 @@ export declare class WorkflowDb {
     sessionUsageSamples(runId: string, role?: "builder" | "qa"): SessionUsageSample[];
     acknowledgeSettings(ack: LiveSettingsAcknowledgment): void;
     settingsAcknowledgments(revision: number): LiveSettingsAcknowledgment[];
+    settingsAdoptionState(runId: string, role: "builder" | "qa"): "active" | "deferred" | "unknown";
     appendContinuityEvent(input: {
         runId: string;
         role: "builder" | "qa" | "host";
@@ -494,6 +505,9 @@ export declare class WorkflowDb {
     recordQaHandoffReceipt(receipt: HandoffAcceptanceReceiptV2): void;
     qaHandoffReceipt(operationId: string): HandoffAcceptanceReceiptV2 | undefined;
     beginQaTurn(intent: QaTurnIntentV2): void;
+    /** Retire an interrupted, proven read-only review transport, never a QA pass
+     * or Builder remediation. A fresh immutable review must still run afterward. */
+    reconcileInterruptedQaDispatch(runId: string, ticketId: string): boolean;
     commitQaTurnIntent(intent: QaTurnIntentV2, expectedRevision: number): QaReducerStateV2;
     finishQaTurn(receipt: QaTurnReceiptV2): void;
     recordQaReport(input: Omit<QaReportRecordV2, "reportOccurrenceId" | "disposition" | "createdAt" | "updatedAt">, findingIds: string[], now?: Date): QaReportRecordV2;
@@ -521,6 +535,7 @@ export declare class WorkflowDb {
     authorizeContractQaWaiver(runId: string, workId: string, decisionId: string): string;
     commitQaWaiver(runId: string, ticketId: string, expectedRevision: number, reason: string, now?: Date, authorizationRef?: string): QaReducerStateV2;
     builderRemediationReceipt(operationId: string): BuilderRemediationReceiptV2 | BuilderRemediationReceiptV3 | undefined;
+    hasConfirmedQaRemediationForRecheck(runId: string, ticketId: string): boolean;
     recordBuilderRemediationReceipt(receipt: BuilderRemediationReceiptV2 | BuilderRemediationReceiptV3): void;
     commitBuilderRemediationSuccess(receipt: BuilderRemediationReceiptV2 | BuilderRemediationReceiptV3, expectedRevision: number, now?: Date): QaReducerStateV2;
     commitQaRemediationOutcome(input: {