ai-foreman 1.7.19 → 1.7.21

package/dist/buildOwnershipRepair.js

@@ -0,0 +1,111 @@
+import { WorkflowDb } from "./workflowDb.js";
+import { WorkflowReader } from "./workflowReader.js";
+import { readQaEvidenceSnapshot, evidenceRecord } from "./qaEvidenceReader.js";
+import { assessBuildOwnership, ownershipRevision } from "./buildOwnershipReconciliation.js";
+import { captureBuildSource } from "./buildAssignment.js";
+import { buildScopeRevision } from "./buildApproval.js";
+import { loadTicketsConfig, resolveTicketPaths } from "./tickets/config.js";
+import { loadTickets } from "./tickets/ticketLoader.js";
+import { bindBuildAuthority, checkpointBuildRun } from "./buildRuns.js";
+import { classifyProcess } from "./processIdentity.js";
+import { validateOwnershipRepair } from "./buildWorkReconciliation.js";
+export function prepareOwnershipRepair(projectDir, runId, workId) {
+    const snapshot = readQaEvidenceSnapshot(projectDir, runId);
+    if (snapshot.availability === "corrupt" || snapshot.availability === "unreadable" || snapshot.availability === "missing")
+        throw new Error("Ownership evidence must be readable and intact before repair");
+    const assignment = (snapshot.rows.operation_journal ?? []).filter(row => row.kind === "build-assignment" && evidenceRecord(row, "intent_json")?.ticketId === workId).sort((a, b) => String(a.created_at).localeCompare(String(b.created_at)) || String(a.idempotency_key).localeCompare(String(b.idempotency_key))).at(-1);
+    const intent = assignment ? evidenceRecord(assignment, "intent_json") : undefined;
+    const worktree = typeof intent?.worktree === "string" ? intent.worktree : projectDir;
+    const source = captureBuildSource(worktree);
+    const before = intent?.before;
+    const requiredPaths = [...new Set([...source.pathInventory.map(path => path.path), ...(before?.pathInventory ?? []).map(path => path.path)])].sort();
+    return { runId, workId, expectedRevision: ownershipRevision(snapshot), inspectedSourceDigest: source.digest, scopeRevision: buildScopeRevision(projectDir), requiredPaths, worktree, sourceInventory: source.pathInventory, ownership: assessBuildOwnership(projectDir, runId, snapshot), sourceMutationAuthorized: false, choices: ["link_provenance", "authorize_mapped_work", "quarantine"] };
+}
+export function repairOwnership(projectDir, value, userTurn, faults) {
+    validateOwnershipRepair(value);
+    const request = value;
+    if (!userTurn.trim().startsWith("/qa-repair ") || JSON.stringify(JSON.parse(userTurn.trim().slice("/qa-repair ".length))) !== JSON.stringify(request))
+        throw new Error("Repair requires the original explicit host request");
+    const reader = new WorkflowReader(projectDir);
+    try {
+        const lease = reader.currentLease();
+        const admission = reader.buildAdmission();
+        if (lease && classifyProcess(lease.pid, lease.processStart, lease.host).state !== "dead" || admission && classifyProcess(admission.pid, admission.processStart, admission.host).state !== "dead")
+            throw new Error("Stop and verify the build owner before repairing ownership");
+    }
+    finally {
+        reader.close();
+    }
+    const db = new WorkflowDb(projectDir);
+    let authority;
+    let lease;
+    try {
+        authority = db.acquireBuildRecoveryAdmission(request.runId);
+        lease = db.acquireLease(request.runId);
+        const prior = db.reconciliation(request.requestId);
+        const plan = prepareOwnershipRepair(projectDir, request.runId, request.workId);
+        if (request.scopeRevision !== plan.scopeRevision)
+            throw new Error("Requirements changed after the repair was prepared; inspect and approve current scope");
+        if (prior && prior.sourceDigest !== plan.inspectedSourceDigest)
+            throw new Error("Inspected source changed after the committed repair; prepare a new reconciliation before publication");
+        const definition = loadTickets(resolveTicketPaths(loadTicketsConfig(projectDir), projectDir).tickets).find(ticket => ticket.id === request.workId);
+        if (!definition && request.choice !== "quarantine")
+            throw new Error("Approved target ticket definition is unavailable; preserve quarantine until scope is resolved");
+        const receipt = db.atomic(() => {
+            faults?.afterDecision?.();
+            const receipt = db.reconcileWork(request, { revision: plan.expectedRevision, sourceDigest: plan.inspectedSourceDigest, definition, requiredPaths: plan.requiredPaths, userTurn });
+            faults?.afterMembership?.();
+            if (prior && !prior.executionDisposition && request.choice !== "quarantine" && !["completed", "waived"].includes(db.qaTicketHead(request.runId, request.workId).state)) {
+                // Compatibility for old receipts: retire only certificates predating
+                // this repair, never a fresh review issued after its committed outcome.
+                db.invalidateUnconsumedQaPassCertificates(request.runId, request.workId, "ownership-repair", new Date(), String(prior.createdAt));
+            }
+            if (!prior && request.choice !== "quarantine") {
+                const head = db.qaTicketHead(request.runId, request.workId);
+                if (!["completed", "waived"].includes(head.state))
+                    db.invalidateUnconsumedQaPassCertificates(request.runId, request.workId, "ownership-repair");
+                if (!["idle", "operator-menu", "completed", "waived"].includes(head.state)) {
+                    if (head.state === "passed")
+                        db.transitionQa(request.runId, request.workId, head.revision, { type: "pass-invalidated", reason: "Ownership repair requires fresh QA on inspected source" });
+                    else if (!["finalizing", "remediation-intended"].includes(head.state))
+                        db.transitionQa(request.runId, request.workId, head.revision, { type: "operator-menu" });
+                    else
+                        throw new Error("Reconcile pending finalization/remediation before ownership repair");
+                }
+                const packet = db.qaRecoveryHead(request.runId, request.workId);
+                if (packet && packet.pendingAction !== "resolved")
+                    db.putQaRecoveryHead({ ...packet, pendingAction: "resolved" });
+                if (!prior)
+                    db.transition(request.runId, { checkpoint: "ownership-reconciled", event: "build_ownership_reconciled", payload: { ...receipt, retainedHistoricalPacket: packet } });
+            }
+            return receipt;
+        });
+        faults?.afterLocalCommit?.();
+        if (request.choice !== "quarantine") {
+            // Publication remains journaled separately; an interrupted publication can be repeated.
+            const state = db.getRun(request.runId)?.state;
+            if (state?.version !== undefined)
+                checkpointBuildRun(projectDir, bindBuildAuthority(state, lease), "ownership-reconciled");
+        }
+        faults?.afterPublication?.();
+        // Older immutable receipts used requiresFreshQa for every non-quarantine
+        // repair. Clarify execution eligibility without rewriting that history.
+        const head = db.qaTicketHead(request.runId, request.workId);
+        return receipt.executionDisposition ? receipt : { ...receipt, executionDisposition: request.choice === "quarantine" ? "quarantined" : head.state === "completed" ? "terminal_metadata_repaired" : head.state === "waived" ? "existing_waiver_policy" : "fresh_qa_required", requiresFreshQa: request.choice !== "quarantine" && !["completed", "waived"].includes(head.state), executionReopened: false };
+    }
+    finally {
+        try {
+            if (lease)
+                db.releaseLease(lease);
+        }
+        finally {
+            try {
+                if (authority)
+                    db.releaseBuildAdmission(authority);
+            }
+            finally {
+                db.close();
+            }
+        }
+    }
+}

package/dist/buildRuns.d.ts

@@ -1,12 +1,17 @@
+export { withBuildInvocation as withBuildRecoveryInvocation, launchDigest as launchArgumentDigest } from "./buildAdmission.js";
 import type { AutonomyProfile, BuildRunRecordV2, ProviderSessionRefV1, ResolvedAgentSettings, ResolvedAutonomyPolicy, SessionAvailabilityV1 } from "rafi-spec";
+import { type ProjectLease } from "./workflowDb.js";
 import { type ResolveSessionAvailabilityOptions } from "./sessionAvailability.js";
 export declare const BUILD_RUN_VERSION = 3;
 export declare const BUILD_RUN_DIRECTORY = ".foreman/runs";
 export declare const BUILD_HEARTBEAT_MS = 10000;
 export declare const BUILD_LEASE_STALE_MS = 45000;
+export declare function bindBuildAuthority(run: BuildRunRecordV2, lease: ProjectLease): BuildRunRecordV2;
 export interface CreateBuildRunInput {
     runId?: string;
     tickets: string[];
+    authorizedBatch?: BuildRunRecordV2["authorizedBatch"];
+    builderCapabilities?: BuildRunRecordV2["builderCapabilities"];
     deliveryUnit?: string;
     branchMode?: BuildRunRecordV2["branchMode"];
     repositoryRoot: string;
@@ -44,10 +49,19 @@ export declare function recordBuildReceipt(projectDir: string, run: BuildRunReco
 export declare function heartbeatBuildRun(projectDir: string, run: BuildRunRecordV2, now?: Date): BuildRunRecordV2;
 export declare function releaseBuildLease(projectDir: string, run: BuildRunRecordV2, status?: BuildRunRecordV2["status"]): BuildRunRecordV2;
 export declare function completeBuildRun(projectDir: string, run: BuildRunRecordV2, now?: Date): BuildRunRecordV2;
+/** A recovered ticket boundary is complete only when the saved run scope is done. */
+export declare function finishRecoveredTicketScope(projectDir: string, run: BuildRunRecordV2, checkpoint: string): BuildRunRecordV2;
 export declare function readBuildRuns(projectDir: string): BuildRunRecordV2[];
 export declare function recoverableBuildRuns(projectDir: string, now?: Date): Array<BuildRunRecordV2 & {
     active: boolean;
+    ownership: "live" | "dead" | "unknown";
+    ownershipReason: string;
+    cleanupOnly?: boolean;
 }>;
+/**
+ * Timestamp correlations are diagnostic hints, never executable membership.
+ */
+export declare function legacyTrackerWorkHints(projectDir: string, run: BuildRunRecordV2): string[];
 export declare function isLeaseActive(run: BuildRunRecordV2, now?: Date): boolean;
 export declare function buildRecoveryPreview(run: BuildRunRecordV2): string[];
 export interface BuildRecoveryProjection {
@@ -74,7 +88,16 @@ export interface BuildRecoveryProjection {
     sessionCandidateRef?: ProviderSessionRefV1;
     sessionAvailability?: SessionAvailabilityV1;
 }
+/** Saved context may be broader than the work authorized for this invocation. */
+export declare function recoveryExecutionTickets(run: BuildRunRecordV2, requested: readonly string[], frozen: boolean): string[];
+/** Read-only reconciliation also handles crashes before the last progress checkpoint. */
+export declare function currentBranchTicketProgress(projectDir: string, run: BuildRunRecordV2): {
+    completed: string[];
+    remaining: string[];
+    pendingQa: string[];
+} | undefined;
+/** Match the frozen preview at both the resume wrapper and direct start boundary. */
+export declare function currentBranchRecoveryTicket(projectDir: string, run: BuildRunRecordV2): string | undefined;
 export declare function projectBuildRecovery(projectDir: string, run: BuildRunRecordV2, now?: Date, ticketOverride?: string, sessionAvailability?: SessionAvailabilityV1): BuildRecoveryProjection;
 export declare function resolveBuildRecoveryProjection(projectDir: string, run: BuildRunRecordV2, now?: Date, ticketOverride?: string, probe?: ResolveSessionAvailabilityOptions): Promise<BuildRecoveryProjection>;
 export declare function formatBuildRecoveryProjection(projection: BuildRecoveryProjection): string[];
-export {};